ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.
Python active-directorycloud-securitydefensive-validationfastapigood-first-issuemitre-attackopsecreactred-teamreportingsecurity
"""Deterministic SQLite contract tests for revision-0010 lifecycle storage."""
from __future__ import annotations
import asyncio
import hashlib
import sqlite3
import struct
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from dataclasses import MISSING, FrozenInstanceError, fields, is_dataclass, replace
from typing import Any, get_type_hints
import aiosqlite
import pytest
import ares.modules.descriptors as descriptor_module
from ares.core.capabilities import Capability
from ares.db.database import AresDatabase
from ares.db.execution_lifecycle import (
ACTOR_ROLES,
CAPABILITY_BITS_V1,
DESCRIPTOR_BLOCKER_BITS_V1,
LIFECYCLE_TABLES,
MAX_I53,
OUTBOX_LEASE_MS,
SYSTEM_PRINCIPAL_SUBJECT_REF,
ActorAuthorityMutation,
AdmissionIntentV3,
AdmissionRequest,
ApprovalAuthorityGrant,
ApprovalAuthorityMutation,
AttemptPolicySnapshot,
AttemptState,
BudgetConfiguration,
BudgetReservation,
BudgetSettlement,
CampaignActorGrantMutation,
CampaignAuthorityMutation,
ClosureRequest,
CredentialAuthorityMutation,
DestinationAuthorityMutation,
ExecutionLifecycleStore,
FixedResult,
GatewayAuthorityMutation,
OperationResult,
OutboxMutation,
OutcomeCode,
OutputKind,
OutputObservation,
PolicyReasonBit,
RetryIntentV3,
RetryRequest,
TerminalCommitIntentV3,
TerminalCommitRequest,
TransitionRequest,
TrustedPrincipal,
_AbortOperationError,
canonical_operation_binding_digest,
retry_delay_ms,
valid_uuid,
validate_sqlite_lifecycle_catalog,
)
from ares.db.schema import CREATE_TABLES, SCHEMA_VERSION
from ares.modules.descriptors import (
CancellationOwnership,
CompensationClass,
ContractState,
DestinationCardinality,
DestinationKind,
DestinationSpec,
ExternalEffectClass,
IdempotencyClass,
MinimumRole,
ModuleDescriptor,
OpsecClassification,
ResultContract,
RetryEligibility,
ScopeSemantics,
TimeoutPolicy,
TimeoutSettlement,
)
_UUIDS = (
"00000000-0000-4000-8000-000000000001",
"00000000-0000-4000-8000-000000000002",
"00000000-0000-4000-8000-000000000003",
"00000000-0000-4000-8000-000000000004",
"00000000-0000-4000-8000-000000000005",
"00000000-0000-4000-8000-000000000006",
"00000000-0000-4000-8000-000000000007",
"00000000-0000-4000-8000-000000000008",
)
_STATE_VALUES = (
"rejected",
"blocked",
"accepted",
"queued",
"dispatching",
"running",
"cancelling",
"settlement_pending",
"succeeded",
"partial",
"failed",
"skipped",
"cancelled",
"timed_out",
"indeterminate",
)
_EXPECTED_LEGAL = frozenset(
{
("accepted", "queued"),
("accepted", "dispatching"),
("accepted", "cancelling"),
("accepted", "skipped"),
("accepted", "failed"),
("queued", "dispatching"),
("queued", "cancelling"),
("queued", "skipped"),
("queued", "failed"),
("dispatching", "running"),
("dispatching", "cancelling"),
("dispatching", "failed"),
("dispatching", "settlement_pending"),
("running", "cancelling"),
("running", "succeeded"),
("running", "partial"),
("running", "failed"),
("running", "timed_out"),
("running", "settlement_pending"),
("cancelling", "succeeded"),
("cancelling", "partial"),
("cancelling", "failed"),
("cancelling", "cancelled"),
("cancelling", "timed_out"),
("cancelling", "settlement_pending"),
("settlement_pending", "succeeded"),
("settlement_pending", "partial"),
("settlement_pending", "failed"),
("settlement_pending", "cancelled"),
("settlement_pending", "timed_out"),
("settlement_pending", "indeterminate"),
}
)
_ALL_ORDERED_PAIRS = tuple((source, target) for source in _STATE_VALUES for target in _STATE_VALUES)
_ILLEGAL = tuple(pair for pair in _ALL_ORDERED_PAIRS if pair not in _EXPECTED_LEGAL)
@pytest.mark.parametrize(
("source", "target"),
tuple(sorted(_EXPECTED_LEGAL)),
ids=lambda value: value,
)
@pytest.mark.asyncio
async def test_each_legal_transition_is_frozen(tmp_path, source: str, target: str) -> None:
result, before, after, observer = await _exercise_transition_pair(
tmp_path / f"legal-{source}-{target}.db", source, target
)
assert result is FixedResult.APPLIED, "legal persistence transition failed"
assert after != before, "legal persistence transition did not mutate"
assert observer == after, "legal transition was not durably observable"
@pytest.mark.parametrize(
("source", "target"),
_ILLEGAL,
ids=lambda value: value,
)
@pytest.mark.asyncio
async def test_each_illegal_transition_is_rejected(tmp_path, source: str, target: str) -> None:
result, before, after, observer = await _exercise_transition_pair(
tmp_path / f"illegal-{source}-{target}.db", source, target
)
assert result is not FixedResult.APPLIED, "illegal persistence transition applied"
assert after == before, "illegal persistence transition mutated state"
assert observer == before, "illegal transition leaked a committed mutation"
def test_transition_matrix_has_exact_recomputed_totals() -> None:
assert len(_EXPECTED_LEGAL) == 31, "legal transition total changed"
assert len(_ILLEGAL) == 194, "illegal transition total changed"
assert len(_ALL_ORDERED_PAIRS) == 225, "state matrix total changed"
def test_self_transitions_are_never_legal() -> None:
assert all((state, state) in _ILLEGAL for state in _STATE_VALUES), "self transition accepted"
def test_runtime_catalog_has_exact_eleven_tables_and_disabled_gateway() -> None:
connection = sqlite3.connect(":memory:")
try:
connection.execute("PRAGMA foreign_keys=ON")
connection.executescript(CREATE_TABLES)
validate_sqlite_lifecycle_catalog(connection)
rows = connection.execute(
"SELECT name FROM sqlite_schema WHERE type='table' "
"AND name IN (?,?,?,?,?,?,?,?,?,?,?) ORDER BY name",
LIFECYCLE_TABLES,
).fetchall()
gateway = connection.execute(
"SELECT mode,revision,catalog_digest,activation_revision,activation_at "
"FROM execution_gateway_state"
).fetchall()
finally:
connection.close()
assert tuple(row[0] for row in rows) == tuple(sorted(LIFECYCLE_TABLES)), (
"lifecycle table inventory changed"
)
assert gateway == [("disabled", 0, None, None, None)], "gateway bootstrap changed"
assert SCHEMA_VERSION == 9, "legacy schema marker changed"
def _independent_binding_digest(
domain: str, values: tuple[tuple[str, str | int | bool | None], ...]
) -> str:
import struct
encoded = bytearray(b"ares.execution-operation-binding.v2\x00")
def frame(value: bytes) -> None:
encoded.extend(struct.pack(">I", len(value)))
encoded.extend(value)
frame(domain.encode("ascii"))
for name, value in values:
frame(name.encode("ascii"))
if value is None:
encoded.extend(b"n")
elif type(value) is bool:
encoded.extend(b"b\x01" if value else b"b\x00")
elif type(value) is int:
encoded.extend(b"i")
frame(value.to_bytes(8, "big"))
else:
encoded.extend(b"s")
frame(value.encode("utf-8"))
return hashlib.sha256(encoded).hexdigest()
def test_operation_binding_uses_independent_typed_length_framing() -> None:
fields = (("alpha", "value"), ("beta", 7), ("gamma", True), ("delta", None))
expected = "ef0eb625d5c662f1f1b30a1e72facc1871aa242627ccd7756f706eecc4b6401d"
assert _independent_binding_digest("test.operation", fields) == expected, (
"independent operation binding oracle changed"
)
assert canonical_operation_binding_digest("test.operation", fields) == expected, (
"operation binding canonicalization changed"
)
@pytest.mark.asyncio
async def test_authority_receipt_replay_is_stable_after_later_revision() -> None:
connection = await _new_connection()
try:
await connection.executemany(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(
(_uuid(900), "receipt-a", "fixed-hash", "admin", "fixed"),
(_uuid(901), "receipt-b", "fixed-hash", "admin", "fixed"),
),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
applied = await store.ensure_actor_authority(_uuid(900), _uuid(902))
replayed = await store.ensure_actor_authority(_uuid(900), _uuid(902))
conflicted = await store.ensure_actor_authority(_uuid(901), _uuid(902))
invalidated = await store.invalidate_actor_authority(_uuid(900), 0, _uuid(903))
replayed_after_revision = await store.ensure_actor_authority(_uuid(900), _uuid(902))
counts = await (
await connection.execute(
"SELECT (SELECT count(*) FROM execution_actor_authority_revisions),"
"(SELECT count(*) FROM execution_operation_receipts)"
)
).fetchone()
finally:
await connection.close()
assert (
applied.result,
replayed.result,
conflicted.result,
invalidated.result,
replayed_after_revision.result,
) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
FixedResult.CONFLICT_OPERATION,
FixedResult.APPLIED,
FixedResult.REPLAYED,
), "authority receipt classification changed"
assert tuple(counts) == (1, 2), "authority receipt cardinality changed"
@pytest.mark.asyncio
async def test_receipt_failure_rolls_back_domain_mutation(monkeypatch) -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(910), "receipt-rollback", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
async def fail_receipt(*_args, **_kwargs) -> None:
raise RuntimeError("fixed-receipt-failure")
monkeypatch.setattr(store, "_insert_receipt", fail_receipt)
with pytest.raises(RuntimeError, match="fixed-receipt-failure"):
await store.ensure_actor_authority(_uuid(910), _uuid(911))
counts = await (
await connection.execute(
"SELECT (SELECT count(*) FROM execution_actor_authority_revisions),"
"(SELECT count(*) FROM execution_operation_receipts)"
)
).fetchone()
finally:
await connection.close()
assert tuple(counts) == (0, 0), "receipt failure split the atomic mutation"
@pytest.mark.asyncio
async def test_forced_zero_row_cas_never_reports_applied(monkeypatch) -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(920), "zero-row", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(920), _uuid(921))
).result is FixedResult.APPLIED, "zero-row authority setup failed"
async def zero_rows(*_args, **_kwargs):
return ()
monkeypatch.setattr(store, "_returning_rows", zero_rows)
result = await store.invalidate_actor_authority(_uuid(920), 0, _uuid(922))
row = await (
await connection.execute(
"SELECT revision FROM execution_actor_authority_revisions WHERE user_id=?",
(_uuid(920),),
)
).fetchone()
finally:
await connection.close()
assert result.result is FixedResult.CONFLICT_REVISION, "zero-row CAS reported success"
assert int(row[0]) == 0, "zero-row CAS mutated authority"
@pytest.mark.asyncio
async def test_unexpected_returning_set_rolls_back_and_fails_fixed(monkeypatch) -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(930), "returning-set", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(930), _uuid(931))
).result is FixedResult.APPLIED, "returning-set authority setup failed"
original = store._returning_rows
async def duplicate_rows(*args, **kwargs):
rows = await original(*args, **kwargs)
return rows + rows
monkeypatch.setattr(store, "_returning_rows", duplicate_rows)
result = await store.invalidate_actor_authority(_uuid(930), 0, _uuid(932))
row = await (
await connection.execute(
"SELECT revision FROM execution_actor_authority_revisions WHERE user_id=?",
(_uuid(930),),
)
).fetchone()
receipt = await (
await connection.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(_uuid(932),),
)
).fetchone()
finally:
await connection.close()
assert result.result is FixedResult.INVARIANT_FAILURE, "returned-set mismatch was accepted"
assert (int(row[0]), int(receipt[0])) == (0, 0), "returned-set mismatch split atomic state"
@pytest.mark.parametrize(
("value", "accepted"),
[
("00000000-0000-4000-8000-000000000001", True),
("00000000-0000-5000-8000-000000000001", False),
("00000000-0000-4000-7000-000000000001", False),
("00000000-0000-4000-8000-00000000000A", False),
(True, False),
(1, False),
(None, False),
],
ids=("valid", "wrong-version", "wrong-variant", "uppercase", "bool", "int", "none"),
)
def test_uuid_contract_is_exact(value: object, accepted: bool) -> None:
assert valid_uuid(value) is accepted, "UUID contract changed"
def test_stable_mask_allocations_are_literal() -> None:
assert CAPABILITY_BITS_V1 == {
"network": 1,
"execution": 2,
"filesystem": 4,
"process": 8,
}, "capability allocation changed"
assert DESCRIPTOR_BLOCKER_BITS_V1 == {
"ambient_credentials_forbidden": 1,
"cancellation_ownership_unproven": 2,
"dynamic_destination_unbounded": 4,
"default_factory_unevaluated": 8,
"llm_egress_policy_required": 16,
"lifecycle_contract_unproven": 32,
"raw_credential_input": 64,
"result_authority_unproven": 128,
"sensitive_nonempty_default": 256,
}, "descriptor blocker allocation changed"
assert {member.name: member.value for member in PolicyReasonBit} == {
"INVALID_CONTRACT": 1,
"INCONSISTENT_CONTRACT": 2,
"INVALID_REQUEST": 4,
"DESCRIPTOR_UNTRUSTED": 8,
"DESCRIPTOR_BINDING_INVALID": 16,
"DESCRIPTOR_INCOMPLETE": 32,
"STATIC_POLICY_UNAVAILABLE": 64,
"AUTHORITY_RESOLUTION_REQUIRED": 128,
"STALE_AUTHORITY": 256,
"ACTOR_UNAUTHENTICATED": 512,
"ACTOR_INACTIVE": 1_024,
"CAMPAIGN_INACTIVE": 2_048,
"CAMPAIGN_UNAUTHORIZED": 4_096,
"INSUFFICIENT_ROLE": 8_192,
"HIGH_NOISE_ROLE_REQUIRED": 16_384,
"APPROVAL_REQUIRED": 32_768,
"APPROVAL_STALE": 65_536,
"APPROVAL_BINDING_INVALID": 131_072,
"CAPABILITY_REQUIRED": 262_144,
"DESTINATION_RESOLUTION_REQUIRED": 524_288,
"DESTINATION_OUT_OF_SCOPE": 1_048_576,
"CREDENTIAL_AUTHORITY_REQUIRED": 2_097_152,
"CREDENTIAL_AUTHORITY_STALE": 4_194_304,
"RAW_CREDENTIAL_FORBIDDEN": 8_388_608,
"AMBIENT_CREDENTIAL_FORBIDDEN": 16_777_216,
"CREDENTIAL_HANDLE_POLICY_VIOLATION": 33_554_432,
"BUDGET_AUTHORITY_REQUIRED": 67_108_864,
"BUDGET_AUTHORITY_STALE": 134_217_728,
"BUDGET_CAPACITY_UNAVAILABLE": 268_435_456,
"DESCRIPTOR_BLOCKED": 536_870_912,
"PREVIEW_NOT_READY": 1_073_741_824,
"LIFECYCLE_NOT_READY": 2_147_483_648,
"RESULT_AUTHORITY_NOT_READY": 4_294_967_296,
"TRANSPORT_NOT_READY": 8_589_934_592,
"FUTURE_GATEWAY_INELIGIBLE": 17_179_869_184,
}, "policy reason allocation changed"
@pytest.mark.parametrize(
("actor", "minimum", "satisfies"),
tuple(
(actor, minimum, actor_rank >= minimum_rank and actor != "reporter")
for actor, actor_rank in (("reporter", 0), ("operator", 1), ("team_lead", 2), ("admin", 3))
for minimum, minimum_rank in (("operator", 1), ("team_lead", 2), ("admin", 3))
),
ids=lambda value: value,
)
@pytest.mark.asyncio
async def test_every_actor_minimum_role_pair(actor: str, minimum: str, satisfies: bool) -> None:
persisted_state, result = await _persist_role_cell(actor, minimum, satisfies)
assert result is FixedResult.APPLIED, "role admission did not commit"
assert persisted_state == ("accepted" if satisfies else "blocked"), (
"role admission state changed"
)
assert actor in ACTOR_ROLES, "actor role domain changed"
@pytest.mark.parametrize(
("attempt", "delay"),
tuple((attempt, min((1 << (attempt - 1)) * 1_000, 600_000)) for attempt in range(1, 20)),
ids=lambda value: str(value),
)
def test_each_retry_delay_is_bounded(attempt: int, delay: int) -> None:
assert retry_delay_ms(attempt) == delay, "outbox retry delay changed"
def test_public_operation_records_are_immutable_and_unhashable() -> None:
request = TransitionRequest(
_UUIDS[0],
0,
AttemptState.QUEUED,
_UUIDS[1],
campaign_id=_UUIDS[2],
actor_subject_ref=_UUIDS[3],
actor_user_id=_UUIDS[3],
actor_authority_revision=0,
)
mutation = OutboxMutation(
_UUIDS[2],
0,
_UUIDS[3],
_UUIDS[4],
0,
_UUIDS[5],
_UUIDS[6],
_UUIDS[7],
"execution_failed",
)
assert request.__hash__ is None, "transition request became hashable"
assert mutation.__hash__ is None, "outbox mutation became hashable"
assert tuple(field.name for field in fields(request)) == (
"attempt_id",
"expected_revision",
"target_state",
"operation_id",
"owner_ref",
"lease_generation",
"lease_duration_ms",
"cancellation_request_revision",
"outcome_code",
"authoritative_proof",
"resolver_subject_ref",
"resolver_user_id",
"resolver_authority_revision",
"outbox_id",
"publication_key",
"campaign_id",
"actor_subject_ref",
"actor_user_id",
"actor_authority_revision",
), "transition request shape changed"
async def _new_connection(path: str = ":memory:") -> aiosqlite.Connection:
connection = await aiosqlite.connect(path)
connection.row_factory = aiosqlite.Row
await connection.execute("PRAGMA foreign_keys=ON")
await connection.executescript(CREATE_TABLES)
return connection
def _uuid(number: int) -> str:
return f"00000000-0000-4000-8000-{number:012x}"
_P1C_AUTHORITY_MUTATOR_ALIASES = (
"gateway-update",
"actor-activate",
"actor-update",
"actor-revoke",
"campaign-activate",
"campaign-update",
"campaign-revoke",
"grant-put",
"grant-revoke",
"destination-update",
"destination-revoke",
"credential-update",
"credential-revoke",
"approval-grant",
"approval-revoke",
)
_P1C_INITIAL_AUTHORITY_ALIASES = (
"new-v3-applied",
"v3-exact-replay",
"v3-logical-id-conflict",
"v3-attempt-id-conflict",
"v3-operation-id-conflict",
"v3-module-id-conflict",
"v3-ingress-conflict",
"v3-trusted-principal-conflict",
"v3-after-gateway-change",
"v3-after-authority-deletion",
"v2-exact-replay",
"v2-changed-intent-conflict",
"v2-after-gateway-change",
"v2-after-authority-deletion",
"new-v2-rejected",
"v3-row-downgrade-rejected",
)
_P1C_UNTRUSTED_AUTHORITY_CLAIM_ALIASES = (
"gateway-mode-claim",
"gateway-revision-claim",
"actor-user-claim",
"actor-role-claim",
"actor-revision-claim",
"campaign-status-claim",
"campaign-revision-claim",
"campaign-owner-claim",
"descriptor-authority-claim",
"destination-authority-claim",
"credential-authority-claim",
"budget-authority-claim",
)
_P1C_AUTHORITY_DELETION_ALIASES = (
"campaign-authority-cascade",
"actor-authority-cascade",
"destination-credential-authority-cascade",
"snapshot-no-live-fk",
)
_P1C_PERSISTED_AUTHORITY_ALIASES = (
"gateway-mode",
"gateway-revision",
"gateway-catalog-digest",
"actor-identity",
"actor-active",
"actor-role",
"actor-authority-revision",
"campaign-status",
"campaign-authority-revision",
"campaign-ownership",
"destination-extraction",
"destination-campaign-scope",
"destination-authority-revision",
"credential-exists",
"credential-ownership",
"credential-authority-revision",
"descriptor-module-identity",
"descriptor-contract-version",
"descriptor-semantic-digest",
"policy-minimum-role",
"policy-noise-class",
"policy-required-capabilities",
"policy-approval",
"budget-authority-revisions",
"budget-capacity",
)
_P1C_RETRY_AUTHORITY_ALIASES = (
"v3-retry-applied",
"v3-retry-exact-replay",
"v3-retry-child-binding-conflict",
"v3-retry-parent-revision-conflict",
"v3-retry-after-authority-change",
"v2-retry-exact-replay",
"v2-retry-child-binding-conflict",
"v2-retry-after-authority-change",
"new-v2-retry-rejected",
"v3-retry-downgrade-rejected",
)
async def _p1c_sqlite_authority_store(
tmp_path: Any,
) -> tuple[
AresDatabase,
ExecutionLifecycleStore,
TrustedPrincipal,
str,
str,
str,
]:
database = AresDatabase(tmp_path / "p1c-authority.db")
await database.connect()
principal_id = _uuid(12_000)
actor_id = _uuid(12_001)
campaign_id = _uuid(12_002)
credential_id = _uuid(12_003)
await database.conn.executemany(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(
(principal_id, "p1c-admin", "fixed", "admin", "fixed"),
(actor_id, "p1c-actor", "fixed", "operator", "fixed"),
),
)
await database.conn.execute(
"INSERT INTO campaigns(id,name,operator,scope_json,targets_json) VALUES(?,?,?,?,?)",
(campaign_id, "p1c-authority", "p1c-admin", "[]", '["host.example"]'),
)
await database.conn.execute(
"INSERT INTO credentials(id,campaign_id,username,cred_type,source_module) "
"VALUES(?,?,?,?,?)",
(credential_id, campaign_id, "opaque-user", "cleartext", "p1c-fixture"),
)
await database.conn.commit()
store = ExecutionLifecycleStore(database.conn, "sqlite")
for user_id, operation in (
(principal_id, _uuid(12_010)),
(actor_id, _uuid(12_011)),
):
assert (
await store.ensure_actor_authority(user_id, operation)
).result is FixedResult.APPLIED
assert (
await store.ensure_campaign_authority(campaign_id, _uuid(12_012))
).result is FixedResult.APPLIED
return (
database,
store,
TrustedPrincipal(principal_id, principal_id),
actor_id,
campaign_id,
credential_id,
)
def _p1c_v3_intent(campaign_id: str) -> AdmissionIntentV3:
return AdmissionIntentV3(
logical_execution_id=_uuid(12_500),
submission_id=_uuid(12_501),
attempt_id=_uuid(12_502),
outbox_id=None,
publication_key=None,
campaign_id=campaign_id,
module_id="opsec.coverage_predictor",
ingress_code="sdk",
operation_id=_uuid(12_503),
evaluation_mode="live",
raw_parameters={"noise_profile": "stealth"},
)
def _p1c_eligible_descriptor(monkeypatch: pytest.MonkeyPatch) -> ModuleDescriptor:
source = descriptor_module.FIRST_PARTY_DESCRIPTORS["opsec.coverage_predictor"]
values = {
field.name: getattr(source, field.name) for field in fields(ModuleDescriptor) if field.init
}
values.update(
idempotency=IdempotencyClass.PROVEN_IDEMPOTENT,
external_effect=ExternalEffectClass.READ_ONLY,
retry_eligibility=RetryEligibility.AFTER_REVALIDATION,
cancellation_ownership=CancellationOwnership.OWNED,
compensation=CompensationClass.NOT_APPLICABLE,
timeout=TimeoutPolicy(
source.timeout.seconds,
source.timeout.source,
TimeoutSettlement.PROVEN,
),
result_contract=ResultContract(
findings=ContractState.PROVEN_NONE,
credentials=ContractState.PROVEN_NONE,
discovered_hosts=ContractState.PROVEN_NONE,
loot_artifacts=ContractState.PROVEN_NONE,
authoritative_evidence=ContractState.SUPPORTED,
),
blocker_codes=(),
future_gateway_eligible=True,
)
descriptor = ModuleDescriptor(**values)
descriptors = dict(descriptor_module.FIRST_PARTY_DESCRIPTORS)
descriptors[descriptor.module_id] = descriptor
monkeypatch.setattr(descriptor_module, "FIRST_PARTY_DESCRIPTORS", descriptors)
return descriptor
@pytest.mark.parametrize(
"_case_alias",
_P1C_UNTRUSTED_AUTHORITY_CLAIM_ALIASES,
ids=_P1C_UNTRUSTED_AUTHORITY_CLAIM_ALIASES,
)
def test_admission_intent_rejects_each_untrusted_authority_claim(
_case_alias: str,
) -> None:
intent = _p1c_v3_intent(_uuid(12_002))
claims: dict[str, object] = {
"gateway-mode-claim": "enforced",
"gateway-revision-claim": 7,
"actor-user-claim": _uuid(12_900),
"actor-role-claim": "admin",
"actor-revision-claim": 7,
"campaign-status-claim": "running",
"campaign-revision-claim": 7,
"campaign-owner-claim": _uuid(12_901),
"descriptor-authority-claim": "a" * 64,
"destination-authority-claim": "b" * 64,
"credential-authority-claim": "c" * 64,
"budget-authority-claim": 7,
}
field_name = _case_alias.removesuffix("-claim").replace("-", "_")
with pytest.raises(TypeError):
replace(intent, **{field_name: claims[_case_alias]})
@pytest.mark.parametrize(
"_case_alias",
_P1C_AUTHORITY_DELETION_ALIASES,
ids=_P1C_AUTHORITY_DELETION_ALIASES,
)
@pytest.mark.asyncio
async def test_sqlite_p1c_authority_deletion_and_fk_contract(
tmp_path, monkeypatch, _case_alias: str
) -> None:
_p1c_eligible_descriptor(monkeypatch)
(
database,
store,
principal,
actor_id,
campaign_id,
credential_id,
) = await _p1c_sqlite_authority_store(tmp_path)
try:
grant_actor = principal.user_id if _case_alias == "snapshot-no-live-fk" else actor_id
assert (
await store.put_campaign_actor_grant(
principal,
CampaignActorGrantMutation(_uuid(12_950), campaign_id, grant_actor, None),
)
).result is FixedResult.APPLIED
if _case_alias == "campaign-authority-cascade":
deleted = await database.delete_campaign_lifecycle(
campaign_id,
operation_id=_uuid(12_951),
)
observed = await (
await database.conn.execute(
"SELECT "
"(SELECT count(*) FROM campaigns WHERE id=?),"
"(SELECT count(*) FROM campaign_execution_authority_revisions "
"WHERE campaign_id=?),"
"(SELECT count(*) FROM campaign_execution_actor_grants "
"WHERE campaign_id=?),"
"(SELECT count(*) FROM execution_operation_receipts "
"WHERE operation_id=?)",
(campaign_id, campaign_id, campaign_id, _uuid(12_951)),
)
).fetchone()
assert deleted.result is FixedResult.APPLIED, "campaign purge was rejected"
assert tuple(observed) == (0, 0, 0, 1), (
"campaign purge retained mutable authority or lost its receipt"
)
elif _case_alias == "actor-authority-cascade":
await database.conn.execute(
"DELETE FROM campaign_execution_actor_grants WHERE actor_user_id=?",
(actor_id,),
)
await database.conn.execute("DELETE FROM users WHERE id=?", (actor_id,))
await database.conn.commit()
observed = await (
await database.conn.execute(
"SELECT "
"(SELECT count(*) FROM execution_actor_authority_revisions "
"WHERE user_id=?),"
"(SELECT count(*) FROM users WHERE id=?)",
(actor_id, actor_id),
)
).fetchone()
assert tuple(observed) == (0, 0), "actor authority did not cascade with user"
elif _case_alias == "destination-credential-authority-cascade":
deleted = await database.delete_campaign_lifecycle(
campaign_id,
operation_id=_uuid(12_952),
)
observed = await (
await database.conn.execute(
"SELECT "
"(SELECT count(*) FROM campaign_execution_destination_authorities "
"WHERE campaign_id=?),"
"(SELECT count(*) FROM credentials WHERE id=?)",
(campaign_id, credential_id),
)
).fetchone()
assert deleted.result is FixedResult.APPLIED, "campaign purge was rejected"
assert tuple(observed) == (0, 0), (
"campaign purge retained destination or credential authority"
)
else:
intent = _p1c_v3_intent(campaign_id)
applied = await store.create_initial_execution_v3(principal, intent)
assert applied.result is FixedResult.APPLIED
await database.conn.execute(
"DELETE FROM campaign_execution_actor_grants WHERE campaign_id=?",
(campaign_id,),
)
await database.conn.execute(
"DELETE FROM campaign_execution_destination_authorities WHERE campaign_id=?",
(campaign_id,),
)
await database.conn.execute("DELETE FROM credentials WHERE id=?", (credential_id,))
await database.conn.commit()
observed = await (
await database.conn.execute(
"SELECT authority_contract_version,trusted_principal_user_id,"
"destination_authority_binding_digest,credential_authority_binding_digest "
"FROM execution_attempts WHERE id=?",
(intent.attempt_id,),
)
).fetchone()
assert observed is not None, "historical snapshot row is missing"
assert tuple(observed[:2]) == (
3,
principal.user_id,
), "historical snapshot depended on live authority"
assert all(isinstance(value, str) and len(value) == 64 for value in observed[2:]), (
"historical snapshot lost authority digests"
)
purged = await database.delete_campaign_lifecycle(
campaign_id,
operation_id=_uuid(12_953),
)
remaining = await (
await database.conn.execute(
"SELECT count(*) FROM execution_attempts WHERE id=?",
(intent.attempt_id,),
)
).fetchone()
assert purged.result is FixedResult.APPLIED, "historical campaign purge failed"
assert int(remaining[0]) == 0, "historical snapshot survived campaign purge"
finally:
await database.close()
@pytest.mark.asyncio
async def test_sqlite_actor_revocation_and_admission_are_linearized(tmp_path, monkeypatch) -> None:
_p1c_eligible_descriptor(monkeypatch)
(
database,
setup_store,
principal,
_actor_id,
campaign_id,
_credential_id,
) = await _p1c_sqlite_authority_store(tmp_path)
contender_connection = await aiosqlite.connect((tmp_path / "p1c-authority.db").as_posix())
contender_connection.row_factory = aiosqlite.Row
await contender_connection.execute("PRAGMA foreign_keys=ON")
await contender_connection.execute("PRAGMA busy_timeout=5000")
await contender_connection.commit()
admission_entered = asyncio.Event()
revocation_attempted = asyncio.Event()
admission_store = _SQLiteWinnerBarrierStore(
database.conn,
admission_entered,
revocation_attempted,
)
revocation_store = _SQLiteContenderBarrierStore(
contender_connection,
revocation_attempted,
)
admission_task: asyncio.Task[OperationResult] | None = None
revocation_task: asyncio.Task[OperationResult] | None = None
try:
assert (
await setup_store.put_campaign_actor_grant(
principal,
CampaignActorGrantMutation(_uuid(12_960), campaign_id, principal.user_id, None),
)
).result is FixedResult.APPLIED
await _p1c_enable_acceptance(setup_store, principal, campaign_id)
intent = _p1c_v3_intent(campaign_id)
revoke_operation_id = _uuid(12_961)
admission_task = asyncio.create_task(
admission_store.create_initial_execution_v3(principal, intent)
)
await asyncio.wait_for(admission_entered.wait(), timeout=2)
revocation_task = asyncio.create_task(
revocation_store.revoke_actor_authority(
principal,
ActorAuthorityMutation(revoke_operation_id, principal.user_id, 0),
)
)
await asyncio.wait_for(revocation_attempted.wait(), timeout=2)
admitted, revoked = await asyncio.wait_for(
asyncio.gather(admission_task, revocation_task),
timeout=10,
)
observed_attempt = await (
await database.conn.execute(
"SELECT state,actor_authority_revision FROM execution_attempts WHERE id=?",
(intent.attempt_id,),
)
).fetchone()
observed_actor = await (
await database.conn.execute(
"SELECT authority_state,authority_revision "
"FROM execution_actor_authority_revisions WHERE user_id=?",
(principal.user_id,),
)
).fetchone()
receipt_counts = await (
await database.conn.execute(
"SELECT "
"sum(CASE WHEN operation_id=? THEN 1 ELSE 0 END),"
"sum(CASE WHEN operation_id=? THEN 1 ELSE 0 END) "
"FROM execution_operation_receipts",
(intent.operation_id, revoke_operation_id),
)
).fetchone()
finally:
for task in (admission_task, revocation_task):
if task is not None and not task.done():
task.cancel()
pending = tuple(
task
for task in (admission_task, revocation_task)
if task is not None and not task.done()
)
if pending:
await asyncio.gather(*pending, return_exceptions=True)
await contender_connection.close()
await database.close()
assert (admitted.result, revoked.result) == (
FixedResult.APPLIED,
FixedResult.APPLIED,
), "serialized admission/revocation result changed"
assert tuple(observed_attempt) == ("accepted", 0), (
"admission did not retain its locked actor authority revision"
)
assert tuple(observed_actor) == ("revoked", 1), "revocation did not serialize after admission"
assert tuple(receipt_counts) == (0, 1), (
"serialized operations wrote the wrong receipt cardinality"
)
def _p1c_v2_request(principal: TrustedPrincipal, campaign_id: str) -> AdmissionRequest:
return AdmissionRequest(
_uuid(12_500),
_uuid(12_501),
_uuid(12_502),
_uuid(12_504),
_uuid(12_505),
campaign_id,
principal.subject_ref,
principal.user_id,
"opsec.coverage_predictor",
"sdk",
AttemptState.BLOCKED,
_uuid(12_503),
replace(_blocked_snapshot(), actor_role="admin"),
)
async def _p1c_admission_counts(
connection: aiosqlite.Connection, operation_id: str
) -> tuple[int, int, int, int]:
values = []
for statement, parameters in (
("SELECT count(*) FROM logical_executions", ()),
("SELECT count(*) FROM execution_attempts", ()),
("SELECT count(*) FROM execution_publication_outbox", ()),
(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(operation_id,),
),
):
row = await (await connection.execute(statement, parameters)).fetchone()
values.append(int(row[0]))
return tuple(values) # type: ignore[return-value]
async def _p1c_zero_delta_snapshot(
connection: aiosqlite.Connection,
) -> tuple[int, ...]:
row = await (
await connection.execute(
"SELECT "
"(SELECT count(*) FROM logical_executions),"
"(SELECT count(*) FROM execution_attempts),"
"(SELECT count(*) FROM execution_publication_outbox),"
"(SELECT count(*) FROM execution_attempt_approvals),"
"(SELECT count(*) FROM campaign_execution_budget_ledger),"
"(SELECT count(*) FROM execution_attempt_destination_observations),"
"(SELECT count(*) FROM execution_attempt_credential_observations),"
"(SELECT coalesce(sum(reserved_units),0) "
"FROM campaign_execution_budgets),"
"(SELECT coalesce(sum(consumed_units),0) "
"FROM campaign_execution_budgets)"
)
).fetchone()
return tuple(int(value) for value in row)
def _p1c_mutate_descriptor_without_rebinding(
descriptor: ModuleDescriptor,
case_alias: str,
) -> None:
if case_alias == "destination-extraction":
value: object = (
DestinationSpec(
DestinationKind.HOST,
"noise_profile",
DestinationCardinality.SCALAR,
ScopeSemantics.PRIMARY_CAMPAIGN,
ContractState.SUPPORTED,
),
)
field_name = "destinations"
else:
field_name, value = {
"descriptor-module-identity": ("module_id", "opsec.changed_identity"),
"descriptor-contract-version": (
"contract_version",
"ares.module-descriptor.invalid",
),
"descriptor-semantic-digest": ("semantic_digest", "0" * 64),
"policy-minimum-role": ("minimum_role", MinimumRole.TEAM_LEAD),
"policy-noise-class": ("opsec", OpsecClassification.HIGH_NOISE),
"policy-required-capabilities": (
"required_capabilities",
(Capability.CAP_NET,),
),
"policy-approval": ("explicit_attempt_approval", True),
}[case_alias]
object.__setattr__(descriptor, field_name, value)
if field_name != "semantic_digest":
object.__setattr__(
descriptor,
"semantic_digest",
hashlib.sha256(case_alias.encode("ascii")).hexdigest(),
)
@pytest.mark.parametrize(
"_case_alias",
_P1C_PERSISTED_AUTHORITY_ALIASES,
ids=_P1C_PERSISTED_AUTHORITY_ALIASES,
)
@pytest.mark.asyncio
async def test_sqlite_p1c_each_persisted_authority_contradiction_is_atomic(
tmp_path, monkeypatch, _case_alias: str
) -> None:
descriptor = _p1c_eligible_descriptor(monkeypatch)
(
database,
store,
principal,
_actor_id,
campaign_id,
credential_id,
) = await _p1c_sqlite_authority_store(tmp_path)
try:
assert (
await store.put_campaign_actor_grant(
principal,
CampaignActorGrantMutation(_uuid(12_700), campaign_id, principal.user_id, None),
)
).result is FixedResult.APPLIED
await _p1c_enable_acceptance(store, principal, campaign_id)
intent = _p1c_v3_intent(campaign_id)
if _case_alias.startswith("credential-"):
intent = replace(intent, credential_ids=(credential_id,))
if _case_alias == "gateway-mode":
await database.conn.execute("PRAGMA ignore_check_constraints=ON")
await database.conn.execute(
"UPDATE execution_gateway_state SET mode='invalid-persisted-mode'"
)
await database.conn.execute("PRAGMA ignore_check_constraints=OFF")
elif _case_alias == "gateway-revision":
await database.conn.execute(
"UPDATE execution_gateway_state SET activation_revision=revision+1"
)
elif _case_alias == "gateway-catalog-digest":
await database.conn.execute(
"UPDATE execution_gateway_state SET catalog_digest=?",
("0" * 64,),
)
elif _case_alias == "actor-identity":
principal = TrustedPrincipal(_uuid(12_701), _uuid(12_701))
elif _case_alias == "actor-active":
await database.conn.execute(
"UPDATE users SET is_active=0 WHERE id=?", (principal.user_id,)
)
elif _case_alias == "actor-role":
await database.conn.execute("PRAGMA ignore_check_constraints=ON")
await database.conn.execute(
"UPDATE users SET role='recon' WHERE id=?", (principal.user_id,)
)
await database.conn.execute("PRAGMA ignore_check_constraints=OFF")
elif _case_alias == "actor-authority-revision":
await database.conn.execute(
"UPDATE execution_actor_authority_revisions "
"SET authority_revision=authority_revision+1 WHERE user_id=?",
(principal.user_id,),
)
elif _case_alias == "campaign-status":
await database.conn.execute(
"UPDATE campaigns SET status='completed' WHERE id=?", (campaign_id,)
)
elif _case_alias == "campaign-authority-revision":
await database.conn.execute(
"UPDATE campaign_execution_authority_revisions "
"SET authority_revision=authority_revision+1 WHERE campaign_id=?",
(campaign_id,),
)
elif _case_alias == "campaign-ownership":
await database.conn.execute(
"UPDATE campaigns SET operator='different-owner' WHERE id=?",
(campaign_id,),
)
elif _case_alias == "destination-campaign-scope":
await database.conn.execute(
"UPDATE campaigns SET targets_json='[\"other.example\"]' WHERE id=?",
(campaign_id,),
)
elif _case_alias == "destination-authority-revision":
await database.conn.execute(
"UPDATE campaign_execution_destination_authorities "
"SET revision=revision+1 WHERE campaign_id=?",
(campaign_id,),
)
elif _case_alias == "credential-exists":
await database.conn.execute("DELETE FROM credentials WHERE id=?", (credential_id,))
elif _case_alias == "credential-ownership":
other_campaign = _uuid(12_702)
await database.conn.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)",
(other_campaign, "other-authority"),
)
await database.conn.execute(
"UPDATE credentials SET campaign_id=? WHERE id=?",
(other_campaign, credential_id),
)
elif _case_alias == "credential-authority-revision":
await database.conn.execute(
"UPDATE credentials SET execution_authority_revision="
"execution_authority_revision+1 WHERE id=?",
(credential_id,),
)
elif _case_alias in {
"destination-extraction",
"descriptor-module-identity",
"descriptor-contract-version",
"descriptor-semantic-digest",
"policy-minimum-role",
"policy-noise-class",
"policy-required-capabilities",
"policy-approval",
}:
_p1c_mutate_descriptor_without_rebinding(descriptor, _case_alias)
elif _case_alias == "budget-authority-revisions":
await database.conn.execute(
"UPDATE campaign_execution_budgets SET revision=revision+1,"
"latest_operation_code='reserve' WHERE budget_kind='noise' "
"AND campaign_id=?",
(campaign_id,),
)
else:
await database.conn.execute(
"UPDATE campaign_execution_budgets SET reserved_units=capacity_units "
"WHERE budget_kind='concurrency' AND campaign_id=?",
(campaign_id,),
)
await database.conn.commit()
before = await _p1c_zero_delta_snapshot(database.conn)
result = await store.create_initial_execution_v3(principal, intent)
observer = await aiosqlite.connect((tmp_path / "p1c-authority.db").as_posix())
try:
after = await _p1c_zero_delta_snapshot(observer)
finally:
await observer.close()
expected = (
FixedResult.CAPACITY_UNAVAILABLE
if _case_alias == "budget-capacity"
else FixedResult.AUTHORITY_STALE
)
assert result.result is expected, "persisted contradiction classification changed"
assert after == before, "persisted contradiction leaked durable admission state"
finally:
await database.close()
async def _p1c_enable_acceptance(
store: ExecutionLifecycleStore,
principal: TrustedPrincipal,
campaign_id: str,
) -> None:
assert (
await store.update_gateway_authority(
principal,
GatewayAuthorityMutation(_uuid(12_530), 0, "enforced"),
)
).result is FixedResult.APPLIED
assert (
await store.configure_campaign_budgets(
BudgetConfiguration(
campaign_id,
_uuid(12_531),
10,
_uuid(12_532),
10,
_uuid(12_533),
1,
_uuid(12_534),
"actor",
principal.subject_ref,
principal.user_id,
0,
)
)
).result is FixedResult.APPLIED
async def _p1c_fail_accepted_parent_for_retry(
connection: aiosqlite.Connection,
store: ExecutionLifecycleStore,
principal: TrustedPrincipal,
intent: AdmissionIntentV3,
) -> int:
budgets = await (
await connection.execute(
"SELECT budget_kind,id,revision FROM campaign_execution_budgets "
"WHERE campaign_id=? ORDER BY budget_kind",
(intent.campaign_id,),
)
).fetchall()
by_kind = {str(row[0]): (str(row[1]), int(row[2])) for row in budgets}
transition = TransitionRequest(
intent.attempt_id,
0,
AttemptState.FAILED,
_uuid(12_540),
outcome_code=OutcomeCode.CONFIRMED_FAILURE_NO_DISPATCH,
authoritative_proof="no_dispatch",
campaign_id=intent.campaign_id,
actor_subject_ref=principal.subject_ref,
actor_user_id=principal.user_id,
actor_authority_revision=0,
)
settlement = BudgetSettlement(
intent.campaign_id,
intent.attempt_id,
by_kind["noise"][0],
intent.noise_units,
0,
by_kind["noise"][1],
by_kind["exfiltration"][0],
intent.exfiltration_units,
0,
by_kind["exfiltration"][1],
by_kind["concurrency"][0],
by_kind["concurrency"][1],
_uuid(12_541),
"actor",
principal.subject_ref,
principal.user_id,
0,
)
result = await store.commit_terminal_attempt(
TerminalCommitRequest(
intent.logical_execution_id,
intent.campaign_id,
_uuid(12_542),
_uuid(12_543),
transition,
settlement,
)
)
assert result.result is FixedResult.APPLIED, "v3 retry parent did not fail"
observed = await (
await connection.execute(
"SELECT revision,retry_disposition FROM execution_attempts WHERE id=?",
(intent.attempt_id,),
)
).fetchone()
assert tuple(observed) == (1, "eligible"), "v3 retry parent was not promoted"
return 1
def _p1c_v3_retry_intent(intent: AdmissionIntentV3) -> RetryIntentV3:
return RetryIntentV3(
intent.logical_execution_id,
intent.attempt_id,
_uuid(12_550),
None,
None,
_uuid(12_551),
1,
"live",
intent.raw_parameters,
)
def _p1c_v2_retry_request(principal: TrustedPrincipal) -> RetryRequest:
child = AdmissionRequest(
_uuid(4),
_uuid(12_560),
_uuid(12_561),
_uuid(12_562),
_uuid(12_563),
_uuid(2),
principal.subject_ref,
principal.user_id,
"test.module",
"sdk",
AttemptState.BLOCKED,
_uuid(12_564),
replace(_blocked_snapshot(), actor_role="admin"),
)
return RetryRequest(_uuid(4), _uuid(6), child, 0)
@pytest.mark.parametrize(
"_case_alias",
_P1C_RETRY_AUTHORITY_ALIASES,
ids=_P1C_RETRY_AUTHORITY_ALIASES,
)
@pytest.mark.asyncio
async def test_sqlite_p1c_retry_v2_v3_authority(tmp_path, monkeypatch, _case_alias: str) -> None:
if _case_alias.startswith("v2-") or _case_alias == "new-v2-retry-rejected":
connection = await _new_connection((tmp_path / "p1c-v2-retry.db").as_posix())
principal = TrustedPrincipal(_uuid(1), _uuid(1))
request = _p1c_v2_retry_request(principal)
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
if _case_alias == "new-v2-retry-rejected":
result = await store.create_retry_attempt(request)
attempts = await (
await connection.execute("SELECT count(*) FROM execution_attempts")
).fetchone()
assert result.result is FixedResult.INVALID_CONTRACT, (
"public fresh-v2 retry was accepted"
)
assert int(attempts[0]) == 1, "fresh-v2 rejection created a child"
return
assert (
await store._create_retry_attempt_v2_for_migration_fixture(request)
).result is FixedResult.APPLIED
if _case_alias == "v2-retry-child-binding-conflict":
request = replace(
request,
child=replace(request.child, attempt_id=_uuid(12_565)),
)
expected = FixedResult.CONFLICT_OPERATION
else:
if _case_alias == "v2-retry-after-authority-change":
await connection.execute(
"UPDATE execution_actor_authority_revisions "
"SET authority_revision=authority_revision+1 WHERE user_id=?",
(principal.user_id,),
)
await connection.commit()
expected = FixedResult.REPLAYED_BOUND_CHILD
result = await store.replay_retry_attempt_v2(principal, request)
assert result.result is expected, "historical v2 retry replay changed"
finally:
await connection.close()
return
_p1c_eligible_descriptor(monkeypatch)
(
database,
store,
principal,
_actor_id,
campaign_id,
_credential_id,
) = await _p1c_sqlite_authority_store(tmp_path)
try:
assert (
await store.put_campaign_actor_grant(
principal,
CampaignActorGrantMutation(_uuid(12_570), campaign_id, principal.user_id, None),
)
).result is FixedResult.APPLIED
await _p1c_enable_acceptance(store, principal, campaign_id)
initial = _p1c_v3_intent(campaign_id)
assert (
await store.create_initial_execution_v3(principal, initial)
).result is FixedResult.APPLIED
await _p1c_fail_accepted_parent_for_retry(database.conn, store, principal, initial)
intent = _p1c_v3_retry_intent(initial)
applied = await store.create_retry_attempt_v3(principal, intent)
assert applied.result is FixedResult.APPLIED, "first v3 retry was not applied"
if _case_alias == "v3-retry-applied":
result = applied
expected = FixedResult.APPLIED
elif _case_alias == "v3-retry-exact-replay":
result = await store.create_retry_attempt_v3(principal, intent)
expected = FixedResult.REPLAYED_BOUND_CHILD
elif _case_alias == "v3-retry-child-binding-conflict":
result = await store.create_retry_attempt_v3(
principal,
replace(intent, child_attempt_id=_uuid(12_571)),
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-retry-parent-revision-conflict":
result = await store.create_retry_attempt_v3(
principal,
replace(intent, expected_parent_revision=2),
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-retry-after-authority-change":
assert (
await store.update_actor_authority(
principal,
ActorAuthorityMutation(_uuid(12_572), principal.user_id, 0),
)
).result is FixedResult.APPLIED
result = await store.create_retry_attempt_v3(principal, intent)
expected = FixedResult.REPLAYED_BOUND_CHILD
else:
result = await store.replay_retry_attempt_v2(
principal,
RetryRequest(
intent.logical_execution_id,
intent.parent_attempt_id,
AdmissionRequest(
intent.logical_execution_id,
initial.submission_id,
intent.child_attempt_id,
_uuid(12_573),
_uuid(12_574),
campaign_id,
principal.subject_ref,
principal.user_id,
initial.module_id,
initial.ingress_code,
AttemptState.BLOCKED,
intent.operation_id,
replace(_blocked_snapshot(), actor_role="admin"),
),
intent.expected_parent_revision,
),
)
expected = FixedResult.CONFLICT_OPERATION
assert result.result is expected, "v3 retry replay authority changed"
rows = await (
await database.conn.execute(
"SELECT id,parent_attempt_id,authority_contract_version "
"FROM execution_attempts WHERE logical_execution_id=? ORDER BY ordinal",
(initial.logical_execution_id,),
)
).fetchall()
receipts = await (
await database.conn.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(intent.operation_id,),
)
).fetchone()
assert tuple(tuple(row) for row in rows) == (
(initial.attempt_id, None, 3),
(intent.child_attempt_id, initial.attempt_id, 3),
), "v3 retry child binding changed"
assert int(receipts[0]) == 1, "v3 retry lost or duplicated its receipt"
finally:
await database.close()
@pytest.mark.parametrize(
"_case_alias",
_P1C_INITIAL_AUTHORITY_ALIASES,
ids=_P1C_INITIAL_AUTHORITY_ALIASES,
)
@pytest.mark.asyncio
async def test_sqlite_p1c_initial_v2_v3_submission_authority(
tmp_path, monkeypatch, _case_alias: str
) -> None:
_p1c_eligible_descriptor(monkeypatch)
(
database,
store,
principal,
_actor_id,
campaign_id,
_credential_id,
) = await _p1c_sqlite_authority_store(tmp_path)
try:
grant = CampaignActorGrantMutation(_uuid(12_510), campaign_id, principal.user_id, None)
assert (
await store.put_campaign_actor_grant(principal, grant)
).result is FixedResult.APPLIED
intent = _p1c_v3_intent(campaign_id)
v2_request = _p1c_v2_request(principal, campaign_id)
if _case_alias.startswith("v2-") or _case_alias == "new-v2-rejected":
if _case_alias == "new-v2-rejected":
result = await store.create_initial_execution(v2_request)
assert result.result is FixedResult.INVALID_CONTRACT, (
"public fresh-v2 creation was accepted"
)
assert await _p1c_admission_counts(database.conn, v2_request.operation_id) == (
0,
0,
0,
0,
), "fresh-v2 rejection created durable state"
return
assert (
await store._create_initial_execution_v2_for_migration_fixture(v2_request)
).result is FixedResult.APPLIED
if _case_alias == "v2-exact-replay":
result = await store.replay_initial_execution_v2(principal, v2_request)
expected = FixedResult.REPLAYED
elif _case_alias == "v2-changed-intent-conflict":
result = await store.replay_initial_execution_v2(
principal,
replace(v2_request, module_id="opsec.coverage_predictor.changed"),
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v2-after-gateway-change":
assert (
await store.update_gateway_authority(
principal,
GatewayAuthorityMutation(_uuid(12_511), 0, "enforced"),
)
).result is FixedResult.APPLIED
result = await store.replay_initial_execution_v2(principal, v2_request)
expected = FixedResult.REPLAYED
else:
await database.conn.execute(
"DELETE FROM campaign_execution_actor_grants WHERE campaign_id=?",
(campaign_id,),
)
await database.conn.execute(
"DELETE FROM campaign_execution_destination_authorities WHERE campaign_id=?",
(campaign_id,),
)
await database.conn.commit()
result = await store.replay_initial_execution_v2(principal, v2_request)
expected = FixedResult.REPLAYED
assert result.result is expected, "historical v2 replay authority changed"
return
await _p1c_enable_acceptance(store, principal, campaign_id)
applied = await store.create_initial_execution_v3(principal, intent)
assert applied.result is FixedResult.APPLIED, "first v3 admission was not applied"
if _case_alias == "new-v3-applied":
result = applied
expected = FixedResult.APPLIED
elif _case_alias == "v3-exact-replay":
result = await store.create_initial_execution_v3(principal, intent)
expected = FixedResult.REPLAYED
elif _case_alias == "v3-logical-id-conflict":
result = await store.create_initial_execution_v3(
principal, replace(intent, logical_execution_id=_uuid(12_520))
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-attempt-id-conflict":
result = await store.create_initial_execution_v3(
principal, replace(intent, attempt_id=_uuid(12_521))
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-operation-id-conflict":
result = await store.create_initial_execution_v3(
principal, replace(intent, operation_id=_uuid(12_522))
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-module-id-conflict":
result = await store.create_initial_execution_v3(
principal, replace(intent, module_id="opsec.coverage_predictor.changed")
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-ingress-conflict":
result = await store.create_initial_execution_v3(
principal, replace(intent, ingress_code="cli_module")
)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-trusted-principal-conflict":
changed = TrustedPrincipal(_uuid(12_523), _uuid(12_523))
result = await store.create_initial_execution_v3(changed, intent)
expected = FixedResult.CONFLICT_OPERATION
elif _case_alias == "v3-after-gateway-change":
assert (
await store.update_gateway_authority(
principal,
GatewayAuthorityMutation(_uuid(12_524), 1, "shadow_candidate"),
)
).result is FixedResult.APPLIED
result = await store.create_initial_execution_v3(principal, intent)
expected = FixedResult.REPLAYED
elif _case_alias == "v3-after-authority-deletion":
await database.conn.execute(
"DELETE FROM campaign_execution_actor_grants WHERE campaign_id=?",
(campaign_id,),
)
await database.conn.execute(
"DELETE FROM campaign_execution_destination_authorities WHERE campaign_id=?",
(campaign_id,),
)
await database.conn.commit()
result = await store.create_initial_execution_v3(principal, intent)
expected = FixedResult.REPLAYED
else:
result = await store.replay_initial_execution_v2(principal, v2_request)
expected = FixedResult.CONFLICT_OPERATION
assert result.result is expected, "v3 submission replay authority changed"
counts = await _p1c_admission_counts(database.conn, intent.operation_id)
assert counts[:3] == (1, 1, 0), "v3 accepted admission cardinality changed"
assert counts[3] == 0, "initial admission created a redundant operation receipt"
attempt = await (
await database.conn.execute(
"SELECT state,retry_disposition FROM execution_attempts WHERE id=?",
(intent.attempt_id,),
)
).fetchone()
reservations = await (
await database.conn.execute(
"SELECT count(*) FROM campaign_execution_budget_ledger WHERE attempt_id=?",
(intent.attempt_id,),
)
).fetchone()
assert tuple(attempt) == (
"accepted",
"not_applicable",
), "v3 acceptance state changed"
assert int(reservations[0]) == 3, "v3 acceptance missed budget reservations"
finally:
await database.close()
@pytest.mark.parametrize(
"_case_alias",
_P1C_AUTHORITY_MUTATOR_ALIASES,
ids=_P1C_AUTHORITY_MUTATOR_ALIASES,
)
@pytest.mark.asyncio
async def test_sqlite_p1c_each_authority_mutator_is_exactly_replayable(
tmp_path, monkeypatch, _case_alias: str
) -> None:
descriptor = (
_p1c_eligible_descriptor(monkeypatch)
if _case_alias in {"gateway-update", "approval-grant"}
else None
)
(
database,
store,
principal,
actor_id,
campaign_id,
credential_id,
) = await _p1c_sqlite_authority_store(tmp_path)
operation_id = _uuid(12_100 + _P1C_AUTHORITY_MUTATOR_ALIASES.index(_case_alias))
approval_id = _uuid(12_200)
approval_ref = _uuid(12_201)
try:
if _case_alias == "gateway-update":
request: Any = GatewayAuthorityMutation(operation_id, 0, "enforced")
method_name = "update_gateway_authority"
elif _case_alias.startswith("actor-"):
action = _case_alias.removeprefix("actor-")
expected_revision = 0
if action == "activate":
assert (
await store.revoke_actor_authority(
principal,
ActorAuthorityMutation(_uuid(12_300), actor_id, 0),
)
).result is FixedResult.APPLIED
expected_revision = 1
request = ActorAuthorityMutation(operation_id, actor_id, expected_revision)
method_name = f"{action}_actor_authority"
elif _case_alias.startswith("campaign-"):
action = _case_alias.removeprefix("campaign-")
expected_revision = 0
if action == "activate":
assert (
await store.revoke_campaign_authority(
principal,
CampaignAuthorityMutation(_uuid(12_301), campaign_id, 0),
)
).result is FixedResult.APPLIED
expected_revision = 1
request = CampaignAuthorityMutation(operation_id, campaign_id, expected_revision)
method_name = f"{action}_campaign_authority"
elif _case_alias.startswith("grant-"):
action = _case_alias.removeprefix("grant-")
expected_revision = None
if action == "revoke":
assert (
await store.put_campaign_actor_grant(
principal,
CampaignActorGrantMutation(_uuid(12_302), campaign_id, actor_id, None),
)
).result is FixedResult.APPLIED
expected_revision = 0
request = CampaignActorGrantMutation(
operation_id, campaign_id, actor_id, expected_revision
)
method_name = f"{action}_campaign_actor_grant"
elif _case_alias.startswith("destination-"):
action = _case_alias.removeprefix("destination-")
request = DestinationAuthorityMutation(operation_id, campaign_id, 0)
method_name = f"{action}_destination_authority"
elif _case_alias.startswith("credential-"):
action = _case_alias.removeprefix("credential-")
request = CredentialAuthorityMutation(operation_id, credential_id, 0)
method_name = f"{action}_credential_authority"
elif _case_alias == "approval-grant":
request = ApprovalAuthorityGrant(
operation_id,
approval_id,
approval_ref,
campaign_id,
_uuid(12_202),
_uuid(12_203),
actor_id,
actor_id,
"opsec.coverage_predictor",
0,
)
method_name = "grant_approval_authority"
else:
grant = ApprovalAuthorityGrant(
_uuid(12_303),
approval_id,
approval_ref,
campaign_id,
_uuid(12_202),
_uuid(12_203),
actor_id,
actor_id,
"opsec.coverage_predictor",
0,
)
assert (
await store.grant_approval_authority(principal, grant)
).result is FixedResult.APPLIED
request = ApprovalAuthorityMutation(operation_id, approval_id, 0)
method_name = "revoke_approval_authority"
async def invoke() -> OperationResult:
method = getattr(store, method_name)
return await method(principal, request)
def changed_request() -> Any:
if type(request) is GatewayAuthorityMutation:
return replace(request, mode="shadow_candidate")
if type(request) in {
ActorAuthorityMutation,
CampaignAuthorityMutation,
DestinationAuthorityMutation,
CredentialAuthorityMutation,
ApprovalAuthorityMutation,
}:
return replace(request, expected_revision=request.expected_revision + 1)
if type(request) is CampaignActorGrantMutation:
expected = 0 if request.expected_revision is None else request.expected_revision + 1
return replace(request, expected_revision=expected)
if type(request) is ApprovalAuthorityGrant:
return replace(request, granted_capability_mask=1)
raise AssertionError("unsupported authority mutation request")
async def observe_target() -> tuple[tuple[object, ...], ...]:
table, where, parameters = {
"gateway-update": (
"execution_gateway_state",
"singleton_id=1",
(),
),
"actor-activate": (
"execution_actor_authority_revisions",
"user_id=?",
(actor_id,),
),
"actor-update": (
"execution_actor_authority_revisions",
"user_id=?",
(actor_id,),
),
"actor-revoke": (
"execution_actor_authority_revisions",
"user_id=?",
(actor_id,),
),
"campaign-activate": (
"campaign_execution_authority_revisions",
"campaign_id=?",
(campaign_id,),
),
"campaign-update": (
"campaign_execution_authority_revisions",
"campaign_id=?",
(campaign_id,),
),
"campaign-revoke": (
"campaign_execution_authority_revisions",
"campaign_id=?",
(campaign_id,),
),
"grant-put": (
"campaign_execution_actor_grants",
"campaign_id=? AND actor_user_id=?",
(campaign_id, actor_id),
),
"grant-revoke": (
"campaign_execution_actor_grants",
"campaign_id=? AND actor_user_id=?",
(campaign_id, actor_id),
),
"destination-update": (
"campaign_execution_destination_authorities",
"campaign_id=?",
(campaign_id,),
),
"destination-revoke": (
"campaign_execution_destination_authorities",
"campaign_id=?",
(campaign_id,),
),
"credential-update": ("credentials", "id=?", (credential_id,)),
"credential-revoke": ("credentials", "id=?", (credential_id,)),
"approval-grant": (
"execution_approval_authorities",
"id=?",
(approval_id,),
),
"approval-revoke": (
"execution_approval_authorities",
"id=?",
(approval_id,),
),
}[_case_alias]
rows = await (
await database.conn.execute(
f"SELECT * FROM {table} WHERE {where}", # noqa: S608
parameters,
)
).fetchall()
return tuple(tuple(row) for row in rows)
applied = await invoke()
receipt_count_after_apply = int(
(
await (
await database.conn.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(operation_id,),
)
).fetchone()
)[0]
)
replayed = await invoke()
receipt_count_after_replay = int(
(
await (
await database.conn.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(operation_id,),
)
).fetchone()
)[0]
)
target_before_conflict = await observe_target()
method = getattr(store, method_name)
conflicting = await method(principal, changed_request())
target_after_conflict = await observe_target()
receipt_count_after_conflict = int(
(
await (
await database.conn.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(operation_id,),
)
).fetchone()
)[0]
)
receipt_first: OperationResult | None = None
if _case_alias == "gateway-update":
assert descriptor is not None
_p1c_mutate_descriptor_without_rebinding(
descriptor,
"descriptor-semantic-digest",
)
receipt_first = await invoke()
elif _case_alias.startswith("credential-"):
await database.conn.execute("DELETE FROM credentials WHERE id=?", (credential_id,))
await database.conn.commit()
receipt_first = await invoke()
elif _case_alias.startswith("approval-"):
if descriptor is not None:
_p1c_mutate_descriptor_without_rebinding(
descriptor,
"descriptor-semantic-digest",
)
await database.conn.execute(
"DELETE FROM execution_approval_authorities WHERE id=?",
(approval_id,),
)
await database.conn.commit()
receipt_first = await invoke()
assert (applied.result, replayed.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
), "authority mutation lost exact replay"
assert conflicting.result is FixedResult.CONFLICT_OPERATION, (
"changed authority mutation reused an immutable operation"
)
assert target_after_conflict == target_before_conflict, (
"changed authority mutation altered its target"
)
assert (
receipt_count_after_apply
== receipt_count_after_replay
== receipt_count_after_conflict
== 1
), "authority mutation replay duplicated its receipt"
if receipt_first is not None:
assert receipt_first.result is FixedResult.REPLAYED, (
"authority mutation replay consulted mutable current authority"
)
finally:
await database.close()
_P1B_AUTHORITY_CASES = (
("actor-authority-ensure", "actor_authority_ensure"),
("campaign-authority-ensure", "campaign_authority_ensure"),
("actor-authority-invalidate", "actor_authority_invalidate"),
("campaign-authority-invalidate", "campaign_authority_invalidate"),
("budget-configure", "budget_configure"),
("budget-reserve", "budget_reserve"),
("budget-settle", "budget_settle"),
("admission", "admission"),
("retry-attempt", "retry"),
("attempt-transition", "queue"),
("settlement-pending", "settlement_pending"),
("expired-lease-settlement", "lease_loss"),
("terminal-commit", "terminal_failed"),
("close-without-retry", "close_without_retry"),
("outbox-claim", "outbox_claim"),
("outbox-reclaim", "outbox_reclaim"),
("outbox-poison", "outbox_poison"),
("outbox-renew", "outbox_renew"),
("outbox-publish", "outbox_publish"),
("outbox-fail-retryable", "outbox_retryable_failure"),
("outbox-fail-nonretryable", "outbox_nonretryable_failure"),
("outbox-purge", "outbox_purge"),
("campaign-delete", "campaign_delete"),
)
_P1B_PUBLIC_METHOD_MAP = (
("actor-authority-ensure", "ExecutionLifecycleStore.ensure_actor_authority"),
("campaign-authority-ensure", "ExecutionLifecycleStore.ensure_campaign_authority"),
("actor-authority-invalidate", "ExecutionLifecycleStore.invalidate_actor_authority"),
(
"campaign-authority-invalidate",
"ExecutionLifecycleStore.invalidate_campaign_authority",
),
("budget-configure", "ExecutionLifecycleStore.configure_campaign_budgets"),
("budget-reserve", "ExecutionLifecycleStore.reserve_budgets"),
("budget-settle", "ExecutionLifecycleStore.settle_budgets"),
("admission", "ExecutionLifecycleStore.create_initial_execution"),
("retry-attempt", "ExecutionLifecycleStore.create_retry_attempt"),
("attempt-transition", "ExecutionLifecycleStore.transition_attempt"),
("settlement-pending", "ExecutionLifecycleStore.enter_settlement_pending"),
(
"expired-lease-settlement",
"ExecutionLifecycleStore.mark_expired_lease_settlement_pending",
),
("terminal-commit", "ExecutionLifecycleStore.commit_terminal_attempt"),
("close-without-retry", "ExecutionLifecycleStore.close_without_retry"),
("outbox-claim", "ExecutionLifecycleStore.claim_outbox"),
("outbox-reclaim", "ExecutionLifecycleStore.claim_outbox(reclaim=True)"),
("outbox-poison", "ExecutionLifecycleStore.poison_expired_attempt_twenty"),
("outbox-renew", "ExecutionLifecycleStore.renew_outbox"),
("outbox-publish", "ExecutionLifecycleStore.publish_outbox"),
("outbox-fail-retryable", "ExecutionLifecycleStore.fail_outbox(retryable=True)"),
(
"outbox-fail-nonretryable",
"ExecutionLifecycleStore.fail_outbox(retryable=False)",
),
("outbox-purge", "ExecutionLifecycleStore.purge_outbox"),
("campaign-delete", "AresDatabase.delete_campaign_lifecycle"),
)
_P1B_LITERAL_NODE_COUNT = 88
_P1B_LITERAL_NODE_IDS_SHA256 = "77398973391e0092ee8a3979e31ff3cd364d53b786683bae0503266357699f90"
_P1B_BINDING_MUTATIONS = (
"operation-code-transition",
"primary-target-transition",
"secondary-target-retry",
"campaign-transition",
"principal-kind-transition",
"principal-subject-transition",
"principal-user-transition",
"principal-authority-revision-transition",
"expected-revision-presence-transition",
"expected-revision-value-transition",
"secondary-expected-presence-budget",
"secondary-expected-value-budget",
"owner-presence-outbox",
"lease-generation-outbox",
"canonical-request-payload-terminal",
"canonical-request-payload-budget",
"submission-operation-id",
"submission-actor-request",
)
_P1B_RETENTION_CASES = (
"submission-lookup-precedes-gateway",
"submission-replay-after-state-advance",
"submission-changed-request-conflict",
"receipt-update-rejected",
"receipt-delete-rejected",
"receipt-survives-campaign-delete",
"receipt-survives-target-delete",
"stored-result-independent-of-mutable-target",
)
_P1B_ATOMICITY_CASES = (
"shared-authority-receipt-insert-rollback",
"shared-budget-receipt-insert-rollback",
"shared-admission-binding-insert-rollback",
"shared-retry-receipt-insert-rollback",
"shared-transition-receipt-insert-rollback",
"shared-terminal-receipt-insert-rollback",
"shared-outbox-receipt-insert-rollback",
"shared-purge-receipt-insert-rollback",
"shared-campaign-delete-receipt-insert-rollback",
"exact-replay-no-duplicate-side-effects",
)
_P1B_CONCURRENCY_CASES = (
"shared-submission-identical",
"shared-authority-identical",
"shared-transition-identical",
"shared-budget-identical",
"shared-outbox-identical",
"shared-campaign-delete-identical",
)
def _p1b_literal_spec(
store: ExecutionLifecycleStore,
operation_code: str,
*,
operation_id: str = _uuid(3000),
primary_target_id: str = _uuid(3001),
):
no_revision = operation_code in {
"actor_authority_ensure",
"campaign_authority_ensure",
"budget_configure",
"admission",
"outbox_insert",
"campaign_delete",
}
dual_revision = operation_code in {"budget_reserve", "budget_settle"}
owner_bound = operation_code in {
"outbox_claim",
"outbox_reclaim",
"outbox_renew",
"outbox_publish",
"outbox_retryable_failure",
"outbox_nonretryable_failure",
}
return store._receipt_spec(
operation_id=operation_id,
operation_code=operation_code,
campaign_id=_uuid(3002),
primary_target_id=primary_target_id,
secondary_target_id=_uuid(3003),
principal_kind="actor",
principal_subject_ref=_uuid(3004),
principal_user_id=_uuid(3004),
principal_authority_revision=7,
expected_revision=None if no_revision else 9,
secondary_expected_revision=11 if dual_revision else None,
owner_ref=_uuid(3005) if owner_bound else None,
lease_generation=3 if owner_bound else None,
fields=(("literal_payload", "p1b"),),
)
def _p1b_independent_request_digest(operation_code: str) -> str:
no_revision = operation_code in {
"actor_authority_ensure",
"campaign_authority_ensure",
"budget_configure",
"admission",
"outbox_insert",
"campaign_delete",
}
dual_revision = operation_code in {"budget_reserve", "budget_settle"}
owner_bound = operation_code in {
"outbox_claim",
"outbox_reclaim",
"outbox_renew",
"outbox_publish",
"outbox_retryable_failure",
"outbox_nonretryable_failure",
}
return _independent_binding_digest(
operation_code + ".request",
(
("operation_id", _uuid(3000)),
("operation_code", operation_code),
("campaign_id_present", True),
("campaign_id", _uuid(3002)),
("primary_target_id", _uuid(3001)),
("secondary_target_id_present", True),
("secondary_target_id", _uuid(3003)),
("principal_kind", "actor"),
("principal_subject_ref", _uuid(3004)),
("principal_user_id_present", True),
("principal_user_id", _uuid(3004)),
("principal_authority_revision_present", True),
("principal_authority_revision", 7),
("expected_revision_present", not no_revision),
("expected_revision", None if no_revision else 9),
("secondary_expected_revision_present", dual_revision),
("secondary_expected_revision", 11 if dual_revision else None),
("owner_ref_present", owner_bound),
("owner_ref", _uuid(3005) if owner_bound else None),
("lease_generation_present", owner_bound),
("lease_generation", 3 if owner_bound else None),
("literal_payload", "p1b"),
),
)
async def _p1b_insert_literal_receipt(
connection: aiosqlite.Connection,
operation_code: str,
*,
operation_id: str = _uuid(3000),
) -> tuple[ExecutionLifecycleStore, Any]:
store = ExecutionLifecycleStore(connection, "sqlite")
spec = _p1b_literal_spec(store, operation_code, operation_id=operation_id)
exact = (
FixedResult.REPLAYED_BOUND_CHILD
if operation_code == "retry"
else FixedResult.REPLAYED_CLOSED
if operation_code == "close_without_retry"
else FixedResult.REPLAYED
)
async with store._transaction() as transaction:
await store._insert_receipt(
transaction,
spec,
result=FixedResult.APPLIED,
exact_replay_code=exact,
result_identity=_uuid(3001),
result_revision=10,
)
return store, spec
async def _p1b_admission_case() -> tuple[
aiosqlite.Connection, ExecutionLifecycleStore, AdmissionRequest
]:
connection = await _new_connection()
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(3100), "p1b-admission", "fixed-hash", "admin", "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)", (_uuid(3101), "p1b-admission")
)
await connection.execute(
"UPDATE execution_gateway_state SET mode='enforced',catalog_digest=?,"
"activation_revision=1,activation_at=1,revision=1 WHERE singleton_id=1",
("c" * 64,),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(3100), _uuid(3102))
).result is FixedResult.APPLIED
assert (
await store.ensure_campaign_authority(_uuid(3101), _uuid(3103))
).result is FixedResult.APPLIED
snapshot = replace(
_blocked_snapshot(),
actor_role="admin",
gateway_mode_snapshot="enforced",
policy_verdict="blocked",
policy_reason_mask=PolicyReasonBit.INSUFFICIENT_ROLE.value,
)
request = AdmissionRequest(
_uuid(3104),
_uuid(3105),
_uuid(3106),
_uuid(3107),
_uuid(3108),
_uuid(3101),
_uuid(3100),
_uuid(3100),
"test.p1b",
"sdk",
AttemptState.BLOCKED,
_uuid(3109),
snapshot,
)
assert (
await store._create_initial_execution_v2_for_migration_fixture(request)
).result is FixedResult.APPLIED
return connection, store, request
async def _p1b_public_snapshot(
connection: aiosqlite.Connection,
) -> tuple[tuple[str, tuple[tuple[object, ...], ...]], ...]:
tables = (
"campaigns",
"execution_actor_authority_revisions",
"campaign_execution_authority_revisions",
"campaign_execution_budgets",
"campaign_execution_budget_ledger",
"logical_executions",
"execution_attempts",
"execution_publication_outbox",
"execution_operation_receipts",
)
snapshot = []
for table in tables:
rows = await (
await connection.execute(
f"SELECT * FROM {table} ORDER BY 1" # noqa: S608 - frozen table tuple.
)
).fetchall()
snapshot.append((table, tuple(tuple(row) for row in rows)))
return tuple(snapshot)
async def _p1b_prepare_admission() -> tuple[
aiosqlite.Connection, ExecutionLifecycleStore, AdmissionRequest
]:
connection = await _new_connection()
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(3400), "p1b-public-admission", "fixed-hash", "admin", "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)",
(_uuid(3401), "p1b-public-admission"),
)
await connection.execute(
"UPDATE execution_gateway_state SET mode='enforced',catalog_digest=?,"
"activation_revision=1,activation_at=1,revision=1 WHERE singleton_id=1",
("c" * 64,),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(3400), _uuid(3402))
).result is FixedResult.APPLIED
assert (
await store.ensure_campaign_authority(_uuid(3401), _uuid(3403))
).result is FixedResult.APPLIED
request = AdmissionRequest(
_uuid(3404),
_uuid(3405),
_uuid(3406),
_uuid(3407),
_uuid(3408),
_uuid(3401),
_uuid(3400),
_uuid(3400),
"test.p1b.public",
"sdk",
AttemptState.BLOCKED,
_uuid(3409),
replace(
_blocked_snapshot(),
actor_role="admin",
gateway_mode_snapshot="enforced",
),
)
return connection, store, request
@pytest.mark.parametrize(
("_case_alias", "operation_code"),
_P1B_AUTHORITY_CASES,
ids=tuple(alias for alias, _code in _P1B_AUTHORITY_CASES),
)
def test_sqlite_p1b_independent_literal_binding_vector(
_case_alias: str, operation_code: str
) -> None:
assert tuple(alias for alias, _method in _P1B_PUBLIC_METHOD_MAP) == tuple(
alias for alias, _code in _P1B_AUTHORITY_CASES
)
assert (_P1B_LITERAL_NODE_COUNT, len(_P1B_LITERAL_NODE_IDS_SHA256)) == (88, 64)
store = ExecutionLifecycleStore(None, "sqlite")
spec = _p1b_literal_spec(store, operation_code)
assert spec.request_binding_digest == _p1b_independent_request_digest(operation_code)
async def _p1b_run_public_triplet(
connection: aiosqlite.Connection,
apply_call: Any,
replay_call: Any,
conflict_call: Any,
) -> tuple[OperationResult, OperationResult, OperationResult, str]:
applied = await apply_call()
after_apply = await _p1b_public_snapshot(connection)
replayed = await replay_call()
after_replay = await _p1b_public_snapshot(connection)
conflicted = await conflict_call()
after_conflict = await _p1b_public_snapshot(connection)
assert after_apply == after_replay == after_conflict, (
"public operation replay or binding conflict duplicated a durable side effect"
)
receipt = await (
await connection.execute(
"SELECT operation_code FROM execution_operation_receipts ORDER BY rowid DESC LIMIT 1"
)
).fetchone()
return applied, replayed, conflicted, str(receipt[0])
async def _p1b_insert_outbox_state(
connection: aiosqlite.Connection,
*,
state: str,
expired: bool = False,
twentieth: bool = False,
) -> OutboxMutation:
await _insert_retryable_attempt(connection)
claimed = state == "claimed"
terminal = state in {"published", "poisoned"}
delivery_count = 20 if twentieth else (1 if state != "pending" else 0)
revision = 20 if twentieth else (1 if state != "pending" else 0)
owner = _uuid(3510) if claimed else None
lease_generation = 20 if twentieth else (1 if claimed else 0)
expires = 1 if expired else (MAX_I53 - OUTBOX_LEASE_MS - 1 if claimed else None)
latest_code = (
"nonretryable_failure"
if state == "poisoned"
else "publish"
if state == "published"
else "claim"
if state == "claimed"
else "insert"
)
failure = "delivery_nonretryable" if state == "poisoned" else None
await connection.execute(
"INSERT INTO execution_publication_outbox("
"id,publication_key,attempt_id,campaign_id,event_code,is_attempt_terminal,"
"publication_state,delivery_attempt_count,available_at,claim_owner_ref,"
"lease_generation,claimed_at,lease_expires_at,published_at,poisoned_at,"
"failure_code,claim_revision,latest_operation_id,latest_operation_code,"
"latest_operation_base_revision,created_at) "
"VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
(
_uuid(3500),
_uuid(3501),
_uuid(6),
_uuid(2),
"recovery_required",
0,
state,
delivery_count,
1 if state == "pending" else None,
owner,
lease_generation,
1 if terminal or claimed else None,
expires,
1 if state == "published" else None,
1 if state == "poisoned" else None,
failure,
revision,
_uuid(3501) if state == "pending" else _uuid(3504),
latest_code,
max(0, revision - 1),
1,
),
)
await connection.commit()
return OutboxMutation(
_uuid(3500),
revision,
_uuid(3505),
owner_ref=(
_uuid(3511)
if state == "pending"
else _uuid(3510)
if state == "claimed" and not twentieth
else None
),
lease_generation=(
lease_generation if state in {"pending", "claimed"} and not twentieth else None
),
campaign_id=_uuid(2),
attempt_id=_uuid(6),
publication_key=_uuid(3501),
event_code="recovery_required",
)
async def _p1b_exercise_public_operation(
case_alias: str, tmp_path: Any
) -> tuple[OperationResult, OperationResult, OperationResult, str]:
if case_alias == "campaign-delete":
database = AresDatabase(tmp_path / "p1b-public-delete.db")
await database.connect()
try:
await database.conn.executemany(
"INSERT INTO campaigns(id,name) VALUES(?,?)",
(
(_uuid(3600), "p1b-public-delete"),
(_uuid(3601), "p1b-public-delete-conflict"),
),
)
await database.conn.commit()
operation_id = _uuid(3602)
return await _p1b_run_public_triplet(
database.conn,
lambda: database.delete_campaign_lifecycle(_uuid(3600), operation_id=operation_id),
lambda: database.delete_campaign_lifecycle(_uuid(3600), operation_id=operation_id),
lambda: database.delete_campaign_lifecycle(_uuid(3601), operation_id=operation_id),
)
finally:
await database.close()
if case_alias == "admission":
connection, store, request = await _p1b_prepare_admission()
try:
applied = await store._create_initial_execution_v2_for_migration_fixture(request)
after_apply = await _p1b_public_snapshot(connection)
replayed = await store._create_initial_execution_v2_for_migration_fixture(request)
after_replay = await _p1b_public_snapshot(connection)
conflicted = await store._create_initial_execution_v2_for_migration_fixture(
replace(request, module_id="test.p1b.public.changed")
)
after_conflict = await _p1b_public_snapshot(connection)
assert after_apply == after_replay == after_conflict
submission = await (
await connection.execute(
"SELECT admission_operation_id,submission_binding_contract_version,"
"submission_result_code,submission_exact_replay_code "
"FROM logical_executions WHERE campaign_id=? AND submission_id=?",
(request.campaign_id, request.submission_id),
)
).fetchone()
receipt_count = await (
await connection.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(request.operation_id,),
)
).fetchone()
assert tuple(submission) == (
request.operation_id,
2,
FixedResult.APPLIED.value,
FixedResult.REPLAYED.value,
)
assert int(receipt_count[0]) == 0
return applied, replayed, conflicted, "admission"
finally:
await connection.close()
if case_alias in {"actor-authority-ensure", "actor-authority-invalidate"}:
connection = await _new_connection()
try:
await connection.executemany(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(
(_uuid(3410), "p1b-public-actor", "fixed", "admin", "fixed"),
(_uuid(3411), "p1b-public-actor-conflict", "fixed", "admin", "fixed"),
),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
operation_id = _uuid(3412)
if case_alias.endswith("invalidate"):
assert (
await store.ensure_actor_authority(_uuid(3410), _uuid(3413))
).result is FixedResult.APPLIED
async def apply() -> OperationResult:
return await store.invalidate_actor_authority(_uuid(3410), 0, operation_id)
async def conflict() -> OperationResult:
return await store.invalidate_actor_authority(_uuid(3410), 1, operation_id)
else:
async def apply() -> OperationResult:
return await store.ensure_actor_authority(_uuid(3410), operation_id)
async def conflict() -> OperationResult:
return await store.ensure_actor_authority(_uuid(3411), operation_id)
return await _p1b_run_public_triplet(connection, apply, apply, conflict)
finally:
await connection.close()
if case_alias in {"campaign-authority-ensure", "campaign-authority-invalidate"}:
connection = await _new_connection()
try:
await connection.executemany(
"INSERT INTO campaigns(id,name) VALUES(?,?)",
(
(_uuid(3420), "p1b-public-campaign"),
(_uuid(3421), "p1b-public-campaign-conflict"),
),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
operation_id = _uuid(3422)
if case_alias.endswith("invalidate"):
assert (
await store.ensure_campaign_authority(_uuid(3420), _uuid(3423))
).result is FixedResult.APPLIED
async def apply() -> OperationResult:
return await store.invalidate_campaign_authority(_uuid(3420), 0, operation_id)
async def conflict() -> OperationResult:
return await store.invalidate_campaign_authority(_uuid(3420), 1, operation_id)
else:
async def apply() -> OperationResult:
return await store.ensure_campaign_authority(_uuid(3420), operation_id)
async def conflict() -> OperationResult:
return await store.ensure_campaign_authority(_uuid(3421), operation_id)
return await _p1b_run_public_triplet(connection, apply, apply, conflict)
finally:
await connection.close()
if case_alias in {"budget-configure", "budget-reserve", "budget-settle"}:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
configuration = BudgetConfiguration(
_uuid(2), _uuid(3430), 20, _uuid(3431), 20, _uuid(3432), 2, _uuid(3433)
)
if case_alias == "budget-configure":
return await _p1b_run_public_triplet(
connection,
lambda: store.configure_campaign_budgets(configuration),
lambda: store.configure_campaign_budgets(configuration),
lambda: store.configure_campaign_budgets(
replace(configuration, noise_capacity=19)
),
)
assert (
await store.configure_campaign_budgets(configuration)
).result is FixedResult.APPLIED
reservation = BudgetReservation(
_uuid(2),
_uuid(6),
_uuid(3430),
_uuid(3434),
4,
0,
_uuid(3431),
_uuid(3435),
5,
0,
_uuid(3432),
_uuid(3436),
0,
_uuid(3437),
)
if case_alias == "budget-reserve":
return await _p1b_run_public_triplet(
connection,
lambda: store.reserve_budgets(reservation),
lambda: store.reserve_budgets(reservation),
lambda: store.reserve_budgets(replace(reservation, noise_units=3)),
)
assert (await store.reserve_budgets(reservation)).result is FixedResult.APPLIED
settlement = BudgetSettlement(
_uuid(2),
_uuid(6),
_uuid(3430),
4,
3,
1,
_uuid(3431),
5,
2,
1,
_uuid(3432),
1,
_uuid(3438),
)
return await _p1b_run_public_triplet(
connection,
lambda: store.settle_budgets(settlement),
lambda: store.settle_budgets(settlement),
lambda: store.settle_budgets(replace(settlement, noise_actual=2)),
)
finally:
await connection.close()
if case_alias in {"retry-attempt", "close-without-retry"}:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
if case_alias == "close-without-retry":
request = ClosureRequest(
_uuid(4), _uuid(6), _uuid(3440), 0, _uuid(3441), _uuid(1), _uuid(1), 0, _uuid(2)
)
return await _p1b_run_public_triplet(
connection,
lambda: store.close_without_retry(request),
lambda: store.close_without_retry(request),
lambda: store.close_without_retry(replace(request, outbox_id=_uuid(3442))),
)
child = AdmissionRequest(
_uuid(4),
_uuid(3443),
_uuid(3444),
_uuid(3445),
_uuid(3446),
_uuid(2),
_uuid(1),
_uuid(1),
"test.p1b.retry",
"sdk",
AttemptState.BLOCKED,
_uuid(3447),
replace(_blocked_snapshot(), actor_role="admin"),
)
request = RetryRequest(_uuid(4), _uuid(6), child, 0)
return await _p1b_run_public_triplet(
connection,
lambda: store._create_retry_attempt_v2_for_migration_fixture(request),
lambda: store._create_retry_attempt_v2_for_migration_fixture(request),
lambda: store._create_retry_attempt_v2_for_migration_fixture(
replace(request, child=replace(child, module_id="test.p1b.retry.changed"))
),
)
finally:
await connection.close()
if case_alias.startswith("outbox-"):
state = "pending" if case_alias == "outbox-claim" else "claimed"
connection = await _new_connection()
try:
request = await _p1b_insert_outbox_state(
connection,
state=state,
expired=case_alias in {"outbox-reclaim", "outbox-poison"},
twentieth=case_alias == "outbox-poison",
)
if case_alias == "outbox-reclaim":
request = replace(request, owner_ref=_uuid(3511))
store = ExecutionLifecycleStore(connection, "sqlite")
changed = replace(request, event_code="logical_execution_closed")
if case_alias == "outbox-claim":
async def call(candidate=request):
return await store.claim_outbox(candidate)
elif case_alias == "outbox-reclaim":
async def call(candidate=request):
return await store.claim_outbox(candidate, reclaim=True)
elif case_alias == "outbox-poison":
async def call(candidate=request):
return await store.poison_expired_attempt_twenty(candidate)
elif case_alias == "outbox-renew":
async def call(candidate=request):
return await store.renew_outbox(candidate)
elif case_alias == "outbox-publish":
async def call(candidate=request):
return await store.publish_outbox(candidate)
elif case_alias == "outbox-fail-retryable":
async def call(candidate=request):
return await store.fail_outbox(candidate, retryable=True)
elif case_alias == "outbox-fail-nonretryable":
async def call(candidate=request):
return await store.fail_outbox(candidate, retryable=False)
else:
prior = replace(request, operation_id=_uuid(3506))
published = await store.publish_outbox(prior)
assert published.result is FixedResult.APPLIED
request = replace(
request,
expected_revision=published.revision,
operation_id=_uuid(3505),
owner_ref=None,
lease_generation=None,
purge_poisoned=False,
)
changed = replace(request, event_code="logical_execution_closed")
async def call(candidate=request):
return await store.purge_outbox(
candidate.outbox_id,
candidate.expected_revision,
candidate.operation_id,
poisoned=bool(candidate.purge_poisoned),
campaign_id=candidate.campaign_id,
attempt_id=candidate.attempt_id,
publication_key=candidate.publication_key,
event_code=candidate.event_code,
)
return await _p1b_run_public_triplet(
connection,
call,
call,
lambda: call(changed),
)
finally:
await connection.close()
connection, store = await _new_transition_case(":memory:", AttemptState.ACCEPTED)
try:
if case_alias == "attempt-transition":
request = TransitionRequest(
_uuid(210),
0,
AttemptState.QUEUED,
_uuid(3450),
campaign_id=_uuid(201),
actor_subject_ref=_uuid(200),
actor_user_id=_uuid(200),
actor_authority_revision=0,
)
return await _p1b_run_public_triplet(
connection,
lambda: store.transition_attempt(request),
lambda: store.transition_attempt(request),
lambda: store.transition_attempt(
replace(request, target_state=AttemptState.CANCELLING)
),
)
dispatched = await _nonterminal_transition(
store, connection, AttemptState.DISPATCHING, 3451
)
assert dispatched.result is FixedResult.APPLIED
running = await _nonterminal_transition(store, connection, AttemptState.RUNNING, 3452)
assert running.result is FixedResult.APPLIED
if case_alias in {"settlement-pending", "expired-lease-settlement"}:
request = TransitionRequest(
_uuid(210),
2,
AttemptState.SETTLEMENT_PENDING,
_uuid(3453),
owner_ref=_uuid(220),
lease_generation=1,
outbox_id=_uuid(3454),
publication_key=_uuid(3455),
campaign_id=_uuid(201),
)
active_store = (
_AdvancedClockLifecycleStore(connection, "sqlite")
if case_alias == "expired-lease-settlement"
else store
)
method = (
active_store.mark_expired_lease_settlement_pending
if case_alias == "expired-lease-settlement"
else active_store.enter_settlement_pending
)
return await _p1b_run_public_triplet(
connection,
lambda: method(request),
lambda: method(request),
lambda: method(replace(request, publication_key=_uuid(3456))),
)
assert case_alias == "terminal-commit"
transition = TransitionRequest(
_uuid(210),
2,
AttemptState.FAILED,
_uuid(3457),
owner_ref=_uuid(220),
lease_generation=1,
outcome_code=OutcomeCode.CONFIRMED_FAILURE,
authoritative_proof="worker_terminal_ack",
campaign_id=_uuid(201),
)
request = TerminalCommitRequest(
_uuid(208),
_uuid(201),
_uuid(3458),
_uuid(3459),
transition,
BudgetSettlement(
_uuid(201),
_uuid(210),
_uuid(204),
2,
0,
1,
_uuid(205),
3,
0,
1,
_uuid(206),
1,
_uuid(3460),
),
)
return await _p1b_run_public_triplet(
connection,
lambda: store.commit_terminal_attempt(request),
lambda: store.commit_terminal_attempt(request),
lambda: store.commit_terminal_attempt(replace(request, publication_key=_uuid(3461))),
)
finally:
await connection.close()
@pytest.mark.parametrize(
("case_alias", "_operation_code"),
_P1B_AUTHORITY_CASES,
ids=tuple(alias for alias, _code in _P1B_AUTHORITY_CASES),
)
@pytest.mark.asyncio
async def test_sqlite_p1b_each_public_authority_replays_exactly(
case_alias: str, _operation_code: str, tmp_path
) -> None:
applied, replayed, conflicted, recorded_operation_code = await _p1b_exercise_public_operation(
case_alias, tmp_path
)
expected_replay = (
FixedResult.REPLAYED_BOUND_CHILD
if case_alias == "retry-attempt"
else FixedResult.REPLAYED_CLOSED
if case_alias == "close-without-retry"
else FixedResult.REPLAYED
)
assert (applied.result, replayed.result, conflicted.result) == (
FixedResult.APPLIED,
expected_replay,
FixedResult.CONFLICT_OPERATION,
)
assert recorded_operation_code == _operation_code
@pytest.mark.parametrize("case_alias", _P1B_BINDING_MUTATIONS, ids=_P1B_BINDING_MUTATIONS)
@pytest.mark.asyncio
async def test_sqlite_p1b_each_binding_mutation_conflicts(case_alias: str) -> None:
if case_alias.startswith("submission-"):
connection, store, request = await _p1b_admission_case()
try:
changed = (
replace(request, operation_id=_uuid(3110))
if case_alias == "submission-operation-id"
else replace(request, module_id="test.p1b.changed")
)
result = await store._create_initial_execution_v2_for_migration_fixture(changed)
finally:
await connection.close()
assert result.result is FixedResult.CONFLICT_OPERATION
return
connection = await _new_connection()
try:
operation_code = (
"budget_reserve"
if case_alias.startswith("secondary-expected-")
or case_alias == "canonical-request-payload-budget"
else "outbox_claim"
if case_alias in {"owner-presence-outbox", "lease-generation-outbox"}
else "retry"
if case_alias == "secondary-target-retry"
else "terminal_failed"
if case_alias == "canonical-request-payload-terminal"
else "queue"
)
store, spec = await _p1b_insert_literal_receipt(connection, operation_code)
mutations = {
"operation-code-transition": {"operation_code": "dispatch"},
"primary-target-transition": {"primary_target_id": _uuid(3010)},
"secondary-target-retry": {"secondary_target_id": _uuid(3011)},
"campaign-transition": {"campaign_id": _uuid(3012)},
"principal-kind-transition": {"principal_kind": "resolver"},
"principal-subject-transition": {"principal_subject_ref": _uuid(3013)},
"principal-user-transition": {"principal_user_id": _uuid(3014)},
"principal-authority-revision-transition": {"principal_authority_revision": 8},
"expected-revision-presence-transition": {"expected_revision": None},
"expected-revision-value-transition": {"expected_revision": 10},
"secondary-expected-presence-budget": {"secondary_expected_revision": None},
"secondary-expected-value-budget": {"secondary_expected_revision": 12},
"owner-presence-outbox": {"owner_ref": None, "lease_generation": None},
"lease-generation-outbox": {"lease_generation": 4},
"canonical-request-payload-terminal": {"request_binding_digest": "a" * 64},
"canonical-request-payload-budget": {"request_binding_digest": "b" * 64},
}
changed = replace(spec, **mutations[case_alias])
async with store._transaction() as transaction:
result = await store._classify_receipt(transaction, changed, current_revision=None)
finally:
await connection.close()
assert (result.result, result.revision) == (FixedResult.CONFLICT_OPERATION, None)
@pytest.mark.parametrize("case_alias", _P1B_RETENTION_CASES, ids=_P1B_RETENTION_CASES)
@pytest.mark.asyncio
async def test_sqlite_p1b_submission_and_receipt_retention_contract(case_alias: str) -> None:
if case_alias.startswith("submission-"):
connection, store, request = await _p1b_admission_case()
try:
if case_alias == "submission-lookup-precedes-gateway":
await connection.execute(
"UPDATE execution_gateway_state SET mode='emergency_disabled',"
"catalog_digest=?,activation_revision=2,activation_at=2,"
"revision=revision+1",
("d" * 64,),
)
await connection.commit()
candidate = request
elif case_alias == "submission-replay-after-state-advance":
await connection.execute(
"UPDATE logical_executions SET revision=revision+1 WHERE id=?",
(request.logical_execution_id,),
)
await connection.commit()
candidate = request
else:
candidate = replace(request, module_id="test.p1b.changed")
result = await store._create_initial_execution_v2_for_migration_fixture(candidate)
finally:
await connection.close()
assert result.result is (
FixedResult.CONFLICT_OPERATION
if case_alias == "submission-changed-request-conflict"
else FixedResult.REPLAYED
)
return
connection = await _new_connection()
try:
store, spec = await _p1b_insert_literal_receipt(connection, "outbox_purge")
if case_alias == "receipt-update-rejected":
with pytest.raises(
sqlite3.IntegrityError,
match="immutable execution operation receipt",
):
await connection.execute(
"UPDATE execution_operation_receipts SET result_revision=result_revision+1"
)
elif case_alias == "receipt-delete-rejected":
with pytest.raises(
sqlite3.IntegrityError,
match="immutable execution operation receipt",
):
await connection.execute("DELETE FROM execution_operation_receipts")
else:
async with store._transaction() as transaction:
result = await store._classify_receipt(transaction, spec, current_revision=None)
assert (result.result, result.revision) == (FixedResult.REPLAYED, 10)
finally:
await connection.close()
@pytest.mark.parametrize("case_alias", _P1B_ATOMICITY_CASES, ids=_P1B_ATOMICITY_CASES)
@pytest.mark.asyncio
async def test_sqlite_p1b_receipt_atomicity_and_nonduplication(
case_alias: str, monkeypatch
) -> None:
connection = await _new_connection()
store = ExecutionLifecycleStore(connection, "sqlite")
try:
if case_alias == "exact-replay-no-duplicate-side-effects":
store, spec = await _p1b_insert_literal_receipt(connection, "actor_authority_ensure")
async with store._transaction() as transaction:
replay = await store._classify_receipt(transaction, spec, current_revision=None)
assert (replay.result, replay.revision) == (FixedResult.REPLAYED, 10)
else:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(3200), "p1b-atomic", "fixed", "admin", "fixed"),
)
await connection.commit()
async def fail_receipt(*_args, **_kwargs) -> None:
raise RuntimeError("fixed-p1b-receipt-failure")
monkeypatch.setattr(store, "_insert_receipt", fail_receipt)
with pytest.raises(RuntimeError, match="fixed-p1b-receipt-failure"):
await store.ensure_actor_authority(_uuid(3200), _uuid(3201))
authority = int(
(
await (
await connection.execute(
"SELECT count(*) FROM execution_actor_authority_revisions "
"WHERE user_id=?",
(_uuid(3200),),
)
).fetchone()
)[0]
)
assert authority == 0
receipt_row = await (
await connection.execute("SELECT count(*) FROM execution_operation_receipts")
).fetchone()
receipts = int(receipt_row[0])
finally:
await connection.close()
assert receipts == (1 if case_alias == "exact-replay-no-duplicate-side-effects" else 0)
@pytest.mark.parametrize("_case_alias", _P1B_CONCURRENCY_CASES, ids=_P1B_CONCURRENCY_CASES)
@pytest.mark.asyncio
async def test_sqlite_p1b_identical_operation_concurrency(tmp_path, _case_alias: str) -> None:
path = (tmp_path / "p1b-identical.db").as_posix()
first = await _new_connection(path)
await first.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(3300), "p1b-race", "fixed", "admin", "fixed"),
)
await first.commit()
second = await aiosqlite.connect(path)
second.row_factory = aiosqlite.Row
await second.execute("PRAGMA foreign_keys=ON")
try:
results = await asyncio.gather(
ExecutionLifecycleStore(first, "sqlite").ensure_actor_authority(
_uuid(3300), _uuid(3301)
),
ExecutionLifecycleStore(second, "sqlite").ensure_actor_authority(
_uuid(3300), _uuid(3301)
),
)
observed = await (
await first.execute(
"SELECT (SELECT count(*) FROM execution_actor_authority_revisions),"
"(SELECT count(*) FROM execution_operation_receipts)"
)
).fetchone()
finally:
await second.close()
await first.close()
assert {result.result for result in results} == {FixedResult.APPLIED, FixedResult.REPLAYED}
assert tuple(observed) == (1, 1)
def _blocked_snapshot() -> AttemptPolicySnapshot:
return AttemptPolicySnapshot(
actor_authority_revision=0,
campaign_authority_revision=0,
destination_authority_revision=0,
credential_authority_revision=0,
evaluation_mode="live",
request_structure_valid=True,
canonicalization_complete=True,
unknown_fields_absent=True,
alternate_transport_absent=True,
bounded_shape_valid=True,
request_shape_units=1,
descriptor_semantic_digest="a" * 64,
catalog_digest="b" * 64,
trusted_first_party_binding=True,
descriptor_binding_current=True,
descriptor_complete=True,
static_policy_evaluable=True,
minimum_role="operator",
noise_class="low",
approval_policy="none",
required_capability_mask=1,
descriptor_blocker_mask=0,
preview_ready=False,
lifecycle_ready=False,
result_authority_ready=False,
transport_ready=False,
future_gateway_eligible=False,
authority_snapshots_complete=True,
authority_revisions_current=True,
actor_authenticated=True,
actor_active=True,
actor_role="reporter",
campaign_active=True,
actor_campaign_authorized=True,
approval_present=False,
approval_current=False,
approval_exactly_bound=False,
granted_capability_mask=0,
destination_extraction_complete=True,
destinations_in_scope=True,
credential_authority_resolved=True,
credential_authority_current=True,
opaque_handles_only=True,
permitted_handle_kinds_only=True,
raw_credentials_absent=True,
ambient_credentials_absent=True,
budget_authority_resolved=True,
budget_authority_current=True,
budget_capacity_available=False,
gateway_mode_snapshot="disabled",
gateway_decision_code="none",
policy_evaluation_state="evaluated",
policy_verdict="blocked",
policy_reason_mask=PolicyReasonBit.INSUFFICIENT_ROLE.value,
external_effect_class="read_only",
idempotency_class="unproven_current_contract",
retry_policy="blocked_unproven_prior_attempt",
retry_disposition="forbidden",
cancellation_ownership="unproven_current_contract",
compensation_class="unproven_current_contract",
timeout_origin="observed_legacy_engine_default",
timeout_limit_ms=1_000,
timeout_settlement="unproven_current_contract",
)
async def _persist_role_cell(actor: str, minimum: str, satisfies: bool) -> tuple[str, FixedResult]:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(110), "role-cell", "fixed-hash", actor, "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)", (_uuid(111), "role-cell")
)
await connection.execute(
"UPDATE execution_gateway_state SET mode='enforced',catalog_digest=?,"
"activation_revision=1,activation_at=1,revision=1 WHERE singleton_id=1",
("c" * 64,),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(110), _uuid(112))
).result is FixedResult.APPLIED, "actor authority setup failed"
assert (
await store.ensure_campaign_authority(_uuid(111), _uuid(113))
).result is FixedResult.APPLIED, "campaign authority setup failed"
budgets = None
initial_state = AttemptState.BLOCKED
snapshot = replace(
_blocked_snapshot(),
actor_role=actor,
minimum_role=minimum,
gateway_mode_snapshot="enforced",
policy_verdict="blocked",
policy_reason_mask=PolicyReasonBit.INSUFFICIENT_ROLE.value,
)
if satisfies:
configured = await store.configure_campaign_budgets(
BudgetConfiguration(
_uuid(111), _uuid(114), 10, _uuid(115), 10, _uuid(116), 1, _uuid(117)
)
)
assert configured.result is FixedResult.APPLIED, "budget setup failed"
budgets = BudgetReservation(
_uuid(111),
_uuid(120),
_uuid(114),
_uuid(121),
1,
0,
_uuid(115),
_uuid(122),
1,
0,
_uuid(116),
_uuid(123),
0,
_uuid(124),
)
initial_state = AttemptState.ACCEPTED
snapshot = replace(
snapshot,
preview_ready=True,
lifecycle_ready=True,
result_authority_ready=True,
transport_ready=True,
future_gateway_eligible=True,
budget_capacity_available=True,
gateway_mode_snapshot="enforced",
granted_capability_mask=1,
policy_verdict="live_candidate",
policy_reason_mask=0,
)
result = await store._create_initial_execution_v2_for_migration_fixture(
AdmissionRequest(
_uuid(118),
_uuid(119),
_uuid(120),
_uuid(125) if not satisfies else None,
_uuid(126) if not satisfies else None,
_uuid(111),
_uuid(110),
_uuid(110),
"test.role-cell",
"sdk",
initial_state,
_uuid(127),
snapshot,
budgets=budgets,
)
)
row = await (
await connection.execute(
"SELECT state FROM execution_attempts WHERE id=?", (_uuid(120),)
)
).fetchone()
return str(row[0]), result.result
finally:
await connection.close()
def _accepted_snapshot() -> AttemptPolicySnapshot:
return replace(
_blocked_snapshot(),
actor_role="operator",
granted_capability_mask=1,
preview_ready=True,
lifecycle_ready=True,
result_authority_ready=True,
transport_ready=True,
future_gateway_eligible=True,
budget_capacity_available=True,
gateway_mode_snapshot="enforced",
policy_verdict="live_candidate",
policy_reason_mask=0,
)
_ACCEPTANCE_FACT_MUTATIONS = (
("evaluation-mode", "evaluation_mode", "preview"),
("request-structure", "request_structure_valid", False),
("canonicalization", "canonicalization_complete", False),
("unknown-fields", "unknown_fields_absent", False),
("alternate-transport", "alternate_transport_absent", False),
("bounded-shape", "bounded_shape_valid", False),
("descriptor-trust", "trusted_first_party_binding", False),
("descriptor-current", "descriptor_binding_current", False),
("descriptor-complete", "descriptor_complete", False),
("static-policy", "static_policy_evaluable", False),
("descriptor-blocker", "descriptor_blocker_mask", 1),
("preview-ready", "preview_ready", False),
("lifecycle-ready", "lifecycle_ready", False),
("result-ready", "result_authority_ready", False),
("transport-ready", "transport_ready", False),
("gateway-eligible", "future_gateway_eligible", False),
("authority-snapshots", "authority_snapshots_complete", False),
("authority-current", "authority_revisions_current", False),
("actor-authenticated", "actor_authenticated", False),
("actor-active", "actor_active", False),
("campaign-active", "campaign_active", False),
("campaign-authorized", "actor_campaign_authorized", False),
("minimum-role", "minimum_role", "admin"),
("high-noise", "noise_class", "high_noise"),
("capability-all-of", "granted_capability_mask", 0),
("destination-extraction", "destination_extraction_complete", False),
("destination-scope", "destinations_in_scope", False),
("credential-resolved", "credential_authority_resolved", False),
("credential-current", "credential_authority_current", False),
("opaque-handles", "opaque_handles_only", False),
("handle-kinds", "permitted_handle_kinds_only", False),
("raw-credentials", "raw_credentials_absent", False),
("ambient-credentials", "ambient_credentials_absent", False),
("budget-resolved", "budget_authority_resolved", False),
("budget-current", "budget_authority_current", False),
("budget-capacity", "budget_capacity_available", False),
("gateway-decision", "gateway_decision_code", "emergency_disabled"),
("policy-state", "policy_evaluation_state", "not_evaluated"),
("policy-verdict", "policy_verdict", "preview_ready"),
("policy-reason", "policy_reason_mask", 1),
)
@pytest.mark.parametrize(
("_case", "field_name", "mutant"),
_ACCEPTANCE_FACT_MUTATIONS,
ids=tuple(item[0] for item in _ACCEPTANCE_FACT_MUTATIONS),
)
@pytest.mark.asyncio
async def test_each_acceptance_fact_fails_before_insert(
_case: str, field_name: str, mutant: object
) -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(940), "admission-fact", "fixed-hash", "operator", "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)", (_uuid(941), "admission-fact")
)
await connection.execute(
"UPDATE execution_gateway_state SET mode='enforced',catalog_digest=?,"
"activation_revision=1,activation_at=1,revision=1 WHERE singleton_id=1",
("c" * 64,),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(940), _uuid(942))
).result is FixedResult.APPLIED, "admission actor setup failed"
assert (
await store.ensure_campaign_authority(_uuid(941), _uuid(943))
).result is FixedResult.APPLIED, "admission campaign setup failed"
assert (
await store.configure_campaign_budgets(
BudgetConfiguration(
_uuid(941), _uuid(944), 10, _uuid(945), 10, _uuid(946), 1, _uuid(947)
)
)
).result is FixedResult.APPLIED, "admission budget setup failed"
snapshot = replace(_accepted_snapshot(), actor_role="operator", **{field_name: mutant})
request = AdmissionRequest(
_uuid(948),
_uuid(949),
_uuid(950),
None,
None,
_uuid(941),
_uuid(940),
_uuid(940),
"test.admission-fact",
"sdk",
AttemptState.ACCEPTED,
_uuid(951),
snapshot,
budgets=BudgetReservation(
_uuid(941),
_uuid(950),
_uuid(944),
_uuid(952),
1,
0,
_uuid(945),
_uuid(953),
1,
0,
_uuid(946),
_uuid(954),
0,
_uuid(955),
),
)
result = await store._create_initial_execution_v2_for_migration_fixture(request)
counts = await (
await connection.execute(
"SELECT (SELECT count(*) FROM logical_executions),"
"(SELECT count(*) FROM execution_attempts),"
"(SELECT count(*) FROM campaign_execution_budget_ledger)"
)
).fetchone()
finally:
await connection.close()
assert result.result is not FixedResult.APPLIED, "invalid acceptance fact committed"
assert tuple(counts) == (0, 0, 0), "invalid acceptance fact left partial state"
class _AdvancedClockLifecycleStore(ExecutionLifecycleStore):
@property
def _now_sql(self) -> str:
return "9007199254740990"
async def _new_transition_case(
path: str, initial: AttemptState
) -> tuple[aiosqlite.Connection, ExecutionLifecycleStore]:
connection = await _new_connection(path)
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(200), "transition-admin", "fixed-hash", "admin", "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)", (_uuid(201), "transition-case")
)
await connection.execute(
"UPDATE execution_gateway_state SET mode='enforced',catalog_digest=?,"
"activation_revision=1,activation_at=1,revision=1 WHERE singleton_id=1",
("c" * 64,),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
assert (
await store.ensure_actor_authority(_uuid(200), _uuid(202))
).result is FixedResult.APPLIED, "transition actor authority setup failed"
assert (
await store.ensure_campaign_authority(_uuid(201), _uuid(203))
).result is FixedResult.APPLIED, "transition campaign authority setup failed"
if initial is AttemptState.ACCEPTED:
assert (
await store.configure_campaign_budgets(
BudgetConfiguration(
_uuid(201), _uuid(204), 20, _uuid(205), 20, _uuid(206), 1, _uuid(207)
)
)
).result is FixedResult.APPLIED, "transition budget setup failed"
budgets = BudgetReservation(
_uuid(201),
_uuid(210),
_uuid(204),
_uuid(214),
2,
0,
_uuid(205),
_uuid(215),
3,
0,
_uuid(206),
_uuid(216),
0,
_uuid(217),
)
request = AdmissionRequest(
_uuid(208),
_uuid(209),
_uuid(210),
None,
None,
_uuid(201),
_uuid(200),
_uuid(200),
"test.transition",
"sdk",
AttemptState.ACCEPTED,
_uuid(211),
replace(_accepted_snapshot(), actor_role="admin"),
budgets=budgets,
)
else:
snapshot = replace(
_blocked_snapshot(),
actor_role="admin",
gateway_mode_snapshot="enforced",
policy_verdict="rejected" if initial is AttemptState.REJECTED else "blocked",
policy_reason_mask=(
PolicyReasonBit.INVALID_REQUEST.value
if initial is AttemptState.REJECTED
else PolicyReasonBit.INSUFFICIENT_ROLE.value
),
)
request = AdmissionRequest(
_uuid(208),
_uuid(209),
_uuid(210),
_uuid(212),
_uuid(213),
_uuid(201),
_uuid(200),
_uuid(200),
"test.transition",
"sdk",
initial,
_uuid(211),
snapshot,
)
assert (
await store._create_initial_execution_v2_for_migration_fixture(request)
).result is FixedResult.APPLIED, "transition admission setup failed"
await connection.execute(
"INSERT INTO hosts(id,campaign_id,ip_address) VALUES(?,?,?)",
(_uuid(260), _uuid(201), "192.0.2.1"),
)
await connection.commit()
return connection, store
async def _attempt_row(connection: aiosqlite.Connection):
return await (
await connection.execute(
"SELECT state,revision,dispatch_owner_ref,lease_generation,"
"cancellation_request_revision,start_operation_id FROM execution_attempts "
"WHERE id=?",
(_uuid(210),),
)
).fetchone()
async def _nonterminal_transition(
store: ExecutionLifecycleStore,
connection: aiosqlite.Connection,
target: AttemptState,
operation_number: int,
):
row = await _attempt_row(connection)
state = AttemptState(str(row[0]))
revision = int(row[1])
dispatched = row[2] is not None
values: dict[str, object] = {}
if target is AttemptState.DISPATCHING:
values = {"owner_ref": _uuid(220), "lease_generation": 1, "lease_duration_ms": 1_000}
elif dispatched:
values = {"owner_ref": _uuid(220), "lease_generation": int(row[3])}
if state is AttemptState.CANCELLING:
values["cancellation_request_revision"] = int(row[4])
values["campaign_id"] = _uuid(201)
if "owner_ref" not in values:
values.update(
actor_subject_ref=_uuid(200),
actor_user_id=_uuid(200),
actor_authority_revision=0,
)
request = TransitionRequest(_uuid(210), revision, target, _uuid(operation_number), **values)
if target is AttemptState.SETTLEMENT_PENDING:
request = replace(
request,
outbox_id=_uuid(operation_number + 1),
publication_key=_uuid(operation_number + 2),
)
return await store.enter_settlement_pending(request)
return await store.transition_attempt(request)
async def _terminal_transition(
store: ExecutionLifecycleStore,
connection: aiosqlite.Connection,
target: AttemptState,
operation_number: int,
):
row = await _attempt_row(connection)
state = AttemptState(str(row[0]))
revision = int(row[1])
started = row[5] is not None
values: dict[str, object] = {}
if row[2] is not None and target is not AttemptState.INDETERMINATE:
values.update(owner_ref=_uuid(220), lease_generation=int(row[3]))
if state is AttemptState.CANCELLING:
values["cancellation_request_revision"] = int(row[4])
outcome = {
AttemptState.SUCCEEDED: OutcomeCode.CONFIRMED_SUCCESS,
AttemptState.PARTIAL: OutcomeCode.CONFIRMED_PARTIAL,
AttemptState.SKIPPED: OutcomeCode.ORCHESTRATION_SKIPPED,
AttemptState.CANCELLED: OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT,
AttemptState.TIMED_OUT: OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED,
AttemptState.INDETERMINATE: OutcomeCode.UNKNOWN_AFTER_RECOVERY,
}.get(target)
if target is AttemptState.FAILED:
outcome = (
OutcomeCode.CONFIRMED_FAILURE if started else OutcomeCode.CONFIRMED_FAILURE_NO_DISPATCH
)
proof = {
AttemptState.SUCCEEDED: "worker_terminal_ack",
AttemptState.PARTIAL: "worker_terminal_ack",
AttemptState.FAILED: "worker_terminal_ack" if started else "no_dispatch",
AttemptState.SKIPPED: "no_dispatch",
AttemptState.CANCELLED: "cancellation_no_result_ack",
AttemptState.TIMED_OUT: "timeout_termination_ack",
AttemptState.INDETERMINATE: "bounded_recovery_exhausted",
}.get(target)
if target is AttemptState.INDETERMINATE:
values.update(
resolver_subject_ref=_uuid(200),
resolver_user_id=_uuid(200),
resolver_authority_revision=0,
)
transition = TransitionRequest(
_uuid(210),
revision,
target,
_uuid(operation_number),
outcome_code=outcome,
authoritative_proof=proof,
campaign_id=_uuid(201),
actor_subject_ref=(
None if "owner_ref" in values or "resolver_subject_ref" in values else _uuid(200)
),
actor_user_id=(
None if "owner_ref" in values or "resolver_subject_ref" in values else _uuid(200)
),
actor_authority_revision=(
None if "owner_ref" in values or "resolver_subject_ref" in values else 0
),
**values,
)
assert not (
transition.resolver_subject_ref is not None and transition.actor_subject_ref is not None
), "transition principal bindings overlapped"
budget_rows = await (
await connection.execute(
"SELECT budget_kind,id,revision FROM campaign_execution_budgets "
"WHERE campaign_id=? ORDER BY CASE budget_kind WHEN 'noise' THEN 1 "
"WHEN 'exfiltration' THEN 2 ELSE 3 END",
(_uuid(201),),
)
).fetchall()
budget_by_kind = {str(item[0]): (str(item[1]), int(item[2])) for item in budget_rows}
full = target is AttemptState.INDETERMINATE
if not budget_by_kind:
budget_by_kind = {
"noise": (_uuid(204), 0),
"exfiltration": (_uuid(205), 0),
"concurrency": (_uuid(206), 0),
}
settlement = BudgetSettlement(
_uuid(201),
_uuid(210),
budget_by_kind["noise"][0],
2,
2 if full else 0,
budget_by_kind["noise"][1],
budget_by_kind["exfiltration"][0],
3,
3 if full else 0,
budget_by_kind["exfiltration"][1],
budget_by_kind["concurrency"][0],
budget_by_kind["concurrency"][1],
_uuid(operation_number + 1),
)
outputs = (
(OutputObservation(_uuid(operation_number + 4), OutputKind.HOST, _uuid(260)),)
if target is AttemptState.PARTIAL
else ()
)
return await store.commit_terminal_attempt(
TerminalCommitRequest(
_uuid(208),
_uuid(201),
_uuid(operation_number + 2),
_uuid(operation_number + 3),
transition,
settlement,
outputs,
)
)
async def _build_source_state(
store: ExecutionLifecycleStore,
connection: aiosqlite.Connection,
source: AttemptState,
) -> None:
if source is AttemptState.ACCEPTED:
return
if source is AttemptState.QUEUED:
result = await _nonterminal_transition(store, connection, source, 230)
elif source is AttemptState.DISPATCHING:
result = await _nonterminal_transition(store, connection, source, 231)
else:
result = await _nonterminal_transition(store, connection, AttemptState.DISPATCHING, 231)
assert result.result is FixedResult.APPLIED, "source dispatch failed"
if source is AttemptState.CANCELLING and False:
return
result = await _nonterminal_transition(store, connection, AttemptState.RUNNING, 232)
if source in {AttemptState.RUNNING}:
pass
elif source is AttemptState.CANCELLING:
assert result.result is FixedResult.APPLIED, "source start failed"
result = await _nonterminal_transition(store, connection, source, 233)
elif source is AttemptState.SETTLEMENT_PENDING:
assert result.result is FixedResult.APPLIED, "source start failed"
result = await _nonterminal_transition(store, connection, source, 234)
elif source in {
AttemptState.SUCCEEDED,
AttemptState.PARTIAL,
AttemptState.TIMED_OUT,
AttemptState.INDETERMINATE,
}:
assert result.result is FixedResult.APPLIED, "source start failed"
if source is AttemptState.INDETERMINATE:
pending = await _nonterminal_transition(
store, connection, AttemptState.SETTLEMENT_PENDING, 234
)
assert pending.result is FixedResult.APPLIED, "source recovery failed"
store = _AdvancedClockLifecycleStore(connection, "sqlite")
result = await _terminal_transition(store, connection, source, 270)
elif source in {AttemptState.FAILED, AttemptState.SKIPPED}:
raise AssertionError("terminal source must use no-dispatch builder")
elif source is AttemptState.CANCELLED:
assert result.result is FixedResult.APPLIED, "source start failed"
cancelling = await _nonterminal_transition(
store, connection, AttemptState.CANCELLING, 233
)
assert cancelling.result is FixedResult.APPLIED, "source cancel failed"
result = await _terminal_transition(store, connection, source, 270)
else:
raise AssertionError("unsupported source state")
assert result.result is FixedResult.APPLIED, "source transition failed"
async def _snapshot_case(
connection: aiosqlite.Connection,
) -> tuple[tuple[str, tuple[tuple[object, ...], ...]], ...]:
tables = (
"logical_executions",
"execution_attempts",
"campaign_execution_budgets",
"campaign_execution_budget_ledger",
"execution_output_links",
"execution_publication_outbox",
"execution_operation_receipts",
"hosts",
)
observed = []
for table in tables:
rows = await (
await connection.execute(
f"SELECT * FROM {table} ORDER BY 1" # noqa: S608 - fixed tuple.
)
).fetchall()
observed.append((table, tuple(tuple(row) for row in rows)))
return tuple(observed)
async def _exercise_transition_pair(path, source: str, target: str):
source_state = AttemptState(source)
target_state = AttemptState(target)
initial = (
source_state
if source_state in {AttemptState.REJECTED, AttemptState.BLOCKED}
else AttemptState.ACCEPTED
)
connection, store = await _new_transition_case(path.as_posix(), initial)
observer = await aiosqlite.connect(path.as_posix())
try:
if initial is AttemptState.ACCEPTED:
if source_state in {AttemptState.FAILED, AttemptState.SKIPPED}:
result = await _terminal_transition(store, connection, source_state, 270)
assert result.result is FixedResult.APPLIED, "terminal source setup failed"
else:
await _build_source_state(store, connection, source_state)
before = await _snapshot_case(connection)
if target_state in {
AttemptState.QUEUED,
AttemptState.DISPATCHING,
AttemptState.RUNNING,
AttemptState.CANCELLING,
AttemptState.SETTLEMENT_PENDING,
}:
result = await _nonterminal_transition(store, connection, target_state, 400)
elif target_state in {
AttemptState.SUCCEEDED,
AttemptState.PARTIAL,
AttemptState.FAILED,
AttemptState.SKIPPED,
AttemptState.CANCELLED,
AttemptState.TIMED_OUT,
AttemptState.INDETERMINATE,
}:
if (
target_state is AttemptState.INDETERMINATE
and source_state is AttemptState.SETTLEMENT_PENDING
):
store = _AdvancedClockLifecycleStore(connection, "sqlite")
result = await _terminal_transition(store, connection, target_state, 400)
else:
row = await _attempt_row(connection)
result = await store.transition_attempt(
TransitionRequest(
_uuid(210),
int(row[1]),
target_state,
_uuid(400),
campaign_id=_uuid(201),
actor_subject_ref=_uuid(200),
actor_user_id=_uuid(200),
actor_authority_revision=0,
)
)
after = await _snapshot_case(connection)
observer.row_factory = aiosqlite.Row
durable = await _snapshot_case(observer)
return result.result, before, after, durable
finally:
await observer.close()
await connection.close()
async def _insert_retryable_attempt(connection: aiosqlite.Connection) -> None:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(1), "closure-admin", "fixed-hash", "admin", "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)",
(_uuid(2), "closure-campaign"),
)
await connection.execute(
"INSERT INTO execution_actor_authority_revisions("
"user_id,revision,latest_operation_id,latest_operation_base_revision,"
"latest_operation_code,updated_at) VALUES(?,0,?,0,'ensure',1)",
(_uuid(1), _uuid(3)),
)
await connection.execute(
"INSERT INTO campaign_execution_authority_revisions("
"campaign_id,revision,latest_operation_id,latest_operation_base_revision,"
"latest_operation_code,updated_at) VALUES(?,0,?,0,'ensure',1)",
(_uuid(2), _uuid(30)),
)
await connection.execute(
"INSERT INTO logical_executions("
"id,submission_id,campaign_id,actor_subject_ref,actor_user_id,module_id,"
"ingress_code,admission_operation_id,submission_binding_contract_version,"
"submission_request_binding_digest,submission_result_code,"
"submission_exact_replay_code,submission_result_binding_digest,"
"highest_attempt_ordinal,revision,created_at) "
"VALUES(?,?,?,?,?,'test.module','sdk',?,2,?,'applied','replayed',?,0,0,1)",
(
_uuid(4),
_uuid(5),
_uuid(2),
_uuid(1),
_uuid(1),
_uuid(31),
"a" * 64,
"b" * 64,
),
)
columns = (
"id",
"logical_execution_id",
"campaign_id",
"ordinal",
"revision",
"state",
"closes_logical",
"actor_subject_ref",
"actor_user_id",
"actor_authority_revision",
"campaign_authority_revision",
"destination_authority_revision",
"credential_authority_revision",
"request_contract_version",
"evaluation_mode",
"request_structure_valid",
"canonicalization_complete",
"unknown_fields_absent",
"alternate_transport_absent",
"bounded_shape_valid",
"request_shape_units",
"descriptor_contract_version",
"descriptor_semantic_digest",
"catalog_digest",
"trusted_first_party_binding",
"descriptor_binding_current",
"descriptor_complete",
"static_policy_evaluable",
"minimum_role",
"noise_class",
"approval_policy",
"capability_mask_version",
"required_capability_mask",
"descriptor_blocker_mask_version",
"descriptor_blocker_mask",
"preview_ready",
"lifecycle_ready",
"result_authority_ready",
"transport_ready",
"future_gateway_eligible",
"authority_snapshots_complete",
"authority_revisions_current",
"actor_authenticated",
"actor_active",
"actor_role",
"campaign_active",
"actor_campaign_authorized",
"approval_present",
"approval_current",
"approval_exactly_bound",
"granted_capability_mask",
"destination_extraction_complete",
"destinations_in_scope",
"credential_authority_resolved",
"credential_authority_current",
"opaque_handles_only",
"permitted_handle_kinds_only",
"raw_credentials_absent",
"ambient_credentials_absent",
"budget_authority_resolved",
"budget_authority_current",
"budget_capacity_available",
"gateway_mode_snapshot",
"gateway_decision_code",
"policy_evaluation_state",
"policy_contract_version",
"policy_verdict",
"policy_reason_mask_version",
"policy_reason_mask",
"external_effect_class",
"idempotency_class",
"retry_policy",
"retry_disposition",
"cancellation_ownership",
"compensation_class",
"timeout_origin",
"timeout_limit_ms",
"timeout_settlement",
"outcome_code",
"error_action_code",
"settlement_state",
"settlement_proof_code",
"termination_confirmed",
"lease_generation",
"terminal_operation_id",
"created_at",
"finished_at",
"settled_at",
)
values = (
_uuid(6),
_uuid(4),
_uuid(2),
0,
0,
"failed",
0,
_uuid(1),
_uuid(1),
0,
0,
0,
0,
1,
"live",
1,
1,
1,
1,
1,
1,
"ares.module-descriptor.v2",
"a" * 64,
"b" * 64,
1,
1,
1,
1,
"operator",
"low",
"none",
1,
0,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
"admin",
1,
1,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
"enforced",
"none",
"evaluated",
1,
"live_candidate",
1,
0,
"read_only",
"proven_idempotent",
"after_revalidation",
"eligible",
"owned",
"not_applicable",
"module_defined_bounded",
1_000,
"proven",
"confirmed_failure_no_dispatch",
"none",
"not_applicable",
"no_dispatch",
0,
0,
_uuid(7),
1,
1,
1,
)
await connection.execute(
"INSERT INTO execution_attempts("
+ ",".join(columns)
+ ") VALUES("
+ ",".join("?" for _ in columns)
+ ")",
values,
)
await connection.commit()
@pytest.mark.asyncio
async def test_authority_ensure_and_invalidate_are_exactly_replayable() -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_UUIDS[0], "fixed-user", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
created = await store.ensure_actor_authority(_UUIDS[0], _UUIDS[1])
replay = await store.ensure_actor_authority(_UUIDS[0], _UUIDS[1])
invalidated = await store.invalidate_actor_authority(_UUIDS[0], 0, _UUIDS[2])
stale = await store.invalidate_actor_authority(_UUIDS[0], 0, _UUIDS[3])
finally:
await connection.close()
assert (created.result, replay.result, invalidated.result, stale.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
FixedResult.APPLIED,
FixedResult.CONFLICT_REVISION,
), "authority CAS result changed"
@pytest.mark.asyncio
@pytest.mark.parametrize(
("snapshot", "reason"),
[
(_blocked_snapshot(), PolicyReasonBit.INSUFFICIENT_ROLE.value),
(
replace(
_blocked_snapshot(),
actor_role="operator",
required_capability_mask=3,
granted_capability_mask=1,
policy_reason_mask=PolicyReasonBit.CAPABILITY_REQUIRED.value,
),
PolicyReasonBit.CAPABILITY_REQUIRED.value,
),
(
replace(
_blocked_snapshot(),
actor_role="operator",
policy_verdict="preview_ready",
policy_reason_mask=PolicyReasonBit.PREVIEW_NOT_READY.value,
),
PolicyReasonBit.PREVIEW_NOT_READY.value,
),
],
ids=("reporter-role", "capability", "preview-live"),
)
async def test_durable_block_creates_zero_budget_terminal_snapshot(
snapshot: AttemptPolicySnapshot, reason: int
) -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(40), "blocked-user", "fixed-hash", snapshot.actor_role, "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)",
(_uuid(41), "blocked-campaign"),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
await store.ensure_actor_authority(_uuid(40), _uuid(42))
await store.ensure_campaign_authority(_uuid(41), _uuid(43))
request = AdmissionRequest(
_uuid(44),
_uuid(45),
_uuid(46),
_uuid(47),
_uuid(48),
_uuid(41),
_uuid(40),
_uuid(40),
"test.module",
"sdk",
AttemptState.BLOCKED,
_uuid(49),
snapshot,
)
created = await store._create_initial_execution_v2_for_migration_fixture(request)
replayed = await store._create_initial_execution_v2_for_migration_fixture(request)
attempt = await (
await connection.execute(
"SELECT state,policy_reason_mask,closes_logical,outcome_code "
"FROM execution_attempts"
)
).fetchone()
observed_counts = []
for table in (
"execution_attempt_approvals",
"campaign_execution_budget_ledger",
"campaign_execution_budgets",
):
cursor = await connection.execute(
"SELECT count(*) FROM " + table # noqa: S608
)
row = await cursor.fetchone()
observed_counts.append(int(row[0]))
counts = tuple(observed_counts)
finally:
await connection.close()
assert (created.result, replayed.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
), "durable block replay changed"
assert tuple(attempt) == ("blocked", reason, 1, "policy_blocked"), "blocked snapshot changed"
assert counts == (0, 0, 0), "blocked decision reserved budget"
@pytest.mark.asyncio
async def test_accepted_creation_reserves_all_budgets_in_one_transaction() -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(60), "accept-admin", "fixed-hash", "admin", "fixed"),
)
await connection.execute(
"INSERT INTO campaigns(id,name) VALUES(?,?)", (_uuid(61), "accept")
)
await connection.execute(
"UPDATE execution_gateway_state SET mode='enforced',catalog_digest=?,"
"activation_revision=1,activation_at=1,revision=1 WHERE singleton_id=1",
("c" * 64,),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
await store.ensure_actor_authority(_uuid(60), _uuid(62))
await store.ensure_campaign_authority(_uuid(61), _uuid(63))
await store.configure_campaign_budgets(
BudgetConfiguration(
_uuid(61),
_uuid(64),
10,
_uuid(65),
10,
_uuid(66),
1,
_uuid(67),
)
)
snapshot = replace(
_blocked_snapshot(),
actor_role="admin",
required_capability_mask=1,
granted_capability_mask=1,
preview_ready=True,
lifecycle_ready=True,
result_authority_ready=True,
transport_ready=True,
future_gateway_eligible=True,
budget_capacity_available=True,
gateway_mode_snapshot="enforced",
policy_verdict="live_candidate",
policy_reason_mask=0,
)
budgets = BudgetReservation(
_uuid(61),
_uuid(70),
_uuid(64),
_uuid(71),
2,
0,
_uuid(65),
_uuid(72),
3,
0,
_uuid(66),
_uuid(73),
0,
_uuid(74),
)
request = AdmissionRequest(
_uuid(68),
_uuid(69),
_uuid(70),
None,
None,
_uuid(61),
_uuid(60),
_uuid(60),
"test.module",
"sdk",
AttemptState.ACCEPTED,
_uuid(75),
snapshot,
budgets=budgets,
)
created = await store._create_initial_execution_v2_for_migration_fixture(request)
attempt = await (
await connection.execute(
"SELECT state,settlement_state,closes_logical FROM execution_attempts"
)
).fetchone()
ledgers = await (
await connection.execute(
"SELECT budget_kind,reservation_units,disposition "
"FROM campaign_execution_budget_ledger ORDER BY budget_kind"
)
).fetchall()
outbox_count = await (
await connection.execute("SELECT count(*) FROM execution_publication_outbox")
).fetchone()
dispatched = await store.transition_attempt(
TransitionRequest(
_uuid(70),
0,
AttemptState.DISPATCHING,
_uuid(76),
owner_ref=_uuid(77),
lease_generation=1,
lease_duration_ms=1_000,
campaign_id=_uuid(61),
)
)
running = await store.transition_attempt(
TransitionRequest(
_uuid(70),
1,
AttemptState.RUNNING,
_uuid(78),
owner_ref=_uuid(77),
lease_generation=1,
campaign_id=_uuid(61),
)
)
terminal_request = TerminalCommitRequest(
_uuid(68),
_uuid(61),
_uuid(79),
_uuid(80),
TransitionRequest(
_uuid(70),
2,
AttemptState.SUCCEEDED,
_uuid(81),
owner_ref=_uuid(77),
lease_generation=1,
outcome_code=OutcomeCode.CONFIRMED_SUCCESS,
authoritative_proof="worker_terminal_ack",
campaign_id=_uuid(61),
),
BudgetSettlement(
_uuid(61),
_uuid(70),
_uuid(64),
2,
1,
1,
_uuid(65),
3,
2,
1,
_uuid(66),
1,
_uuid(82),
),
)
terminal = await store.commit_terminal_attempt(terminal_request)
terminal_replay = await store.commit_terminal_attempt(terminal_request)
finished = await (
await connection.execute(
"SELECT state,closes_logical,settlement_state,outcome_code FROM execution_attempts"
)
).fetchone()
finally:
await connection.close()
assert created.result is FixedResult.APPLIED, "acceptance failed"
assert tuple(attempt) == ("accepted", "reserved", 0), "attempt changed"
assert tuple(tuple(row) for row in ledgers) == (
("concurrency", 1, "held"),
("exfiltration", 3, "held"),
("noise", 2, "held"),
), "acceptance reservations changed"
assert int(outbox_count[0]) == 0, "acceptance published an event"
assert (dispatched.result, running.result, terminal.result, terminal_replay.result) == (
FixedResult.APPLIED,
FixedResult.APPLIED,
FixedResult.APPLIED,
FixedResult.REPLAYED,
), "terminal transaction changed"
assert tuple(finished) == ("succeeded", 1, "settled", "confirmed_success"), (
"terminal state changed"
)
@pytest.mark.asyncio
async def test_outbox_claim_renew_retry_reclaim_and_poison_are_cas_bound() -> None:
connection = await _new_connection()
try:
await connection.execute("PRAGMA foreign_keys=OFF")
await connection.execute(
"INSERT INTO execution_publication_outbox("
"id,publication_key,attempt_id,campaign_id,event_code,is_attempt_terminal,"
"publication_state,delivery_attempt_count,available_at,lease_generation,"
"claim_revision,latest_operation_id,latest_operation_code,"
"latest_operation_base_revision,created_at) "
"VALUES(?,?,?,?,?,0,'pending',0,1,0,0,?,'insert',0,1)",
(_UUIDS[0], _UUIDS[1], _UUIDS[2], _UUIDS[3], "recovery_required", _UUIDS[1]),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
claimed = await store.claim_outbox(
OutboxMutation(
_UUIDS[0],
0,
_UUIDS[4],
_UUIDS[5],
0,
_UUIDS[3],
_UUIDS[2],
_UUIDS[1],
"recovery_required",
)
)
renewed = await store.renew_outbox(
OutboxMutation(
_UUIDS[0],
1,
_UUIDS[6],
_UUIDS[5],
1,
_UUIDS[3],
_UUIDS[2],
_UUIDS[1],
"recovery_required",
)
)
retried = await store.fail_outbox(
OutboxMutation(
_UUIDS[0],
2,
_UUIDS[7],
_UUIDS[5],
1,
_UUIDS[3],
_UUIDS[2],
_UUIDS[1],
"recovery_required",
),
retryable=True,
)
row = await (
await connection.execute(
"SELECT publication_state,delivery_attempt_count,claim_revision,"
"latest_operation_code FROM execution_publication_outbox"
)
).fetchone()
finally:
await connection.close()
assert (claimed.result, renewed.result, retried.result) == (
FixedResult.APPLIED,
FixedResult.APPLIED,
FixedResult.APPLIED,
), "outbox CAS result changed"
assert tuple(row) == ("pending", 1, 3, "retryable_failure"), "outbox state changed"
@pytest.mark.asyncio
async def test_expired_twentieth_claim_is_poisoned_without_owner_cooperation() -> None:
connection = await _new_connection()
try:
await connection.execute("PRAGMA foreign_keys=OFF")
await connection.execute(
"INSERT INTO execution_publication_outbox("
"id,publication_key,attempt_id,campaign_id,event_code,is_attempt_terminal,"
"publication_state,delivery_attempt_count,available_at,claim_owner_ref,"
"lease_generation,claimed_at,lease_expires_at,failure_code,claim_revision,"
"latest_operation_id,latest_operation_code,latest_operation_base_revision,"
"created_at) VALUES(?,?,?,?,?,0,'claimed',20,NULL,?,20,1,1,NULL,20,?,"
"'reclaim',19,1)",
(
_uuid(100),
_uuid(101),
_uuid(102),
_uuid(103),
"recovery_required",
_uuid(104),
_uuid(105),
),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
request = OutboxMutation(
_uuid(100),
20,
_uuid(106),
campaign_id=_uuid(103),
attempt_id=_uuid(102),
publication_key=_uuid(101),
event_code="recovery_required",
)
applied = await store.poison_expired_attempt_twenty(request)
replayed = await store.poison_expired_attempt_twenty(request)
row = await (
await connection.execute(
"SELECT publication_state,claim_owner_ref,lease_generation,"
"delivery_attempt_count,failure_code,claim_revision,latest_operation_id,"
"latest_operation_code,latest_operation_base_revision "
"FROM execution_publication_outbox"
)
).fetchone()
finally:
await connection.close()
assert (applied.result, replayed.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
), "attempt-limit poison replay changed"
assert tuple(row) == (
"poisoned",
None,
20,
20,
"delivery_attempt_limit",
21,
_uuid(106),
"poison",
20,
), "attempt-limit poison state changed"
@pytest.mark.asyncio
async def test_budget_reserve_and_settle_use_post_cas_revisions() -> None:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
configured = await store.configure_campaign_budgets(
BudgetConfiguration(
_uuid(2),
_uuid(110),
10,
_uuid(111),
10,
_uuid(112),
2,
_uuid(113),
)
)
reserved = await store.reserve_budgets(
BudgetReservation(
_uuid(2),
_uuid(6),
_uuid(110),
_uuid(114),
4,
0,
_uuid(111),
_uuid(115),
5,
0,
_uuid(112),
_uuid(116),
0,
_uuid(117),
)
)
settled = await store.settle_budgets(
BudgetSettlement(
_uuid(2),
_uuid(6),
_uuid(110),
4,
3,
1,
_uuid(111),
5,
0,
1,
_uuid(112),
1,
_uuid(118),
)
)
budget_rows = await (
await connection.execute(
"SELECT budget_kind,reserved_units,consumed_units,revision "
"FROM campaign_execution_budgets ORDER BY CASE budget_kind "
"WHEN 'noise' THEN 1 WHEN 'exfiltration' THEN 2 ELSE 3 END"
)
).fetchall()
ledger_rows = await (
await connection.execute(
"SELECT budget_kind,disposition,consumed_units,"
"budget_revision_reserved,budget_revision_settled "
"FROM campaign_execution_budget_ledger ORDER BY CASE budget_kind "
"WHEN 'noise' THEN 1 WHEN 'exfiltration' THEN 2 ELSE 3 END"
)
).fetchall()
finally:
await connection.close()
assert (configured.result, reserved.result, settled.result) == (
FixedResult.APPLIED,
FixedResult.APPLIED,
FixedResult.APPLIED,
), "budget CAS result changed"
assert tuple(tuple(row) for row in budget_rows) == (
("noise", 0, 3, 2),
("exfiltration", 0, 0, 2),
("concurrency", 0, 0, 2),
), "budget arithmetic changed"
assert tuple(tuple(row) for row in ledger_rows) == (
("noise", "consumed", 3, 1, 2),
("exfiltration", "released", 0, 1, 2),
("concurrency", "released", 0, 1, 2),
), "ledger post-CAS revisions changed"
@pytest.mark.asyncio
async def test_budget_reservation_conflict_rolls_back_all_three_kinds() -> None:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
await store.configure_campaign_budgets(
BudgetConfiguration(
_uuid(2),
_uuid(21),
10,
_uuid(22),
10,
_uuid(23),
1,
_uuid(24),
)
)
result = await store.reserve_budgets(
BudgetReservation(
_uuid(2),
_uuid(6),
_uuid(21),
_uuid(26),
4,
0,
_uuid(22),
_uuid(27),
4,
1,
_uuid(23),
_uuid(28),
0,
_uuid(29),
)
)
rows = await (
await connection.execute(
"SELECT reserved_units,revision FROM campaign_execution_budgets "
"ORDER BY budget_kind"
)
).fetchall()
ledgers = await (
await connection.execute("SELECT count(*) FROM campaign_execution_budget_ledger")
).fetchone()
finally:
await connection.close()
assert result.result is FixedResult.CONFLICT_REVISION, "conflict changed"
assert tuple(tuple(row) for row in rows) == ((0, 0), (0, 0), (0, 0)), (
"reservation conflict committed a partial mutation"
)
assert int(ledgers[0]) == 0, "reservation conflict created a ledger"
@pytest.mark.asyncio
async def test_close_without_retry_is_permanent_after_outbox_purge() -> None:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
request = ClosureRequest(
_uuid(4),
_uuid(6),
_uuid(8),
0,
_uuid(9),
_uuid(1),
_uuid(1),
0,
_uuid(2),
)
applied = await store.close_without_retry(request)
await connection.execute("DELETE FROM execution_publication_outbox WHERE id=?", (_uuid(8),))
await connection.commit()
replayed = await store.close_without_retry(request)
conflicting = await store.close_without_retry(
ClosureRequest(
_uuid(4),
_uuid(6),
_uuid(10),
1,
_uuid(11),
_uuid(1),
_uuid(1),
0,
_uuid(2),
)
)
logical = await (
await connection.execute(
"SELECT closure_operation_id,closing_attempt_id FROM logical_executions"
)
).fetchone()
finally:
await connection.close()
assert (applied.result, replayed.result, conflicting.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED_CLOSED,
FixedResult.ALREADY_CLOSED,
), "closure replay changed"
assert tuple(logical) == (_uuid(9), _uuid(6)), "permanent closure changed"
@pytest.mark.asyncio
async def test_retry_denial_child_uuid_replays_and_excludes_closure() -> None:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
child = AdmissionRequest(
_uuid(4),
_uuid(80),
_uuid(81),
_uuid(82),
_uuid(83),
_uuid(2),
_uuid(1),
_uuid(1),
"test.module",
"sdk",
AttemptState.BLOCKED,
_uuid(84),
replace(
_blocked_snapshot(),
actor_role="admin",
required_capability_mask=1,
granted_capability_mask=0,
policy_reason_mask=PolicyReasonBit.CAPABILITY_REQUIRED.value,
),
)
retry = RetryRequest(_uuid(4), _uuid(6), child, 0)
applied = await store._create_retry_attempt_v2_for_migration_fixture(retry)
replayed = await store._create_retry_attempt_v2_for_migration_fixture(retry)
closure_loser = await store.close_without_retry(
ClosureRequest(
_uuid(4),
_uuid(6),
_uuid(85),
1,
_uuid(86),
_uuid(1),
_uuid(1),
0,
_uuid(2),
)
)
attempts = await (
await connection.execute(
"SELECT id,parent_attempt_id,ordinal,state FROM execution_attempts ORDER BY ordinal"
)
).fetchall()
finally:
await connection.close()
assert (applied.result, replayed.result, closure_loser.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED_BOUND_CHILD,
FixedResult.ALREADY_CLOSED,
), "retry/closure race changed"
assert tuple(tuple(row) for row in attempts) == (
(_uuid(6), None, 0, "failed"),
(_uuid(81), _uuid(6), 1, "blocked"),
), "linear retry chain changed"
@pytest.mark.asyncio
async def test_closure_winner_excludes_retry_child() -> None:
connection = await _new_connection()
try:
await _insert_retryable_attempt(connection)
store = ExecutionLifecycleStore(connection, "sqlite")
closed = await store.close_without_retry(
ClosureRequest(
_uuid(4),
_uuid(6),
_uuid(87),
0,
_uuid(88),
_uuid(1),
_uuid(1),
0,
_uuid(2),
)
)
child = AdmissionRequest(
_uuid(4),
_uuid(89),
_uuid(90),
_uuid(91),
_uuid(92),
_uuid(2),
_uuid(1),
_uuid(1),
"test.module",
"sdk",
AttemptState.BLOCKED,
_uuid(93),
_blocked_snapshot(),
)
retry = await store._create_retry_attempt_v2_for_migration_fixture(
RetryRequest(_uuid(4), _uuid(6), child, 1)
)
attempt_count = await (
await connection.execute("SELECT count(*) FROM execution_attempts")
).fetchone()
finally:
await connection.close()
assert (closed.result, retry.result) == (
FixedResult.APPLIED,
FixedResult.ALREADY_CLOSED,
), "closure/retry race changed"
assert int(attempt_count[0]) == 1, "closure loser created a child"
def test_only_exact_receipt_immutability_triggers_are_created() -> None:
connection = sqlite3.connect(":memory:")
try:
connection.executescript(CREATE_TABLES)
rows = connection.execute(
"SELECT name,tbl_name FROM sqlite_schema WHERE type='trigger' "
"AND tbl_name IN (?,?,?,?,?,?,?,?,?,?,?)",
LIFECYCLE_TABLES,
).fetchall()
finally:
connection.close()
assert tuple(sorted(rows)) == (
("trg_eor_immutable_delete", "execution_operation_receipts"),
("trg_eor_immutable_update", "execution_operation_receipts"),
), "lifecycle trigger inventory changed"
def test_exact_sqlite_catalog_validator_rejects_extra_lifecycle_index() -> None:
connection = sqlite3.connect(":memory:")
try:
connection.executescript(CREATE_TABLES)
connection.execute("CREATE INDEX unexpected_lifecycle_index ON execution_attempts(state)")
rejected = False
try:
validate_sqlite_lifecycle_catalog(connection)
except RuntimeError:
rejected = True
finally:
connection.close()
assert rejected is True, "unexpected lifecycle index passed validation"
def test_i53_boundary_is_exact() -> None:
assert MAX_I53 == 9_007_199_254_740_991, "I53 boundary changed"
class _SQLiteZeroRowTraceStore(ExecutionLifecycleStore):
"""Record the real connection and transaction used after a zero-row write."""
def __init__(self, connection: aiosqlite.Connection) -> None:
super().__init__(connection, "sqlite")
self.zero_connection_id: int | None = None
self.zero_in_transaction = False
self.classifier_connection_ids: list[int] = []
self.classifier_in_transaction: list[bool] = []
self._awaiting_classifier = False
async def _returning_rows(
self, connection: Any, sql: str, params: tuple[Any, ...]
) -> tuple[Any, ...]:
rows = await super()._returning_rows(connection, sql, params)
if not rows and "UPDATE execution_attempts SET" in sql:
self.zero_connection_id = id(connection)
self.zero_in_transaction = bool(connection.in_transaction)
self._awaiting_classifier = True
return rows
async def _fetchrow(self, connection: Any, sql: str, params: tuple[Any, ...]) -> Any:
if self._awaiting_classifier:
self.classifier_connection_ids.append(id(connection))
self.classifier_in_transaction.append(bool(connection.in_transaction))
return await super()._fetchrow(connection, sql, params)
class _SQLiteWinnerBarrierStore(ExecutionLifecycleStore):
def __init__(
self,
connection: aiosqlite.Connection,
winner_entered: asyncio.Event,
contender_attempted: asyncio.Event,
) -> None:
super().__init__(connection, "sqlite")
self._winner_entered = winner_entered
self._contender_attempted = contender_attempted
@asynccontextmanager
async def _transaction(self) -> AsyncIterator[Any]:
async with super()._transaction() as connection:
self._winner_entered.set()
await self._contender_attempted.wait()
yield connection
class _SQLiteContenderBarrierStore(ExecutionLifecycleStore):
def __init__(
self,
connection: aiosqlite.Connection,
contender_attempted: asyncio.Event,
) -> None:
super().__init__(connection, "sqlite")
self._contender_attempted = contender_attempted
@asynccontextmanager
async def _transaction(self) -> AsyncIterator[Any]:
self._contender_attempted.set()
async with super()._transaction() as connection:
yield connection
class _SQLiteCancellationGateStore(ExecutionLifecycleStore):
def __init__(
self,
connection: aiosqlite.Connection,
receipt_entered: asyncio.Event,
receipt_release: asyncio.Event,
) -> None:
super().__init__(connection, "sqlite")
self.receipt_entered = receipt_entered
self.receipt_release = receipt_release
self.armed = True
async def _insert_receipt(self, *args: Any, **kwargs: Any) -> None:
if self.armed:
self.receipt_entered.set()
await self.receipt_release.wait()
await super()._insert_receipt(*args, **kwargs)
class _SQLiteCleanupFailureStore(ExecutionLifecycleStore):
def __init__(
self,
connection: aiosqlite.Connection,
stage: str,
cleanup_faults: list[str],
) -> None:
super().__init__(connection, "sqlite")
self.stage = stage
self.cleanup_faults = cleanup_faults
self.armed = True
async def _returning_rows(
self, connection: Any, sql: str, params: tuple[Any, ...]
) -> tuple[Any, ...]:
rows = await super()._returning_rows(connection, sql, params)
if self.armed and rows and "UPDATE execution_attempts SET" in sql:
return rows + rows
return rows
async def _execute(self, connection: Any, sql: str, params: tuple[Any, ...]) -> None:
await super()._execute(connection, sql, params)
expected = {
"savepoint-rollback": "ROLLBACK TO SAVEPOINT lifecycle_compound",
"savepoint-release": "RELEASE SAVEPOINT lifecycle_compound",
}.get(self.stage)
if self.armed and expected == sql:
self.cleanup_faults.append(self.stage)
raise RuntimeError("fixed-sqlite-cleanup-failure")
_SQLITE_P1A_ZERO_ROW_TRIGGERS = {
"missing": (
"CREATE TEMP TRIGGER p1a_zero_missing BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"DELETE FROM campaign_execution_budget_ledger "
"WHERE attempt_id='00000000-0000-4000-8000-0000000000d2'; "
"DELETE FROM execution_attempts "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-revision": (
"CREATE TEMP TRIGGER p1a_zero_stale_revision BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_attempts SET revision=revision+1 "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-state": (
"CREATE TEMP TRIGGER p1a_zero_stale_state BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_attempts SET state='queued',"
"queue_operation_id='00000000-0000-4000-8000-0000000003d5',"
"queued_at=accepted_at "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-authority": (
"CREATE TEMP TRIGGER p1a_zero_stale_authority BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_actor_authority_revisions SET revision=revision+1,"
"latest_operation_id='00000000-0000-4000-8000-0000000003d6',"
"latest_operation_base_revision=revision,latest_operation_code='invalidate' "
"WHERE user_id='00000000-0000-4000-8000-0000000000c8'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-owner": (
"CREATE TEMP TRIGGER p1a_zero_stale_owner BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_attempts "
"SET dispatch_owner_ref='00000000-0000-4000-8000-0000000003d7' "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-generation": (
"CREATE TEMP TRIGGER p1a_zero_stale_generation BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_attempts SET lease_generation=lease_generation+1 "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-lease": (
"CREATE TEMP TRIGGER p1a_zero_stale_lease BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_attempts SET lease_expires_at=created_at "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"stale-cancellation": (
"CREATE TEMP TRIGGER p1a_zero_stale_cancellation BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"UPDATE execution_attempts SET cancellation_request_revision="
"cancellation_request_revision+1 "
"WHERE id='00000000-0000-4000-8000-0000000000d2'; "
"SELECT RAISE(IGNORE); END;"
),
"operation-conflict": (
"CREATE TEMP TRIGGER p1a_zero_operation_conflict BEFORE UPDATE OF state "
"ON execution_attempts "
"WHEN OLD.id='00000000-0000-4000-8000-0000000000d2' BEGIN "
"INSERT INTO execution_operation_receipts("
"operation_id,operation_code,campaign_id,primary_target_id,secondary_target_id,"
"principal_kind,principal_subject_ref,principal_user_id,"
"principal_authority_revision_present,principal_authority_revision,"
"binding_contract_version,request_binding_digest,"
"expected_revision_present,expected_revision,"
"secondary_expected_revision_present,secondary_expected_revision,"
"owner_ref,lease_generation,result_code,exact_replay_code,result_binding_digest,"
"result_identity,result_revision_present,result_revision,"
"secondary_result_identity,secondary_result_revision_present,"
"secondary_result_revision) VALUES("
"'00000000-0000-4000-8000-0000000003d4','queue',"
"'00000000-0000-4000-8000-0000000000c9',"
"'00000000-0000-4000-8000-0000000003d8',NULL,"
"'system','004cb934-3a47-4cd0-b0cb-a5b18df76a48',NULL,0,NULL,2,"
"'dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd',"
"1,0,0,NULL,NULL,NULL,'conflict_operation','replayed',"
"'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',"
"'00000000-0000-4000-8000-0000000003d8',1,0,NULL,0,NULL); "
"SELECT RAISE(IGNORE); END;"
),
}
async def _install_zero_row_trigger(connection: aiosqlite.Connection, case: str) -> None:
await connection.execute("PRAGMA recursive_triggers=OFF")
await connection.executescript(_SQLITE_P1A_ZERO_ROW_TRIGGERS[case])
await connection.commit()
async def _p1a_transition_request(
connection: aiosqlite.Connection,
case: str,
) -> tuple[TransitionRequest, bool]:
setup_store = ExecutionLifecycleStore(connection, "sqlite")
if case in {"stale-owner", "stale-generation", "stale-lease", "stale-cancellation"}:
dispatched = await _nonterminal_transition(
setup_store, connection, AttemptState.DISPATCHING, 970
)
assert dispatched.result is FixedResult.APPLIED, "P1-A dispatch setup failed"
if case == "stale-cancellation":
running = await _nonterminal_transition(setup_store, connection, AttemptState.RUNNING, 971)
assert running.result is FixedResult.APPLIED, "P1-A running setup failed"
cancelling = await _nonterminal_transition(
setup_store, connection, AttemptState.CANCELLING, 972
)
assert cancelling.result is FixedResult.APPLIED, "P1-A cancellation setup failed"
row = await _attempt_row(connection)
return (
TransitionRequest(
_uuid(210),
int(row[1]),
AttemptState.SETTLEMENT_PENDING,
_uuid(980),
owner_ref=_uuid(220),
lease_generation=int(row[3]),
cancellation_request_revision=int(row[4]),
outbox_id=_uuid(985),
publication_key=_uuid(986),
campaign_id=_uuid(201),
),
True,
)
row = await _attempt_row(connection)
values: dict[str, object] = {}
target = AttemptState.QUEUED
if case in {"stale-owner", "stale-generation", "stale-lease"}:
target = AttemptState.RUNNING
values = {"owner_ref": _uuid(220), "lease_generation": int(row[3])}
else:
values = {
"actor_subject_ref": _uuid(200),
"actor_user_id": _uuid(200),
"actor_authority_revision": 0,
}
return (
TransitionRequest(
_uuid(210),
int(row[1]),
target,
_uuid(980),
campaign_id=_uuid(201),
**values,
),
False,
)
@pytest.mark.asyncio
async def test_sqlite_truth_write_exactly_one_row_is_applied() -> None:
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(960), "p1a-exact-one", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
ensured = await store.ensure_actor_authority(_uuid(960), _uuid(961))
updated = await store.invalidate_actor_authority(_uuid(960), 0, _uuid(962))
row = await (
await connection.execute(
"SELECT revision,latest_operation_id FROM execution_actor_authority_revisions "
"WHERE user_id=?",
(_uuid(960),),
)
).fetchone()
receipt_count = await (
await connection.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id=?",
(_uuid(962),),
)
).fetchone()
finally:
await connection.close()
assert (ensured.result, updated.result, updated.revision) == (
FixedResult.APPLIED,
FixedResult.APPLIED,
1,
), "exactly-one truth write was not applied"
assert tuple(row) == (1, _uuid(962)), "exactly-one truth write returned the wrong row"
assert int(receipt_count[0]) == 1, "exactly-one truth write lost its receipt"
@pytest.mark.asyncio
async def test_sqlite_returning_row_disagrees_with_changes_is_invariant_failure() -> None:
connection = await _new_connection()
try:
await connection.executescript(
"CREATE TABLE p1a_changes_backing(id TEXT PRIMARY KEY,revision INTEGER NOT NULL);"
"INSERT INTO p1a_changes_backing "
"VALUES('00000000-0000-4000-8000-0000000003c3',0);"
"CREATE VIEW p1a_changes_view AS SELECT id,revision FROM p1a_changes_backing;"
"CREATE TRIGGER p1a_changes_view_update INSTEAD OF UPDATE ON p1a_changes_view "
"BEGIN UPDATE p1a_changes_backing SET revision=NEW.revision WHERE id=OLD.id; END;"
)
await connection.commit()
store = ExecutionLifecycleStore(connection, "sqlite")
with pytest.raises(_AbortOperationError) as raised:
async with store._transaction() as transaction:
await store.cas_update_one(
transaction,
"UPDATE p1a_changes_view SET revision=revision+1 "
"WHERE id=? AND revision=? RETURNING id,revision",
(_uuid(963), 0),
identity=_uuid(963),
post_revision=1,
zero_classifier=None,
)
row = await (
await connection.execute(
"SELECT revision FROM p1a_changes_backing WHERE id=?", (_uuid(963),)
)
).fetchone()
finally:
await connection.close()
assert raised.value.result.result is FixedResult.INVARIANT_FAILURE, (
"RETURNING/changes disagreement was not fixed invariant failure"
)
assert int(row[0]) == 0, "RETURNING/changes invariant failure was not rolled back"
@pytest.mark.parametrize(
("case", "expected_result", "expected_revision"),
[
("missing", FixedResult.NOT_FOUND_OR_PURGED, None),
("stale-revision", FixedResult.CONFLICT_REVISION, 1),
("stale-state", FixedResult.CONFLICT_STATE, 0),
("stale-authority", FixedResult.AUTHORITY_STALE, 0),
("stale-owner", FixedResult.CONFLICT_OWNER, 1),
("stale-generation", FixedResult.CONFLICT_GENERATION, 1),
("stale-lease", FixedResult.CONFLICT_STATE, 1),
("stale-cancellation", FixedResult.CONFLICT_REVISION, 3),
("operation-conflict", FixedResult.CONFLICT_OPERATION, 0),
],
ids=(
"missing",
"stale-revision",
"stale-state",
"stale-authority",
"stale-owner",
"stale-generation",
"stale-lease",
"stale-cancellation",
"operation-conflict",
),
)
@pytest.mark.asyncio
async def test_sqlite_zero_row_truth_write_is_reclassified_in_same_transaction(
tmp_path,
case: str,
expected_result: FixedResult,
expected_revision: int | None,
) -> None:
connection, _setup_store = await _new_transition_case(
(tmp_path / f"p1a-zero-{case}.db").as_posix(), AttemptState.ACCEPTED
)
try:
request, settlement = await _p1a_transition_request(connection, case)
await _install_zero_row_trigger(connection, case)
store = _SQLiteZeroRowTraceStore(connection)
result = (
await store.enter_settlement_pending(request)
if settlement
else await store.transition_attempt(request)
)
assert store.zero_connection_id == id(connection), "zero-row write used another connection"
assert store.zero_in_transaction is True, "zero-row write escaped its transaction"
assert store.classifier_connection_ids, "zero-row write was not reread"
assert set(store.classifier_connection_ids) == {id(connection)}, (
"zero-row classifier changed connection"
)
assert all(store.classifier_in_transaction), (
"zero-row classifier ran after transaction exit"
)
finally:
await connection.close()
assert (result.result, result.revision) == (expected_result, expected_revision), (
"zero-row write received the wrong fixed classification"
)
@pytest.mark.asyncio
async def test_sqlite_concurrent_cas_has_one_winner_and_fixed_loser(tmp_path) -> None:
path = tmp_path / "p1a-concurrent-cas.db"
winner_connection, _setup_store = await _new_transition_case(
path.as_posix(), AttemptState.ACCEPTED
)
contender_connection = await aiosqlite.connect(path.as_posix())
contender_connection.row_factory = aiosqlite.Row
await contender_connection.execute("PRAGMA foreign_keys=ON")
await contender_connection.execute("PRAGMA busy_timeout=5000")
await contender_connection.commit()
winner_entered = asyncio.Event()
contender_attempted = asyncio.Event()
winner_store = _SQLiteWinnerBarrierStore(winner_connection, winner_entered, contender_attempted)
contender_store = _SQLiteContenderBarrierStore(contender_connection, contender_attempted)
winner_task: asyncio.Task[Any] | None = None
contender_task: asyncio.Task[Any] | None = None
observer: aiosqlite.Connection | None = None
try:
winner_task = asyncio.create_task(
winner_store.transition_attempt(
TransitionRequest(
_uuid(210),
0,
AttemptState.QUEUED,
_uuid(987),
campaign_id=_uuid(201),
actor_subject_ref=_uuid(200),
actor_user_id=_uuid(200),
actor_authority_revision=0,
)
)
)
await asyncio.wait_for(winner_entered.wait(), timeout=2)
contender_task = asyncio.create_task(
contender_store.transition_attempt(
TransitionRequest(
_uuid(210),
0,
AttemptState.CANCELLING,
_uuid(988),
campaign_id=_uuid(201),
actor_subject_ref=_uuid(200),
actor_user_id=_uuid(200),
actor_authority_revision=0,
)
)
)
await asyncio.wait_for(contender_attempted.wait(), timeout=2)
winner, contender = await asyncio.wait_for(
asyncio.gather(winner_task, contender_task), timeout=10
)
observer = await aiosqlite.connect(path.as_posix())
row = await (
await observer.execute(
"SELECT state,revision FROM execution_attempts WHERE id=?", (_uuid(210),)
)
).fetchone()
receipt_count = await (
await observer.execute(
"SELECT count(*) FROM execution_operation_receipts WHERE operation_id IN (?,?)",
(_uuid(987), _uuid(988)),
)
).fetchone()
finally:
for task in (winner_task, contender_task):
if task is not None and not task.done():
task.cancel()
pending = tuple(
task for task in (winner_task, contender_task) if task is not None and not task.done()
)
if pending:
await asyncio.gather(*pending, return_exceptions=True)
if observer is not None:
await observer.close()
await contender_connection.close()
await winner_connection.close()
assert (winner.result, contender.result) == (
FixedResult.APPLIED,
FixedResult.CONFLICT_REVISION,
), "concurrent SQLite CAS winner/loser changed"
assert tuple(row) == (AttemptState.QUEUED.value, 1), "concurrent CAS changed more than once"
assert int(receipt_count[0]) == 1, "concurrent CAS wrote a loser receipt"
@pytest.mark.asyncio
async def test_sqlite_cancelled_truth_write_rolls_back_and_connection_reuses(tmp_path) -> None:
path = tmp_path / "p1a-cancelled-write.db"
connection = await _new_connection(path.as_posix())
receipt_entered = asyncio.Event()
receipt_release = asyncio.Event()
store = _SQLiteCancellationGateStore(connection, receipt_entered, receipt_release)
task: asyncio.Task[Any] | None = None
observer: aiosqlite.Connection | None = None
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(964), "p1a-cancelled", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
task = asyncio.create_task(store.ensure_actor_authority(_uuid(964), _uuid(965)))
await asyncio.wait_for(receipt_entered.wait(), timeout=2)
assert connection.in_transaction is True, "cancellation gate was outside the transaction"
task.cancel()
with pytest.raises(asyncio.CancelledError):
await asyncio.wait_for(task, timeout=2)
assert connection.in_transaction is False, "cancelled write retained a transaction"
observer = await aiosqlite.connect(path.as_posix())
counts = await (
await observer.execute(
"SELECT (SELECT count(*) FROM execution_actor_authority_revisions),"
"(SELECT count(*) FROM execution_operation_receipts)"
)
).fetchone()
await observer.close()
observer = None
store.armed = False
reused = await store.ensure_actor_authority(_uuid(964), _uuid(965))
finally:
receipt_release.set()
if task is not None and not task.done():
task.cancel()
await asyncio.gather(task, return_exceptions=True)
if observer is not None:
await observer.close()
await connection.close()
assert tuple(counts) == (0, 0), "cancelled truth write leaked partial state"
assert reused.result is FixedResult.APPLIED, "cancelled SQLite connection was not reusable"
@pytest.mark.parametrize(
"stage",
["transaction-rollback", "savepoint-rollback", "savepoint-release"],
ids=("transaction-rollback", "savepoint-rollback", "savepoint-release"),
)
@pytest.mark.asyncio
async def test_sqlite_primary_fixed_failure_survives_cleanup_failure(
monkeypatch, stage: str
) -> None:
cleanup_faults: list[str] = []
if stage == "transaction-rollback":
connection = await _new_connection()
try:
await connection.execute(
"INSERT INTO users(id,username,hashed_password,role,created_by) VALUES(?,?,?,?,?)",
(_uuid(966), "p1a-cleanup", "fixed-hash", "admin", "fixed"),
)
await connection.commit()
original_rollback = connection.rollback
async def rollback_then_fail() -> None:
await original_rollback()
cleanup_faults.append(stage)
raise RuntimeError("fixed-sqlite-cleanup-failure")
monkeypatch.setattr(connection, "rollback", rollback_then_fail)
store = _SQLiteCleanupFailureStore(connection, stage, cleanup_faults)
original_returning = store._returning_rows
async def duplicate_insert_rows(
fault_connection: Any, sql: str, params: tuple[Any, ...]
) -> tuple[Any, ...]:
rows = await original_returning(fault_connection, sql, params)
if store.armed and rows and "execution_actor_authority_revisions" in sql:
return rows + rows
return rows
monkeypatch.setattr(store, "_returning_rows", duplicate_insert_rows)
failed = await store.ensure_actor_authority(_uuid(966), _uuid(967))
store.armed = False
reused = await store.ensure_actor_authority(_uuid(966), _uuid(967))
finally:
await connection.close()
else:
connection, _setup_store = await _new_transition_case(":memory:", AttemptState.ACCEPTED)
try:
store = _SQLiteCleanupFailureStore(connection, stage, cleanup_faults)
request = TransitionRequest(
_uuid(210),
0,
AttemptState.QUEUED,
_uuid(968),
campaign_id=_uuid(201),
actor_subject_ref=_uuid(200),
actor_user_id=_uuid(200),
actor_authority_revision=0,
)
failed = await store.transition_attempt(request)
store.armed = False
reused = await store.transition_attempt(request)
finally:
await connection.close()
assert failed.result is FixedResult.INVARIANT_FAILURE, (
"cleanup failure replaced the primary fixed failure"
)
assert cleanup_faults == [stage], "cleanup failure stage was not deterministic"
assert reused.result is FixedResult.APPLIED, "cleanup failure left SQLite unusable"
_SQLITE_P1C_TERMINAL_V3_ALIASES = (
"invalid-contract-before-receipt",
"v3-binding-vector-and-operation-codes",
"receipt-replay-after-target-deletion",
"receipt-replay-zero-mutable-reads",
"changed-intent-conflict-operation",
"known-success-atomic",
"known-failure-atomic",
"acknowledged-cancellation-atomic",
"acknowledged-timeout-atomic",
"uncertain-outcome-invalid-contract",
"single-transaction-zero-nested-acquire",
"derive-exact-three-held-ledgers",
"missing-ledger-inconsistent-set-rollback",
"duplicate-extra-ledger-inconsistent-set-rollback",
"wrong-kind-ledger-inconsistent-set-rollback",
"wrong-campaign-attempt-ledger-inconsistent-set-rollback",
"non-held-ledger-conflict-operation-rollback",
"current-budget-lock-no-toctou",
"budget-capacity-inconsistent-set-rollback",
"budget-write-failure-rollback",
"output-write-failure-rollback",
"terminal-write-failure-rollback",
"logical-closure-write-failure-rollback",
"outbox-write-failure-rollback",
"receipt-write-failure-rollback",
"public-intent-excludes-derived-fields",
"missing-attempt-not-found-or-purged",
"non-running-attempt-conflict-state",
"stale-attempt-revision-conflict",
"invariant-failure-rollback",
"cancellation-rollback-and-reuse",
"exception-rollback-and-reuse",
"legacy-terminal-apply-replay-bytes-unchanged",
"legacy-v3-crossing-conflict-operation",
"changed-outcome-conflict-operation",
"changed-result-digest-conflict-operation",
"cancellation-caller-result-digest-invalid-contract",
"timeout-caller-result-digest-invalid-contract",
"canonical-output-order-exact-replay",
"terminal-operation-and-system-principal-namespace",
"derived-revision-overflow-invariant-failure-rollback",
)
_SQLITE_P1C_TERMINAL_NODE_COUNT = 41
_SQLITE_P1C_TERMINAL_NODE_ID_SHA256 = (
"5d7df72980bd3e7fdc4bf809965568b127a19f5a080a95b116b221cafb347e4e"
)
def _sqlite_p1c_terminal_inventory_digest() -> str:
encoded = bytearray(b"ares.p1c-terminal-v3-sqlite-test-inventory.v1\x00")
for alias in _SQLITE_P1C_TERMINAL_V3_ALIASES:
node_id = (
"tests/unit/test_execution_lifecycle_persistence.py::"
f"test_sqlite_p1c_terminal_v3_seam[{alias}]"
).encode()
encoded.extend(struct.pack(">I", len(node_id)))
encoded.extend(node_id)
return hashlib.sha256(encoded).hexdigest()
assert len(_SQLITE_P1C_TERMINAL_V3_ALIASES) == _SQLITE_P1C_TERMINAL_NODE_COUNT
assert len(set(_SQLITE_P1C_TERMINAL_V3_ALIASES)) == _SQLITE_P1C_TERMINAL_NODE_COUNT
assert _sqlite_p1c_terminal_inventory_digest() == _SQLITE_P1C_TERMINAL_NODE_ID_SHA256
_SQLITE_P1C_TERMINAL_RESULT_DIGEST = hashlib.sha256(
b"sqlite-p1c-terminal-v3-known-result"
).hexdigest()
def _sqlite_p1c_binding_digest(
domain: str,
values: tuple[tuple[str, str | int | bool | None], ...],
) -> str:
"""Independent literal oracle for the protected v2 typed framing."""
encoded = bytearray(b"ares.execution-operation-binding.v2\x00")
def frame(value: bytes) -> None:
encoded.extend(struct.pack(">I", len(value)))
encoded.extend(value)
frame(domain.encode("ascii"))
seen: set[str] = set()
for name, value in values:
assert name not in seen, "SQLite terminal oracle contains a duplicate field"
seen.add(name)
frame(name.encode("ascii"))
if value is None:
encoded.extend(b"n")
elif type(value) is bool:
encoded.extend(b"b\x01" if value else b"b\x00")
elif type(value) is int:
encoded.extend(b"i")
frame(value.to_bytes(8, "big", signed=False))
elif type(value) is str:
encoded.extend(b"s")
frame(value.encode("utf-8"))
else: # pragma: no cover - a broken test oracle must be loud.
raise AssertionError("unsupported SQLite terminal oracle value")
return hashlib.sha256(encoded).hexdigest()
def _sqlite_p1c_terminal_operation_id(attempt_id: str) -> str:
digest = _sqlite_p1c_binding_digest(
"terminal-commit-operation-id.v3",
(("attempt_id", attempt_id), ("action", "commit-known-settled")),
)
return (
digest[:8]
+ "-"
+ digest[8:12]
+ "-4"
+ digest[13:16]
+ "-8"
+ digest[17:20]
+ "-"
+ digest[20:32]
)
def _sqlite_p1c_terminal_operation_code(outcome: OutcomeCode) -> str:
return {
OutcomeCode.CONFIRMED_SUCCESS: "terminal_succeeded",
OutcomeCode.CONFIRMED_FAILURE: "terminal_failed",
OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT: "cancellation_acknowledgement",
OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED: "timeout",
}[outcome]
def _sqlite_p1c_terminal_request_digest(intent: TerminalCommitIntentV3) -> str:
operation_id = _sqlite_p1c_terminal_operation_id(intent.attempt_id)
operation_code = _sqlite_p1c_terminal_operation_code(intent.outcome_code)
canonical_outputs = tuple(
sorted(
intent.outputs,
key=lambda item: (item.kind.value, item.target_id, item.link_id),
)
)
output_fields = tuple(
field
for index, output in enumerate(canonical_outputs)
for field in (
(f"output_{index}_link_id", output.link_id),
(f"output_{index}_kind", output.kind.value),
(f"output_{index}_target_id", output.target_id),
)
)
return _sqlite_p1c_binding_digest(
"execution-terminal-commit.v3.request",
(
("terminal_commit_contract_version", 3),
("logical_execution_id", intent.logical_execution_id),
("campaign_id", intent.campaign_id),
("attempt_id", intent.attempt_id),
("operation_id", operation_id),
("expected_attempt_revision", intent.expected_attempt_revision),
("operation_code", operation_code),
("outcome_code", intent.outcome_code.value),
("noise_actual", intent.noise_actual),
("exfiltration_actual", intent.exfiltration_actual),
("concurrency_actual", intent.concurrency_actual),
(
"execution_result_digest_present",
intent.execution_result_digest is not None,
),
("execution_result_digest", intent.execution_result_digest),
("output_count", len(canonical_outputs)),
)
+ output_fields,
)
def _sqlite_p1c_terminal_derived_uuid(operation_id: str, label: str) -> str:
digest = hashlib.sha256((operation_id + "\x00" + label).encode("ascii")).hexdigest()
return (
digest[:8]
+ "-"
+ digest[8:12]
+ "-4"
+ digest[13:16]
+ "-8"
+ digest[17:20]
+ "-"
+ digest[20:32]
)
def _sqlite_p1c_terminal_result_digest(intent: TerminalCommitIntentV3) -> str:
operation_id = _sqlite_p1c_terminal_operation_id(intent.attempt_id)
operation_code = _sqlite_p1c_terminal_operation_code(intent.outcome_code)
target, proof = {
OutcomeCode.CONFIRMED_SUCCESS: (AttemptState.SUCCEEDED, "local_completion"),
OutcomeCode.CONFIRMED_FAILURE: (AttemptState.FAILED, "local_completion"),
OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT: (
AttemptState.CANCELLED,
"cancellation_no_result_ack",
),
OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED: (
AttemptState.TIMED_OUT,
"timeout_termination_ack",
),
}[intent.outcome_code]
post_revision = intent.expected_attempt_revision + 1
outbox_id = _sqlite_p1c_terminal_derived_uuid(operation_id, "terminal-outbox")
publication_key = _sqlite_p1c_terminal_derived_uuid(
operation_id,
"terminal-publication",
)
counts = tuple(
sum(output.kind is kind for output in intent.outputs)
for kind in (
OutputKind.FINDING,
OutputKind.CREDENTIAL,
OutputKind.HOST,
OutputKind.ARTIFACT,
)
)
return _sqlite_p1c_binding_digest(
"execution-terminal-commit.v3.result",
(
("result_code", FixedResult.APPLIED.value),
("exact_replay_code", FixedResult.REPLAYED.value),
("result_identity_present", True),
("result_identity", intent.attempt_id),
("result_revision_present", True),
("result_revision", post_revision),
("secondary_result_identity_present", True),
("secondary_result_identity", intent.logical_execution_id),
("secondary_result_revision_present", True),
("secondary_result_revision", 1),
("state", target.value),
("revision", post_revision),
("closes_logical", True),
("finding_count", counts[0]),
("credential_count", counts[1]),
("host_count", counts[2]),
("artifact_count", counts[3]),
("outbox_id", outbox_id),
("terminal_commit_contract_version", 3),
("operation_id", operation_id),
("operation_code", operation_code),
("campaign_id", intent.campaign_id),
("logical_execution_id", intent.logical_execution_id),
("attempt_id", intent.attempt_id),
("outcome_code", intent.outcome_code.value),
("authoritative_proof", proof),
("retry_eligible", False),
(
"execution_result_digest_present",
intent.execution_result_digest is not None,
),
("execution_result_digest", intent.execution_result_digest),
("publication_key", publication_key),
),
)
async def _sqlite_p1c_terminal_case(
path: Any,
*,
predecessor: AttemptState = AttemptState.RUNNING,
) -> tuple[aiosqlite.Connection, ExecutionLifecycleStore, int]:
connection, store = await _new_transition_case(path.as_posix(), AttemptState.ACCEPTED)
if predecessor is AttemptState.ACCEPTED:
return connection, store, 0
dispatched = await _nonterminal_transition(store, connection, AttemptState.DISPATCHING, 20_100)
assert dispatched.result is FixedResult.APPLIED, "terminal fixture dispatch failed"
running = await _nonterminal_transition(store, connection, AttemptState.RUNNING, 20_101)
assert running.result is FixedResult.APPLIED, "terminal fixture start failed"
if predecessor is AttemptState.CANCELLING:
cancelling = await _nonterminal_transition(
store, connection, AttemptState.CANCELLING, 20_102
)
assert cancelling.result is FixedResult.APPLIED, "terminal fixture cancel failed"
return connection, store, 3
assert predecessor is AttemptState.RUNNING, "unsupported terminal fixture predecessor"
return connection, store, 2
def _sqlite_p1c_terminal_intent(
expected_revision: int,
*,
outcome: OutcomeCode = OutcomeCode.CONFIRMED_SUCCESS,
execution_result_digest: str | None | object = ...,
outputs: tuple[OutputObservation, ...] = (),
noise_actual: int = 1,
exfiltration_actual: int = 2,
concurrency_actual: int = 0,
) -> TerminalCommitIntentV3:
if execution_result_digest is ...:
execution_result_digest = (
None
if outcome
in {
OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT,
OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED,
}
else _SQLITE_P1C_TERMINAL_RESULT_DIGEST
)
return TerminalCommitIntentV3(
logical_execution_id=_uuid(208),
campaign_id=_uuid(201),
attempt_id=_uuid(210),
expected_attempt_revision=expected_revision,
outcome_code=outcome,
noise_actual=noise_actual,
exfiltration_actual=exfiltration_actual,
concurrency_actual=concurrency_actual,
execution_result_digest=execution_result_digest, # type: ignore[arg-type]
outputs=outputs,
)
async def _sqlite_p1c_terminal_receipt(
connection: aiosqlite.Connection, attempt_id: str = _uuid(210)
) -> Any:
return await (
await connection.execute(
"SELECT operation_id,operation_code,campaign_id,primary_target_id,"
"secondary_target_id,principal_kind,principal_subject_ref,principal_user_id,"
"principal_authority_revision_present,principal_authority_revision,"
"binding_contract_version,request_binding_digest,result_code,exact_replay_code,"
"result_binding_digest,result_identity,result_revision,secondary_result_identity,"
"secondary_result_revision FROM execution_operation_receipts "
"WHERE operation_id=?",
(_sqlite_p1c_terminal_operation_id(attempt_id),),
)
).fetchone()
async def _sqlite_p1c_terminal_state(connection: aiosqlite.Connection) -> Any:
return await (
await connection.execute(
"SELECT state,revision,outcome_code,settlement_state,settlement_proof_code,"
"termination_confirmed,closes_logical,retry_disposition,terminal_operation_id,"
"cancellation_ack_operation_id,timeout_operation_id "
"FROM execution_attempts WHERE id=?",
(_uuid(210),),
)
).fetchone()
def _sqlite_p1c_legacy_terminal_request(
operation_id: str,
expected_revision: int,
) -> TerminalCommitRequest:
return TerminalCommitRequest(
_uuid(208),
_uuid(201),
_uuid(20_200),
_uuid(20_201),
TransitionRequest(
_uuid(210),
expected_revision,
AttemptState.SUCCEEDED,
operation_id,
owner_ref=_uuid(220),
lease_generation=1,
outcome_code=OutcomeCode.CONFIRMED_SUCCESS,
authoritative_proof="local_completion",
campaign_id=_uuid(201),
),
BudgetSettlement(
_uuid(201),
_uuid(210),
_uuid(204),
2,
1,
1,
_uuid(205),
3,
2,
1,
_uuid(206),
1,
_uuid(20_202),
),
)
_SQLITE_P1C_LEGACY_TERMINAL_RECEIPT_VECTORS = (
(
_uuid(20_200),
"outbox_insert",
2,
"5dccdba355c4feef9cd6df03d5d6b3c8af06feee7ee618108615a35a545425e7",
"7a50d0b26f31239a9fba139b28affd32750988bb7d6dc360c0a570ea8856a0d3",
),
(
_uuid(20_202),
"budget_settle",
2,
"e0d4a8b6ca4ea2e38967e3158283cd1fa175279a41b1c55490cebbf76b48a9a1",
"04f8900897528d734dd7f4fd030af712b34e2cd18ddf929f247b20494f5ddcad",
),
(
_uuid(20_400),
"terminal_succeeded",
2,
"da5caf4a079873de9cdea7f31a284bcac45bdd3526c602038aaeb66147fc5cb8",
"0b15cef8a5886d92669f712e36c80a91e4e10d00a1e0d92d6a479ad1bde08278",
),
)
class _SQLiteP1CTerminalTraceStore(ExecutionLifecycleStore):
def __init__(
self,
backend: Any,
*,
receipt_only: bool = False,
duplicate_ledger_row: bool = False,
ledger_mutation: str | None = None,
fail_at: str | None = None,
cancel_at: str | None = None,
duplicate_terminal_returning: bool = False,
) -> None:
super().__init__(backend, "sqlite")
self.receipt_only = receipt_only
self.duplicate_ledger_row = duplicate_ledger_row
self.ledger_mutation = ledger_mutation
self.fail_at = fail_at
self.cancel_at = cancel_at
self.duplicate_terminal_returning = duplicate_terminal_returning
self.transaction_entries = 0
self.connection_identities: set[int] = set()
self.read_events: list[str] = []
self.budget_writes = 0
self.output_insert_order: list[str] = []
@asynccontextmanager
async def _transaction(self) -> AsyncIterator[Any]:
self.transaction_entries += 1
async with super()._transaction() as connection:
self.connection_identities.add(id(connection))
yield connection
async def _fetchrow(self, connection: Any, sql: str, params: Any) -> Any:
self.connection_identities.add(id(connection))
self.read_events.append("receipt" if "execution_operation_receipts" in sql else "mutable")
if self.receipt_only and "execution_operation_receipts" not in sql:
raise AssertionError("exact terminal replay read a mutable target")
return await super()._fetchrow(connection, sql, params)
async def _fetchall(self, connection: Any, sql: str, params: Any) -> Any:
self.connection_identities.add(id(connection))
self.read_events.append("mutable")
if self.receipt_only:
raise AssertionError("exact terminal receipt classification read a mutable set")
rows = tuple(await super()._fetchall(connection, sql, params))
if self.duplicate_ledger_row and "FROM campaign_execution_budget_ledger" in sql and rows:
return rows + (rows[0],)
if (
self.ledger_mutation is not None
and "FROM campaign_execution_budget_ledger" in sql
and rows
):
mutable = [list(row) for row in rows]
if self.ledger_mutation == "kind":
mutable[0][4] = "exfiltration"
elif self.ledger_mutation == "campaign":
mutable[0][2] = _uuid(20_300)
elif self.ledger_mutation == "attempt":
mutable[0][1] = _uuid(20_301)
else: # pragma: no cover - invalid fault label is a broken test.
raise AssertionError("unknown terminal ledger mutation")
return tuple(tuple(row) for row in mutable)
return rows
async def _returning_rows(self, connection: Any, sql: str, params: Any) -> Any:
self.connection_identities.add(id(connection))
rows = await super()._returning_rows(connection, sql, params)
if (
self.duplicate_terminal_returning
and "UPDATE execution_attempts SET state=" in sql
and rows
):
return rows + rows
return rows
async def cas_update_one(self, connection: Any, sql: str, params: Any, **kwargs: Any) -> Any:
row = await super().cas_update_one(connection, sql, params, **kwargs)
if "UPDATE campaign_execution_budgets" in sql:
self.budget_writes += 1
if self.fail_at == "budget" and self.budget_writes == 2:
raise RuntimeError("fixed-terminal-budget-write-failure")
if self.fail_at == "terminal" and "UPDATE execution_attempts SET state=" in sql:
raise RuntimeError("fixed-terminal-attempt-write-failure")
if self.fail_at == "logical" and "UPDATE logical_executions SET closure" in sql:
raise RuntimeError("fixed-terminal-logical-write-failure")
return row
async def _insert_output_links(self, *args: Any, **kwargs: Any) -> Any:
counts = await super()._insert_output_links(*args, **kwargs)
if self.fail_at == "output":
raise RuntimeError("fixed-terminal-output-write-failure")
if self.fail_at == "exception":
raise RuntimeError("fixed-terminal-exception")
if self.cancel_at == "output":
raise asyncio.CancelledError
return counts
async def update_exact_set(
self,
connection: Any,
sql: str,
params: Any,
**kwargs: Any,
) -> Any:
result = await super().update_exact_set(connection, sql, params, **kwargs)
if "INSERT INTO execution_output_links" in sql:
self.output_insert_order.append(str(params[0]))
return result
async def _insert_terminal_outbox(self, *args: Any, **kwargs: Any) -> Any:
result = await super()._insert_terminal_outbox(*args, **kwargs)
if self.fail_at == "outbox":
raise RuntimeError("fixed-terminal-outbox-write-failure")
return result
async def _insert_receipt(self, connection: Any, spec: Any, **kwargs: Any) -> Any:
result = await super()._insert_receipt(connection, spec, **kwargs)
if self.fail_at == "receipt" and spec.operation_code in {
"terminal_succeeded",
"terminal_failed",
"cancellation_acknowledgement",
"timeout",
}:
raise RuntimeError("fixed-terminal-receipt-write-failure")
return result
async def _insert_terminal_v3_receipt(self, *args: Any, **kwargs: Any) -> Any:
result = await super()._insert_terminal_v3_receipt(*args, **kwargs)
if self.fail_at == "receipt":
raise RuntimeError("fixed-terminal-v3-receipt-write-failure")
return result
async def _sqlite_p1c_assert_rollback(
connection: aiosqlite.Connection,
store: ExecutionLifecycleStore,
intent: TerminalCommitIntentV3,
*,
expected_result: FixedResult | None = None,
expected_exception: type[BaseException] | None = None,
) -> OperationResult | None:
before = await _snapshot_case(connection)
if expected_exception is None:
result = await store.commit_terminal_attempt_v3(intent)
assert result.result is expected_result, "terminal rollback result changed"
else:
with pytest.raises(expected_exception):
await store.commit_terminal_attempt_v3(intent)
result = None
after = await _snapshot_case(connection)
assert after == before, "terminal failure committed partial state"
return result
@pytest.mark.parametrize(
"case_alias",
_SQLITE_P1C_TERMINAL_V3_ALIASES,
ids=_SQLITE_P1C_TERMINAL_V3_ALIASES,
)
@pytest.mark.asyncio
async def test_sqlite_p1c_terminal_v3_seam(tmp_path, case_alias: str) -> None: # noqa: C901, PLR0912, PLR0915
if case_alias == "public-intent-excludes-derived-fields":
public_dataclass_fields = fields(TerminalCommitIntentV3)
public_fields = tuple(item.name for item in public_dataclass_fields)
assert public_fields == (
"logical_execution_id",
"campaign_id",
"attempt_id",
"expected_attempt_revision",
"outcome_code",
"noise_actual",
"exfiltration_actual",
"concurrency_actual",
"execution_result_digest",
"outputs",
), "terminal public authority surface changed"
assert get_type_hints(TerminalCommitIntentV3) == {
"logical_execution_id": str,
"campaign_id": str,
"attempt_id": str,
"expected_attempt_revision": int,
"outcome_code": OutcomeCode,
"noise_actual": int,
"exfiltration_actual": int,
"concurrency_actual": int,
"execution_result_digest": str | None,
"outputs": tuple[OutputObservation, ...],
}, "terminal public field types changed"
assert all(item.default is MISSING for item in public_dataclass_fields[:-1])
assert public_dataclass_fields[-1].default == (), "terminal output default changed"
dataclass_parameters = TerminalCommitIntentV3.__dataclass_params__
assert is_dataclass(TerminalCommitIntentV3)
assert (
dataclass_parameters.init,
dataclass_parameters.repr,
dataclass_parameters.eq,
dataclass_parameters.order,
dataclass_parameters.unsafe_hash,
dataclass_parameters.frozen,
) == (True, False, False, False, False, True)
assert TerminalCommitIntentV3.__slots__ == public_fields
assert TerminalCommitIntentV3.__hash__ is None
forbidden = {
"operation_id",
"principal_kind",
"principal_subject_ref",
"principal_user_id",
"principal_authority_revision",
"actor_subject_ref",
"actor_user_id",
"actor_authority_revision",
"campaign_authority_revision",
"budget_id",
"budget_ids",
"ledger_id",
"ledger_ids",
"reserved_units",
"budget_revision",
"current_budget_revision",
"retry_eligibility",
"retry_eligible",
"policy_result",
"closure_disposition",
"receipt_classification",
}
assert not forbidden.intersection(public_fields), (
"caller authority leaked into terminal intent"
)
baseline = _sqlite_p1c_terminal_intent(2)
assert not hasattr(baseline, "__dict__"), "terminal intent lost its slot boundary"
with pytest.raises(FrozenInstanceError):
baseline.campaign_id = _uuid(20_299)
values = {item.name: getattr(baseline, item.name) for item in fields(baseline)}
for name in sorted(forbidden):
with pytest.raises(TypeError):
TerminalCommitIntentV3(**values, **{name: "caller-controlled"})
return
if case_alias == "missing-attempt-not-found-or-purged":
connection = await _new_connection()
try:
result = await ExecutionLifecycleStore(connection, "sqlite").commit_terminal_attempt_v3(
_sqlite_p1c_terminal_intent(0)
)
receipt = await _sqlite_p1c_terminal_receipt(connection)
finally:
await connection.close()
assert (result.result, result.revision) == (
FixedResult.NOT_FOUND_OR_PURGED,
None,
)
assert receipt is None, "missing attempt created a receipt"
return
if case_alias == "v3-binding-vector-and-operation-codes":
cases = (
(OutcomeCode.CONFIRMED_SUCCESS, AttemptState.RUNNING, "terminal_succeeded"),
(OutcomeCode.CONFIRMED_FAILURE, AttemptState.RUNNING, "terminal_failed"),
(
OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT,
AttemptState.CANCELLING,
"cancellation_acknowledgement",
),
(OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED, AttemptState.RUNNING, "timeout"),
)
for index, (outcome, predecessor, operation_code) in enumerate(cases):
connection, store, revision = await _sqlite_p1c_terminal_case(
tmp_path / f"binding-{index}.db", predecessor=predecessor
)
try:
intent = _sqlite_p1c_terminal_intent(revision, outcome=outcome)
result = await store.commit_terminal_attempt_v3(intent)
receipt = await _sqlite_p1c_terminal_receipt(connection)
finally:
await connection.close()
assert result.result is FixedResult.APPLIED, "terminal binding case failed"
assert receipt[0] == _sqlite_p1c_terminal_operation_id(intent.attempt_id)
assert receipt[1] == operation_code, "terminal operation code changed"
assert receipt[10] == 2, "receipt storage contract version changed"
assert receipt[11] == _sqlite_p1c_terminal_request_digest(intent), (
"terminal request binding vector changed"
)
assert receipt[14] == _sqlite_p1c_terminal_result_digest(intent), (
"terminal result binding vector changed"
)
assert receipt[14] != intent.execution_result_digest, (
"terminal receipt result binding conflated the execution-result digest"
)
return
predecessor = (
AttemptState.CANCELLING
if case_alias
in {
"acknowledged-cancellation-atomic",
"cancellation-caller-result-digest-invalid-contract",
}
else AttemptState.ACCEPTED
if case_alias == "non-running-attempt-conflict-state"
else AttemptState.RUNNING
)
connection, base_store, revision = await _sqlite_p1c_terminal_case(
tmp_path / "terminal.db", predecessor=predecessor
)
store: ExecutionLifecycleStore = base_store
intent = _sqlite_p1c_terminal_intent(revision)
try:
if case_alias == "invalid-contract-before-receipt":
trace = _SQLiteP1CTerminalTraceStore(connection)
duplicate_output = OutputObservation(_uuid(20_610), OutputKind.HOST, _uuid(260))
same_link_other_target = OutputObservation(
duplicate_output.link_id,
OutputKind.HOST,
_uuid(261),
)
same_target_other_link = OutputObservation(
_uuid(20_611),
OutputKind.HOST,
duplicate_output.target_id,
)
oversized_outputs = tuple(
OutputObservation(_uuid(21_000 + index), OutputKind.HOST, _uuid(22_000 + index))
for index in range(257)
)
invalids = (
replace(intent, expected_attempt_revision=MAX_I53),
replace(intent, expected_attempt_revision=True),
replace(intent, expected_attempt_revision=-1),
replace(intent, attempt_id="not-a-canonical-uuid"),
replace(intent, noise_actual=True),
replace(intent, exfiltration_actual=True),
replace(intent, concurrency_actual=True),
replace(intent, noise_actual=-1),
replace(intent, noise_actual=MAX_I53 + 1),
replace(intent, concurrency_actual=1),
replace(intent, execution_result_digest=None),
replace(
intent,
execution_result_digest=_SQLITE_P1C_TERMINAL_RESULT_DIGEST.upper(),
),
replace(intent, execution_result_digest="a" * 63),
replace(intent, outputs=(duplicate_output, duplicate_output)),
replace(intent, outputs=(duplicate_output, same_link_other_target)),
replace(intent, outputs=(duplicate_output, same_target_other_link)),
replace(intent, outputs=[duplicate_output]), # type: ignore[arg-type]
replace(intent, outputs=oversized_outputs),
replace(
intent,
outcome_code=OutcomeCode.CONFIRMED_FAILURE,
outputs=(duplicate_output,),
),
)
before = await _snapshot_case(connection)
results = tuple([await trace.commit_terminal_attempt_v3(item) for item in invalids])
assert all(item.result is FixedResult.INVALID_CONTRACT for item in results)
assert trace.transaction_entries == 0, "invalid intent entered a transaction"
assert await _snapshot_case(connection) == before
elif case_alias == "receipt-replay-after-target-deletion":
applied = await store.commit_terminal_attempt_v3(intent)
receipt_before = await _sqlite_p1c_terminal_receipt(connection)
await connection.execute("PRAGMA foreign_keys=OFF")
await connection.execute("DELETE FROM campaigns WHERE id=?", (_uuid(201),))
await connection.execute("DELETE FROM logical_executions WHERE id=?", (_uuid(208),))
await connection.execute("DELETE FROM execution_attempts WHERE id=?", (_uuid(210),))
await connection.execute("DELETE FROM campaign_execution_budgets")
await connection.execute("DELETE FROM campaign_execution_budget_ledger")
await connection.execute("DELETE FROM execution_publication_outbox")
await connection.commit()
mutable_counts = []
for table, predicate, parameters in (
("campaigns", "id=?", (_uuid(201),)),
("logical_executions", "id=?", (_uuid(208),)),
("execution_attempts", "id=?", (_uuid(210),)),
("campaign_execution_budgets", "campaign_id=?", (_uuid(201),)),
("campaign_execution_budget_ledger", "campaign_id=?", (_uuid(201),)),
("execution_publication_outbox", "campaign_id=?", (_uuid(201),)),
):
row = await (
await connection.execute(
f"SELECT COUNT(*) FROM {table} WHERE {predicate}", # noqa: S608
parameters,
)
).fetchone()
mutable_counts.append(int(row[0]))
assert mutable_counts == [0] * 6, "terminal replay targets were not deleted"
replayed = await store.commit_terminal_attempt_v3(intent)
receipt_after = await _sqlite_p1c_terminal_receipt(connection)
assert (applied.result, replayed.result, replayed.revision) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
revision + 1,
)
assert tuple(receipt_before) == tuple(receipt_after), (
"terminal replay changed its immutable result identities"
)
elif case_alias == "receipt-replay-zero-mutable-reads":
applied = await store.commit_terminal_attempt_v3(intent)
trace = _SQLiteP1CTerminalTraceStore(connection, receipt_only=True)
replayed = await trace.commit_terminal_attempt_v3(intent)
assert (applied.result, replayed.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
)
assert trace.transaction_entries == 1
elif case_alias == "changed-intent-conflict-operation":
applied = await store.commit_terminal_attempt_v3(intent)
receipt_only = _SQLiteP1CTerminalTraceStore(connection, receipt_only=True)
changed = tuple(
[
await receipt_only.commit_terminal_attempt_v3(changed_intent)
for changed_intent in (
replace(intent, noise_actual=0),
replace(
intent,
outputs=(
OutputObservation(
_uuid(20_612),
OutputKind.HOST,
_uuid(260),
),
),
),
)
]
)
assert applied.result is FixedResult.APPLIED
assert all(item.result is FixedResult.CONFLICT_OPERATION for item in changed)
assert receipt_only.transaction_entries == 2
elif case_alias in {
"known-success-atomic",
"known-failure-atomic",
"acknowledged-cancellation-atomic",
"acknowledged-timeout-atomic",
}:
outcome, state, proof, event_code, operation_columns = {
"known-success-atomic": (
OutcomeCode.CONFIRMED_SUCCESS,
AttemptState.SUCCEEDED,
"local_completion",
"execution_succeeded",
"terminal",
),
"known-failure-atomic": (
OutcomeCode.CONFIRMED_FAILURE,
AttemptState.FAILED,
"local_completion",
"execution_failed",
"terminal",
),
"acknowledged-cancellation-atomic": (
OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT,
AttemptState.CANCELLED,
"cancellation_no_result_ack",
"execution_cancelled",
"cancellation",
),
"acknowledged-timeout-atomic": (
OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED,
AttemptState.TIMED_OUT,
"timeout_termination_ack",
"execution_timed_out",
"timeout",
),
}[case_alias]
intent = _sqlite_p1c_terminal_intent(revision, outcome=outcome)
result = await store.commit_terminal_attempt_v3(intent)
attempt = await _sqlite_p1c_terminal_state(connection)
receipt = await _sqlite_p1c_terminal_receipt(connection)
logical = await (
await connection.execute(
"SELECT closure_operation_id,closing_attempt_id,revision "
"FROM logical_executions WHERE id=?",
(_uuid(208),),
)
).fetchone()
outbox = await (
await connection.execute(
"SELECT event_code,is_attempt_terminal FROM execution_publication_outbox "
"WHERE attempt_id=?",
(_uuid(210),),
)
).fetchone()
settled_ledgers = await (
await connection.execute(
"SELECT COUNT(*) FROM campaign_execution_budget_ledger "
"WHERE attempt_id=? AND disposition IN ('consumed','released') "
"AND budget_revision_settled IS NOT NULL",
(_uuid(210),),
)
).fetchone()
operation_id = _sqlite_p1c_terminal_operation_id(intent.attempt_id)
expected_operation_columns = {
"terminal": (operation_id, None, None),
"cancellation": (None, operation_id, None),
"timeout": (None, None, operation_id),
}[operation_columns]
assert (result.result, result.revision) == (
FixedResult.APPLIED,
revision + 1,
)
assert tuple(attempt[:6]) == (
state.value,
revision + 1,
outcome.value,
"settled",
proof,
1,
), "known terminal settlement changed"
assert tuple(attempt[6:]) == (
1,
"closed_without_retry",
*expected_operation_columns,
), "known terminal closure facts changed"
assert tuple(logical) == (operation_id, _uuid(210), 1), (
"known terminal logical closure changed"
)
assert (receipt[12], receipt[13], receipt[15], receipt[16]) == (
FixedResult.APPLIED.value,
FixedResult.REPLAYED.value,
_uuid(210),
revision + 1,
), "known terminal receipt result changed"
assert tuple(outbox) == (event_code, 1), "known terminal outbox binding changed"
assert int(settled_ledgers[0]) == 3, "known terminal budget settlement was incomplete"
elif case_alias == "uncertain-outcome-invalid-contract":
uncertain = replace(
intent,
outcome_code=OutcomeCode.UNKNOWN_AFTER_RECOVERY,
execution_result_digest=None,
)
trace = _SQLiteP1CTerminalTraceStore(connection)
await _sqlite_p1c_assert_rollback(
connection,
trace,
uncertain,
expected_result=FixedResult.INVALID_CONTRACT,
)
assert trace.transaction_entries == 0, "uncertain outcome reached persistence"
elif case_alias == "single-transaction-zero-nested-acquire":
trace = _SQLiteP1CTerminalTraceStore(connection)
applied = await trace.commit_terminal_attempt_v3(intent)
assert applied.result is FixedResult.APPLIED
assert trace.transaction_entries == 1, "terminal seam nested a transaction"
assert trace.connection_identities == {id(connection)}, (
"terminal seam acquired another connection"
)
assert trace.read_events[0] == "receipt", (
"terminal apply read mutable state before receipt classification"
)
elif case_alias == "derive-exact-three-held-ledgers":
applied = await store.commit_terminal_attempt_v3(intent)
ledgers = await (
await connection.execute(
"SELECT budget_kind,disposition,consumed_units "
"FROM campaign_execution_budget_ledger WHERE attempt_id=? "
"ORDER BY CASE budget_kind WHEN 'noise' THEN 1 "
"WHEN 'exfiltration' THEN 2 ELSE 3 END",
(_uuid(210),),
)
).fetchall()
assert applied.result is FixedResult.APPLIED
assert tuple(tuple(row) for row in ledgers) == (
("noise", "consumed", 1),
("exfiltration", "consumed", 2),
("concurrency", "released", 0),
)
elif case_alias == "missing-ledger-inconsistent-set-rollback":
await connection.execute(
"DELETE FROM campaign_execution_budget_ledger "
"WHERE attempt_id=? AND budget_kind='noise'",
(_uuid(210),),
)
await connection.commit()
await _sqlite_p1c_assert_rollback(
connection,
store,
intent,
expected_result=FixedResult.INCONSISTENT_BUDGET_SET,
)
elif case_alias == "duplicate-extra-ledger-inconsistent-set-rollback":
trace = _SQLiteP1CTerminalTraceStore(connection, duplicate_ledger_row=True)
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_result=FixedResult.INCONSISTENT_BUDGET_SET,
)
elif case_alias == "wrong-kind-ledger-inconsistent-set-rollback":
trace = _SQLiteP1CTerminalTraceStore(connection, ledger_mutation="kind")
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_result=FixedResult.INCONSISTENT_BUDGET_SET,
)
elif case_alias == "wrong-campaign-attempt-ledger-inconsistent-set-rollback":
for mutation in ("campaign", "attempt"):
trace = _SQLiteP1CTerminalTraceStore(connection, ledger_mutation=mutation)
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_result=FixedResult.INCONSISTENT_BUDGET_SET,
)
elif case_alias == "non-held-ledger-conflict-operation-rollback":
await connection.execute(
"UPDATE campaign_execution_budget_ledger SET disposition='released',"
"consumed_units=0,budget_revision_settled=1,settled_at=reserved_at "
"WHERE attempt_id=? AND budget_kind='noise'",
(_uuid(210),),
)
await connection.commit()
await _sqlite_p1c_assert_rollback(
connection,
store,
intent,
expected_result=FixedResult.CONFLICT_OPERATION,
)
elif case_alias == "current-budget-lock-no-toctou":
await connection.execute(
"UPDATE campaign_execution_budgets SET revision=2,latest_operation_id=?,"
"latest_operation_base_revision=1,latest_operation_code='configure' "
"WHERE campaign_id=?",
(_uuid(20_310), _uuid(201)),
)
await connection.commit()
applied = await store.commit_terminal_attempt_v3(intent)
revisions = await (
await connection.execute(
"SELECT revision FROM campaign_execution_budgets WHERE campaign_id=? "
"ORDER BY CASE budget_kind WHEN 'noise' THEN 1 "
"WHEN 'exfiltration' THEN 2 ELSE 3 END",
(_uuid(201),),
)
).fetchall()
assert applied.result is FixedResult.APPLIED
assert tuple(int(row[0]) for row in revisions) == (3, 3, 3)
elif case_alias == "budget-capacity-inconsistent-set-rollback":
await connection.execute(
"UPDATE campaign_execution_budgets SET reserved_units=0 "
"WHERE campaign_id=? AND budget_kind='noise'",
(_uuid(201),),
)
await connection.commit()
await _sqlite_p1c_assert_rollback(
connection,
store,
intent,
expected_result=FixedResult.INCONSISTENT_BUDGET_SET,
)
elif case_alias in {
"budget-write-failure-rollback",
"output-write-failure-rollback",
"terminal-write-failure-rollback",
"logical-closure-write-failure-rollback",
"outbox-write-failure-rollback",
"receipt-write-failure-rollback",
}:
fail_at = {
"budget-write-failure-rollback": "budget",
"output-write-failure-rollback": "output",
"terminal-write-failure-rollback": "terminal",
"logical-closure-write-failure-rollback": "logical",
"outbox-write-failure-rollback": "outbox",
"receipt-write-failure-rollback": "receipt",
}[case_alias]
if fail_at == "output":
intent = replace(
intent,
outputs=(OutputObservation(_uuid(20_320), OutputKind.HOST, _uuid(260)),),
)
trace = _SQLiteP1CTerminalTraceStore(connection, fail_at=fail_at)
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_exception=RuntimeError,
)
elif case_alias == "non-running-attempt-conflict-state":
result = await _sqlite_p1c_assert_rollback(
connection,
store,
replace(intent, expected_attempt_revision=revision + 1),
expected_result=FixedResult.CONFLICT_STATE,
)
assert result is not None
assert result.revision == revision, (
"attempt-state precedence did not dominate stale revision"
)
elif case_alias == "stale-attempt-revision-conflict":
await _sqlite_p1c_assert_rollback(
connection,
store,
replace(intent, expected_attempt_revision=revision - 1),
expected_result=FixedResult.CONFLICT_REVISION,
)
elif case_alias == "invariant-failure-rollback":
trace = _SQLiteP1CTerminalTraceStore(connection, duplicate_terminal_returning=True)
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_result=FixedResult.INVARIANT_FAILURE,
)
elif case_alias == "cancellation-rollback-and-reuse":
trace = _SQLiteP1CTerminalTraceStore(connection, cancel_at="output")
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_exception=asyncio.CancelledError,
)
reused = await base_store.commit_terminal_attempt_v3(intent)
assert reused.result is FixedResult.APPLIED, "cancelled connection was not reusable"
elif case_alias == "exception-rollback-and-reuse":
trace = _SQLiteP1CTerminalTraceStore(connection, fail_at="exception")
await _sqlite_p1c_assert_rollback(
connection,
trace,
intent,
expected_exception=RuntimeError,
)
reused = await base_store.commit_terminal_attempt_v3(intent)
assert reused.result is FixedResult.APPLIED, "failed connection was not reusable"
elif case_alias == "legacy-terminal-apply-replay-bytes-unchanged":
operation_id = _uuid(20_400)
legacy = _sqlite_p1c_legacy_terminal_request(operation_id, revision)
applied = await store.commit_terminal_attempt(legacy)
vector_rows = await (
await connection.execute(
"SELECT operation_id,operation_code,binding_contract_version,"
"request_binding_digest,result_binding_digest "
"FROM execution_operation_receipts WHERE operation_id IN (?,?,?) "
"ORDER BY operation_id",
(_uuid(20_200), _uuid(20_202), operation_id),
)
).fetchall()
all_receipts_before = await (
await connection.execute(
"SELECT * FROM execution_operation_receipts ORDER BY operation_id"
)
).fetchall()
replayed = await store.commit_terminal_attempt(legacy)
all_receipts_after = await (
await connection.execute(
"SELECT * FROM execution_operation_receipts ORDER BY operation_id"
)
).fetchall()
assert (applied.result, replayed.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
)
assert tuple(tuple(row) for row in vector_rows) == (
_SQLITE_P1C_LEGACY_TERMINAL_RECEIPT_VECTORS
), "legacy terminal receipt vectors drifted"
assert tuple(tuple(row) for row in all_receipts_before) == tuple(
tuple(row) for row in all_receipts_after
), "legacy replay changed a receipt row"
elif case_alias == "legacy-v3-crossing-conflict-operation":
operation_id = _sqlite_p1c_terminal_operation_id(intent.attempt_id)
legacy = _sqlite_p1c_legacy_terminal_request(operation_id, revision)
applied = await store.commit_terminal_attempt(legacy)
receipt_only = _SQLiteP1CTerminalTraceStore(connection, receipt_only=True)
crossed = await receipt_only.commit_terminal_attempt_v3(intent)
assert (applied.result, crossed.result) == (
FixedResult.APPLIED,
FixedResult.CONFLICT_OPERATION,
)
assert receipt_only.transaction_entries == 1
second_connection, second_store, second_revision = await _sqlite_p1c_terminal_case(
tmp_path / "cross-v3-first.db"
)
try:
second_intent = _sqlite_p1c_terminal_intent(second_revision)
v3_applied = await second_store.commit_terminal_attempt_v3(second_intent)
second_receipt_only = _SQLiteP1CTerminalTraceStore(
second_connection, receipt_only=True
)
legacy_crossed = await second_receipt_only.commit_terminal_attempt(
_sqlite_p1c_legacy_terminal_request(
_sqlite_p1c_terminal_operation_id(second_intent.attempt_id),
second_revision,
)
)
finally:
await second_connection.close()
assert (v3_applied.result, legacy_crossed.result) == (
FixedResult.APPLIED,
FixedResult.CONFLICT_OPERATION,
)
assert second_receipt_only.transaction_entries == 1
elif case_alias == "changed-outcome-conflict-operation":
applied = await store.commit_terminal_attempt_v3(intent)
receipt_only = _SQLiteP1CTerminalTraceStore(connection, receipt_only=True)
changed = await receipt_only.commit_terminal_attempt_v3(
replace(
intent,
outcome_code=OutcomeCode.CONFIRMED_FAILURE,
outputs=(),
execution_result_digest=hashlib.sha256(b"changed-outcome").hexdigest(),
)
)
assert (applied.result, changed.result) == (
FixedResult.APPLIED,
FixedResult.CONFLICT_OPERATION,
)
assert receipt_only.transaction_entries == 1
elif case_alias == "changed-result-digest-conflict-operation":
applied = await store.commit_terminal_attempt_v3(intent)
receipt_only = _SQLiteP1CTerminalTraceStore(connection, receipt_only=True)
changed = await receipt_only.commit_terminal_attempt_v3(
replace(intent, execution_result_digest=hashlib.sha256(b"changed").hexdigest())
)
assert (applied.result, changed.result) == (
FixedResult.APPLIED,
FixedResult.CONFLICT_OPERATION,
)
assert receipt_only.transaction_entries == 1
elif case_alias in {
"cancellation-caller-result-digest-invalid-contract",
"timeout-caller-result-digest-invalid-contract",
}:
outcome = (
OutcomeCode.CONFIRMED_CANCELLED_NO_RESULT
if case_alias.startswith("cancellation")
else OutcomeCode.CONFIRMED_TIMEOUT_TERMINATED
)
invalid = _sqlite_p1c_terminal_intent(
revision,
outcome=outcome,
execution_result_digest=_SQLITE_P1C_TERMINAL_RESULT_DIGEST,
)
trace = _SQLiteP1CTerminalTraceStore(connection)
await _sqlite_p1c_assert_rollback(
connection,
trace,
invalid,
expected_result=FixedResult.INVALID_CONTRACT,
)
assert trace.transaction_entries == 0, "no-result digest reached persistence"
elif case_alias == "canonical-output-order-exact-replay":
await connection.execute(
"INSERT INTO hosts(id,campaign_id,ip_address) VALUES(?,?,?)",
(_uuid(20_500), _uuid(201), "192.0.2.2"),
)
await connection.execute(
"INSERT INTO loot(id,campaign_id,host_id,loot_type,name) VALUES(?,?,?,?,?)",
(_uuid(20_503), _uuid(201), _uuid(260), "artifact", "fixed-output"),
)
await connection.commit()
outputs = (
OutputObservation(_uuid(20_502), OutputKind.HOST, _uuid(20_500)),
OutputObservation(_uuid(20_503), OutputKind.ARTIFACT, _uuid(20_503)),
OutputObservation(_uuid(20_501), OutputKind.HOST, _uuid(260)),
)
forward = replace(intent, outputs=outputs)
reversed_intent = replace(intent, outputs=tuple(reversed(outputs)))
trace = _SQLiteP1CTerminalTraceStore(connection)
applied = await trace.commit_terminal_attempt_v3(forward)
replayed = await trace.commit_terminal_attempt_v3(reversed_intent)
rows = await (
await connection.execute(
"SELECT id,host_id,loot_id FROM execution_output_links "
"WHERE attempt_id=? ORDER BY id",
(_uuid(210),),
)
).fetchall()
assert (applied.result, replayed.result) == (
FixedResult.APPLIED,
FixedResult.REPLAYED,
)
assert _sqlite_p1c_terminal_request_digest(
forward
) == _sqlite_p1c_terminal_request_digest(reversed_intent)
assert tuple(tuple(row) for row in rows) == (
(_uuid(20_501), _uuid(260), None),
(_uuid(20_502), _uuid(20_500), None),
(_uuid(20_503), None, _uuid(20_503)),
)
assert trace.output_insert_order == [
_uuid(20_503),
_uuid(20_501),
_uuid(20_502),
], "persisted output insertion order was not canonical"
elif case_alias == "terminal-operation-and-system-principal-namespace":
applied = await store.commit_terminal_attempt_v3(intent)
receipt = await _sqlite_p1c_terminal_receipt(connection)
actor = await (
await connection.execute(
"SELECT actor_subject_ref,actor_user_id FROM execution_attempts WHERE id=?",
(_uuid(210),),
)
).fetchone()
assert applied.result is FixedResult.APPLIED
assert tuple(receipt[:11]) == (
_sqlite_p1c_terminal_operation_id(_uuid(210)),
"terminal_succeeded",
_uuid(201),
_uuid(210),
_uuid(208),
"system",
SYSTEM_PRINCIPAL_SUBJECT_REF,
None,
0,
None,
2,
)
assert tuple(actor) == (_uuid(200), _uuid(200))
assert SYSTEM_PRINCIPAL_SUBJECT_REF != str(actor[0]), (
"reserved system subject collided with the persisted actor"
)
assert ("system", SYSTEM_PRINCIPAL_SUBJECT_REF) != (
"actor",
str(actor[0]),
), "typed system namespace collided with the user-principal namespace"
elif case_alias == "derived-revision-overflow-invariant-failure-rollback":
await connection.execute(
"UPDATE campaign_execution_budgets SET revision=?,"
"latest_operation_base_revision=? "
"WHERE campaign_id=? AND budget_kind='noise'",
(MAX_I53, MAX_I53 - 1, _uuid(201)),
)
await connection.commit()
await _sqlite_p1c_assert_rollback(
connection,
store,
intent,
expected_result=FixedResult.INVARIANT_FAILURE,
)
await connection.close()
connection, store, revision = await _sqlite_p1c_terminal_case(
tmp_path / "logical-overflow.db"
)
intent = _sqlite_p1c_terminal_intent(revision)
await connection.execute(
"UPDATE logical_executions SET revision=? WHERE id=?",
(MAX_I53, _uuid(208)),
)
await connection.commit()
await _sqlite_p1c_assert_rollback(
connection,
store,
intent,
expected_result=FixedResult.INVARIANT_FAILURE,
)
await connection.close()
connection, store, revision = await _sqlite_p1c_terminal_case(
tmp_path / "actual-max.db"
)
await connection.execute(
"UPDATE campaign_execution_budgets SET capacity_units=?,reserved_units=? "
"WHERE campaign_id=? AND budget_kind='noise'",
(MAX_I53, MAX_I53, _uuid(201)),
)
await connection.execute(
"UPDATE campaign_execution_budget_ledger SET reservation_units=? "
"WHERE attempt_id=? AND budget_kind='noise'",
(MAX_I53, _uuid(210)),
)
await connection.commit()
max_actual = await store.commit_terminal_attempt_v3(
_sqlite_p1c_terminal_intent(revision, noise_actual=MAX_I53)
)
max_rows = await (
await connection.execute(
"SELECT b.reserved_units,b.consumed_units,l.consumed_units "
"FROM campaign_execution_budgets b "
"JOIN campaign_execution_budget_ledger l ON l.budget_id=b.id "
"WHERE b.campaign_id=? AND b.budget_kind='noise' AND l.attempt_id=?",
(_uuid(201), _uuid(210)),
)
).fetchone()
assert max_actual.result is FixedResult.APPLIED, "MAX_I53 actual usage was rejected"
assert tuple(max_rows) == (0, MAX_I53, MAX_I53), (
"MAX_I53 actual usage was not settled with checked arithmetic"
)
else: # pragma: no cover - tuple/dispatcher drift must be loud.
raise AssertionError(f"unhandled SQLite terminal alias: {case_alias}")
finally:
await connection.close()