minitest-cli 0.27.2__tar.gz → 0.28.1__tar.gz

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.27.2
+Version: 0.28.1
 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

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/pyproject.toml

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

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/api/client.py

@@ -8,6 +8,8 @@ from minitest_cli.core.auth import load_token
 from minitest_cli.core.config import Settings
 
 CHANNEL_HEADER = "X-Minitest-Channel"
+CONVERSATION_ID_HEADER = "X-Minitest-Conversation-Id"
+CAUSE_HEADER = "X-Minitest-Cause"
 DEFAULT_TIMEOUT = 30.0
 UPLOAD_TIMEOUT = 300.0  # 5 minutes for large file uploads
 # Creating a batch can block on server-side maintenance before it answers, and the
@@ -31,12 +33,17 @@ class ApiClient:
 
     async def __aenter__(self) -> "ApiClient":
         token = self._token_override or load_token(self._settings)
+        headers: dict[str, str] = {
+            "Authorization": f"Bearer {token}",
+            CHANNEL_HEADER: self._settings.channel,
+        }
+        if self._settings.conversation_id is not None:
+            headers[CONVERSATION_ID_HEADER] = self._settings.conversation_id
+        if self._settings.cause is not None:
+            headers[CAUSE_HEADER] = self._settings.cause
         self._client = httpx.AsyncClient(
             base_url=self._settings.api_url,
-            headers={
-                "Authorization": f"Bearer {token}",
-                CHANNEL_HEADER: self._settings.channel,
-            },
+            headers=headers,
             timeout=DEFAULT_TIMEOUT,
         )
         return self

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/commands/draft_feature.py

@@ -4,6 +4,7 @@ A draft feature is a branch of the app's test suite — it holds a delta against
 main rather than a copy of it, so `show` is the only way to see what it changes.
 """
 
+import json
 from typing import Annotated
 
 import typer
@@ -66,12 +67,18 @@ def create_draft_feature(
         str | None,
         typer.Option("--description", help="What product change the branch describes."),
     ] = None,
+    source_refs: Annotated[
+        str | None,
+        typer.Option("--source-refs", help="JSON array of provenance refs (passed as sourceRefs)."),
+    ] = None,
 ) -> None:
     """Open a branch off the app's main suite."""
     settings, app_id, json_mode = resolve_app()
     body: dict[str, object] = {"title": title}
     if description is not None:
         body["description"] = description
+    if source_refs is not None:
+        body["sourceRefs"] = json.loads(source_refs)
 
     async def _create() -> DraftFeatureResponse:
         async with ApiClient(settings) as client:

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/commands/run_display.py

@@ -27,7 +27,9 @@ def _derive_run_status(run: StoryRunResponse) -> str:
     Mirrors the heuristic used by the cockpit / webapp: any platform
     with a stamped ``cancellation_requested_at`` short-circuits to
     ``cancelled``; otherwise we pick the worst platform state in
