From e18b1bb305e6da5cf5af00ef66ba95307ffb5f23 Mon Sep 17 00:00:00 2001 From: Frank Chen <65260095+zhongkechen@users.noreply.github.com> Date: Wed, 18 Nov 2026 11:02:25 -0700 Subject: [PATCH 1/3] test(lmi): reproduce peer dispatch without a recorded wrapper return --- .../tests/test_lmi_evidence.py | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py b/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py index 87518d95..6c1c390e 100644 --- a/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py +++ b/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py @@ -429,6 +429,38 @@ def test_dispatch_after_wrapper_return_is_rejected() -> None: assert any("after admission closed" in error for error in validate_evidence(value)) +@pytest.mark.parametrize("phase", ["observations", "final"]) +@pytest.mark.parametrize( + "keep_peer_return", + [ + pytest.param(True, id="with-peer-return"), + pytest.param( + False, + id="missing-peer-return", + marks=pytest.mark.xfail( + strict=True, + raises=pytest.fail.Exception, + reason="PR #193: a peer dispatch can pass validation when its wrapper return is missing", + ), + ), + ], +) +def test_late_peer_dispatch(phase: Literal["observations", "final"], keep_peer_return: bool) -> None: + value = evidence() + peer = value["attempts"][1] + if not keep_peer_return: + value["events"].remove( + next(e for e in value["events"] if e["requestId"] == peer["requestId"] and e["kind"] == "wrapper_return") + ) + value["sdkRequests"].append(event(peer, "request", 100, method="CheckpointDurableExecution", outcome="DISPATCHED")) + + errors = validate_evidence(value, phase=phase) + if keep_peer_return: + assert any(peer["requestId"] in error and "after admission closed" in error for error in errors), errors + elif errors == []: + pytest.fail("validate_evidence returned [] for the 100 ms peer dispatch without a recorded wrapper return") + + def test_missing_dispatch_collection_cannot_prove_no_dispatch() -> None: value = evidence(2) value["sdkRequests"] = [] From 78106617574041f91b33f4d95dbe3be8e650293e Mon Sep 17 00:00:00 2001 From: Frank Chen <65260095+zhongkechen@users.noreply.github.com> Date: Thu, 19 Nov 2026 22:45:20 +0000 Subject: [PATCH 2/3] fix(lmi): flag dispatch after an attempt ends without closure evidence --- .../lmi/evidence-schema.md | 5 ++- .../lmi/evidence.py | 30 +++++++++------ .../tests/test_lmi_evidence.py | 37 +++++++++++-------- 3 files changed, 43 insertions(+), 29 deletions(-) diff --git a/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence-schema.md b/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence-schema.md index 8615da14..10112b5e 100644 --- a/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence-schema.md +++ b/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence-schema.md @@ -77,7 +77,10 @@ when their timestamps tie, and for every event when proving physical retirement. Each has the same ownership/time fields plus `method` and `outcome` (`DISPATCHED` or `REJECTED`). No dispatch is allowed at or after that invocation's first `wrapper_return`, `wrapper_raise`, or `admission_closed`. A raised wrapper exit -closes admission for peers, resumes, retries, and warm requests too. The disposal +closes admission for peers, resumes, retries, and warm requests too. If no +closure is recorded and a dispatch follows the attempt's `endedAtMs`, the +evidence is incomplete. The recorded end may come from a fixture observation +and does not establish when admission closed. The disposal fixtures specifically require a `wrapper_return`, including their normal root failure case; a wrapper that itself throws is a different boundary. Admission probes are separate `admission_probe` events with `probe: operation | checkpoint` diff --git a/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence.py b/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence.py index 8948f77b..c573e6c4 100644 --- a/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence.py +++ b/packages/aws-durable-execution-conformance-tests/src/aws_durable_execution_conformance_tests/lmi/evidence.py @@ -409,7 +409,7 @@ def probe_at_or_after(self, probe: Mapping[str, Any], boundary: Mapping[str, Any def no_late_dispatch(self) -> None: disposal = self.value.get("requirementId") in ("lmi-lifecycle-2", "lmi-lifecycle-7") - for request_id in self.attempts: + for request_id, attempt in self.attempts.items(): closures = [ event for event in self.events @@ -417,9 +417,24 @@ def no_late_dispatch(self) -> None: and event.get("kind") in ("wrapper_return", "wrapper_raise", "admission_closed") and isinstance(event.get("atMs"), (float, int)) ] - if not closures: + closed = min((event["atMs"] for event in closures), default=None) + ended = attempt.get("endedAtMs") + for request in self.value.get("sdkRequests", []): + if ( + not isinstance(request, Mapping) + or request.get("requestId") != request_id + or request.get("outcome") != "DISPATCHED" + or not isinstance(at := request.get("atMs"), (float, int)) + ): + continue + if closed is not None and at >= closed: + self.error(f"request {request_id} dispatched SDK work after admission closed", "ASSERTION") + elif closed is None and isinstance(ended, (float, int)) and at > ended: + self.error( + f"request {request_id} dispatched SDK work after its recorded end without closure evidence" + ) + if closed is None: continue - closed = min(event["atMs"] for event in closures) wrapper = None if disposal and request_id == self.selected.get("victim", {}).get("requestId"): exits = [event for event in closures if event["kind"] != "admission_closed"] @@ -427,15 +442,6 @@ def no_late_dispatch(self) -> None: wrapper = exits[0] elif len(exits) > 1: self.error("disposal needs exactly one wrapper exit for the selected victim") - for request in self.value.get("sdkRequests", []): - if ( - isinstance(request, Mapping) - and request.get("requestId") == request_id - and request.get("outcome") == "DISPATCHED" - and isinstance(request.get("atMs"), (float, int)) - and request["atMs"] >= closed - ): - self.error(f"request {request_id} dispatched SDK work after admission closed", "ASSERTION") for event in self.events: if ( event.get("requestId") == request_id diff --git a/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py b/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py index ab1f508a..bb3d29db 100644 --- a/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py +++ b/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py @@ -9,6 +9,7 @@ import pytest from aws_durable_execution_conformance_tests.lmi.evidence import ( + EvidenceValidator, _Evidence, same_json, validate_common_evidence, @@ -430,35 +431,39 @@ def test_dispatch_after_wrapper_return_is_rejected() -> None: @pytest.mark.parametrize("phase", ["observations", "final"]) +@pytest.mark.parametrize("validate", [validate_evidence, validate_common_evidence]) @pytest.mark.parametrize( - "keep_peer_return", + ("keep_peer_return", "at", "outcome", "expected"), [ - pytest.param(True, id="with-peer-return"), - pytest.param( + (True, 100, "DISPATCHED", "ASSERTION: request request-peer dispatched SDK work after admission closed"), + ( False, - id="missing-peer-return", - marks=pytest.mark.xfail( - strict=True, - raises=pytest.fail.Exception, - reason="PR #193: a peer dispatch can pass validation when its wrapper return is missing", - ), + 100, + "DISPATCHED", + "INCOMPLETE: request request-peer dispatched SDK work after its recorded end without closure evidence", ), + (False, 41, "DISPATCHED", None), + (False, 42, "DISPATCHED", None), + (False, 100, "REJECTED", None), ], ) -def test_late_peer_dispatch(phase: Literal["observations", "final"], keep_peer_return: bool) -> None: +def test_late_peer_dispatch( + phase: Literal["observations", "final"], + validate: EvidenceValidator, + keep_peer_return: bool, + at: int, + outcome: str, + expected: str | None, +) -> None: value = evidence() peer = value["attempts"][1] if not keep_peer_return: value["events"].remove( next(e for e in value["events"] if e["requestId"] == peer["requestId"] and e["kind"] == "wrapper_return") ) - value["sdkRequests"].append(event(peer, "request", 100, method="CheckpointDurableExecution", outcome="DISPATCHED")) + value["sdkRequests"].append(event(peer, "request", at, method="CheckpointDurableExecution", outcome=outcome)) - errors = validate_evidence(value, phase=phase) - if keep_peer_return: - assert any(peer["requestId"] in error and "after admission closed" in error for error in errors), errors - elif errors == []: - pytest.fail("validate_evidence returned [] for the 100 ms peer dispatch without a recorded wrapper return") + assert validate(value, phase=phase) == ([expected] if expected is not None else []) def test_missing_dispatch_collection_cannot_prove_no_dispatch() -> None: From b754233a9cb0cb10f671365aecb6bfdbbdea5336 Mon Sep 17 00:00:00 2001 From: Frank Chen <65260095+zhongkechen@users.noreply.github.com> Date: Thu, 19 Nov 2026 23:11:33 +0000 Subject: [PATCH 3/3] test(lmi): cover dispatch before an explicit late closure --- .../tests/test_lmi_evidence.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py b/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py index bb3d29db..a9e5ef84 100644 --- a/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py +++ b/packages/aws-durable-execution-conformance-tests/tests/test_lmi_evidence.py @@ -466,6 +466,20 @@ def test_late_peer_dispatch( assert validate(value, phase=phase) == ([expected] if expected is not None else []) +@pytest.mark.parametrize("phase", ["observations", "final"]) +@pytest.mark.parametrize("validate", [validate_evidence, validate_common_evidence]) +def test_dispatch_after_recorded_end_before_explicit_closure_is_allowed( + phase: Literal["observations", "final"], validate: EvidenceValidator +) -> None: + value = evidence() + peer = value["attempts"][1] + closure = next(e for e in value["events"] if e["requestId"] == peer["requestId"] and e["kind"] == "wrapper_return") + closure.update(kind="admission_closed", atMs=50) + value["sdkRequests"].append(event(peer, "request", 45, method="CheckpointDurableExecution", outcome="DISPATCHED")) + + assert validate(value, phase=phase) == [] + + def test_missing_dispatch_collection_cannot_prove_no_dispatch() -> None: value = evidence(2) value["sdkRequests"] = []