test: improve scenario wording — remove jargon and internal terminology

Rewrite scenarios to use plain language per BDD quality rules:
- "GPU target" → "which GPU is installed"
- "managed runtime" → "CLI-managed runtime"
- "services registry" → "running services"
- "endpoint" → "connection details"
- "dependency error" → "works without errors"
- "TheRock-based installs" → "which install types can be adopted"
- "inference stack" → "inference engine"

Step function annotations updated to match.

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

Author: fredespi

tests/e2e-cucumber/features/chat.feature

@@ -7,28 +7,27 @@ Feature: Chat and endpoint detection
     Then the request identifies the served model by name
 
   @expected-failure-EAI-7220
-  Scenario: 2 - Detection finds a served model through the services registry
+  Scenario: 2 - A served model is discoverable through the services list
     Given a model is being served
-    And the server is registered as a managed service
     When the user checks for running services
-    Then the served model is detected at the correct endpoint
+    Then the served model is listed
 
   Scenario: 3 - The privacy notice is accurate for local endpoints
     Given a model is being served locally
     When the user is offered the detected endpoint
     Then the notice does not claim that requests leave the machine
 
   @expected-failure-EAI-7220
-  Scenario: 4 - The default serve port is included in engine detection
+  Scenario: 4 - A served model is discoverable on the default port
     Given a model is served in the background
     When the user lists running services
-    Then the endpoint port matches the default serve port
+    Then the served model is listed on the default port
 
   @expected-failure-EAI-7223
-  Scenario: 5 - Chat completion with tool definitions does not fail
+  Scenario: 5 - Chat requests that include tool definitions are accepted
     Given a managed runtime is active
     And a model is served in the background
-    When a chat completion request with tools is sent
+    When a chat request with tool definitions is sent
     Then the chat response is successful
 
   @expected-failure-EAI-7221

tests/e2e-cucumber/features/examine.feature

@@ -8,14 +8,14 @@ Feature: GPU detection and system inspection
     When the user lists available engines
     Then all supported engines are listed
 
-  Scenario: 3 - System inspection detects GPU and ROCm on a supported machine
-    Given a machine with an AMD GPU and ROCm installed
+  Scenario: 3 - System inspection detects the GPU and driver
+    Given a machine with an AMD GPU
     When the user inspects the system
-    Then the inspection reports a detected GPU target
+    Then the inspection reports which GPU is installed
     And the inspection reports that the driver is available
 
-  Scenario: 4 - System inspection distinguishes managed from unmanaged ROCm
-    Given a machine with a pre-installed ROCm that was not set up by the CLI
+  Scenario: 4 - System inspection distinguishes CLI-managed from pre-existing ROCm
+    Given a machine with a ROCm install that was not set up by the CLI
     When the user inspects the system
-    Then the inspection reports the ROCm install as unmanaged
-    And the inspection suggests installing a managed runtime
+    Then the inspection reports the install as pre-existing
+    And the inspection suggests setting up a CLI-managed install

tests/e2e-cucumber/features/model_serving.feature

@@ -11,24 +11,22 @@ Feature: Model serving
     Then all engines expand to the same full model name
 
   @expected-failure-EAI-7220
-  Scenario: 3 - A managed server appears in the services list with its model name
+  Scenario: 3 - A running model server is discoverable by name
     Given a model is being served on the default port
-    And the server is registered as a managed service
     When the user lists running services
-    Then the service appears with the correct model name and endpoint
+    Then the service appears with the correct model name and connection details
 
   @expected-failure-EAI-7220
-  Scenario: 4 - The services registry reports the actual endpoint port
+  Scenario: 4 - Running services show the correct connection details
     Given a model is being served on a non-default port
-    And the server is registered as a managed service
     When the user lists running services
-    Then the endpoint matches the actual server port
+    Then the connection details match the actual server port
 
   @expected-failure-EAI-7218
-  Scenario: 5 - Serving with the PyTorch engine resolves dependencies correctly
+  Scenario: 5 - Serving a model with the PyTorch engine works without errors
     Given a managed runtime is active
     When the user serves a model using the PyTorch engine
-    Then the serve command does not fail with a dependency error
+    Then the model is served successfully
 
   @expected-failure-EAI-7219
   Scenario: 6 - Serve output shows the full model name when given a short name
@@ -43,9 +41,9 @@ Feature: Model serving
     Then the response contains a model reply
     And the response identifies the correct model
 
-  Scenario: 8 - Serving a model with the default engine produces a working endpoint
+  Scenario: 8 - Serving a model without specifying an engine produces a working endpoint
     Given a managed runtime is active
     When the user serves a model without specifying an engine
     Then an engine is selected automatically
-    And the model is reachable at the reported endpoint
-    And the endpoint responds to inference requests
+    And the model is reachable
+    And the model responds to inference requests

tests/e2e-cucumber/features/runtime_setup.feature

@@ -1,14 +1,14 @@
 Feature: Runtime configuration
 
-  Scenario: 1 - Installing a managed runtime makes it the active runtime
-    Given a machine with no managed runtimes
+  Scenario: 1 - Installing the SDK makes it the active runtime
+    Given a machine with no CLI-managed runtimes
     When the user installs the SDK
-    Then a managed runtime is registered
+    Then a runtime is registered
     And the runtime is set as active
-    And the runtime includes a matching inference stack
+    And the runtime includes an inference engine
 
-  Scenario: 2 - Adopting a non-TheRock install is rejected with guidance
+  Scenario: 2 - Adopting a pre-existing ROCm install is rejected with guidance
     Given a machine with a standard ROCm install
-    When the user tries to adopt the standard install as a managed runtime
+    When the user tries to adopt the existing install
     Then the adoption is refused
-    And the error explains that only TheRock-based installs can be adopted
+    And the error explains which install types can be adopted

tests/e2e-cucumber/tests/e2e/chat_steps.rs

@@ -69,7 +69,7 @@ async fn user_checks_services(world: &mut E2eWorld) {
 #[when("the user is offered the detected endpoint")]
 async fn user_offered_endpoint(_world: &mut E2eWorld) {}
 
-#[when("a chat completion request with tools is sent")]
+#[when("a chat request with tool definitions is sent")]
 async fn send_chat_with_tools(world: &mut E2eWorld) {
     let endpoint = world.endpoint.as_ref().expect("no endpoint configured");
     let models_url = format!("{endpoint}/models");
@@ -132,15 +132,15 @@ async fn assert_request_uses_served_model(world: &mut E2eWorld) {
     );
 }
 
-#[then("the served model is detected at the correct endpoint")]
-async fn assert_model_detected(world: &mut E2eWorld) {
+#[then("the served model is listed")]
+async fn assert_model_listed(world: &mut E2eWorld) {
     let output = world
         .cli_output
         .as_ref()
         .expect("no services query was run");
     assert!(
         output.contains("127.0.0.1"),
-        "endpoint not found in services:\n{output}"
+        "served model not found in services:\n{output}"
     );
 }
 
@@ -152,12 +152,12 @@ async fn assert_privacy_notice_accurate(_world: &mut E2eWorld) {
     );
 }
 
-#[then("the endpoint port matches the default serve port")]
-async fn assert_default_port(world: &mut E2eWorld) {
+#[then("the served model is listed on the default port")]
+async fn assert_listed_on_default_port(world: &mut E2eWorld) {
     let (stdout, _, _) = run_rocm(world, &["services", "list"]);
     assert!(
         stdout.contains("11435"),
-        "default serve port 11435 not found in services list:\n{stdout}"
+        "served model not listed on default port 11435:\n{stdout}"
     );
 }
 

tests/e2e-cucumber/tests/e2e/examine_steps.rs

@@ -21,7 +21,7 @@ fn run_rocm(world: &E2eWorld, args: &[&str]) -> (String, String, i32) {
     )
 }
 
-#[given("a machine with an AMD GPU and ROCm installed")]
+#[given("a machine with an AMD GPU")]
 async fn setup_gpu_machine(world: &mut E2eWorld) {
     let (stdout, _, _) = run_rocm(world, &["examine"]);
     assert!(
@@ -30,7 +30,7 @@ async fn setup_gpu_machine(world: &mut E2eWorld) {
     );
 }
 
-#[given("a machine with a pre-installed ROCm that was not set up by the CLI")]
+#[given("a machine with a ROCm install that was not set up by the CLI")]
 async fn setup_unmanaged_rocm(_world: &mut E2eWorld) {}
 
 #[when("the user asks for the version")]
@@ -71,7 +71,7 @@ async fn assert_all_engines_listed(world: &mut E2eWorld) {
     }
 }
 
-#[then("the inspection reports a detected GPU target")]
+#[then("the inspection reports which GPU is installed")]
 async fn assert_gpu_detected(world: &mut E2eWorld) {
     let output = world.cli_output.as_ref().expect("no command was run");
     assert!(
@@ -99,7 +99,7 @@ async fn assert_driver_available(world: &mut E2eWorld) {
     );
 }
 
-#[then("the inspection reports the ROCm install as unmanaged")]
+#[then("the inspection reports the install as pre-existing")]
 async fn assert_rocm_unmanaged(world: &mut E2eWorld) {
     let output = world.cli_output.as_ref().expect("no command was run");
     assert!(
@@ -108,7 +108,7 @@ async fn assert_rocm_unmanaged(world: &mut E2eWorld) {
     );
 }
 
-#[then("the inspection suggests installing a managed runtime")]
+#[then("the inspection suggests setting up a CLI-managed install")]
 async fn assert_suggests_managed_runtime(world: &mut E2eWorld) {
     let output = world.cli_output.as_ref().expect("no command was run");
     assert!(

tests/e2e-cucumber/tests/e2e/runtime_steps.rs

@@ -21,7 +21,7 @@ fn run_rocm(world: &E2eWorld, args: &[&str]) -> (String, String, i32) {
     )
 }
 
-#[given("a machine with no managed runtimes")]
+#[given("a machine with no CLI-managed runtimes")]
 async fn setup_no_runtimes(world: &mut E2eWorld) {
     let (stdout, _, _) = run_rocm(world, &["runtimes", "list"]);
     assert!(
@@ -54,7 +54,7 @@ async fn user_installs_sdk(world: &mut E2eWorld) {
     world.cli_output = Some(stdout);
 }
 
-#[when("the user tries to adopt the standard install as a managed runtime")]
+#[when("the user tries to adopt the existing install")]
 async fn user_tries_adopt(world: &mut E2eWorld) {
     let (stdout, stderr, rc) = run_rocm(
         world,
@@ -72,7 +72,7 @@ async fn user_tries_adopt(world: &mut E2eWorld) {
     world.cli_rc = Some(rc);
 }
 
-#[then("a managed runtime is registered")]
+#[then("a runtime is registered")]
 async fn assert_runtime_registered(world: &mut E2eWorld) {
     let (stdout, _, _) = run_rocm(world, &["runtimes", "list"]);
     assert!(
@@ -96,7 +96,7 @@ async fn assert_runtime_active(world: &mut E2eWorld) {
     );
 }
 
-#[then("the runtime includes a matching inference stack")]
+#[then("the runtime includes an inference engine")]
 async fn assert_runtime_has_stack(world: &mut E2eWorld) {
     let (stdout, _, _) = run_rocm(world, &["examine"]);
     assert!(
@@ -111,7 +111,7 @@ async fn assert_adoption_refused(world: &mut E2eWorld) {
     assert!(rc != 0, "adopt unexpectedly succeeded");
 }
 
-#[then("the error explains that only TheRock-based installs can be adopted")]
+#[then("the error explains which install types can be adopted")]
 async fn assert_adopt_error_explains(world: &mut E2eWorld) {
     let stdout = world.cli_output.as_deref().unwrap_or("");
     let stderr = world.cli_stderr.as_deref().unwrap_or("");

tests/e2e-cucumber/tests/e2e/serving_steps.rs

@@ -56,9 +56,6 @@ async fn setup_mock_custom_port(world: &mut E2eWorld) {
     world.mock = Some(mock);
 }
 
-#[given("the server is registered as a managed service")]
-async fn setup_registered_service(_world: &mut E2eWorld) {}
-
 #[given("a model is being served on GPU")]
 async fn setup_gpu_model(world: &mut E2eWorld) {
     let (stdout, _, rc) = run_rocm(
@@ -181,7 +178,7 @@ async fn assert_consistent_expansion(world: &mut E2eWorld) {
     }
 }
 
-#[then("the service appears with the correct model name and endpoint")]
+#[then("the service appears with the correct model name and connection details")]
 async fn assert_service_in_list(world: &mut E2eWorld) {
     let (stdout, _, _) = run_rocm(world, &["services", "list"]);
     let model = world.model_name.as_deref().unwrap_or("");
@@ -195,7 +192,7 @@ async fn assert_service_in_list(world: &mut E2eWorld) {
     );
 }
 
-#[then("the endpoint matches the actual server port")]
+#[then("the connection details match the actual server port")]
 async fn assert_endpoint_port(world: &mut E2eWorld) {
     let mock = world.mock.as_ref().expect("no mock server running");
     let port = mock.port();
@@ -206,7 +203,7 @@ async fn assert_endpoint_port(world: &mut E2eWorld) {
     );
 }
 
-#[then("the serve command does not fail with a dependency error")]
+#[then("the model is served successfully")]
 async fn assert_no_dependency_error(world: &mut E2eWorld) {
     let stdout = world.cli_output.as_deref().unwrap_or("");
     let stderr = world.cli_stderr.as_deref().unwrap_or("");
@@ -231,7 +228,7 @@ async fn assert_engine_auto_selected(world: &mut E2eWorld) {
     );
 }
 
-#[then("the model is reachable at the reported endpoint")]
+#[then("the model is reachable")]
 async fn assert_model_reachable(world: &mut E2eWorld) {
     let endpoint = world.endpoint.as_ref().expect("no endpoint configured");
     let url = format!("{endpoint}/models");
@@ -248,7 +245,7 @@ async fn assert_model_reachable(world: &mut E2eWorld) {
     );
 }
 
-#[then("the endpoint responds to inference requests")]
+#[then("the model responds to inference requests")]
 async fn assert_endpoint_responds(world: &mut E2eWorld) {
     crate::send_chat(world).await;
     let resp = world.chat_response.as_ref().expect("no chat response");