-    lifecycle order (running > pending/blocked > failed > completed).
+    lifecycle order (running > pending/blocked > evaluating > failed >
+    completed). ``evaluating`` is a platform that finished executing and
+    is waiting for its verdict, so it outranks every terminal state.
     """
     if any(p.cancellation_requested_at is not None for p in run.platforms):
         return "cancelled"
@@ -38,6 +40,8 @@ def _derive_run_status(run: StoryRunResponse) -> str:
         return "running"
     if "pending" in states or "blocked" in states:
         return "pending"
+    if "evaluating" in states:
+        return "evaluating"
     if "failed" in states:
         return "failed"
     if all(s in _TERMINAL_EXEC_STATES for s in states) and any(s == "completed" for s in states):

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/commands/test_profile.py

@@ -4,6 +4,14 @@ import typer
 
 from minitest_cli.api.client import ApiClient
 from minitest_cli.commands import test_profile_default, test_profile_list, test_profile_update
+from minitest_cli.commands.test_profile_card import (
+    CardCvcOption,
+    CardExpiryOption,
+    CardHolderNameOption,
+    CardNumberOption,
+    CardPostalCodeOption,
+    card_fields,
+)
 from minitest_cli.commands.test_profile_helpers import (
     app_base_path,
     get_app_flag,
@@ -65,6 +73,11 @@ def create_profile(
     about: Annotated[
         str | None, typer.Option("--about", help="Free-text notes about the account.")
     ] = None,
+    test_card_number: CardNumberOption = None,
+    test_card_expiry: CardExpiryOption = None,
+    test_card_cvc: CardCvcOption = None,
+    test_card_holder_name: CardHolderNameOption = None,
+    test_card_postal_code: CardPostalCodeOption = None,
 ) -> None:
     settings = get_settings()
     json_mode = is_json_mode()
@@ -91,6 +104,15 @@ def create_profile(
         body["static_otp_code"] = otp
     if about is not None:
         body["about"] = about
+    card = card_fields(
+        test_card_number,
+        test_card_expiry,
+        test_card_cvc,
+        test_card_holder_name,
+        test_card_postal_code,
+    )
+    if card:
+        body["test_card"] = card
 
     async def _run() -> dict[str, Any]:
         async with ApiClient(settings) as client:

minitest_cli-0.28.1/src/minitest_cli/commands/test_profile_card.py

@@ -0,0 +1,52 @@
+from typing import Annotated, Any
+
+import typer
+
+CardNumberOption = Annotated[
+    str | None,
+    typer.Option(
+        "--test-card-number",
+        help="Sandbox payment card number the persona pays with (e.g. 4242 4242 4242 4242).",
+    ),
+]
+CardExpiryOption = Annotated[
+    str | None,
+    typer.Option("--test-card-expiry", help="Test card expiry, exactly as the app expects it."),
+]
+CardCvcOption = Annotated[
+    str | None,
+    typer.Option("--test-card-cvc", help="Test card security code, exactly as the app expects it."),
+]
+CardHolderNameOption = Annotated[
+    str | None, typer.Option("--test-card-holder-name", help="Name on the test card.")
+]
+CardPostalCodeOption = Annotated[
+    str | None, typer.Option("--test-card-postal-code", help="Test card billing postal code.")
+]
+
+_API_KEYS: dict[str, str] = {"holderName": "holder_name", "postalCode": "postal_code"}
+
+
+def card_fields(
+    number: str | None,
+    expiry: str | None,
+    cvc: str | None,
+    holder_name: str | None,
+    postal_code: str | None,
+) -> dict[str, str]:
+    """The card fields the command was given, in the API's shape."""
+    given = {
+        "number": number,
+        "expiry": expiry,
+        "cvc": cvc,
+        "holder_name": holder_name,
+        "postal_code": postal_code,
+    }
+    return {key: value for key, value in given.items() if value is not None}
+
+
+def merged_card(stored: dict[str, Any] | None, changes: dict[str, str]) -> dict[str, str]:
+    """The stored card with ``changes`` applied, since the API replaces a card whole."""
+    items: dict[str, Any] = stored or {}
+    current = {_API_KEYS.get(key, key): str(value) for key, value in items.items() if value}
+    return {**current, **changes}

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/commands/test_profile_update.py

@@ -3,6 +3,15 @@ from typing import Annotated, Any
 import typer
 
 from minitest_cli.api.client import ApiClient
+from minitest_cli.commands.test_profile_card import (
+    CardCvcOption,
+    CardExpiryOption,
+    CardHolderNameOption,
+    CardNumberOption,
+    CardPostalCodeOption,
+    card_fields,
+    merged_card,
+)
 from minitest_cli.commands.test_profile_helpers import (
     app_base_path,
     get_app_flag,
@@ -66,6 +75,15 @@ def register(app: typer.Typer) -> None:
             bool,
             typer.Option("--clear-about", help="Remove the stored about text."),
         ] = False,
+        test_card_number: CardNumberOption = None,
+        test_card_expiry: CardExpiryOption = None,
+        test_card_cvc: CardCvcOption = None,
+        test_card_holder_name: CardHolderNameOption = None,
+        test_card_postal_code: CardPostalCodeOption = None,
+        clear_test_card: Annotated[
+            bool,
+            typer.Option("--clear-test-card", help="Remove the stored test card."),
+        ] = False,
     ) -> None:
         settings = get_settings()
         json_mode = is_json_mode()
@@ -107,13 +125,31 @@ def register(app: typer.Typer) -> None:
             elif clear:
                 body[key] = None
 
