Marsh 1979-06-14
" + return "No matches were found.
" + + +def test_a_step_write_that_changes_the_search_result_stops_the_save(app_page): + """The span sends a step write (the page's draft) after the duplicate + search was read and before the save. The GUI checks its empty-result + guard after that write, right before the save; so must the API step.""" + + from openadapt_flow.ir import ApiBinding, WebFormPrecheck, WebFormWrite + from openadapt_flow.runtime.actuators import ActuationStatus + + app, page = app_page + app.form( + script="document.forms[0].lname.addEventListener('change', e => fetch('/draft.php', {" + " method: 'POST', headers: {'Content-Type': 'application/x-www-form-urlencoded'}," + " body: 'lname=' + encodeURIComponent(e.target.value) }));" + ) + app.pages = _DupSearch(app) + html = app.pages["/new.php"].replace("{n}", "1") + names = ["csrf", "lname", "dob", "state"] + spec = WebFormSpec( + form_path="/new.php", + fields=[ + WebFormField(name="csrf", source="session"), + WebFormField(name="lname", source="param", param="lname"), + WebFormField(name="dob", source="param", param="dob"), + WebFormField(name="state", source="select_label", param="state_label"), + ], + controls=sorted(names), + client_scripts=page_scripts(html, "/save.php", names, None), + submitter="button[type=submit]", + prechecks=[ + WebFormPrecheck( + path="/dup.php", + query=[("lname", "{lname}")], + require_text=["No matches were found."], + from_step="s0", + ) + ], + writes=[ + WebFormWrite( + role="step", + method="POST", + path="/draft.php", + from_step="s1", + fields=[WebFormField(name="lname", source="param", param="lname")], + expected_status=[200], + ) + ], + replaces_steps=["s0", "s1", "s2"], + folded_checks_digest="sha256:" + "0" * 64, + ) + binding = ApiBinding( + kind="web_form", method="POST", url_template="/save.php", web_form=spec + ) + actuator = WebFormActuator(PlaywrightSessionTransport(page)) + out = actuator.actuate(binding, RUN) + # The draft went out, as under the GUI steps; the search then finds the + # record, so the save never leaves. + assert app.writes == ["/draft.php"], app.writes + assert out.status is ActuationStatus.HALT, out.reason + assert "after the 1 step write(s) were accepted" in out.reason + assert "No matches were found." in out.reason + assert [e["stage"] for e in actuator.log][-3:] == ["precheck", "write", "precheck"] diff --git a/packages/flow/tests/test_create_form_wire.py b/packages/flow/tests/test_create_form_wire.py index ef5cb23bec..f0265811af 100644 --- a/packages/flow/tests/test_create_form_wire.py +++ b/packages/flow/tests/test_create_form_wire.py @@ -1195,3 +1195,122 @@ def test_an_api_span_after_a_late_refusal_halts_before_sending( assert "after the previous save" in (halt.error or "") or ( "after an earlier save" in (halt.error or "") ), halt.error + + +class _LateSubmitThenRejectedActuator: + """An API step whose save the server rejects, while the live page sends + a stray submit that the earlier save's wire check, still armed, aborts.""" + + def __init__(self, page: Any) -> None: + self.page, self.calls = page, 0 + + def actuate(self, binding: Any, params: Any) -> Any: + from openadapt_flow.runtime.actuators import ( + ActuationStatus, + ApiActuationResult, + ApiHaltKind, + ) + + self.calls += 1 + # After the span's first read of the check: the stray submit goes out + # now, and the wire check aborts it. + self.page.evaluate("() => window.__sendLate()") + self.page.wait_for_timeout(500) + return ApiActuationResult( + status=ActuationStatus.HALT, + halt_kind=ApiHaltKind.RESPONSE_REJECTED, + http_status=500, + reason="POST /save.php -> 500 without the recorded success response", + ) + + +def test_a_late_refusal_adds_to_an_earlier_halt_instead_of_replacing_it( + server: _Server, tmp_path_factory: pytest.TempPathFactory +) -> None: + """The span halts for its own reason (its save was rejected), and a + stray submit is aborted during the span. The end-of-run read keeps the + span's message and category and adds the late refusal.""" + + from openadapt_flow.backends.playwright_backend import ( + PlaywrightBackend, + prepare_ws_guard, + ) + from openadapt_flow.ir import RunReport, StepResult + from openadapt_flow.mockmed.fault_server import serve as fault_serve + from openadapt_flow.runtime import Replayer + from openadapt_flow.runtime.effects import RestRecordVerifier + from tests.test_api_tier_web_form import _span_workflow + + bundle = _bundle(server, "fetch", tmp_path_factory.mktemp("rec")) + sor_url, _db, stop_sor = fault_serve() + with sync_api.sync_playwright() as playwright: + browser = playwright.chromium.launch(headless=True) + try: + page = browser.new_context( + service_workers="block", viewport={"width": 1280, "height": 800} + ).new_page() + prepare_ws_guard(page.context) + page.goto(f"{server.url}?v=fetchlate") + page.wait_for_selector("[name=field_summary]", state="visible") + backend = PlaywrightBackend(page) + saved = Replayer(backend).run( + Workflow.load(bundle), + params={ + "field_summary": "Scanner offline on floor 3", + "field_description": "Since this morning", + }, + bundle_dir=bundle, + run_dir=tmp_path_factory.mktemp("run"), + ) + assert backend.form_submit_guard_refusal() is None + actuator = _LateSubmitThenRejectedActuator(page) + span_bundle = tmp_path_factory.mktemp("span") + (span_bundle / "templates").mkdir() + replayer = Replayer( + backend, + web_form_actuator=actuator, + effect_verifier=RestRecordVerifier(sor_url.rstrip("/")), + poll_interval_s=0.01, + ) + report = replayer.run( + _span_workflow(), + bundle_dir=span_bundle, + run_dir=tmp_path_factory.mktemp("run"), + ) + late = backend.form_submit_guard_refusal() + # The same end-of-run read on a run whose last step halted with + # another category: the category is kept. + governed = RunReport( + workflow_name="span", + started_at="t", + success=False, + results=[ + StepResult( + step_id="step_001", + intent="save", + ok=False, + failure_category="governed_refusal", + error="the record check was refuted; reconcile", + ) + ], + ) + replayer._halt_on_late_form_submit(governed) + finally: + browser.close() + stop_sor() + assert saved.success, [(r.step_id, r.error) for r in saved.results] + assert actuator.calls == 1 and late is not None + assert not report.success + halt = report.results[-1] + assert halt.actuation == "api" and halt.delivery_attempted + assert halt.safety_halt and halt.failure_category == "safety_halt" + # The span's own reason first, then the late refusal. + own, _, added = (halt.error or "").partition("; also after an earlier save, ") + assert "outside the binding's accepted contract" in own, halt.error + assert added == late, halt.error + kept = governed.results[0] + assert not governed.success and not kept.ok and kept.safety_halt + assert kept.failure_category == "governed_refusal" + assert kept.error == ( + f"the record check was refuted; reconcile; also after an earlier save, {late}" + )