verifaied 0.31.0.dev78__tar.gz → 0.32.0.dev80__tar.gz

{verifaied-0.31.0.dev78 → verifaied-0.32.0.dev80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifaied
-Version: 0.31.0.dev78
+Version: 0.32.0.dev80
 Summary: Find what's untested in your code — locally, no account required
 Project-URL: Homepage, https://pypi.org/project/verifaied/
 Author: Kyle Richards
@@ -1054,11 +1054,18 @@ cloud can stop it. A request that fails is reported with the reason and
 the studio carries on — one bad pre-step chain is not a reason for it to
 die.
 
+**Stopping a run from the web.** While a run is replaying, the spinning
+Run button on the page turns into **Stop**. The studio hears it on its next
+beat, ends the replay's whole process group (SIGTERM, then SIGKILL), and
+records the run as failed with "Stopped from the web"; its video and trace
+are not kept. This uses POSIX process groups (`os.killpg`), so it needs
+macOS or Linux — the studio does not support Windows.
+
 **Branches.** The branch is re-detected on every beat, so switching
 branches under a running studio moves what the web shows and what the next
 recording lands against. `--branch` pins it instead.
 
-**Ctrl-C** does the safe thing at either moment. Mid-recording, the
+**Ctrl-C** (and SIGTERM, or the terminal closing) does the safe thing at either moment. Mid-recording, the
 interrupt is forwarded to the recorder exactly as it is for `test record`:
 the browser closes, the spec is saved, the replay runs, the request
 completes — and only then does the studio exit. At the idle prompt it
@@ -1101,9 +1108,12 @@ replay and lays over the file.
 - `0` — recorded, or replayed cleanly
 - `*` — the replay's own exit code when the spec failed (`test run --all`
   reports the worst across the run)
-- `2` — the replay was clean but its final coverage upload failed (coverage,
-  video and trace uploads are each tried three times, 2 s and 6 s apart, on a
-  dropped connection, a timeout or a 5xx — never on a 4xx)
+- `2` — the replay was clean but its final coverage upload failed, or the
+  service never received its verdict because the session could not be closed
+  (coverage, video and trace uploads and the session's close are each tried
+  three times, 2 s and 6 s apart, on a dropped connection, a timeout or a 5xx
+  — never on a 4xx; a close that still fails prints the session id and the
+  `curl` that records the verdict by hand)
 - `1` — usage/config error (no token, bad `--repo`, unknown test, no
   Playwright)
 

{verifaied-0.31.0.dev78 → verifaied-0.32.0.dev80}/README.md

@@ -1008,11 +1008,18 @@ cloud can stop it. A request that fails is reported with the reason and
 the studio carries on — one bad pre-step chain is not a reason for it to
 die.
 
+**Stopping a run from the web.** While a run is replaying, the spinning
+Run button on the page turns into **Stop**. The studio hears it on its next
+beat, ends the replay's whole process group (SIGTERM, then SIGKILL), and
+records the run as failed with "Stopped from the web"; its video and trace
+are not kept. This uses POSIX process groups (`os.killpg`), so it needs
+macOS or Linux — the studio does not support Windows.
+
 **Branches.** The branch is re-detected on every beat, so switching
 branches under a running studio moves what the web shows and what the next
 recording lands against. `--branch` pins it instead.
 
-**Ctrl-C** does the safe thing at either moment. Mid-recording, the
+**Ctrl-C** (and SIGTERM, or the terminal closing) does the safe thing at either moment. Mid-recording, the
 interrupt is forwarded to the recorder exactly as it is for `test record`:
 the browser closes, the spec is saved, the replay runs, the request
 completes — and only then does the studio exit. At the idle prompt it
@@ -1055,9 +1062,12 @@ replay and lays over the file.
 - `0` — recorded, or replayed cleanly
 - `*` — the replay's own exit code when the spec failed (`test run --all`
   reports the worst across the run)