-        if not body:
+        card = card_fields(
+            test_card_number,
+            test_card_expiry,
+            test_card_cvc,
+            test_card_holder_name,
+            test_card_postal_code,
+        )
+        if card and clear_test_card:
+            print_error("Use either --test-card-* options or --clear-test-card, not both.")
+            raise typer.Exit(code=1)
+        if clear_test_card:
+            body["test_card"] = None
+
+        if not body and not card:
             print_error("Provide at least one field to update.")
             raise typer.Exit(code=1)
 
         async def _run() -> dict[str, Any]:
             async with ApiClient(settings) as client:
-                resp = await client.patch(f"{app_base_path(app_id)}/{profile_id}", json=body)
+                path = f"{app_base_path(app_id)}/{profile_id}"
+                if card:
+                    current = await client.get(path)
+                    handle_profile_response(current)
+                    body["test_card"] = merged_card(current.json().get("testCard"), card)
+                resp = await client.patch(path, json=body)
                 handle_profile_response(resp)
                 return resp.json()
 

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/core/config.py

@@ -48,6 +48,14 @@ class Settings(BaseSettings):
         default="cli",
         description="X-Minitest-Channel header value sent on every API call (MINITEST_CHANNEL)",
     )
+    conversation_id: str | None = Field(
+        default=None,
+        description="X-Minitest-Conversation-Id header value (MINITEST_CONVERSATION_ID)",
+    )
+    cause: str | None = Field(
+        default=None,
+        description="X-Minitest-Cause header value sent on every API call (MINITEST_CAUSE)",
+    )
     token: str | None = Field(
         default=None,
         description="API authentication token (MINITEST_TOKEN)",

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/src/minitest_cli/models/story_run.py

@@ -33,7 +33,9 @@ class PlatformRun(CamelModel):
     Every previously-flat ``ios_*`` / ``android_*`` field on
     :class:`StoryRunResponse` now lives here, one row per platform that
     was in scope for the run. ``execution_state`` is the lifecycle axis
-    (pending/running/completed/failed/blocked/skipped); ``verdict`` is
+    (pending/running/evaluating/completed/failed/blocked/skipped);
+    ``evaluating`` is a platform that finished executing and is waiting
+    for its verdict. ``verdict`` is
     the criticality-aware outcome populated once the platform reaches a
     non-skipped terminal state. ``cancellation_requested_at`` is
     stamped when a user requested cancellation on this platform; UI

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/tests/test_run_commands.py

@@ -11,6 +11,7 @@ from click.exceptions import Exit
 from typer.testing import CliRunner
 
 from minitest_cli.commands.run import app as run_app
+from minitest_cli.commands.run_display import _derive_run_status
 from minitest_cli.commands.run_helpers import (
     display_run_result,
     extract_detail,
@@ -1273,3 +1274,65 @@ class TestRunFeedback:
             tmp_path, ["feedback", "0e4a4b4f-6f0e-4a3b-9e0a-000000000042", "text"], resp=resp
         )
         assert result.exit_code == 4
+
+
+_EVALUATING_RUN = {
+    **_PENDING_RUN,
+    "platforms": [
+        {**p, "executionState": "evaluating", "finishedAt": "2025-06-01T10:05:00Z"}
+        for p in _PENDING_RUN["platforms"]
+    ],
+}
+
+
+class TestEvaluatingRunStatus:
+    def test_evaluating_lane_derives_evaluating(self) -> None:
+        run = StoryRunResponse.model_validate(_EVALUATING_RUN)
+        assert _derive_run_status(run) == "evaluating"
+
+    def test_evaluating_outranks_a_failed_sibling(self) -> None:
+        run = StoryRunResponse.model_validate(
+            {
+                **_EVALUATING_RUN,
+                "platforms": [
+                    _EVALUATING_RUN["platforms"][0],
+                    {**_EVALUATING_RUN["platforms"][1], "executionState": "failed"},
+                ],
+            }
+        )
+        assert _derive_run_status(run) == "evaluating"
+
+    def test_pending_sibling_still_wins(self) -> None:
+        run = StoryRunResponse.model_validate(
+            {
+                **_EVALUATING_RUN,
+                "platforms": [
+                    _EVALUATING_RUN["platforms"][0],
+                    _PENDING_RUN["platforms"][1],
+                ],
+            }
+        )
+        assert _derive_run_status(run) == "pending"
+
+    def test_status_with_watch_polls_through_evaluating(self, tmp_path) -> None:
+        settings = _make_settings(tmp_path)
+        client = _mock_client()
+        client.get = AsyncMock(
+            side_effect=[
+                _mock_response(200, _EVALUATING_RUN),
+                _mock_response(200, _EVALUATING_RUN),
+                _mock_response(200, _COMPLETED_RUN),
+            ]
+        )
+
+        with (
+            patch("minitest_cli.commands.run.ApiClient", return_value=client),
+            patch("minitest_cli.commands.run_helpers.asyncio.sleep", new_callable=AsyncMock),
+            patch("minitest_cli.commands.run_helpers.err_console"),
+        ):
+            result = _run_with_context(["status", _RUN_UUID, "--watch"], settings, json_mode=True)
+
+        assert result.exit_code == 0
+        assert client.get.call_count == 3
+        data = json.loads(result.output)
+        assert all(p["executionState"] == "completed" for p in data["platforms"])

minitest_cli-0.28.1/tests/test_suite_change_provenance.py

@@ -0,0 +1,108 @@
+"""Tests for suite-change provenance contract (section 3).
+
+Uses real httpx request cycles via MockTransport so headers are proven at
+the HTTP wire level rather than by inspecting mock call args.
+"""
+
+import json
+
+import httpx
+from typer.testing import CliRunner
+
+from minitest_cli.commands.draft_feature import app as df_app
+from tests._commit_transport import cli_context, make_settings, routed
+
+runner = CliRunner()
+
+_APP_ID = "a0d9820f-5136-4f70-b46b-e5966f56bfb5"
+_FEATURE_PAYLOAD = {
+    "id": "b1",
+    "tenantId": "t1",
+    "appId": _APP_ID,
+    "title": "Checkout",
+    "description": "test branch",
+    "status": "open",
+    "rebaseState": "in_sync",
+    "rebasedToMainRev": 1,
+    "sourceRefs": [],
+    "createdAt": "2026-01-01T00:00:00Z",
+    "updatedAt": "2026-01-01T00:00:00Z",
+    "mergedAt": None,
+}
+
+
+class TestProvenanceHeaders:
+    """X-Minitest-Conversation-Id and X-Minitest-Cause are sent on every request."""
+
+    def test_headers_present_when_env_vars_set(self, tmp_path):
+        """Both provenance headers appear when their env vars are set."""
+        received: dict[str, str] = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            received["conversation_id"] = request.headers.get("x-minitest-conversation-id", "")
+            received["cause"] = request.headers.get("x-minitest-cause", "")
+            return httpx.Response(201, json=_FEATURE_PAYLOAD)
+
+        settings = make_settings(
+            tmp_path,
+            conversation_id="conv-abc-123",
+            cause="ci/pipeline",
+        )
+        with routed(handler), cli_context(settings, json_mode=True):
+            result = runner.invoke(df_app, ["create", "--title", "Checkout"])
+
+        assert result.exit_code == 0, result.output
+        assert received["conversation_id"] == "conv-abc-123"
+        assert received["cause"] == "ci/pipeline"
+
+    def test_headers_absent_when_env_vars_not_set(self, tmp_path):
+        """Neither header is sent when the env vars are absent."""
+        received_keys: list[str] = []
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            received_keys.extend(request.headers.keys())
+            return httpx.Response(201, json=_FEATURE_PAYLOAD)
+
+        settings = make_settings(tmp_path)
+        with routed(handler), cli_context(settings, json_mode=True):
+            result = runner.invoke(df_app, ["create", "--title", "Checkout"])
+
+        assert result.exit_code == 0, result.output
+        assert "x-minitest-conversation-id" not in received_keys
+        assert "x-minitest-cause" not in received_keys
+
+
+class TestDfCreateSourceRefs:
+    """--source-refs flag is passed as sourceRefs in the POST body."""
+
+    def test_source_refs_included_in_post_body(self, tmp_path):
+        received_body: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            received_body.update(json.loads(request.content))
+            return httpx.Response(201, json=_FEATURE_PAYLOAD)
+
+        source_refs = [{"type": "github_pr", "ref": "https://github.com/org/repo/pull/42"}]
+        settings = make_settings(tmp_path)
+        with routed(handler), cli_context(settings, json_mode=True):
+            result = runner.invoke(
+                df_app,
+                ["create", "--title", "Checkout", "--source-refs", json.dumps(source_refs)],
+            )
+
+        assert result.exit_code == 0, result.output
+        assert received_body["sourceRefs"] == source_refs
+
+    def test_source_refs_absent_when_flag_not_given(self, tmp_path):
+        received_body: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            received_body.update(json.loads(request.content))
+            return httpx.Response(201, json=_FEATURE_PAYLOAD)
+
+        settings = make_settings(tmp_path)
+        with routed(handler), cli_context(settings, json_mode=True):
+            result = runner.invoke(df_app, ["create", "--title", "Checkout"])
+
+        assert result.exit_code == 0, result.output
+        assert "sourceRefs" not in received_body

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/tests/test_test_profile_commands.py

@@ -177,6 +177,67 @@ class TestCreate:
         assert result.exit_code == 1
 
 
+class TestTestCard:
+    def test_create_sends_only_the_card_fields_given(self, tmp_path):
+        settings = _make_settings(tmp_path)
+        client = _mock_client(post=_mock_response(201, _PROFILE))
+        with patch("minitest_cli.commands.test_profile.ApiClient", return_value=client):
+            result = _run(
+                [
+                    "create",
+                    "--name",
+                    "Shopper",
+                    "--test-card-number",
+                    "4242 4242 4242 4242",
+                    "--test-card-expiry",
+                    "12/34",
+                ],
+                settings,
+                json_mode=True,
+            )
+        assert result.exit_code == 0
+        body = client.post.await_args.kwargs["json"]
+        assert body["test_card"] == {"number": "4242 4242 4242 4242", "expiry": "12/34"}
+
+    def test_update_changes_one_card_field_and_keeps_the_rest(self, tmp_path):
+        settings = _make_settings(tmp_path)
+        stored = {
+            **_PROFILE,
+            "testCard": {"number": "4242 4242 4242 4242", "cvc": "123", "holderName": "Ada"},
+        }
+        client = _mock_client(get=_mock_response(200, stored), patch_=_mock_response(200, stored))
+        with patch("minitest_cli.commands.test_profile_update.ApiClient", return_value=client):
+            result = _run(
+                ["update", "p-111", "--test-card-cvc", "999"],
+                settings,
+                json_mode=True,
+            )
+        assert result.exit_code == 0
+        body = client.patch.await_args.kwargs["json"]
+        assert body == {
+            "test_card": {"number": "4242 4242 4242 4242", "cvc": "999", "holder_name": "Ada"}
+        }
+
+    def test_update_clear_test_card(self, tmp_path):
+        settings = _make_settings(tmp_path)
+        client = _mock_client(patch_=_mock_response(200, _PROFILE))
+        with patch("minitest_cli.commands.test_profile_update.ApiClient", return_value=client):
+            result = _run(["update", "p-111", "--clear-test-card"], settings, json_mode=True)
+        assert result.exit_code == 0
+        assert client.patch.await_args.kwargs["json"] == {"test_card": None}
+        client.get.assert_not_awaited()
+
+    def test_update_card_field_and_clear_rejected(self, tmp_path):
+        settings = _make_settings(tmp_path)
+        client = _mock_client()
+        with patch("minitest_cli.commands.test_profile_update.ApiClient", return_value=client):
+            result = _run(
+                ["update", "p-111", "--test-card-cvc", "999", "--clear-test-card"], settings
+            )
+        assert result.exit_code == 1
+        client.patch.assert_not_awaited()
+
+
 class TestUpdate:
     def test_update_clear_password(self, tmp_path):
         settings = _make_settings(tmp_path)

{minitest_cli-0.27.2 → minitest_cli-0.28.1}/uv.lock

@@ -141,7 +141,7 @@ wheels = [
 
 [[package]]
 name = "minitest-cli"
-version = "0.27.2"
+version = "0.28.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },