minitest-cli 0.41.0__tar.gz → 0.42.0__tar.gz

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.41.0
+Version: 0.42.0
 Summary: Minitest CLI – command-line interface for the Minitest testing platform
 Project-URL: Homepage, https://minitap.ai/
 Project-URL: Source, https://github.com/minitap-ai/minitest-cli
@@ -368,6 +368,53 @@ least one domain. Connectors cannot be created from the CLI: a workspace owner
 or admin creates them in the webapp, under **Workspace settings → Private
 network**.
 
+## Backend API
+
+Mini can read the OpenAPI document of a backend you own and call it during runs,
+authenticated with app vault secrets (it is off by default). `set` reads the
+current settings first and changes only what you pass.
+
+```bash
+minitest --app <app-id> apps backend-api show
+minitest --app <app-id> apps backend-api set --enable \
+  --base-url https://api.staging.example.com \
+  --openapi-url https://api.staging.example.com/openapi.json \
+  --secret API_TOKEN [--remove-secret <name> ...] [--clear-secrets] \
+  [--skill <name-or-id> | --clear-skill]
+minitest --app <app-id> apps backend-api set --disable
+```
+
+Secrets are named references to the app vault (`minitest secret set`); `show`
+warns about names no longer in the vault. URLs must be public `http(s)`
+addresses: private, loopback and cloud-metadata addresses are rejected.
+
+When the OpenAPI document itself needs authentication, say how to download it.
+The credential comes from the app vault, is used for that download only, and is
+sent only to the saved OpenAPI URL's origin (a one-run OpenAPI URL on another
+origin gets none):
+
+```bash
+minitest --app <app-id> apps backend-api set --openapi-auth bearer --openapi-auth-secret API_TOKEN
+minitest --app <app-id> apps backend-api set --openapi-auth header \
+  --openapi-auth-header X-Api-Key --openapi-auth-secret API_TOKEN
+minitest --app <app-id> apps backend-api set --openapi-auth basic \
+  --openapi-auth-username docs-reader --openapi-auth-secret DOCS_PASSWORD
+minitest --app <app-id> apps backend-api set --openapi-auth query \
+  --openapi-auth-param api_key --openapi-auth-secret API_TOKEN
+minitest --app <app-id> apps backend-api set --openapi-auth none
+```
+
+To point one run at another backend, pass `--backend-base-url` and/or
+`--backend-openapi-url` to `run start`, `run all` or `run from-commit`. Only
+that run uses them; the saved settings do not change, and the app's backend API
+must be on.
+
+```bash
+minitest --app <app-id> run all --web \
+  --backend-base-url https://pr-42.api.example.com \
+  --backend-openapi-url https://pr-42.api.example.com/openapi.json
+```
+
 ## Exit Codes
 
 | Code | Meaning                                            |

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/README.md

@@ -334,6 +334,53 @@ least one domain. Connectors cannot be created from the CLI: a workspace owner
 or admin creates them in the webapp, under **Workspace settings → Private
 network**.
 
+## Backend API
+
+Mini can read the OpenAPI document of a backend you own and call it during runs,
+authenticated with app vault secrets (it is off by default). `set` reads the
+current settings first and changes only what you pass.
+
+```bash
+minitest --app <app-id> apps backend-api show
+minitest --app <app-id> apps backend-api set --enable \
+  --base-url https://api.staging.example.com \
+  --openapi-url https://api.staging.example.com/openapi.json \
+  --secret API_TOKEN [--remove-secret <name> ...] [--clear-secrets] \
+  [--skill <name-or-id> | --clear-skill]
+minitest --app <app-id> apps backend-api set --disable
+```
+
+Secrets are named references to the app vault (`minitest secret set`); `show`
+warns about names no longer in the vault. URLs must be public `http(s)`
+addresses: private, loopback and cloud-metadata addresses are rejected.
+
+When the OpenAPI document itself needs authentication, say how to download it.
+The credential comes from the app vault, is used for that download only, and is
+sent only to the saved OpenAPI URL's origin (a one-run OpenAPI URL on another
+origin gets none):
+
+```bash
+minitest --app <app-id> apps backend-api set --openapi-auth bearer --openapi-auth-secret API_TOKEN
+minitest --app <app-id> apps backend-api set --openapi-auth header \
+  --openapi-auth-header X-Api-Key --openapi-auth-secret API_TOKEN
+minitest --app <app-id> apps backend-api set --openapi-auth basic \
+  --openapi-auth-username docs-reader --openapi-auth-secret DOCS_PASSWORD
+minitest --app <app-id> apps backend-api set --openapi-auth query \
+  --openapi-auth-param api_key --openapi-auth-secret API_TOKEN
+minitest --app <app-id> apps backend-api set --openapi-auth none
+```
+
+To point one run at another backend, pass `--backend-base-url` and/or
+`--backend-openapi-url` to `run start`, `run all` or `run from-commit`. Only
+that run uses them; the saved settings do not change, and the app's backend API
+must be on.
+
+```bash
+minitest --app <app-id> run all --web \
+  --backend-base-url https://pr-42.api.example.com \
+  --backend-openapi-url https://pr-42.api.example.com/openapi.json
+```
+
 ## Exit Codes
 
 | Code | Meaning                                            |

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitest-cli"
-version = "0.41.0"
+version = "0.42.0"
 description = "Minitest CLI – command-line interface for the Minitest testing platform"
 readme = "README.md"
 license = "MIT"

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/src/minitest_cli/commands/app_network_helpers.py

@@ -38,12 +38,12 @@ def fail(message: str, code: int = EXIT_GENERAL_ERROR) -> typer.Exit:
     return typer.Exit(code=code)
 
 
-def _raise_for_status(resp: httpx.Response) -> None:
+def _raise_for_status(resp: httpx.Response, forbidden: str) -> None:
     if resp.status_code < 400:
         return
     detail = extract_detail(resp)
     if resp.status_code == 403:
-        raise fail(f"{ADMIN_ONLY_MESSAGE} ({detail})", EXIT_AUTH_ERROR)
+        raise fail(f"{forbidden} ({detail})", EXIT_AUTH_ERROR)
     if resp.status_code == 401:
         raise fail(f"Authentication failed: {detail}", EXIT_AUTH_ERROR)
     if resp.status_code == 404:
@@ -54,12 +54,17 @@ def _raise_for_status(resp: httpx.Response) -> None:
 
 
 def call_api(
-    settings: Settings, method: str, path: str, body: dict[str, Any] | None = None
+    settings: Settings,
+    method: str,
+    path: str,
+    body: dict[str, Any] | None = None,
+    *,
+    forbidden: str = ADMIN_ONLY_MESSAGE,
 ) -> dict[str, Any]:
     async def _run() -> dict[str, Any]:
         async with ApiClient(settings) as client:
             resp = await client.request(method, path, json=body)
-        _raise_for_status(resp)
+        _raise_for_status(resp, forbidden)
         try:
             return resp.json()
         except ValueError as exc:

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/src/minitest_cli/commands/apps.py

@@ -12,6 +12,7 @@ from minitest_cli.api.client import ApiClient
 from minitest_cli.api.errors import format_network_error
 from minitest_cli.commands import (
     apps_dependencies,
+    backend_api,
     apps_get,
     private_network,
     residential_proxy,
@@ -38,6 +39,7 @@ app.command(name="dependencies")(apps_dependencies.dependencies)
 app.command(name="get")(apps_get.get_app)
 app.add_typer(residential_proxy.app)
 app.add_typer(private_network.app)
+app.add_typer(backend_api.app)
 
 
 @app.callback()

minitest_cli-0.42.0/src/minitest_cli/commands/backend_api.py

@@ -0,0 +1,152 @@
+"""'apps backend-api': the backend Mini reads an OpenAPI document of and calls during runs."""
+
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.commands.app_network_helpers import call_api, fail, is_json_mode, resolve_target
+from minitest_cli.core.config import Settings
+from minitest_cli.commands.app_skill_helpers import skills_path
+from minitest_cli.commands.backend_api_helpers import (
+    merge_secret_names,
+    openapi_auth_body,
+    render_config,
+)
+from minitest_cli.utils.output import print_success
+
+app = typer.Typer(
+    name="backend-api",
+    help=(
+        "Backend API of the app (--app): during runs Mini searches its OpenAPI document and "
+        "calls it, authenticated with app vault secrets. Off by default."
+    ),
+    no_args_is_help=True,
+)
+
+
+def _path(app_id: str) -> str:
+    return f"/api/v1/apps/{app_id}/backend-config"
+
+
+def _call(
+    settings: Settings, method: str, path: str, body: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    return call_api(settings, method, path, body, forbidden="You cannot access this app.")
+
+
+@app.command(name="show")
+def show() -> None:
+    """Show the app's backend API settings."""
+    settings, app_id = resolve_target()
+    render_config(_call(settings, "GET", _path(app_id)))
+
+
+@app.command(name="set")
+def set_config(
+    enable: Annotated[
+        bool | None,
+        typer.Option(
+            "--enable/--disable",
+            help="Switch it on or off. On needs a base URL and an OpenAPI URL.",
+        ),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option("--base-url", help="Base URL Mini calls, e.g. https://api.staging.example."),
+    ] = None,
+    openapi_url: Annotated[
+        str | None,
+        typer.Option("--openapi-url", help="URL of the OpenAPI (or Swagger) document."),
+    ] = None,
+    secret: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--secret",
+            help="App vault secret Mini authenticates calls with (repeatable), e.g. API_TOKEN.",
+        ),
+    ] = None,
+    remove_secret: Annotated[
+        list[str] | None,
+        typer.Option("--remove-secret", help="Authentication secret to drop (repeatable)."),
+    ] = None,
+    clear_secrets: Annotated[
+        bool,
+        typer.Option("--clear-secrets", help="Drop every current secret before adding --secret."),
+    ] = False,
+    skill: Annotated[
+        str | None,
+        typer.Option("--skill", help="App skill (name or id) explaining how to use the backend."),
+    ] = None,
+    clear_skill: Annotated[
+        bool, typer.Option("--clear-skill", help="Stop pointing Mini at a skill.")
+    ] = False,
+    openapi_auth: Annotated[
+        str | None,
+        typer.Option(
+            "--openapi-auth",
+            help=(
+                "How the OpenAPI document is downloaded when it needs authentication: none, "
+                "bearer, header, basic or query. Used for nothing else, and only sent to the "
+                "saved OpenAPI URL's origin."
+            ),
+        ),
+    ] = None,
+    openapi_auth_secret: Annotated[
+        str | None,
+        typer.Option("--openapi-auth-secret", help="App vault secret holding the credential."),
+    ] = None,
+    openapi_auth_header: Annotated[
+        str | None, typer.Option("--openapi-auth-header", help="Header name, for header.")
+    ] = None,
+    openapi_auth_username: Annotated[
+        str | None, typer.Option("--openapi-auth-username", help="Username, for basic.")
+    ] = None,
+    openapi_auth_param: Annotated[
+        str | None, typer.Option("--openapi-auth-param", help="Query parameter, for query.")
+    ] = None,
+) -> None:
+    """Change the app's backend API settings; options not passed stay as they are."""
+    if skill and clear_skill:
+        raise fail("Pass either --skill or --clear-skill, not both.")
+    changes = [enable is not None, base_url, openapi_url, secret, remove_secret, clear_secrets]
+    auth_names = {
+        "--openapi-auth-header": openapi_auth_header,
+        "--openapi-auth-username": openapi_auth_username,
+        "--openapi-auth-param": openapi_auth_param,
+    }
+    auth_given = any([openapi_auth, openapi_auth_secret, *auth_names.values()])
+    if not any([*changes, skill, clear_skill, auth_given]):
+        raise fail(
+            "Nothing to change: pass --enable/--disable, --base-url, --openapi-url, "
+            "a secret option, a skill option or an --openapi-auth option."
+        )
+    settings, app_id = resolve_target()
+    current = _call(settings, "GET", _path(app_id))
+    body: dict[str, Any] = {
+        "enabled": current["enabled"] if enable is None else enable,
+        "baseUrl": current["baseUrl"] if base_url is None else base_url,
+        "openapiUrl": current["openapiUrl"] if openapi_url is None else openapi_url,
+        "authenticationSecretNames": merge_secret_names(
+            current["authenticationSecretNames"],
+            add=secret,
+            remove=remove_secret,
+            clear=clear_secrets,
+        ),
+        "skillId": current["skill"]["id"] if current["skill"] else None,
+    }
+    if auth_given:
+        body["openapiAuth"] = openapi_auth_body(
+            current["openapiAuth"],
+            auth_type=openapi_auth,
+            secret=openapi_auth_secret,
+            names=auth_names,
+        )
+    if clear_skill:
+        body["skillId"] = None
+    elif skill:
+        body["skillId"] = _call(settings, "GET", f"{skills_path(app_id)}/{skill}")["id"]
+
+    updated = _call(settings, "PUT", _path(app_id), body)
+    if not is_json_mode():
+        print_success("Backend API updated.")
+    render_config(updated)

minitest_cli-0.42.0/src/minitest_cli/commands/backend_api_helpers.py

@@ -0,0 +1,93 @@
+"""Rendering and secret-list editing for 'apps backend-api'."""
+
+from typing import Any
+
+from minitest_cli.commands.app_network_helpers import fail, is_json_mode, on_off
+from minitest_cli.utils.output import print_json, print_warning
+
+
+def merge_secret_names(
+    current: list[str], *, add: list[str] | None, remove: list[str] | None, clear: bool
+) -> list[str]:
+    """Apply ``--clear-secrets``, ``--remove-secret`` then ``--secret``."""
+    removed = {name.strip() for name in remove or []}
+    unknown = sorted(removed - set(current))
+    if unknown:
+        raise fail(f"Not an authentication secret of this app: {', '.join(unknown)}.")
+    base = [] if clear else [name for name in current if name not in removed]
+    return list(dict.fromkeys([*base, *(name.strip() for name in add or [])]))
+
+
+OPENAPI_AUTH_TYPES = ("none", "bearer", "header", "basic", "query")
+_AUTH_NAME_FIELD = {
+    "header": ("headerName", "--openapi-auth-header"),
+    "basic": ("username", "--openapi-auth-username"),
+    "query": ("paramName", "--openapi-auth-param"),
+}
+
+
+def openapi_auth_body(
+    current: dict[str, Any],
+    *,
+    auth_type: str | None,
+    secret: str | None,
+    names: dict[str, str | None],
+) -> dict[str, Any]:
+    """Apply the --openapi-auth options to the saved setting; ``names`` is keyed by option."""
+    kind = auth_type or current["type"]
+    if kind not in OPENAPI_AUTH_TYPES:
+        raise fail(f"--openapi-auth must be one of: {', '.join(OPENAPI_AUTH_TYPES)}.")
+    field = _AUTH_NAME_FIELD.get(kind)
+    stray = [
+        option for option, value in names.items() if value and (not field or option != field[1])
+    ]
+    if kind == "none" and secret:
+        stray.insert(0, "--openapi-auth-secret")
+    if stray:
+        raise fail(f"{', '.join(stray)} does not apply to --openapi-auth {kind}.")
+    if kind == "none":
+        return {"type": "none"}
+    same = current["type"] == kind
+    body = {"type": kind, "secretName": secret or (current.get("secretName") if same else None)}
+    if field:
+        body[field[0]] = names[field[1]] or (current.get(field[0]) if same else None)
+    required = [("--openapi-auth-secret", body["secretName"])] + (
+        [(field[1], body[field[0]])] if field else []
+    )
+    missing = [option for option, value in required if not value]
+    if missing:
+        raise fail(f"--openapi-auth {kind} needs {' and '.join(missing)}.")
+    return body
+
+
+def _describe_openapi_auth(auth: dict[str, Any]) -> str:
+    if auth["type"] == "none":
+        return "none"
+    field = _AUTH_NAME_FIELD.get(auth["type"])
+    detail = f" {field[0]}={auth[field[0]]}" if field else ""
+    return f"{auth['type']}{detail} secret={auth['secretName']}"
+
+
+def render_config(config: dict[str, Any]) -> None:
+    if is_json_mode():
+        print_json(config)
+    else:
+        skill = config["skill"]
+        print(f"Enabled: {on_off(config['enabled'])}")  # noqa: T201
+        print(f"Base URL: {config['baseUrl'] or '-'}")  # noqa: T201
+        print(f"OpenAPI URL: {config['openapiUrl'] or '-'}")  # noqa: T201
+        secrets = ", ".join(config["authenticationSecretNames"]) or "-"
+        print(f"Authentication secrets: {secrets}")  # noqa: T201
+        print(f"Skill: {skill['name'] + ' ' + skill['id'] if skill else '-'}")  # noqa: T201
+        print(f"OpenAPI download: {_describe_openapi_auth(config['openapiAuth'])}")  # noqa: T201
+    missing = config["missingSecretNames"]
+    if missing:
+        print_warning(
+            f"Not in the app vault anymore: {', '.join(missing)}. Create them with "
+            "'minitest secret set' or drop them with --remove-secret."
+        )
+    if config["openapiAuthSecretMissing"]:
+        print_warning(
+            f"The OpenAPI download secret {config['openapiAuth']['secretName']} is not in the "
+            "app vault anymore: runs will not start until it is created again or replaced."
+        )

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/src/minitest_cli/commands/run.py

@@ -18,6 +18,11 @@ from minitest_cli.commands.run_helpers import (
     run_api_call,
     TERMINAL_STATUSES,
 )
+from minitest_cli.commands.run_backend_override import (
+    BackendBaseUrlOpt,
+    BackendOpenapiUrlOpt,
+    backend_api_override,
+)
 from minitest_cli.commands.run_cancel import cancel
 from minitest_cli.commands.run_commit import from_commit
 from minitest_cli.commands.run_targets import (
@@ -34,7 +39,7 @@ from minitest_cli.commands.run_feedback import feedback
 from minitest_cli.commands.run_list import list_runs
 from minitest_cli.commands.run_logs import register_logs_command
 from minitest_cli.commands.run_recording import register_recording_commands
-from minitest_cli.commands.run_tagged import print_batch_started, start_tagged
+from minitest_cli.commands.run_tagged import print_batch_started, start_selected, start_tagged
 from minitest_cli.commands.verdicts import verdicts
 from minitest_cli.models.batch import BatchResponse, CreateBatchRequest
 from minitest_cli.models.story_run import (
@@ -54,8 +59,9 @@ app = typer.Typer(
 
 @app.command()
 def start(
-    user_story: Annotated[
-        str | None, typer.Argument(help="Scenario name or UUID to run. Excludes --tag.")
+    user_stories: Annotated[
+        list[str] | None,
+        typer.Argument(help="Scenario names or UUIDs to run (one or more). Excludes --tag."),
     ] = None,
     tag: Annotated[
         list[str] | None,
@@ -68,13 +74,18 @@ def start(
     android_device_type: AndroidDeviceTypeOpt = None,
     ios_physical: IosPhysicalOpt = False,
     android_physical: AndroidPhysicalOpt = False,
+    backend_base_url: BackendBaseUrlOpt = None,
+    backend_openapi_url: BackendOpenapiUrlOpt = None,
     watch: Annotated[
         bool, typer.Option("--watch/--no-watch", help="Poll for results (default: watch).")
     ] = True,
 ) -> None:
-    """Start a run for one scenario, or for every scenario carrying --tag."""
-    if (user_story is None) == (not tag):
-        print_error("Pass either a scenario or --tag, not both or neither.")
+    """Start a run for one or more scenarios, or for every scenario carrying --tag.
+
+    Several scenarios, like --tag, start one run and print its summary without polling.
+    """
+    if bool(user_stories) == bool(tag):
+        print_error("Pass either scenarios or --tag, not both or neither.")
         raise typer.Exit(code=1)
     settings, app_id, json_mode = resolve_app()
     targets = build_targets(
@@ -86,15 +97,22 @@ def start(
         ios_physical,
         android_physical,
     )
-    if tag:
-        print_batch_started(start_tagged(settings, app_id, tag, targets), json_mode)
+    override = backend_api_override(backend_base_url, backend_openapi_url)
+    story_refs = list(dict.fromkeys(user_stories or []))
+    if tag or len(story_refs) > 1:
+        start_batch = start_tagged if tag else start_selected
+        print_batch_started(
+            start_batch(settings, app_id, tag or story_refs, targets, override), json_mode
+        )
         return
-    story_ref = user_story or ""
+    story_ref = story_refs[0]
 
     async def _start() -> StoryRunResponse:
         async with ApiClient(settings) as client:
             user_story_id = await resolve_user_story_id(client, app_id, story_ref)
-            body = CreateBatchRequest(user_story_ids=[user_story_id], targets=targets)
+            body = CreateBatchRequest(
+                user_story_ids=[user_story_id], targets=targets, backend_api_override=override
+            )
             batch = await post_batch(client, app_id, body)
             if not batch.story_runs:
                 print_error("Batch created but no scenario runs were returned.")
@@ -147,6 +165,8 @@ def run_all(
     android_device_type: AndroidDeviceTypeOpt = None,
     ios_physical: IosPhysicalOpt = False,
     android_physical: AndroidPhysicalOpt = False,
+    backend_base_url: BackendBaseUrlOpt = None,
+    backend_openapi_url: BackendOpenapiUrlOpt = None,
 ) -> None:
     """Start a run covering every scenario of the app."""
     settings, app_id, json_mode = resolve_app()
@@ -162,7 +182,10 @@ def run_all(
 
     async def _run_all() -> BatchResponse:
         async with ApiClient(settings) as client:
-            body = CreateBatchRequest(targets=targets)
+            body = CreateBatchRequest(
+                targets=targets,
+                backend_api_override=backend_api_override(backend_base_url, backend_openapi_url),
+            )
             return await post_batch(client, app_id, body)
 
     print_batch_started(run_api_call(_run_all()), json_mode)

minitest_cli-0.42.0/src/minitest_cli/commands/run_backend_override.py

@@ -0,0 +1,30 @@
+"""One-run backend API URL flags shared by the commands that start runs."""
+
+from typing import Annotated
+
+import typer
+
+from minitest_cli.models.batch import BackendApiRunOverride
+
+BackendBaseUrlOpt = Annotated[
+    str | None,
+    typer.Option(
+        "--backend-base-url",
+        help="Backend API base URL for this run only (the app's backend API must be on).",
+    ),
+]
+BackendOpenapiUrlOpt = Annotated[
+    str | None,
+    typer.Option(
+        "--backend-openapi-url",
+        help="OpenAPI document URL for this run only (the app's backend API must be on).",
+    ),
+]
+
+
+def backend_api_override(
+    base_url: str | None, openapi_url: str | None
+) -> BackendApiRunOverride | None:
+    if base_url is None and openapi_url is None:
+        return None
+    return BackendApiRunOverride(base_url=base_url, openapi_url=openapi_url)

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/src/minitest_cli/commands/run_commit.py

@@ -18,6 +18,11 @@ from minitest_cli.commands.run_commit_helpers import (
     batch_commit_payload,
     poll_batch,
 )
+from minitest_cli.commands.run_backend_override import (
+    BackendBaseUrlOpt,
+    BackendOpenapiUrlOpt,
+    backend_api_override,
+)
 from minitest_cli.commands.run_helpers import (
     resolve_app,
     resolve_user_story_id,
@@ -64,6 +69,8 @@ def from_commit(
     legacy_user_story: LegacyUserStoryOpt = None,
     watch: WatchOpt = True,
     timeout: TimeoutOpt = DEFAULT_TIMEOUT_SECONDS,
+    backend_base_url: BackendBaseUrlOpt = None,
+    backend_openapi_url: BackendOpenapiUrlOpt = None,
 ) -> None:
     """Build a GitHub commit and run the test suite against it."""
     settings, app_id, json_mode = resolve_app()
@@ -86,6 +93,7 @@ def from_commit(
                 commit_sha=sha,
                 platforms=platforms if targets is None else None,
                 targets=targets,
+                backend_api_override=backend_api_override(backend_base_url, backend_openapi_url),
             )
             batch = await post_batch(client, app_id, body)
             if not watch:

{minitest_cli-0.41.0 → minitest_cli-0.42.0}/src/minitest_cli/commands/run_tagged.py

@@ -1,14 +1,20 @@
-"""Batch launch over every scenario carrying a tag, and the shared batch summary output."""
+"""Batch launch over a scenario selection (several scenarios, or every scenario carrying a
+tag), and the shared batch summary output."""
 
 import typer
 
 from minitest_cli.api.client import ApiClient
 from minitest_cli.commands.batch_helpers import batch_summary_payload, post_batch
-from minitest_cli.commands.run_helpers import RUN_TABLE_HEADERS, format_run_row, run_api_call
+from minitest_cli.commands.run_helpers import (
+    RUN_TABLE_HEADERS,
+    format_run_row,
+    resolve_user_story_id,
+    run_api_call,
+)
 from minitest_cli.commands.tags_helpers import resolve_tag_ids
 from minitest_cli.commands.user_story_helpers import EXIT_NOT_FOUND, fetch_all_user_stories
 from minitest_cli.core.config import Settings
-from minitest_cli.models.batch import BatchResponse, CreateBatchRequest
+from minitest_cli.models.batch import BackendApiRunOverride, BatchResponse, CreateBatchRequest
 from minitest_cli.models.targets import BatchTarget
 from minitest_cli.utils.output import print_error, print_info, print_json, print_table
 
@@ -26,7 +32,11 @@ def print_batch_started(batch: BatchResponse, json_mode: bool) -> None:
 
 
 def start_tagged(
-    settings: Settings, app_id: str, tags: list[str], targets: list[BatchTarget]
+    settings: Settings,
+    app_id: str,
+    tags: list[str],
+    targets: list[BatchTarget],
+    backend_api_override: BackendApiRunOverride | None = None,
 ) -> BatchResponse:
     async def _start() -> BatchResponse:
         async with ApiClient(settings) as client:
@@ -37,7 +47,35 @@ def start_tagged(
                 print_error(f"No scenario carries any of these tags: {', '.join(tags)}.")
                 raise typer.Exit(code=EXIT_NOT_FOUND)
             body = CreateBatchRequest(
-                user_story_ids=[str(s["id"]) for s in stories], targets=targets
+                user_story_ids=[str(s["id"]) for s in stories],
+                targets=targets,
+                backend_api_override=backend_api_override,
+            )
+            return await post_batch(client, app_id, body)
+
+    return run_api_call(_start())
+
+
+def start_selected(
+    settings: Settings,
+    app_id: str,
+    story_refs: list[str],
+    targets: list[BatchTarget],
+    backend_api_override: BackendApiRunOverride | None = None,
+) -> BatchResponse:
+    """Start one batch covering the given scenarios (names or UUIDs).
+
+    Only the selected scenarios run: dependencies between them are kept, and a
+    scenario whose parent is not selected starts on its own.
+    """
+
+    async def _start() -> BatchResponse:
+        async with ApiClient(settings) as client:
+            story_ids = [await resolve_user_story_id(client, app_id, ref) for ref in story_refs]
+            body = CreateBatchRequest(
+                user_story_ids=list(dict.fromkeys(story_ids)),
+                targets=targets,
+                backend_api_override=backend_api_override,
             )
             return await post_batch(client, app_id, body)