verifaied 0.23.1.dev48__tar.gz → 0.24.0.dev49__tar.gz

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifaied
-Version: 0.23.1.dev48
+Version: 0.24.0.dev49
 Summary: Find what's untested in your code — locally, no account required
 Project-URL: Homepage, https://pypi.org/project/verifaied/
 Author: Kyle Richards

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/pyproject.toml

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

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/src/verifaied/client.py

@@ -741,6 +741,41 @@ def post_recording_request_status(
         raise ApiError(response.status_code, _detail(response))
 
 
+def delete_recorded_test(
+    *,
+    api_url: str,
+    token: str,
+    test_id: UUID,
+    timeout: float = 30.0,
+) -> bool:
+    """Remove a test row. True when it was there, False when it wasn't.
+
+    The discard's other half. The browser closes without saving, and the
+    row a first recording created is then no use to anybody — so the
+    machine that did the recording is what removes it, because deleting
+    a row for a recording that may still be running is not something the
+    service can safely do on its own.
+
+    A 404 is not an error: the row is gone, which is the state the caller
+    was asking for. Everything else raises, so a failure can be said out
+    loud rather than leaving somebody believing a test was removed.
+    """
+    url = f"{api_url.rstrip('/')}/recorded-tests/{test_id}"
+    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 == 404:
+        return False
+    if response.status_code >= 400:
+        raise ApiError(response.status_code, _detail(response))
+    return True
+
+
 def check_done(
     *,
     api_url: str,

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/src/verifaied/testcmd.py

@@ -111,6 +111,7 @@ from rich.table import Table
 from verifaied.client import (
     ApiError,
     create_recorded_test,
+    delete_recorded_test,
     list_recorded_tests,
     patch_recorded_test,
     post_recorder_heartbeat,
@@ -3934,6 +3935,12 @@ class RecordingSession:
         # the save path still reads it if the browser dies before the
         # `cancelled` event makes it back out.
         self.cancelled = False
+        # Whether that discard also asked for the test row itself to go.
+        # Set beside ``cancelled``, for its reason, and acted on by
+        # whoever called ``record_one`` rather than here: this session has
+        # no idea what a row is, and the delete has to happen after the
+        # closing posts have landed.
+        self.discard = False
         self.error: str | None = None
         self._picked: dict[str, Any] | None = None
         self._last_action: dict[str, Any] | None = None
@@ -4651,15 +4658,23 @@ class RecordingSession:
             # rather than as the deliberate stop it was.
             self._cancel_all_flows()
             self._send({"cmd": "finish", "id": command_id})
-        elif kind == "cancel_recording":
+        elif kind in ("cancel_recording", "discard_recording"):
             # The discard, and finish's twin in every way but the one that
             # matters: nothing is written. The flag is set here rather than
             # when the driver answers, because the save path has to know a
             # cancel was asked for even if the browser goes away before the
             # `cancelled` event gets back out. Waiting flows are cancelled
             # first for exactly finish's reason.
+            #
+            # The two kinds travel the identical road down stdin — the
+            # driver knows one ending, not two — and differ only in what
+            # the *caller* does once the browser has closed and the
+            # closing posts have landed: `discard_recording` also asks for
+            # the row to be removed, which is only ever offered on a test
+            # that has never produced a spec.
             self._cancel_all_flows()
             self.cancelled = True
+            self.discard = kind == "discard_recording"
             self._send({"cmd": "cancel", "id": command_id})
         elif kind == "assert":
             code = str(payload.get("code") or "")
@@ -5335,10 +5350,12 @@ def run_test_record(
         has_pre=bool(pre),
         base_url=base_url,
     )
-    # Only the code: a terminal recording that was discarded is a
-    # deliberate 0, and the studio is the one caller that has anywhere to
-    # report the difference to.
-    return record_one(
+    # A terminal recording that was discarded is a deliberate 0, and the
+    # studio is the one caller that has anywhere to report *that*
+    # difference to — but the row a discard asks for is this caller's to
+    # remove, exactly as it is the loop's, and it goes after the closing
+    # posts for the same reason.
+    outcome = record_one(
         api_url=api_url,
         token=token,
         repo_id=repo_id,
@@ -5365,7 +5382,17 @@ def run_test_record(
         runner=runner,
         stream_runner=stream_runner,
         shell_runner=shell_runner,
-    ).code
+    )
+    if outcome.discarded:
+        discard_test_row(
+            api_url=api_url,
+            token=token,
+            test_id=UUID(str(test["id"])),
+            label=ref_of(feature, name),
+            console=console,
+            err_console=err_console,
+        )
+    return outcome.code
 
 
 def saved_flowchart(
@@ -5422,10 +5449,52 @@ class RecordOutcome(NamedTuple):
     which the studio has to report as its own ending rather than as
     ``done`` — that word means the recording was saved, and a discard is
     precisely the case where nothing was.
+
+    ``discarded`` is the narrower half of that: the user asked for the
+    test itself to be removed, not just for this attempt to be thrown
+    away. The removal is the **caller's** — ``record_one`` never deletes
+    a row — because the closing posts have to land first, and only the
+    caller knows whether there is also a request row riding on it.
     """
 
     code: int
     cancelled: bool = False
+    discarded: bool = False
+
+
+def discard_test_row(
+    *,
+    api_url: str,
+    token: str,
+    test_id: UUID,
+    label: str,
+    console: Console,
+    err_console: Console,
+) -> None:
+    """Remove the row a discarded first recording left behind.
+
+    Fail-soft, and deliberately: the recording is already over and the
+    browser is already closed, so a delete that cannot land is worth one
+    yellow line and nothing more. The row simply stays a draft, which is
+    exactly where it was a moment ago and which the user can remove from
+    the Tests page.
+
+    Never raises — a caller reporting the recording's own ending must not
+    have that ending rewritten by the tidy-up after it.
+    """
+    try:
+        removed = delete_recorded_test(api_url=api_url, token=token, test_id=test_id)
+    except ApiError as e:
+        err_console.print(
+            f'[yellow]could not remove "{escape(label)}"[/yellow] — '
+            f"it stays a draft: {escape(str(e))}"
+        )
+        return
+    console.print(
+        f'[dim]"{escape(label)}" removed from verifAIed.[/dim]'
+        if removed
+        else f'[dim]"{escape(label)}" was already gone.[/dim]'
+    )
 
 
 def record_one(
@@ -5658,6 +5727,21 @@ def record_one(
             # recording, and this post is the only channel that can put
             # the saved spec's flow back — PATCH never writes steps, by
             # design.
+            #
+            # A discard of a *draft* asks for one more thing: the row goes
+            # too. The endpoint already refuses that on a row with a spec,
+            # and the status is checked again here so an older service
+            # that let one through degrades to a plain cancel rather than
+            # deleting somebody's test. The delete itself is the caller's
+            # — the closing posts have to land first.
+            discard = session.discard and str(test.get("status")) == "draft"
+            if discard:
+                session.finish([])
+                console.print(
+                    "[yellow]recording discarded[/yellow] — nothing was "
+                    f'saved, and "{label}" is being removed.'
+                )
+                return RecordOutcome(0, cancelled=True, discarded=True)
             session.finish(saved_flowchart(spec_path, pre_refs))
             note = (
                 f' — nothing was saved, so "{label}" stays a draft'
@@ -6134,6 +6218,12 @@ def edit_one(
             # Nothing is written, so the spec on disk is the one that was
             # there — and the closing post has to put its flow back, because
             # the live feed has been clobbering `steps` with this session's.
+            #
+            # ``session.discard`` is deliberately not read here. An edit is
+            # only ever offered on a test that already has a spec, which is
+            # exactly the row the discard is fenced off from — so a session
+            # that somehow collected one still ends as a plain cancel and
+            # the saved flow stands.
             session.finish(saved_flowchart(spec_path, pre_refs))
             console.print(
                 f"[yellow]edit cancelled[/yellow] — nothing was saved, so "
@@ -6805,6 +6895,11 @@ def run_test_studio(
                 # than requiring the field keeps an upgraded CLI working
                 # against a service that hasn't been deployed yet.
                 cancelled = False
+                # Whether the recording also asked for its row to go. Held
+                # until after the status post below, because the request
+                # row cascades with the test it names — deleting first
+                # would leave that post with nothing to report to.
+                discarded = False
                 with keeper(busy_beat):
                     kind = request.get("kind")
                     if kind in ("run", "run_headless"):
@@ -6874,7 +6969,7 @@ def run_test_studio(
                             shell_runner=shell_runner,
                         )
                     else:
-                        cancelled = _record_requested(
+                        outcome = _record_requested(
                             request,
                             api_url=api_url,
                             token=token,
@@ -6894,6 +6989,8 @@ def run_test_studio(
                             stream_runner=stream_runner,
                             shell_runner=shell_runner,
                         )
+                        cancelled = outcome.cancelled
+                        discarded = outcome.discarded
                 # Done means "the recording was saved" — or, for a run,
                 # "the replay finished", or, for an amendment, "the new
                 # lines are in the file", whatever the exit code was.
@@ -6912,6 +7009,19 @@ def run_test_studio(
                     request_id=request_id,
                     status="cancelled" if cancelled else "done",
                 )
+                if discarded:
+                    # **After** the status post, never before: this request
+                    # row cascades with the test it names, so deleting
+                    # first would leave the ending with nowhere to land and
+                    # the page watching a request that simply vanished.
+                    discard_test_row(
+                        api_url=api_url,
+                        token=token,
+                        test_id=UUID(str(request["recorded_test_id"])),
+                        label=ref_of(request["feature"], request["name"]),
+                        console=console,
+                        err_console=err_console,
+                    )
             except RecordedTestError as e:
                 err_console.print(f"[red]VerifAIed error[/red]: {e}")
                 _fail_request(
@@ -6974,12 +7084,15 @@ def _record_requested(
     stream_runner: StreamRunner,
     shell_runner: ShellRunner,
     env_name: str | None = None,
-) -> bool:
-    """Record the one flow a heartbeat handed over. True when discarded.
+) -> RecordOutcome:
+    """Record the one flow a heartbeat handed over.
 
-    The return value is the one thing the loop cannot see for itself:
-    ``done`` means the recording was saved, so a recording the user
-    threw away has to be reported as its own ending instead.
+    The outcome is the two things the loop cannot see for itself.
+    ``cancelled`` — ``done`` means the recording was saved, so a recording
+    the user threw away has to be reported as its own ending instead.
+    ``discarded`` — the user asked for the test itself to go, which the
+    loop does **after** posting that ending, because the request row
+    cascades with the test it names.
 
     ``recording`` is posted **first**, before anything slow: replaying a
     chain of pre-steps can take a minute, and the page that asked for
@@ -7039,7 +7152,7 @@ def _record_requested(
         runner=runner,
         stream_runner=stream_runner,
         shell_runner=shell_runner,
-    ).cancelled
+    )
 
 
 def _edit_requested(

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/tests/test_client.py

@@ -21,6 +21,7 @@ from verifaied.client import (
     clear_manual_coverage,
     create_recorded_test,
     create_session,
+    delete_recorded_test,
     finalize_session,
     list_installations,
     list_recorded_tests,
@@ -1382,6 +1383,50 @@ def test_post_recording_request_status_wraps_a_transport_failure(
     assert "could not reach" in exc.value.message
 
 
+def test_delete_recorded_test_removes_the_row(httpx_mock: HTTPXMock):
+    """The discard's other half: the machine that did the recording is
+    what removes the row a first recording left behind."""
+    test_id = uuid4()
+    httpx_mock.add_response(
+        method="DELETE",
+        url=f"http://api.test/recorded-tests/{test_id}",
+        status_code=204,
+    )
+    assert (
+        delete_recorded_test(api_url="http://api.test/", token="t", test_id=test_id)
+        is True
+    )
+    assert httpx_mock.get_request().headers["Authorization"] == "Bearer t"
+
+
+def test_delete_recorded_test_reads_a_404_as_already_gone(httpx_mock: HTTPXMock):
+    """Not an error: the row is gone, which is the state the caller was
+    asking for."""
+    httpx_mock.add_response(
+        method="DELETE", status_code=404, json={"detail": "recorded test not found"}
+    )
+    assert (
+        delete_recorded_test(api_url="http://api.test", token="t", test_id=uuid4())
+        is False
+    )
+
+
+def test_delete_recorded_test_raises_on_anything_else(httpx_mock: HTTPXMock):
+    httpx_mock.add_response(method="DELETE", status_code=500, json={"detail": "boom"})
+    with pytest.raises(ApiError) as exc:
+        delete_recorded_test(api_url="http://api.test", token="t", test_id=uuid4())
+    assert exc.value.status_code == 500
+    assert exc.value.message == "boom"
+
+
+def test_delete_recorded_test_wraps_a_transport_failure(httpx_mock: HTTPXMock):
+    httpx_mock.add_exception(httpx.ConnectError("no route"))
+    with pytest.raises(ApiError) as exc:
+        delete_recorded_test(api_url="http://api.test", token="t", test_id=uuid4())
+    assert exc.value.status_code == 0
+    assert "could not reach" in exc.value.message
+
+
 def test_post_recorder_heartbeat_declares_the_kinds_it_can_do(
     httpx_mock: HTTPXMock,
 ):

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/tests/test_testcmd.py

@@ -1674,6 +1674,7 @@ class Recording:
         rows,
         results,
         outcome,
+        deleted,
     ):
         self.code = code
         self.stream = stream
@@ -1685,9 +1686,12 @@ class Recording:
         self.rows = rows
         # Command results the CLI reported back on the driver's behalf.
         self.results = results
-        # What `record_one` answered — the exit code plus the one thing an
-        # exit code cannot say, whether the recording was discarded.
+        # What `record_one` answered — the exit code plus the two things an
+        # exit code cannot say: whether the recording was discarded, and
+        # whether the row was asked to go with it.
         self.outcome = outcome
+        # The ids `delete_recorded_test` was called with, in order.
+        self.deleted = deleted
 
 
 def _record(
@@ -1700,6 +1704,8 @@ def _record(
     replay_code: int = 0,
     extra_lines: tuple[str, ...] = (),
     acks: list[dict] | None = None,
+    delete_error: Exception | None = None,
+    delete_found: bool = True,
     **overrides,
 ) -> Recording:
     root = _repo(tmp_path)
@@ -1714,6 +1720,13 @@ def _record(
     queued = list(acks or [])
 
     outcomes: list[RecordOutcome] = []
+    deleted: list[dict] = []
+
+    def _delete(**kw):
+        deleted.append(kw)
+        if delete_error is not None:
+            raise delete_error
+        return delete_found
 
     def _post(**kw):
         posted.append(kw)
@@ -1760,6 +1773,7 @@ def _record(
             side_effect=lambda **kw: results.append(kw),
         ),
         patch("verifaied.testcmd.record_one", side_effect=_capture_outcome),
+        patch("verifaied.testcmd.delete_recorded_test", side_effect=_delete),
         _inline_poster(),
     ):
         code = run_test_record(**kwargs)
@@ -1774,6 +1788,7 @@ def _record(
         rows,
         results,
         outcomes[-1] if outcomes else None,
+        deleted,
     )
 
 
@@ -6095,9 +6110,165 @@ def test_record_discards_whatever_the_driver_exit_looked_like(tmp_path: Path):
     assert result.patched.call_count == 0
 
 
+DISCARD_COMMAND = {"id": "cmd-dis", "kind": "discard_recording", "payload": {}}
+
+
+def test_record_forwards_a_discard_the_same_way_it_forwards_a_cancel(tmp_path: Path):
+    """One ending down stdin, not two: the driver knows how to stop, and
+    what the row is worth afterwards is the CLI's question."""
+    row = _test_row(status="draft")
+    result = _record(
+        tmp_path,
+        test=row,
+        rows=[row],
+        events=(
+            {"type": "ready"},
+            {"type": "spec", "text": SPEC_BODY},
+            {"type": "cancelled", "id": "cmd-dis"},
+            {"type": "done", "spec_saved": True},
+        ),
+        acks=[{"commands": [DISCARD_COMMAND]}],
+    )
+    assert result.stream.stdin == [READY_CAPTURE, {"cmd": "cancel", "id": "cmd-dis"}]
+    assert result.results == [
+        {
+            "api_url": "http://api.test",
+            "token": "t",
+            "test_id": UUID(row["id"]),
+            "command_id": "cmd-dis",
+            "status": "done",
+            "result": {"ok": True, "cancelled": True},
+        }
+    ]
+
+
+def test_record_removes_the_row_when_a_first_recording_is_discarded(tmp_path: Path):
+    """The whole point of the second button: the row exists only because
+    somebody named a flow, so "this was a mistake" takes it with it."""
+    row = _test_row(status="draft")
+    console = _console()
+    result = _record(
+        tmp_path,
+        test=row,
+        rows=[row],
+        console=console,
+        events=(
+            {"type": "ready"},
+            {"type": "spec", "text": SPEC_BODY},
+            {"type": "cancelled", "id": "cmd-dis"},
+            {"type": "done", "spec_saved": True},
+        ),
+        acks=[{"commands": [DISCARD_COMMAND]}],
+    )
+    assert result.code == 0
+    assert result.outcome == RecordOutcome(0, cancelled=True, discarded=True)
+    assert not (result.root / row["spec_path"]).exists()
+    assert result.patched.call_count == 0
+    assert result.replayed.call_count == 0
+    # Nothing on disk, so nothing for the closing flowchart to say.
+    assert result.posted[-1]["live"] is False
+    assert result.posted[-1]["steps"] == []
+    assert [call["test_id"] for call in result.deleted] == [UUID(row["id"])]
+    assert result.deleted[0]["api_url"] == "http://api.test"
+    assert result.deleted[0]["token"] == "t"
+    printed = [str(call.args[0]) for call in console.print.call_args_list]
+    assert (
+        "[yellow]recording discarded[/yellow] — nothing was saved, and "
+        '"Settings/API tokens" is being removed.'
+    ) in printed
+    assert '[dim]"Settings/API tokens" removed from verifAIed.[/dim]' in printed
+
+
+def test_record_degrades_a_discard_on_a_saved_test_to_a_plain_cancel(tmp_path: Path):
+    """The endpoint refuses this, and the CLI checks again: a re-record
+    throwing away its attempt must never take the spec with it."""
+    row = _test_row(status="ready")
+    root = _repo(tmp_path)
+    _write_spec(root, row, OLD_SPEC_BODY)
+    before = (root / row["spec_path"]).read_bytes()
+    console = _console()
+
+    result = _record(
+        tmp_path,
+        test=row,
+        rows=[row],
+        console=console,
+        events=(
+            {"type": "ready"},
+            {"type": "spec", "text": SPEC_BODY},
+            {"type": "cancelled", "id": "cmd-dis"},
+            {"type": "done", "spec_saved": True},
+        ),
+        acks=[{"commands": [DISCARD_COMMAND]}],
+    )
+
+    assert result.outcome == RecordOutcome(0, cancelled=True, discarded=False)
+    assert result.deleted == []
+    assert (result.root / row["spec_path"]).read_bytes() == before
+    assert (
+        "[yellow]recording cancelled[/yellow] — nothing was saved, so "
+        '"Settings/API tokens" keeps the spec it already had.'
+    ) in [str(call.args[0]) for call in console.print.call_args_list]
+
+
+def test_record_says_so_when_the_row_was_already_gone(tmp_path: Path):
+    """A 404 is the state the caller asked for, not a failure."""
+    row = _test_row(status="draft")
+    console = _console()
+    result = _record(
+        tmp_path,
+        test=row,
+        rows=[row],
+        console=console,
+        delete_found=False,
+        events=(
+            {"type": "ready"},
+            {"type": "spec", "text": SPEC_BODY},
+            {"type": "cancelled", "id": "cmd-dis"},
+            {"type": "done", "spec_saved": True},
+        ),
+        acks=[{"commands": [DISCARD_COMMAND]}],
+    )
+    assert result.code == 0
+    assert '[dim]"Settings/API tokens" was already gone.[/dim]' in [
+        str(call.args[0]) for call in console.print.call_args_list
+    ]
+
+
+def test_record_survives_a_delete_it_could_not_land(tmp_path: Path):
+    """The recording is already over and the browser is already closed, so
+    a delete that fails is worth one yellow line and nothing more."""
+    row = _test_row(status="draft")
+    err_console = _console()
+    result = _record(
+        tmp_path,
+        test=row,
+        rows=[row],
+        err_console=err_console,
+        delete_error=ApiError(500, "boom"),
+        events=(
+            {"type": "ready"},
+            {"type": "spec", "text": SPEC_BODY},
+            {"type": "cancelled", "id": "cmd-dis"},
+            {"type": "done", "spec_saved": True},
+        ),
+        acks=[{"commands": [DISCARD_COMMAND]}],
+    )
+    assert result.code == 0
+    assert [str(call.args[0]) for call in err_console.print.call_args_list] == [
+        '[yellow]could not remove "Settings/API tokens"[/yellow] — '
+        "it stays a draft: boom"
+    ]
+
+
+def test_record_deletes_nothing_when_the_recording_was_saved(tmp_path: Path):
+    result = _record(tmp_path)
+    assert result.deleted == []
+
+
 def test_record_answers_not_cancelled_when_the_recording_was_saved(tmp_path: Path):
     result = _record(tmp_path)
-    assert result.outcome == RecordOutcome(0, cancelled=False)
+    assert result.outcome == RecordOutcome(0, cancelled=False, discarded=False)
 
 
 def test_record_ignores_a_command_kind_it_does_not_know(tmp_path: Path):
@@ -6446,6 +6617,8 @@ class Studio:
         amends,
         sleeps,
         err_console,
+        deleted,
+        order,
     ):
         self.code = code
         # Every heartbeat, in order, including the goodbye.
@@ -6461,6 +6634,11 @@ class Studio:
         self.amends = amends
         self.sleeps = sleeps
         self.err_console = err_console
+        # The ids `delete_recorded_test` was called with, in order.
+        self.deleted = deleted
+        # Status posts and deletes interleaved, so "after the status post"
+        # is something a test can actually see.
+        self.order = order
 
 
 def _studio_request(test_id: str, **overrides) -> dict:
@@ -6501,6 +6679,7 @@ def _studio(
     edit: object = None,
     amend: object = None,
     status_error: Exception | None = None,
+    delete_error: Exception | None = None,
     goodbye_error: Exception | None = None,
     sleeps_before_stop: int | None = None,
     branches: list[str] | None = None,
@@ -6515,6 +6694,8 @@ def _studio(
     edits: list[dict] = []
     amends: list[dict] = []
     sleeps: list[float] = []
+    deleted: list[dict] = []
+    order: list[str] = []
     queued = list(acks)
     err_console = _console()
 
@@ -6535,9 +6716,17 @@ def _studio(
 
     def _status(**kw):
         statuses.append(kw)
+        order.append(f"status:{kw['status']}")
         if status_error is not None and kw["status"] == "failed":
             raise status_error
 
+    def _delete(**kw):
+        deleted.append(kw)
+        order.append("delete")
+        if delete_error is not None:
+            raise delete_error
+        return True
+
     def _sleep(seconds):
         sleeps.append(seconds)
         if sleeps_before_stop is not None and len(sleeps) >= sleeps_before_stop:
@@ -6604,10 +6793,21 @@ def _studio(
         patch("verifaied.testcmd.replay_spec", side_effect=_replay_spec),
         patch("verifaied.testcmd.edit_one", side_effect=_edit_one),
         patch("verifaied.testcmd.amend_one", side_effect=_amend_one),
+        patch("verifaied.testcmd.delete_recorded_test", side_effect=_delete),
     ):
         code = run_test_studio(**kwargs)
     return Studio(
-        code, beats, statuses, records, replays, edits, amends, sleeps, err_console
+        code,
+        beats,
+        statuses,
+        records,
+        replays,
+        edits,
+        amends,
+        sleeps,
+        err_console,
+        deleted,
+        order,
     )
 
 
@@ -6879,6 +7079,68 @@ def test_studio_reports_a_discarded_recording_as_cancelled(tmp_path: Path):
     assert "error" not in result.statuses[1]
 
 
+def test_studio_removes_the_row_after_reporting_a_discard(tmp_path: Path):
+    """The order is load-bearing: the request row cascades with the test
+    it names, so deleting first would leave the ending nowhere to land."""
+    row = _test_row(status="draft")
+    request = _studio_request(row["id"])
+
+    result = _studio(
+        tmp_path,
+        acks=[_ack(request)],
+        rows=[row],
+        record=lambda **kw: RecordOutcome(0, cancelled=True, discarded=True),
+    )
+
+    assert result.code == 0
+    assert [s["status"] for s in result.statuses] == ["recording", "cancelled"]
+    assert result.order == ["status:recording", "status:cancelled", "delete"]
+    assert [call["test_id"] for call in result.deleted] == [
+        UUID(request["recorded_test_id"])
+    ]
+    assert result.deleted[0]["api_url"] == "http://api.test"
+
+
+def test_studio_deletes_nothing_for_a_cancel_that_kept_the_draft(tmp_path: Path):
+    row = _test_row(status="draft")
+    result = _studio(
+        tmp_path,
+        acks=[_ack(_studio_request(row["id"]))],
+        rows=[row],
+        record=lambda **kw: RecordOutcome(0, cancelled=True),
+    )
+    assert [s["status"] for s in result.statuses] == ["recording", "cancelled"]
+    assert result.deleted == []
+
+
+def test_studio_keeps_going_when_a_discard_could_not_be_removed(tmp_path: Path):
+    """One row that would not delete is not a dead daemon: the next
+    request is still taken."""
+    first = _test_row(status="draft")
+    second = _test_row(status="draft")
+
+    result = _studio(
+        tmp_path,
+        acks=[
+            _ack(_studio_request(first["id"])),
+            _ack(_studio_request(second["id"])),
+        ],
+        rows=[first, second],
+        record=lambda **kw: RecordOutcome(0, cancelled=True, discarded=True),
+        delete_error=ApiError(500, "boom"),
+    )
+
+    assert result.code == 0
+    assert [s["status"] for s in result.statuses] == [
+        "recording",
+        "cancelled",
+        "recording",
+        "cancelled",
+    ]
+    assert len(result.deleted) == 2
+    assert result.err_console.print.called
+
+
 def test_studio_fails_a_request_whose_test_was_deleted(tmp_path: Path):
     result = _studio(
         tmp_path,
@@ -10898,6 +11160,39 @@ def test_a_cancelled_edit_leaves_the_spec_byte_identical(tmp_path: Path):
     assert result.posted[-1]["live"] is False
 
 
+def test_a_discard_collected_during_an_edit_is_just_a_cancel(tmp_path: Path):
+    """An edit only ever happens on a test that already has a spec, which
+    is exactly the row a discard is fenced off from — so a session that
+    somehow collected one still ends with the saved flow standing."""
+    events = (
+        {"type": "ready"},
+        {"type": "spec", "text": EDIT_TAIL},
+        {"type": "cancelled", "id": "c1"},
+        {"type": "done", "spec_saved": False},
+    )
+    result = _edit(
+        tmp_path,
+        edit_from=1,
+        events=events,
+        acks=[
+            {
+                "commands": [
+                    {"id": "c1", "kind": "discard_recording", "payload": {}},
+                ]
+            }
+        ],
+    )
+    assert result.code == 0
+    assert result.spec == EDIT_SPEC
+    assert result.patched.call_count == 0
+    assert result.replayed.call_count == 0
+    assert [step["label"] for step in result.posted[-1]["steps"]] == [
+        "Open http://localhost:3000/settings",
+        "Click 'New token'",
+        "'Created' is visible",
+    ]
+
+
 def test_an_edit_that_recorded_nothing_truncates_to_what_was_kept(
     tmp_path: Path,
 ):

{verifaied-0.23.1.dev48 → verifaied-0.24.0.dev49}/uv.lock

@@ -442,7 +442,7 @@ wheels = [
 
 [[package]]
 name = "verifaied"
-version = "0.23.1"
+version = "0.24.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },