test: fix pre-commit issues in e2e test framework

- Add license headers to all Python and shell files
- Fix ruff import ordering and formatting
- Fix shellcheck warnings (brace variable references)
- Remove hard line wraps in README and scenarios prose

Signed-off-by: fredespi <fredrik.espinoza@gmail.com>

Author: fredespi

tests/e2e/README.md

@@ -34,60 +34,37 @@ Behavioral end-to-end tests for rocm-cli using Robot Framework.
                      └─────────────────┘
 ```
 
-Tests run the real `rocm` binary via subprocess, the same way a user would.
-Keyword libraries parse CLI output and make HTTP requests to served endpoints.
-No imports from the rocm-cli codebase.
+Tests run the real `rocm` binary via subprocess, the same way a user would. Keyword libraries parse CLI output and make HTTP requests to served endpoints. No imports from the rocm-cli codebase.
 
 ## Why a separate test layer
 
 The existing test infrastructure covers two levels:
 
-- **Rust unit and integration tests** (`cargo test --workspace`) — pure,
-  deterministic, no GPU or runtime needed. These validate individual components
-  in isolation with fixtures and mocks.
-- **Python smoke scripts** (`scripts/smoke_local.py`,
-  `scripts/*_therock_gpu_test.py`) — zero-dependency, stdlib-only scripts that
-  verify CLI behavior against real or fake binaries. These run as linear scripts
-  with basic substring assertions.
+- **Rust unit and integration tests** (`cargo test --workspace`) — pure, deterministic, no GPU or runtime needed. These validate individual components in isolation with fixtures and mocks.
+- **Python smoke scripts** (`scripts/smoke_local.py`, `scripts/*_therock_gpu_test.py`) — zero-dependency, stdlib-only scripts that verify CLI behavior against real or fake binaries. These run as linear scripts with basic substring assertions.
 
-Both layers are valuable but leave a gap: **cross-component user journeys are
-not tested.** Each component works individually, but the seams between them
-break in practice. For example:
+Both layers are valuable but leave a gap: **cross-component user journeys are not tested.** Each component works individually, but the seams between them break in practice. For example:
 
-- Model alias resolution works in the recipe registry but is not forwarded
-  correctly to all engine adapters.
-- `rocm serve` binds to port 11435 but the TUI chat detection probes ports
-  8000 and 13305.
-- The managed-services registry tracks a running server with its real model
-  name, but the TUI chat falls back to a hardcoded `local-model` default.
+- Model alias resolution works in the recipe registry but is not forwarded correctly to all engine adapters.
+- `rocm serve` binds to port 11435 but the TUI chat detection probes ports 8000 and 13305.
+- The managed-services registry tracks a running server with its real model name, but the TUI chat falls back to a hardcoded `local-model` default.
 
-These are integration failures that only surface when exercising the full user
-flow: install → examine → configure runtime → serve model → detect → chat.
+These are integration failures that only surface when exercising the full user flow: install → examine → configure runtime → serve model → detect → chat.
 
 ## Why Robot Framework
 
-The product scripts (`scripts/*.py`) are deliberately zero-dependency to run on
-user machines and in minimal CI environments. E2E tests have a different
-audience — they run in developer and CI environments where installing packages
-is expected. Keeping the two concerns separate avoids compromising either:
+The product scripts (`scripts/*.py`) are deliberately zero-dependency to run on user machines and in minimal CI environments. E2E tests have a different audience — they run in developer and CI environments where installing packages is expected. Keeping the two concerns separate avoids compromising either:
 
 - Product scripts stay zero-dependency and stdlib-only.
-- E2E tests get proper test infrastructure without reinventing scenario
-  discovery, tagging, parameterization, setup/teardown lifecycle, and
-  structured reporting.
+- E2E tests get proper test infrastructure without reinventing scenario discovery, tagging, parameterization, setup/teardown lifecycle, and structured reporting.
 
 Robot Framework was chosen because:
 
-- **Keyword-driven syntax** — `.robot` files are readable without knowing
-  Python, making scenarios accessible to anyone reviewing test coverage.
-- **Built-in tagging** — scenarios can be tagged `gpu`, `mock`, `smoke`, etc.
-  and selectively run in different CI environments.
-- **Setup/teardown lifecycle** — suite and test-level setup and teardown handle
-  isolated config directories, server startup/shutdown, and cleanup.
-- **Structured reporting** — HTML reports show which scenario failed, at which
-  step, with full output, without custom reporting code.
-- **Step reuse** — shared keywords across scenarios without building a custom
-  framework.
+- **Keyword-driven syntax** — `.robot` files are readable without knowing Python, making scenarios accessible to anyone reviewing test coverage.
+- **Built-in tagging** — scenarios can be tagged `gpu`, `mock`, `smoke`, etc. and selectively run in different CI environments.
+- **Setup/teardown lifecycle** — suite and test-level setup and teardown handle isolated config directories, server startup/shutdown, and cleanup.
+- **Structured reporting** — HTML reports show which scenario failed, at which step, with full output, without custom reporting code.
+- **Step reuse** — shared keywords across scenarios without building a custom framework.
 
 ## Directory layout
 
@@ -175,9 +152,7 @@ python3 -m robot --pythonpath tests/e2e --outputdir tests/e2e/results tests/e2e/
 
 ## From scenarios to tests
 
-Scenarios are written in BDD style (Given/When/Then). The `.robot` file is a
-near-verbatim copy of the behavioral scenario. The keyword library translates
-the behavioral language into technical actions.
+Scenarios are written in BDD style (Given/When/Then). The `.robot` file is a near-verbatim copy of the behavioral scenario. The keyword library translates the behavioral language into technical actions.
 
 ```
 Scenario (spec)  →  .robot file (same words)  →  Keyword Library (Python)
@@ -226,23 +201,10 @@ def user_serves_model(self, alias: str, engine: str):
 
 ## Test design principles
 
-- **Platform-agnostic scenarios.** The same behavioral expectations apply
-  across MI300X, RDNA 3, and WSL. Hardware determines which GPU is detected or
-  which engine is auto-selected, but the contract is the same: "examine detects
-  a GPU," "serve makes a model reachable," "chat connects and gets a response."
-
-- **Real binary, real hardware.** Tests run the actual `rocm` binary, not a
-  mock. On GPU runners they exercise real serving and inference. On CPU-only
-  runners they verify graceful failure and non-GPU paths.
-
-- **Isolated state.** Each suite uses isolated `ROCM_CLI_CONFIG_DIR`,
-  `ROCM_CLI_DATA_DIR`, and `ROCM_CLI_CACHE_DIR` directories (following the
-  pattern established by `smoke_local.py`). Tests never touch the user's real
-  `~/.rocm` state.
-
-- **Black-box only.** Keywords interact with `rocm` through its CLI and HTTP
-  endpoints. No imports from the rocm-cli Rust codebase or internal Python
-  modules. Tests verify observable behavior, not implementation details.
+- **Platform-agnostic scenarios.** The same behavioral expectations apply across MI300X, RDNA 3, and WSL. Hardware determines which GPU is detected or which engine is auto-selected, but the contract is the same: "examine detects a GPU," "serve makes a model reachable," "chat connects and gets a response."
+- **Real binary, real hardware.** Tests run the actual `rocm` binary, not a mock. On GPU runners they exercise real serving and inference. On CPU-only runners they verify graceful failure and non-GPU paths.
+- **Isolated state.** Each suite uses isolated `ROCM_CLI_CONFIG_DIR`, `ROCM_CLI_DATA_DIR`, and `ROCM_CLI_CACHE_DIR` directories (following the pattern established by `smoke_local.py`). Tests never touch the user's real `~/.rocm` state.
+- **Black-box only.** Keywords interact with `rocm` through its CLI and HTTP endpoints. No imports from the rocm-cli Rust codebase or internal Python modules. Tests verify observable behavior, not implementation details.
 
 ## Relationship to existing tests
 
@@ -255,8 +217,7 @@ This layer does **not** replace existing tests:
 | `*_therock_gpu_test.py` | Per-engine GPU validation | Hardware CI (planned) |
 | **`tests/e2e/`** | Cross-component user journeys | Hardware CI + mock subset on hosted CI |
 
-The e2e suites are the only layer that tests the seams between components —
-where most user-facing bugs live.
+The e2e suites are the only layer that tests the seams between components — where most user-facing bugs live.
 
 ## Writing new tests
 

tests/e2e/libraries/RocmCliLibrary.py

@@ -1,14 +1,17 @@
+# Copyright Advanced Micro Devices, Inc.
+#
+# SPDX-License-Identifier: MIT
+
 """Keyword library for core rocm-cli interactions.
 
 Maps BDD step text to CLI commands and output assertions. Covers
 examine, runtime, engine, and version scenarios.
 """
 
+from common.cli_runner import CliResult, run_rocm
 from robot.api import logger
 from robot.api.deco import keyword, library
 
-from common.cli_runner import CliResult, run_rocm
-
 
 @library(scope="TEST")
 class RocmCliLibrary:
@@ -28,9 +31,9 @@ def __init__(self):
     def setup_gpu_machine(self):
         """Precondition: verify GPU is detectable (will fail on CPU-only)."""
         result = run_rocm("examine")
-        assert result.contains("AMD GPU detected") or result.contains("detected_gfx_target"), (
-            f"No AMD GPU detected on this machine:\n{result.stdout}"
-        )
+        assert result.contains("AMD GPU detected") or result.contains(
+            "detected_gfx_target"
+        ), f"No AMD GPU detected on this machine:\n{result.stdout}"
 
     @keyword("a machine with a pre-installed ROCm that was not set up by the CLI")
     def setup_unmanaged_rocm(self):
@@ -41,9 +44,9 @@ def setup_unmanaged_rocm(self):
     def setup_no_runtimes(self):
         """Precondition: verify no managed runtimes are registered."""
         result = run_rocm("runtimes", "list")
-        assert result.contains("installed: none") or result.contains("managed_runtimes: 0"), (
-            f"Expected no managed runtimes:\n{result.stdout}"
-        )
+        assert result.contains("installed: none") or result.contains(
+            "managed_runtimes: 0"
+        ), f"Expected no managed runtimes:\n{result.stdout}"
 
     @keyword("a machine with a standard ROCm install")
     def setup_standard_rocm(self):
@@ -91,9 +94,12 @@ def user_installs_sdk(self):
     def user_tries_adopt(self):
         """Run rocm runtimes adopt with /opt/rocm."""
         self._result = run_rocm(
-            "runtimes", "adopt",
-            "--python", "/usr/bin/python3",
-            "--root", "/opt/rocm",
+            "runtimes",
+            "adopt",
+            "--python",
+            "/usr/bin/python3",
+            "--root",
+            "/opt/rocm",
         )
         logger.info(self._result.stdout)
 
@@ -153,17 +159,17 @@ def assert_gpu_detected(self):
     def assert_driver_available(self):
         """Assert examine output shows driver available."""
         assert self._result is not None, "No command was run"
-        assert self._result.contains("amdgpu") or self._result.contains("driver_status"), (
-            f"Driver status not found in examine output:\n{self._result.stdout}"
-        )
+        assert self._result.contains("amdgpu") or self._result.contains(
+            "driver_status"
+        ), f"Driver status not found in examine output:\n{self._result.stdout}"
 
     @keyword("the inspection reports the ROCm install as unmanaged")
     def assert_rocm_unmanaged(self):
         """Assert examine shows legacy/unmanaged ROCm."""
         assert self._result is not None, "No command was run"
-        assert self._result.contains("detected_unmanaged") or self._result.contains("legacy"), (
-            f"Expected unmanaged ROCm status:\n{self._result.stdout}"
-        )
+        assert self._result.contains("detected_unmanaged") or self._result.contains(
+            "legacy"
+        ), f"Expected unmanaged ROCm status:\n{self._result.stdout}"
 
     @keyword("the inspection suggests installing a managed runtime")
     def assert_suggests_managed_runtime(self):
@@ -211,9 +217,9 @@ def assert_adopt_error_explains(self):
         """Assert error message mentions TheRock or unsupported."""
         assert self._result is not None, "No command was run"
         output = self._result.stdout + self._result.stderr
-        assert any(term in output.lower() for term in ("therock", "rocm_sdk", "not supported")), (
-            f"Error does not explain TheRock requirement:\n{output}"
-        )
+        assert any(
+            term in output.lower() for term in ("therock", "rocm_sdk", "not supported")
+        ), f"Error does not explain TheRock requirement:\n{output}"
 
     @keyword("the serve plan shows the full model identifier")
     def assert_serve_plan_full_id(self):

tests/e2e/libraries/ServeLibrary.py

@@ -1,3 +1,7 @@
+# Copyright Advanced Micro Devices, Inc.
+#
+# SPDX-License-Identifier: MIT
+
 """Keyword library for model serving, endpoint interaction, and chat.
 
 Manages the mock OpenAI server for mock-tier tests and interacts
@@ -9,11 +13,10 @@
 import json
 import urllib.request
 
-from robot.api import logger
-from robot.api.deco import keyword, library
-
 from common.cli_runner import CliResult, run_rocm
 from common.mock_server import MockOpenAIServer
+from robot.api import logger
+from robot.api.deco import keyword, library
 
 
 @library(scope="TEST")
@@ -89,8 +92,11 @@ def setup_localhost_model(self):
     def setup_gpu_model(self):
         """Start a real model server using rocm serve."""
         self._serve_result = run_rocm(
-            "serve", "Qwen/Qwen2.5-1.5B-Instruct",
-            "--engine", "vllm", "--managed",
+            "serve",
+            "Qwen/Qwen2.5-1.5B-Instruct",
+            "--engine",
+            "vllm",
+            "--managed",
             timeout=600,
         )
         assert self._serve_result.rc == 0, (
@@ -126,10 +132,12 @@ def send_chat_via_cli(self):
         """Send a chat completion request to the endpoint."""
         assert self._endpoint is not None, "No endpoint configured"
         url = f"{self._endpoint}/chat/completions"
-        payload = json.dumps({
-            "model": self._model_name or "local-model",
-            "messages": [{"role": "user", "content": "Hello"}],
-        }).encode()
+        payload = json.dumps(
+            {
+                "model": self._model_name or "local-model",
+                "messages": [{"role": "user", "content": "Hello"}],
+            }
+        ).encode()
         req = urllib.request.Request(
             url,
             data=payload,
@@ -153,7 +161,9 @@ def user_sends_chat(self):
     def user_serves_default_engine(self):
         """Run rocm serve with a small model, no --engine flag."""
         self._serve_result = run_rocm(
-            "serve", "Qwen/Qwen2.5-1.5B-Instruct", "--managed",
+            "serve",
+            "Qwen/Qwen2.5-1.5B-Instruct",
+            "--managed",
             timeout=600,
         )
         logger.info(self._serve_result.stdout)
@@ -270,9 +280,7 @@ def assert_model_reachable(self):
         req = urllib.request.Request(url)
         with urllib.request.urlopen(req, timeout=10) as resp:
             data = json.loads(resp.read())
-        assert "data" in data and len(data["data"]) > 0, (
-            f"No models at {url}: {data}"
-        )
+        assert "data" in data and len(data["data"]) > 0, f"No models at {url}: {data}"
 
     @keyword("the endpoint responds to inference requests")
     def assert_endpoint_responds(self):

tests/e2e/libraries/common/__init__.py

@@ -0,0 +1,3 @@
+# Copyright Advanced Micro Devices, Inc.
+#
+# SPDX-License-Identifier: MIT

tests/e2e/libraries/common/cli_runner.py

@@ -1,3 +1,7 @@
+# Copyright Advanced Micro Devices, Inc.
+#
+# SPDX-License-Identifier: MIT
+
 """Subprocess wrapper for running the rocm binary."""
 
 from __future__ import annotations

tests/e2e/libraries/common/mock_server.py

@@ -1,3 +1,7 @@
+# Copyright Advanced Micro Devices, Inc.
+#
+# SPDX-License-Identifier: MIT
+
 """Minimal mock OpenAI-compatible server for E2E tests.
 
 Implements GET /v1/models and POST /v1/chat/completions with canned
@@ -15,10 +19,12 @@
 class MockOpenAIHandler(BaseHTTPRequestHandler):
     def do_GET(self):
         if self.path.rstrip("/") in ("/v1/models", "/models"):
-            body = json.dumps({
-                "object": "list",
-                "data": [{"id": self.server.model_name, "object": "model"}],
-            })
+            body = json.dumps(
+                {
+                    "object": "list",
+                    "data": [{"id": self.server.model_name, "object": "model"}],
+                }
+            )
             self._respond(200, body)
         else:
             self._respond(404, json.dumps({"error": "not found"}))
@@ -31,24 +37,28 @@ def do_POST(self):
             received_model = request.get("model", "<missing>")
             self.server.received_models.append(received_model)
 
-            body = json.dumps({
-                "id": "mock-completion-1",
-                "object": "chat.completion",
-                "model": received_model,
-                "choices": [{
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": "This is a mock response for testing.",
+            body = json.dumps(
+                {
+                    "id": "mock-completion-1",
+                    "object": "chat.completion",
+                    "model": received_model,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": "This is a mock response for testing.",
+                            },
+                            "finish_reason": "stop",
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": 10,
+                        "completion_tokens": 8,
+                        "total_tokens": 18,
                     },
-                    "finish_reason": "stop",
-                }],
-                "usage": {
-                    "prompt_tokens": 10,
-                    "completion_tokens": 8,
-                    "total_tokens": 18,
-                },
-            })
+                }
+            )
             self._respond(200, body)
         else:
             self._respond(404, json.dumps({"error": "not found"}))
@@ -66,8 +76,12 @@ def log_message(self, format, *args):
 class MockOpenAIServer:
     """Start and stop a mock OpenAI-compatible server in a background thread."""
 
-    def __init__(self, host: str = "127.0.0.1", port: int = 18435,
-                 model_name: str = "TestModel/E2E-1B"):
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 18435,
+        model_name: str = "TestModel/E2E-1B",
+    ):
         self.host = host
         self.port = port
         self.model_name = model_name