-- `2` — the replay was clean but its final coverage upload failed (coverage,
-  video and trace uploads are each tried three times, 2 s and 6 s apart, on a
-  dropped connection, a timeout or a 5xx — never on a 4xx)
+- `2` — the replay was clean but its final coverage upload failed, or the
+  service never received its verdict because the session could not be closed
+  (coverage, video and trace uploads and the session's close are each tried
+  three times, 2 s and 6 s apart, on a dropped connection, a timeout or a 5xx
+  — never on a 4xx; a close that still fails prints the session id and the
+  `curl` that records the verdict by hand)
 - `1` — usage/config error (no token, bad `--repo`, unknown test, no
   Playwright)
 

{verifaied-0.31.0.dev78 → verifaied-0.32.0.dev80}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "verifaied"
-version = "0.31.0.dev78"
+version = "0.32.0.dev80"
 description = "Find what's untested in your code — locally, no account required"
 readme = "README.md"
 requires-python = ">=3.10"

{verifaied-0.31.0.dev78 → verifaied-0.32.0.dev80}/src/verifaied/client.py

@@ -18,11 +18,11 @@ import httpx
 
 from verifaied.uploader import Payload
 
-# Seconds to wait before the second and third attempt of an upload. A
-# replay's evidence is posted once, at the end, over whatever network the
-# machine has — a laptop roaming between access points, a CI runner
-# sharing one uplink with five others — and one dropped connection there
-# would otherwise turn a passing run into exit 2.
+# Seconds to wait before the second and third attempt of an upload or of a
+# session's close. A replay's evidence and its verdict are posted once, at
+# the end, over whatever network the machine has — a laptop roaming between
+# access points, a CI runner sharing one uplink with five others — and one
+# dropped connection there would otherwise turn a passing run into exit 2.
 UPLOAD_BACKOFF: tuple[float, ...] = (2.0, 6.0)
 # Indirected so tests can skip the waits.
 _sleep: Callable[[float], None] = time.sleep
@@ -245,6 +245,11 @@ def finalize_session(
     ``failure_message`` — what the runner said there — are sent only when
     there is one, so a close from anything without a flowchart is the same
     request it always was.
+
+    Retried like :func:`upload` on a dropped connection, a timeout or a
+    5xx. Safe to repeat: the service keeps the first close's end time and
+    writes the verdict again, so a close that landed but whose answer was
+    lost is only recorded twice.
     """
     url = f"{api_url.rstrip('/')}/sessions/{session_id}"
     body: dict[str, Any] = {"ended": True}
@@ -255,11 +260,13 @@ def finalize_session(
     if failure_message is not None:
         body["failure_message"] = failure_message
     try:
-        response = httpx.patch(
-            url,
-            json=body,
-            headers={"Authorization": f"Bearer {token}"},
-            timeout=timeout,
+        response = _send_with_retry(
+            lambda: httpx.patch(
+                url,
+                json=body,
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=timeout,
+            )
         )
     except httpx.HTTPError as e:
         raise ApiError(0, f"could not reach {url}: {e}") from e
@@ -715,6 +722,7 @@ def post_recorder_heartbeat(
     kinds: list[str] | None = None,
     environment: str | None = None,
     busy: bool = False,
+    working: UUID | None = None,
     timeout: float = 30.0,
 ) -> dict[str, Any]:
     """Say a studio is listening, and collect what to record next.
@@ -762,6 +770,10 @@ def post_recorder_heartbeat(
         body["environment"] = environment
     if busy:
         body["busy"] = True
+    if working is not None:
+        # Which run this busy studio is on, so the service does not stop it
+        # as a run whose studio went away. Sent only when named.
+        body["working"] = str(working)
     try:
         response = _http().post(
             request_url,
@@ -813,6 +825,35 @@ def post_recording_request_status(
         raise ApiError(response.status_code, _detail(response))
 
 
+def cancel_queued_runs(
+    *,
+    api_url: str,
+    token: str,
+    repo_id: UUID,
+    timeout: float = 10.0,
+) -> int:
+    """Take back this user's queued runs in a repository; how many.
+
+    The web's "Stop queued runs", called by a studio on its way out: a run
+    queued for it is one nothing else will pick up, because presence is
+    one studio per user per repository. Runs only, never one a studio has
+    already taken — the endpoint's own rule. A short timeout, because the
+    caller is a process that has been asked to exit.
+    """
+    url = f"{api_url.rstrip('/')}/repositories/{repo_id}/recording-requests"
+    try:
+        response = httpx.delete(
+            url,
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=timeout,
+        )
+    except httpx.HTTPError as e:
+        raise ApiError(0, f"could not reach {url}: {e}") from e
+    if response.status_code >= 400:
+        raise ApiError(response.status_code, _detail(response))
+    return int(response.json().get("cancelled", 0))
+
+
 def delete_recorded_test(
     *,
     api_url: str,

{verifaied-0.31.0.dev78 → verifaied-0.32.0.dev80}/src/verifaied/record.py

@@ -38,6 +38,7 @@ from typing import Any
 from uuid import UUID
 
 from rich.console import Console
+from rich.markup import escape
 
 from verifaied.client import (
     ApiError,
@@ -1062,10 +1063,17 @@ def _close_session(
     err_console: Console,
     failed_step: int | None = None,
     failure_message: str | None = None,
-) -> None:
-    """Close the session, best-effort. Same reasoning as ``_open_session``:
-    the run's own verdict is what matters, and a failed PATCH must not
-    change it.
+) -> bool:
+    """Close the session. Returns whether the service recorded the close.
+
+    The close is tried three times (``finalize_session`` retries a dropped
+    connection, a timeout or a 5xx). If it still fails, one line names the
+    session and the exact request that closes it by hand, and False goes
+    back to the caller: a replay's verdict rides this close, so a caller
+    whose verdict is the point (``test run``) turns it into exit 2 rather
+    than reporting a pass nobody recorded. A caller with nothing riding on
+    it may ignore the answer. With no session there is nothing to close,
+    which is True.
 
     ``failed_step`` is which flowchart block a failing replay died on, and
     ``failure_message`` is what the runner said there. Both default to None
@@ -1074,7 +1082,7 @@ def _close_session(
     fail.
     """
     if session_id is None:
-        return
+        return True
     try:
         finalize_session(
             api_url=api_url,
@@ -1085,7 +1093,43 @@ def _close_session(
             failure_message=failure_message,
         )
     except ApiError as e:
-        err_console.print(f"[yellow]could not close the session[/yellow]: {e.message}")
+        err_console.print(
+            f"[yellow]could not close session {session_id}[/yellow]: "
+            f"{escape(e.message)} — its verdict was not recorded, and the "
+            "service will mark it abandoned. To record it now: "
+            + escape(
+                _close_command(
+                    api_url=api_url,
+                    session_id=session_id,
+                    exit_code=exit_code,
+                    failed_step=failed_step,
+                )
+            ),
+            soft_wrap=True,
+        )
+        return False
+    return True
+
+
+def _close_command(
+    *, api_url: str, session_id: UUID, exit_code: int, failed_step: int | None
+) -> str:
+    """The ``curl`` that closes a session by hand, with the verdict it had.
+
+    The token is left as ``$VERIFAIED_API_TOKEN`` rather than printed: this
+    line lands in CI logs. The failure text is left out — it is free text
+    that would need shell quoting to survive, and the exit code and step
+    are the verdict.
+    """
+    body: dict[str, Any] = {"ended": True, "exit_code": exit_code}
+    if failed_step is not None:
+        body["failed_step"] = failed_step
+    return (
+        f"curl -X PATCH {api_url.rstrip('/')}/sessions/{session_id} "
+        '-H "Authorization: Bearer $VERIFAIED_API_TOKEN" '
+        "-H 'Content-Type: application/json' "
+        f"-d '{json.dumps(body, separators=(',', ':'))}'"
+    )
 
 
 def _window_url(