minitest-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minitest-cli
-Version: 0.6.0
+Version: 0.7.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
@@ -118,7 +118,7 @@ minitest run --app <app-id>
 | ---------------- | ------------------------- |
 | `minitest auth`  | Authentication management |
 | `minitest apps`  | App management            |
-| `minitest flow`  | Testing flow operations   |
+| `minitest user-story` | User-story operations |
 | `minitest build` | Build management          |
 | `minitest run`   | Test execution            |
 

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/README.md

@@ -85,7 +85,7 @@ minitest run --app <app-id>
 | ---------------- | ------------------------- |
 | `minitest auth`  | Authentication management |
 | `minitest apps`  | App management            |
-| `minitest flow`  | Testing flow operations   |
+| `minitest user-story` | User-story operations |
 | `minitest build` | Build management          |
 | `minitest run`   | Test execution            |
 

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/pyproject.toml

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

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/src/minitest_cli/commands/apps.py

@@ -61,7 +61,7 @@ def list_apps() -> None:
         raise typer.Exit(code=EXIT_NETWORK_ERROR) from exc
 
     if json_mode:
-        print_json([a.model_dump(mode="json") for a in data.apps])
+        print_json([a.model_dump(mode="json", by_alias=True) for a in data.apps])
         return
 
     rows = [[a.id, a.name] for a in data.apps]

minitest_cli-0.7.0/src/minitest_cli/commands/batch.py

@@ -0,0 +1,169 @@
+"""Batch commands: list, get, cancel."""
+
+import math
+from typing import Annotated
+
+import typer
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.batch_helpers import batches_base_path
+from minitest_cli.commands.run_helpers import (
+    ensure_uuid,
+    handle_response_error,
+    resolve_app,
+    run_api_call,
+)
+from minitest_cli.models.story_run import (
+    BatchListItem,
+    BatchListResponse,
+    BatchResponse,
+)
+from minitest_cli.utils.output import (
+    output,
+    print_info,
+    print_success,
+    print_table,
+)
+
+app = typer.Typer(name="batch", help="Manage batch runs (multi-story executions).")
+
+BATCH_TABLE_HEADERS = ["ID", "Status", "Source", "Commit", "Tag", "Story runs", "Created"]
+
+
+def _format_batch_row(item: BatchListItem) -> list[str]:
+    return [
+        item.id,
+        item.status.value,
+        item.source,
+        (item.commit_sha or "")[:10],
+        item.tag_name or "",
+        str(len(item.story_runs)),
+        item.created_at.strftime("%Y-%m-%d %H:%M"),
+    ]
+
+
+@app.command(name="list")
+def list_batches(
+    page: Annotated[int, typer.Option(help="Page number.")] = 1,
+    page_size: Annotated[int, typer.Option(help="Items per page (max 100).")] = 20,
+    status_filter: Annotated[
+        list[str] | None,
+        typer.Option("--status", help="Filter by status (repeatable)."),
+    ] = None,
+    result_filter: Annotated[
+        list[str] | None,
+        typer.Option("--result", help="Filter by derived result (repeatable)."),
+    ] = None,
+    commit_sha: Annotated[str | None, typer.Option("--commit-sha")] = None,
+    user_story_id: Annotated[str | None, typer.Option("--user-story-id")] = None,
+    search: Annotated[str | None, typer.Option("--search")] = None,
+    all_pages: Annotated[bool, typer.Option("--all", help="Fetch all pages.")] = False,
+) -> None:
+    """List batches for the current app."""
+    settings, app_id, json_mode = resolve_app()
+    if all_pages:
+        page, page_size = 1, 100
+
+    params: dict[str, object] = {"page": page, "page_size": page_size}
+    if status_filter:
+        params["status"] = status_filter
+    if result_filter:
+        params["result"] = result_filter
+    if commit_sha:
+        params["commit_sha"] = commit_sha
+    if user_story_id:
+        params["user_story_id"] = user_story_id
+    if search:
+        params["search"] = search
+
+    async def _list() -> BatchListResponse:
+        async with ApiClient(settings) as client:
+            resp = await client.get(batches_base_path(app_id), params=params)
+            handle_response_error(resp, resource="Batches")
+            return BatchListResponse.model_validate(resp.json())
+
+    result = run_api_call(_list())
+
+    if json_mode:
+        output(result.model_dump(mode="json", by_alias=True), json_mode=True)
+        return
+
+    if not result.items:
+        print_info("No batches found.")
+        return
+
+    total_pages = math.ceil(result.total / result.page_size) if result.total else 1
+    start = (result.page - 1) * result.page_size + 1
+    end = min(result.page * result.page_size, result.total)
+    title = (
+        f"Batches — page {result.page} of {total_pages}, showing {start}–{end} of {result.total}"
+    )
+    rows = [_format_batch_row(item) for item in result.items]
+    print_table(BATCH_TABLE_HEADERS, rows, title=title)
+    if result.page < total_pages:
+        print_info(f"Use --page {result.page + 1} to see more, or --all to fetch everything.")
+
+
+@app.command(name="get")
+def get_batch(
+    batch_id: Annotated[str, typer.Argument(help="Batch ID.")],
+) -> None:
+    """Get a single batch with its story runs."""
+    settings, app_id, json_mode = resolve_app()
+    ensure_uuid(batch_id, kind="batch id")
+
+    async def _get() -> BatchResponse:
+        async with ApiClient(settings) as client:
+            resp = await client.get(f"{batches_base_path(app_id)}/{batch_id}")
+            handle_response_error(resp, resource="Batch")
+            return BatchResponse.model_validate(resp.json())
+
+    batch = run_api_call(_get())
+
+    if json_mode:
+        output(batch.model_dump(mode="json", by_alias=True), json_mode=True)
+        return
+
+    print_info(f"Batch {batch.id} — {batch.status.value} ({batch.source})")
+    if batch.commit_sha:
+        print_info(f"  commit: {batch.commit_sha}")
+    if batch.tag_name:
+        print_info(f"  tag: {batch.tag_name}")
+
+    rows: list[list[str]] = []
+    for r in batch.story_runs:
+        rows.append(
+            [
+                r.id,
+                r.user_story_name or r.user_story_id,
+                r.status.value,
+                r.created_at.strftime("%Y-%m-%d %H:%M"),
+            ]
+        )
+    if rows:
+        print_table(
+            ["Run ID", "User Story", "Status", "Created"],
+            rows,
+            title=f"Story runs ({len(rows)})",
+        )
+
+
+@app.command()
+def cancel(
+    batch_id: Annotated[str, typer.Argument(help="Batch ID to cancel.")],
+) -> None:
+    """Cancel a batch and all its pending/running story runs."""
+    settings, app_id, json_mode = resolve_app()
+    ensure_uuid(batch_id, kind="batch id")
+
+    async def _cancel() -> BatchResponse:
+        async with ApiClient(settings) as client:
+            resp = await client.post(f"{batches_base_path(app_id)}/{batch_id}/cancel")
+            handle_response_error(resp, resource="Batch")
+            return BatchResponse.model_validate(resp.json())
+
+    batch = run_api_call(_cancel())
+    if json_mode:
+        output(batch.model_dump(mode="json", by_alias=True), json_mode=True)
+    else:
+        print_success(f"Batch cancelled: {batch.id} (status: {batch.status.value})")

minitest_cli-0.7.0/src/minitest_cli/commands/batch_helpers.py

@@ -0,0 +1,38 @@
+"""Helpers for batch-related endpoints."""
+
+from typing import Any
+
+from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.run_helpers import handle_response_error
+from minitest_cli.models.story_run import BatchResponse, CreateBatchRequest
+
+
+def batches_base_path(app_id: str) -> str:
+    """Return the base API path for batches."""
+    return f"/api/v1/apps/{app_id}/batches"
+
+
+async def post_batch(client: ApiClient, app_id: str, body: CreateBatchRequest) -> BatchResponse:
+    """POST a CreateBatchRequest and return a BatchResponse; handles errors."""
+    resp = await client.post(
+        batches_base_path(app_id),
+        json=body.model_dump(by_alias=True, exclude_none=True),
+    )
+    handle_response_error(resp, resource="Batch")
+    return BatchResponse.model_validate(resp.json())
+
+
+def batch_summary_payload(batch: BatchResponse) -> dict[str, Any]:
+    """Serialise a batch to a compact JSON payload for --json output (camelCase)."""
+    return {
+        "batchId": batch.id,
+        "status": batch.status.value,
+        "storyRuns": [
+            {
+                "runId": r.id,
+                "userStory": r.user_story_name or r.user_story_id,
+                "status": r.status.value,
+            }
+            for r in batch.story_runs
+        ],
+    }

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/src/minitest_cli/commands/build.py

@@ -74,7 +74,7 @@ def upload(
         return BuildResponse.model_validate(resp.json())
 
     result = run_api_call(_run())
-    result_dict = result.model_dump(mode="json")
+    result_dict = result.model_dump(mode="json", by_alias=True)
 
     if json_mode:
         output(result_dict, json_mode=True)
@@ -113,7 +113,7 @@ def list_builds(
     result = run_api_call(_run())
 
     if json_mode:
-        output(result.model_dump(mode="json"), json_mode=True)
+        output(result.model_dump(mode="json", by_alias=True), json_mode=True)
         return
 
     if not result.items:

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/src/minitest_cli/commands/maintenance_check.py

@@ -43,9 +43,9 @@ def maintenance_check(
         print_json(
             {
                 "id": result.id,
-                "app_id": result.app_id,
-                "commit_sha": result.commit_sha,
-                "created_at": result.created_at,
+                "appId": result.app_id,
+                "commitSha": result.commit_sha,
+                "createdAt": result.created_at,
             }
         )
     else:

minitest_cli-0.7.0/src/minitest_cli/commands/run.py

@@ -0,0 +1,199 @@
+"""Test execution commands: start, status, list, cancel, run all."""
+
+from typing import Annotated
+
+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 (
+    base_path,
+    display_run_result,
+    ensure_uuid,
+    fetch_runs,
+    format_run_pagination_info,
+    format_run_row,
+    handle_response_error,
+    poll_run_status,
+    resolve_app,
+    resolve_user_story_id,
+    run_api_call,
+    RUN_TABLE_HEADERS,
+    TERMINAL_STATUSES,
+)
+from minitest_cli.models.story_run import (
+    BatchResponse,
+    CreateBatchRequest,
+    StoryRunListResponse,
+    StoryRunResponse,
+)
+from minitest_cli.utils.output import (
+    output,
+    print_error,
+    print_info,
+    print_json,
+    print_success,
+    print_table,
+)
+
+app = typer.Typer(name="run", help="Test execution.")
+
+IosBuildOpt = Annotated[
+    str | None, typer.Option("--ios-build", help="iOS build ID (omit for Android-only apps).")
+]
+AndroidBuildOpt = Annotated[
+    str | None, typer.Option("--android-build", help="Android build ID (omit for iOS-only apps).")
+]
+
+
+def _require_build(ios_build: str | None, android_build: str | None) -> None:
+    if not ios_build and not android_build:
+        print_error("Provide at least one of --ios-build or --android-build.")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def start(
+    user_story: Annotated[str, typer.Argument(help="User-story name or UUID to run.")],
+    ios_build: IosBuildOpt = None,
+    android_build: AndroidBuildOpt = None,
+    watch: Annotated[
+        bool, typer.Option("--watch/--no-watch", help="Poll for results (default: watch).")
+    ] = True,
+) -> None:
+    """Start a new test run for a user story (via the batches endpoint)."""
+    settings, app_id, json_mode = resolve_app()
+    _require_build(ios_build, android_build)
+
+    async def _start() -> StoryRunResponse:
+        async with ApiClient(settings) as client:
+            user_story_id = await resolve_user_story_id(client, app_id, user_story)
+            body = CreateBatchRequest(
+                user_story_ids=[user_story_id],
+                ios_build_id=ios_build,
+                android_build_id=android_build,
+            )
+            batch = await post_batch(client, app_id, body)
+            if not batch.story_runs:
+                print_error("Batch created but no story runs were returned.")
+                raise typer.Exit(code=3)
+            run = batch.story_runs[0]
+            if not watch:
+                return run
+            return await poll_run_status(client, app_id, run.id, json_mode)
+
+    run = run_api_call(_start())
+    if not watch:
+        if json_mode:
+            print_json({"runId": run.id, "status": run.status.value})
+        else:
+            print_success(f"Run started: {run.id}")
+            print_info(f"Use `minitest run status {run.id}` to check progress.")
+        return
+    display_run_result(run, json_mode)
+
+
+@app.command()
+def status(
+    run_id: Annotated[str, typer.Argument(help="Run ID to check.")],
+    watch: Annotated[
+        bool, typer.Option("--watch/--no-watch", help="Poll for results (default: no-watch).")
+    ] = False,
+) -> None:
+    """Check the status of a test run."""
+    settings, app_id, json_mode = resolve_app()
+    ensure_uuid(run_id, kind="run id")
+
+    async def _status() -> StoryRunResponse:
+        async with ApiClient(settings) as client:
+            resp = await client.get(f"{base_path(app_id)}/{run_id}")
+            handle_response_error(resp, resource="Run")
+            run = StoryRunResponse.model_validate(resp.json())
+            if watch and run.status not in TERMINAL_STATUSES:
+                return await poll_run_status(client, app_id, run.id, json_mode)
+            return run
+
+    display_run_result(run_api_call(_status()), json_mode)
+
+
+@app.command(name="list")
+def list_runs(
+    user_story: Annotated[str, typer.Argument(help="User-story name or UUID to list runs for.")],
+    page: Annotated[int, typer.Option(help="Page number.")] = 1,
+    page_size: Annotated[int, typer.Option(help="Items per page.")] = 20,
+    status_filter: Annotated[
+        str | None,
+        typer.Option(
+            "--status",
+            help="Filter by status (pending, running, completed, failed, cancelled).",
+        ),
+    ] = None,
+    all_pages: Annotated[bool, typer.Option("--all", help="Fetch all results.")] = False,
+) -> None:
+    """List runs for a user story."""
+    settings, app_id, json_mode = resolve_app()
+    if all_pages:
+        page, page_size = 1, 100
+
+    async def _list() -> StoryRunListResponse:
+        async with ApiClient(settings) as client:
+            user_story_id = await resolve_user_story_id(client, app_id, user_story)
+            return await fetch_runs(client, app_id, user_story_id, page, page_size, status_filter)
+
+    result = run_api_call(_list())
+    if json_mode:
+        output(result.model_dump(mode="json", by_alias=True), json_mode=True)
+        return
+    if not result.items:
+        print_info("No runs found.")
+        return
+    title, tip = format_run_pagination_info(result)
+    rows = [format_run_row(r) for r in result.items]
+    print_table(RUN_TABLE_HEADERS, rows, title=title)
+    if tip:
+        print_info(tip)
+
+
+@app.command()
+def cancel(run_id: Annotated[str, typer.Argument(help="Run ID to cancel.")]) -> None:
+    """Cancel a pending or running story run."""
+    settings, app_id, json_mode = resolve_app()
+    ensure_uuid(run_id, kind="run id")
+
+    async def _cancel() -> StoryRunResponse:
+        async with ApiClient(settings) as client:
+            resp = await client.post(f"{base_path(app_id)}/{run_id}/cancel")
+            handle_response_error(resp, resource="Run")
+            return StoryRunResponse.model_validate(resp.json())
+
+    run = run_api_call(_cancel())
+    if json_mode:
+        output(run.model_dump(mode="json", by_alias=True), json_mode=True)
+    else:
+        print_success(f"Run cancelled: {run.id} (status: {run.status.value})")
+
+
+@app.command(name="all")
+def run_all(
+    ios_build: IosBuildOpt = None,
+    android_build: AndroidBuildOpt = None,
+) -> None:
+    """Start a batch covering every user story for the app."""
+    settings, app_id, json_mode = resolve_app()
+    _require_build(ios_build, android_build)
+
+    async def _run_all() -> BatchResponse:
+        async with ApiClient(settings) as client:
+            body = CreateBatchRequest(ios_build_id=ios_build, android_build_id=android_build)
+            return await post_batch(client, app_id, body)
+
+    batch = run_api_call(_run_all())
+    if json_mode:
+        print_json(batch_summary_payload(batch))
+        return
+    rows = [format_run_row(r) for r in batch.story_runs]
+    print_table(RUN_TABLE_HEADERS, rows, title=f"Batch {batch.id} — {batch.status.value}")
+    print_info(
+        f"Started {len(batch.story_runs)} runs. "
+        f"Use `minitest batch get {batch.id}` or `minitest run status <id>` to follow up."
+    )

{minitest_cli-0.6.0 → minitest_cli-0.7.0}/src/minitest_cli/commands/run_display.py

@@ -2,7 +2,7 @@
 
 import math
 
-from minitest_cli.models.flow_run import FlowRunListResponse, FlowRunResponse, RunStatus
+from minitest_cli.models.story_run import RunStatus, StoryRunListResponse, StoryRunResponse
 from minitest_cli.utils.output import (
     err_console,
     print_error,
@@ -12,22 +12,22 @@ from minitest_cli.utils.output import (
     print_table,
 )
 
-RUN_TABLE_HEADERS = ["ID", "Flow", "Status", "Created"]
+RUN_TABLE_HEADERS = ["ID", "User Story", "Status", "Created"]
 
 RESULTS_TABLE_HEADERS = ["Criterion ID", "Platform", "Result", "Fail Reason"]
 
 
-def format_run_row(run: FlowRunResponse) -> list[str]:
-    """Format a single FlowRunResponse as a table row."""
+def format_run_row(run: StoryRunResponse) -> list[str]:
+    """Format a single StoryRunResponse as a table row."""
     return [
         run.id,
-        run.flow_template_name or run.flow_template_id,
+        run.user_story_name or run.user_story_id,
         run.status.value,
         run.created_at.strftime("%Y-%m-%d %H:%M"),
     ]
 
 
-def _platform_status_line(platform: str, run: FlowRunResponse) -> tuple[str, str | None] | None:
+def _platform_status_line(platform: str, run: StoryRunResponse) -> tuple[str, str | None] | None:
     """Build a status line for a platform from the flat run fields."""
     if platform == "ios" and not run.ios_build_id:
         return None
@@ -48,10 +48,10 @@ def _platform_status_line(platform: str, run: FlowRunResponse) -> tuple[str, str
     return "".join(parts), recording
 
 
-def display_run_result(run: FlowRunResponse, json_mode: bool) -> None:
+def display_run_result(run: StoryRunResponse, json_mode: bool) -> None:
     """Display the full results of a completed run."""
     if json_mode:
-        print_json(run.model_dump(mode="json"))
+        print_json(run.model_dump(mode="json", by_alias=True))
         return
 
     status_icon = {
@@ -59,6 +59,7 @@ def display_run_result(run: FlowRunResponse, json_mode: bool) -> None:
         RunStatus.failed: "✗",
         RunStatus.pending: "…",
         RunStatus.running: "…",
+        RunStatus.cancelled: "⊘",
     }[run.status]
     print_info(f"Run {run.id} — {status_icon} {run.status.value}")
 
@@ -74,7 +75,7 @@ def display_run_result(run: FlowRunResponse, json_mode: bool) -> None:
     rows: list[list[str]] = []
     for cr in run.results:
         result_str = "[green]✓ pass[/green]" if cr.success else "[red]✗ fail[/red]"
-        rows.append([cr.acceptance_criteria_id, cr.platform, result_str, cr.fail_reason or ""])
+        rows.append([cr.criterion_version_id, cr.platform, result_str, cr.fail_reason or ""])
 
     if rows:
         print_table(RESULTS_TABLE_HEADERS, rows, title="Acceptance Criteria Results")
@@ -95,9 +96,11 @@ def display_run_result(run: FlowRunResponse, json_mode: bool) -> None:
             print_error(f"Run failed — {'; '.join(errors)}")
         else:
             print_error("Run failed.")
+    elif run.status == RunStatus.cancelled:
+        print_info("Run cancelled.")
 
 
-def format_run_pagination_info(data: FlowRunListResponse) -> tuple[str, str]:
+def format_run_pagination_info(data: StoryRunListResponse) -> tuple[str, str]:
     """Return (title, tip) for paginated run table display."""
     total_pages = math.ceil(data.total / data.page_size) if data.total else 1
     start = (data.page - 1) * data.page_size + 1