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 abc84eb1..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 @@ -9,6 +9,7 @@ import pytest from aws_durable_execution_conformance_tests.lmi.evidence import ( + EvidenceValidator, _Evidence, same_json, validate_common_evidence, @@ -429,6 +430,56 @@ 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("validate", [validate_evidence, validate_common_evidence]) +@pytest.mark.parametrize( + ("keep_peer_return", "at", "outcome", "expected"), + [ + (True, 100, "DISPATCHED", "ASSERTION: request request-peer dispatched SDK work after admission closed"), + ( + False, + 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"], + 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", at, method="CheckpointDurableExecution", outcome=outcome)) + + 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"] = []