| """Strict schema-v3 state codec and historical-state compatibility contracts.""" |
|
|
| from __future__ import annotations |
|
|
| from collections.abc import Callable |
|
|
| import pytest |
|
|
| from ctx.engine.benefit import ABSTENTION_CODES |
| from ctx.engine.content import AuthorizedMaterial, MaterialDescriptor, MaterialIdentity |
| from ctx.engine.installation import InstallPlanDescriptor |
| from ctx.engine.lineage import CatalogCapabilityIdentity, InstalledMaterialLineage |
| from ctx.engine.planner import CapabilityCandidate |
| from ctx.engine.planning_v3 import ( |
| BenefitAuditReference, |
| CapabilityBenefitProjection, |
| CapabilityPlanSelectionV3, |
| InstallPlanningAuthority, |
| LoadPlanningAuthority, |
| ManualPlanningAuthority, |
| PlanningAuthority, |
| ) |
| from ctx.engine.protocol import ( |
| INSTALL_ACTION_PAYLOAD_SCHEMA_V3, |
| INSTALL_RECEIPT_SCHEMA_V3, |
| MATERIAL_ACTION_PAYLOAD_SCHEMA_V3, |
| MATERIAL_RECEIPT_SCHEMA_V3, |
| HostAction, |
| ScopeRef, |
| ) |
| from ctx.engine.state import ( |
| CapabilityState, |
| CapabilityStateV3, |
| CommittedPlanV3, |
| EngineState, |
| LeaseRef, |
| PendingConsent, |
| PendingEffect, |
| PlanCapabilityV3, |
| StateValidationError, |
| ) |
|
|
|
|
| def _digest(character: str) -> str: |
| return character * 64 |
|
|
|
|
| def _scope(*, exposure_id: str = "exposure-a") -> ScopeRef: |
| return ScopeRef( |
| tenant_id="tenant-a", |
| workspace_id="workspace-a", |
| repository_id="repo-a", |
| session_id="session-a", |
| exposure_id=exposure_id, |
| host_context_id="codex-a", |
| ) |
|
|
|
|
| def _lease(index: int = 1) -> LeaseRef: |
| return LeaseRef( |
| lease_id=f"lease-{index}", |
| owner_id=f"owner-{index}", |
| exposure_id="exposure-a", |
| ) |
|
|
|
|
| def _catalog_identity(name: str = "python-debugger") -> CatalogCapabilityIdentity: |
| return CatalogCapabilityIdentity.create( |
| capability_id=f"skill:{name}", |
| kind="skill", |
| catalog_namespace_digest=_digest("1"), |
| ) |
|
|
|
|
| def _material_identity(name: str = "python-debugger") -> MaterialIdentity: |
| return MaterialIdentity.create( |
| capability_id=f"skill:{name}", |
| kind="skill", |
| content_sha256=_digest("2"), |
| content_bytes=120, |
| ) |
|
|
|
|
| def _catalog_material(name: str = "python-debugger") -> AuthorizedMaterial: |
| identity = _material_identity(name) |
| descriptor = MaterialDescriptor.create( |
| capability_id=identity.capability_id, |
| kind=identity.kind, |
| actionability="load", |
| content_sha256=identity.content_sha256, |
| content_bytes=identity.content_bytes, |
| estimated_tokens=30, |
| provenance_digest=_digest("3"), |
| material_identity_digest=identity.identity_digest, |
| ) |
| return AuthorizedMaterial.from_catalog( |
| catalog_identity_digest=_catalog_identity(name).identity_digest, |
| descriptor=descriptor, |
| ) |
|
|
|
|
| def _install_descriptor(name: str = "python-debugger") -> InstallPlanDescriptor: |
| return InstallPlanDescriptor.create( |
| capability_id=f"skill:{name}", |
| kind="skill", |
| installer_id="ctx-install-actuator-v1", |
| plan_digest=_digest("4"), |
| provenance_digest=_digest("5"), |
| result_material_identity_digest=_material_identity(name).identity_digest, |
| ) |
|
|
|
|
| def _installed_material(name: str = "python-debugger") -> AuthorizedMaterial: |
| lineage = InstalledMaterialLineage.create( |
| capability_id=f"skill:{name}", |
| kind="skill", |
| catalog_identity_digest=_catalog_identity(name).identity_digest, |
| material_identity_digest=_material_identity(name).identity_digest, |
| origin_install_descriptor_digest=_install_descriptor(name).descriptor_digest, |
| install_action_content_digest=_digest("6"), |
| install_receipt_content_digest=_digest("7"), |
| ) |
| return AuthorizedMaterial.from_installed(lineage) |
|
|
|
|
| def _presentation(name: str, actionability: str) -> CapabilityCandidate: |
| install = _install_descriptor(name) if actionability == "install" else None |
| return CapabilityCandidate( |
| capability_id=f"skill:{name}", |
| kind="skill", |
| name=name, |
| source_digest=_digest("8"), |
| normalized_score_ppm=800_000, |
| matching_signals=("python",), |
| reason_codes=("relevant",), |
| actionability=actionability, |
| install_descriptor_digest=None if install is None else install.descriptor_digest, |
| install_plan_digest=None if install is None else install.plan_digest, |
| ) |
|
|
|
|
| def _plan_capability( |
| actionability: str = "load", |
| *, |
| name: str = "python-debugger", |
| ) -> PlanCapabilityV3: |
| authority: PlanningAuthority |
| if actionability == "load": |
| authority = LoadPlanningAuthority(material=_catalog_material(name)) |
| elif actionability == "install": |
| authority = InstallPlanningAuthority( |
| descriptor=_install_descriptor(name), |
| result_material=_material_identity(name), |
| ) |
| else: |
| authority = ManualPlanningAuthority() |
| tier = "advisory" if actionability == "manual" else "executable" |
| return PlanCapabilityV3( |
| selection=CapabilityPlanSelectionV3( |
| presentation=_presentation(name, actionability), |
| catalog_identity=_catalog_identity(name), |
| benefit=CapabilityBenefitProjection( |
| tier=tier, |
| individual_net_benefit_u=100, |
| marginal_net_benefit_u=50, |
| ), |
| authority=authority, |
| ) |
| ) |
|
|
|
|
| def _audit( |
| *, |
| requested_limit: int = 5, |
| candidate_pool_count: int = 1, |
| search_evaluation_count: int = 5, |
| ) -> BenefitAuditReference: |
| return BenefitAuditReference( |
| result_schema_id="ctx.benefit-selection-result-v1", |
| result_digest=_digest("a"), |
| policy_schema_id="ctx.net-benefit-policy-v3", |
| policy_digest=_digest("b"), |
| selection_algorithm_id="ctx.greedy-bounded-subset-exchange-v1", |
| calibration_digest=_digest("c"), |
| requested_limit=requested_limit, |
| candidate_pool_count=candidate_pool_count, |
| search_evaluation_count=search_evaluation_count, |
| ) |
|
|
|
|
| def _committed_plan(*rows: PlanCapabilityV3) -> CommittedPlanV3: |
| return CommittedPlanV3( |
| plan_id="plan-a", |
| catalog_snapshot_id=_digest("d"), |
| decision_digest=_digest("e"), |
| status="ready", |
| abstention_code=None, |
| benefit_audit=_audit(candidate_pool_count=max(1, len(rows))), |
| capabilities=rows, |
| ) |
|
|
|
|
| def _capability_state( |
| selection: PlanCapabilityV3, |
| *, |
| installation: str, |
| current_authorized_material: AuthorizedMaterial | None, |
| active: bool = False, |
| rollback_held: bool = False, |
| leases: tuple[LeaseRef, ...] | None = None, |
| plan_id: str = "plan-a", |
| catalog_snapshot_id: str | None = None, |
| ) -> CapabilityStateV3: |
| return CapabilityStateV3( |
| selection=selection, |
| material_identity=_material_identity(selection.name), |
| current_authorized_material=current_authorized_material, |
| installation=installation, |
| plan_id=plan_id, |
| catalog_snapshot_id=(_digest("d") if catalog_snapshot_id is None else catalog_snapshot_id), |
| leases=(_lease(),) if leases is None else leases, |
| activation="active" if active else "inactive", |
| activation_lease_id="lease-1" if active else None, |
| rollback_held=rollback_held, |
| rollback_owner_id="replacement-owner" if rollback_held else None, |
| ) |
|
|
|
|
| def _state( |
| plan: CommittedPlanV3, |
| *capabilities: CapabilityStateV3, |
| pending_effects: tuple[PendingEffect, ...] = (), |
| pending_consents: tuple[PendingConsent, ...] = (), |
| last_manual_bundle: tuple[str, ...] = (), |
| rollback_requested_capability_ids: tuple[str, ...] = (), |
| blocked_install_descriptor_digests: tuple[str, ...] = (), |
| ) -> EngineState: |
| return EngineState( |
| revision=6, |
| scope=_scope(), |
| host_level="managing", |
| host_descriptor_digest=_digest("f"), |
| capabilities=capabilities, |
| pending_effects=pending_effects, |
| pending_consents=pending_consents, |
| committed_plan=plan, |
| last_manual_bundle=last_manual_bundle, |
| rollback_requested_capability_ids=rollback_requested_capability_ids, |
| blocked_install_descriptor_digests=blocked_install_descriptor_digests, |
| install_policy_snapshot_digest=_digest("9"), |
| _contract_version=3, |
| ) |
|
|
|
|
| def _install_action(capability: CapabilityStateV3) -> HostAction: |
| authority = capability.selection.authority |
| assert isinstance(authority, InstallPlanningAuthority) |
| return HostAction( |
| action_id="install-1", |
| kind="InstallCapability", |
| scope=_scope(), |
| precondition_revision=6, |
| entity_id=capability.capability_id, |
| source_digest=capability.source_digest, |
| plan_id=capability.plan_id, |
| catalog_snapshot_id=capability.catalog_snapshot_id, |
| consent_id="consent-1", |
| required_host_feature="installation", |
| payload={ |
| "schema": INSTALL_ACTION_PAYLOAD_SCHEMA_V3, |
| "capability_kind": capability.kind, |
| "catalog_identity": capability.catalog_identity.to_dict(), |
| "result_material": capability.material_identity.to_dict(), |
| "install_plan_descriptor": authority.descriptor.to_dict(), |
| "installer_digest": _digest("0"), |
| "policy_snapshot_digest": _digest("9"), |
| }, |
| verification={ |
| "receipt_required": True, |
| "expected_state": "installed", |
| "receipt_schema": INSTALL_RECEIPT_SCHEMA_V3, |
| }, |
| rollback={ |
| "kind": "UninstallCapability", |
| "installer_id": authority.descriptor.installer_id, |
| }, |
| ) |
|
|
|
|
| def _material_action( |
| capability: CapabilityStateV3, |
| *, |
| kind: str = "ActivateCapability", |
| action_id: str = "activate-1", |
| lease_id: str = "lease-1", |
| exposure_id: str = "exposure-a", |
| ) -> HostAction: |
| assert capability.current_authorized_material is not None |
| expected_state = { |
| "ActivateCapability": "active", |
| "PrepareExposure": "prepared", |
| "DeactivateCapability": "inactive", |
| }[kind] |
| rollback = { |
| "ActivateCapability": {"kind": "DeactivateCapability"}, |
| "PrepareExposure": { |
| "kind": "cleanup-prepared-exposure", |
| "exposure_id": exposure_id, |
| }, |
| "DeactivateCapability": { |
| "kind": "ActivateCapability", |
| "source_digest": capability.source_digest, |
| }, |
| }[kind] |
| return HostAction( |
| action_id=action_id, |
| kind=kind, |
| scope=_scope(exposure_id=exposure_id), |
| precondition_revision=6, |
| entity_id=capability.capability_id, |
| source_digest=capability.source_digest, |
| plan_id=capability.plan_id, |
| catalog_snapshot_id=capability.catalog_snapshot_id, |
| lease_id=lease_id, |
| expires_at="2026-08-02T12:00:00Z", |
| required_host_feature="activation", |
| payload={ |
| "schema": MATERIAL_ACTION_PAYLOAD_SCHEMA_V3, |
| "capability_kind": capability.kind, |
| "catalog_identity": capability.catalog_identity.to_dict(), |
| "material_identity": capability.material_identity.to_dict(), |
| "authorized_material": capability.current_authorized_material.to_dict(), |
| }, |
| verification={ |
| "receipt_required": True, |
| "expected_state": expected_state, |
| "receipt_schema": MATERIAL_RECEIPT_SCHEMA_V3, |
| }, |
| rollback=rollback, |
| ) |
|
|
|
|
| def test_v3_load_state_round_trips_exact_plan_row_material_and_pending_action() -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ) |
| pending = PendingEffect(action=_material_action(capability), effect="activate") |
| state = _state(_committed_plan(row), capability, pending_effects=(pending,)) |
|
|
| encoded = state.to_json() |
| decoded = EngineState.from_json(encoded) |
|
|
| assert decoded == state |
| assert decoded.to_json() == encoded |
| assert decoded.to_dict()["state_schema"] == "ctx.engine-state-v3" |
| decoded_capability = decoded.capabilities[0] |
| assert isinstance(decoded_capability, CapabilityStateV3) |
| assert decoded_capability.selection == row |
| assert decoded_capability.current_authorized_material == _catalog_material() |
| assert decoded_capability.material_identity == _material_identity() |
|
|
|
|
| def test_v3_absent_install_decision_and_receipt_promoted_material_round_trip() -> None: |
| row = _plan_capability("install") |
| absent = _capability_state( |
| row, |
| installation="absent", |
| current_authorized_material=None, |
| ) |
| promoted = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_installed_material(), |
| ) |
|
|
| for capability in (absent, promoted): |
| state = _state(_committed_plan(row), capability) |
| decoded = EngineState.from_json(state.to_json()) |
| assert decoded == state |
|
|
| assert absent.installation == "absent" |
| assert absent.actionability == "install" |
| assert promoted.installation == "installed" |
| assert promoted.actionability == "install" |
| assert promoted.installed_lineage == _installed_material().installed_material_lineage |
|
|
|
|
| def test_v3_pending_install_and_consent_persist_the_exact_precomputed_action() -> None: |
| row = _plan_capability("install") |
| capability = _capability_state( |
| row, |
| installation="absent", |
| current_authorized_material=None, |
| ) |
| action = _install_action(capability) |
|
|
| awaiting_receipt = _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=action, effect="install"),), |
| ) |
| awaiting_consent = _state( |
| _committed_plan(row), |
| capability, |
| pending_consents=(PendingConsent(consent_id="consent-1", install_action=action),), |
| ) |
|
|
| for state in (awaiting_receipt, awaiting_consent): |
| assert EngineState.from_json(state.to_json()) == state |
|
|
|
|
| def test_v3_pending_install_rejects_another_valid_descriptor_and_material() -> None: |
| row = _plan_capability("install") |
| capability = _capability_state( |
| row, |
| installation="absent", |
| current_authorized_material=None, |
| ) |
| action = _install_action(capability) |
| other_material = MaterialIdentity.create( |
| capability_id=capability.capability_id, |
| kind=capability.kind, |
| content_sha256=_digest("a"), |
| content_bytes=121, |
| ) |
| other_descriptor = InstallPlanDescriptor.create( |
| capability_id=capability.capability_id, |
| kind=capability.kind, |
| installer_id="ctx-install-actuator-v1", |
| plan_digest=_digest("b"), |
| provenance_digest=_digest("c"), |
| result_material_identity_digest=other_material.identity_digest, |
| ) |
| values = action.to_dict() |
| values["payload"]["result_material"] = other_material.to_dict() |
| values["payload"]["install_plan_descriptor"] = other_descriptor.to_dict() |
| substituted = HostAction.from_dict(values) |
|
|
| with pytest.raises(StateValidationError, match="install.*authority|runtime capability"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=substituted, effect="install"),), |
| ) |
|
|
|
|
| def test_manual_selection_is_committed_but_never_creates_lifecycle_state() -> None: |
| manual = _plan_capability("manual", name="manual-advice") |
| state = _state( |
| _committed_plan(manual), |
| last_manual_bundle=(manual.capability_id,), |
| ) |
|
|
| assert EngineState.from_json(state.to_json()) == state |
| assert state.capabilities == () |
|
|
| with pytest.raises(StateValidationError, match="manual"): |
| _capability_state( |
| manual, |
| installation="installed", |
| current_authorized_material=_catalog_material("manual-advice"), |
| ) |
|
|
|
|
| @pytest.mark.parametrize( |
| ("actionability", "installation", "current_authorized_material", "match"), |
| [ |
| ("install", "absent", None, "material_identity"), |
| ("load", "installed", None, "current_authorized_material"), |
| ], |
| ) |
| def test_v3_capability_rejects_install_without_material_or_load_without_authority( |
| actionability: str, |
| installation: str, |
| current_authorized_material: AuthorizedMaterial | None, |
| match: str, |
| ) -> None: |
| row = _plan_capability(actionability) |
| values = { |
| "selection": row, |
| "material_identity": None if actionability == "install" else _material_identity(), |
| "current_authorized_material": current_authorized_material, |
| "installation": installation, |
| "plan_id": "plan-a", |
| "catalog_snapshot_id": _digest("d"), |
| "leases": (_lease(),), |
| } |
| with pytest.raises(StateValidationError, match=match): |
| CapabilityStateV3(**values) |
|
|
|
|
| def test_v3_rejects_substituted_catalog_material_benefit_and_lineage() -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ) |
| state = _state(_committed_plan(row), capability) |
|
|
| invalid = state.to_dict() |
| invalid["committed_plan"]["capabilities"][0]["benefit"]["marginal_net_benefit_u"] = 0 |
| with pytest.raises(StateValidationError, match="benefit|marginal"): |
| EngineState.from_dict(invalid) |
|
|
| invalid = state.to_dict() |
| invalid["capabilities"][0]["material_identity"]["content_bytes"] = 121 |
| with pytest.raises(StateValidationError, match="material_identity"): |
| EngineState.from_dict(invalid) |
|
|
| install = _plan_capability("install") |
| promoted = _state( |
| _committed_plan(install), |
| _capability_state( |
| install, |
| installation="installed", |
| current_authorized_material=_installed_material(), |
| ), |
| ) |
| invalid = promoted.to_dict() |
| invalid["capabilities"][0]["current_authorized_material"]["installed_material_lineage"][ |
| "lineage_digest" |
| ] = _digest("0") |
| with pytest.raises(StateValidationError, match="lineage"): |
| EngineState.from_dict(invalid) |
|
|
| invalid = state.to_dict() |
| invalid["committed_plan"]["capabilities"][0]["catalog_identity"]["catalog_namespace_digest"] = ( |
| _digest("0") |
| ) |
| with pytest.raises(StateValidationError, match="catalog identity|identity_digest"): |
| EngineState.from_dict(invalid) |
|
|
|
|
| def test_v3_rejects_more_than_five_rows_unknown_fields_and_state_plan_mismatch() -> None: |
| rows = tuple(_plan_capability("load", name=f"cap-{index}") for index in range(6)) |
| with pytest.raises(StateValidationError, match="five"): |
| _committed_plan(*rows) |
|
|
| row = _plan_capability("load") |
| state = _state( |
| _committed_plan(row), |
| _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ), |
| ) |
| invalid = state.to_dict() |
| invalid["surprise"] = True |
| with pytest.raises(StateValidationError, match="unknown"): |
| EngineState.from_dict(invalid) |
|
|
| invalid = state.to_dict() |
| invalid["capabilities"][0]["selection"]["capability_id"] = "skill:other" |
| with pytest.raises(StateValidationError, match="selection|committed|identity"): |
| EngineState.from_dict(invalid) |
|
|
|
|
| def test_v3_rejects_the_untagged_unreleased_draft_projection() -> None: |
| row = _plan_capability("load") |
| state = _state( |
| _committed_plan(row), |
| _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ), |
| ) |
| untagged = state.to_dict() |
| untagged.pop("state_schema") |
|
|
| with pytest.raises(StateValidationError, match="complete supported schema"): |
| EngineState.from_dict(untagged) |
|
|
|
|
| def test_v3_abstained_plan_persists_exact_nine_field_audit_without_rows() -> None: |
| for code in ABSTENTION_CODES: |
| plan = CommittedPlanV3( |
| plan_id="plan-a", |
| catalog_snapshot_id=_digest("d"), |
| decision_digest=_digest("e"), |
| status="abstained", |
| abstention_code=code, |
| benefit_audit=_audit( |
| requested_limit=0 if code == "limit-zero" else 5, |
| search_evaluation_count=(5 if code == "below-net-benefit" else 0), |
| ), |
| capabilities=(), |
| ) |
| decoded = EngineState.from_json(_state(plan).to_json()) |
| assert decoded.committed_plan == plan |
| assert set(plan.to_dict()["benefit_audit"]) == { |
| "result_schema_id", |
| "result_digest", |
| "policy_schema_id", |
| "policy_digest", |
| "selection_algorithm_id", |
| "calibration_digest", |
| "requested_limit", |
| "candidate_pool_count", |
| "search_evaluation_count", |
| } |
|
|
|
|
| @pytest.mark.parametrize( |
| ("code", "audit"), |
| [ |
| ("limit-zero", _audit(requested_limit=1, search_evaluation_count=0)), |
| ( |
| "below-net-benefit", |
| _audit(candidate_pool_count=0, search_evaluation_count=0), |
| ), |
| ("no-feasible-capability", _audit(search_evaluation_count=1)), |
| ], |
| ) |
| def test_v3_abstention_rejects_impossible_compact_audit_semantics( |
| code: str, |
| audit: BenefitAuditReference, |
| ) -> None: |
| with pytest.raises(StateValidationError, match="audit"): |
| CommittedPlanV3( |
| plan_id="plan-a", |
| catalog_snapshot_id=_digest("d"), |
| decision_digest=_digest("e"), |
| status="abstained", |
| abstention_code=code, |
| benefit_audit=audit, |
| capabilities=(), |
| ) |
|
|
|
|
| def test_historical_state_bytes_remain_untagged_and_stable() -> None: |
| capability = CapabilityState( |
| capability_id="skill:legacy", |
| source_digest="legacy-source", |
| plan_id="legacy-plan", |
| catalog_snapshot_id="legacy-catalog", |
| leases=(_lease(),), |
| ) |
| state = EngineState( |
| revision=1, |
| scope=_scope(), |
| host_level="query-only", |
| host_descriptor_digest="legacy-host", |
| capabilities=(capability,), |
| ) |
|
|
| encoded = state.to_json() |
| assert "state_schema" not in encoded |
| assert "committed_plan" not in encoded |
| assert EngineState.from_json(encoded).to_json() == encoded |
|
|
|
|
| def test_v3_pending_action_must_exactly_match_runtime_material() -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ) |
| action = _material_action(capability) |
| values = action.to_dict() |
| values["payload"]["authorized_material"] = _installed_material().to_dict() |
| substituted = HostAction.from_dict(values) |
|
|
| with pytest.raises(StateValidationError, match="pending action.*material|authorized"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=substituted, effect="activate"),), |
| ) |
|
|
|
|
| @pytest.mark.parametrize( |
| "action", |
| [ |
| lambda capability: _material_action(capability, lease_id="unowned-lease"), |
| lambda capability: _material_action(capability, exposure_id="other-exposure"), |
| ], |
| ) |
| def test_v3_activation_requires_the_exact_current_lease_and_exposure( |
| action: Callable[[CapabilityStateV3], HostAction], |
| ) -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ) |
| pending_action = action(capability) |
|
|
| with pytest.raises(StateValidationError, match="activation.*lease"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=pending_action, effect="activate"),), |
| ) |
|
|
|
|
| def test_v3_prepare_and_deactivate_require_effect_specific_lease_authority() -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| active=True, |
| ) |
| prepare = _material_action( |
| capability, |
| kind="PrepareExposure", |
| exposure_id="other-exposure", |
| ) |
| deactivate = _material_action( |
| capability, |
| kind="DeactivateCapability", |
| action_id="deactivate-1", |
| lease_id="not-the-activation-lease", |
| ) |
|
|
| with pytest.raises(StateValidationError, match="preparation.*lease|exact exposure"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=prepare, effect="prepare"),), |
| ) |
| with pytest.raises(StateValidationError, match="deactivation lease"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=deactivate, effect="deactivate"),), |
| ) |
|
|
|
|
| def test_v3_rollback_activation_requires_and_accepts_exact_held_authority() -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| rollback_held=True, |
| ) |
| rollback = _material_action( |
| capability, |
| action_id="rollback-activate-1", |
| lease_id=f"rollback:{capability.capability_id}", |
| ) |
| state = _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=rollback, effect="rollback-activate"),), |
| rollback_requested_capability_ids=(capability.capability_id,), |
| ) |
|
|
| assert EngineState.from_json(state.to_json()) == state |
|
|
| with pytest.raises(StateValidationError, match="held rollback authority"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=( |
| PendingEffect( |
| action=_material_action( |
| capability, |
| action_id="rollback-wrong-lease", |
| lease_id="rollback:wrong", |
| ), |
| effect="rollback-activate", |
| ), |
| ), |
| rollback_requested_capability_ids=(capability.capability_id,), |
| ) |
|
|
|
|
| def test_v3_rejects_multiple_pending_operations_for_one_capability() -> None: |
| row = _plan_capability("load") |
| capability = _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ) |
| first = _material_action(capability, action_id="activate-1") |
| second = _material_action(capability, action_id="activate-2") |
|
|
| with pytest.raises(StateValidationError, match="multiple pending lifecycle"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=( |
| PendingEffect(action=first, effect="activate"), |
| PendingEffect(action=second, effect="activate"), |
| ), |
| ) |
|
|
|
|
| def test_v3_rejects_install_waiting_for_consent_and_receipt_under_distinct_ids() -> None: |
| row = _plan_capability("install") |
| capability = _capability_state( |
| row, |
| installation="absent", |
| current_authorized_material=None, |
| ) |
| receipt_action = _install_action(capability) |
| consent_values = receipt_action.to_dict() |
| consent_values["action_id"] = "install-2" |
| consent_values["consent_id"] = "consent-2" |
| consent_action = HostAction.from_dict(consent_values) |
|
|
| with pytest.raises(StateValidationError, match="consent and a pending effect"): |
| _state( |
| _committed_plan(row), |
| capability, |
| pending_effects=(PendingEffect(action=receipt_action, effect="install"),), |
| pending_consents=( |
| PendingConsent(consent_id="consent-2", install_action=consent_action), |
| ), |
| ) |
|
|
|
|
| def test_v3_row_codec_rejects_unknown_authority_and_partial_benefit() -> None: |
| row = _plan_capability("load") |
| mapping = row.to_dict() |
| mapping["authority"]["surprise"] = True |
| with pytest.raises(StateValidationError, match="unknown"): |
| PlanCapabilityV3.from_dict(mapping) |
|
|
| mapping = row.to_dict() |
| mapping["benefit"].pop("tier") |
| with pytest.raises(StateValidationError, match="missing.*tier"): |
| PlanCapabilityV3.from_dict(mapping) |
|
|
|
|
| def test_ready_plan_allows_unleased_omitted_active_capability_to_retire() -> None: |
| current = _plan_capability("load", name="current") |
| retiring = _plan_capability("load", name="retiring") |
| capability = _capability_state( |
| retiring, |
| installation="installed", |
| current_authorized_material=_catalog_material("retiring"), |
| active=True, |
| leases=(), |
| plan_id="plan-old", |
| catalog_snapshot_id=_digest("c"), |
| ) |
| deactivation = _material_action( |
| capability, |
| kind="DeactivateCapability", |
| action_id="retire-1", |
| ) |
| state = _state( |
| _committed_plan(current), |
| capability, |
| pending_effects=(PendingEffect(action=deactivation, effect="deactivate"),), |
| ) |
|
|
| assert EngineState.from_json(state.to_json()) == state |
|
|
|
|
| def test_abstained_plan_allows_unleased_active_capability_to_cool() -> None: |
| retiring = _plan_capability("load", name="retiring") |
| capability = _capability_state( |
| retiring, |
| installation="installed", |
| current_authorized_material=_catalog_material("retiring"), |
| active=True, |
| leases=(), |
| plan_id="plan-old", |
| catalog_snapshot_id=_digest("c"), |
| ) |
| plan = CommittedPlanV3( |
| plan_id="plan-a", |
| catalog_snapshot_id=_digest("d"), |
| decision_digest=_digest("e"), |
| status="abstained", |
| abstention_code="no-feasible-capability", |
| benefit_audit=_audit(search_evaluation_count=0), |
| capabilities=(), |
| ) |
| deactivation = _material_action( |
| capability, |
| kind="DeactivateCapability", |
| action_id="cool-1", |
| ) |
| state = _state( |
| plan, |
| capability, |
| pending_effects=(PendingEffect(action=deactivation, effect="deactivate"),), |
| ) |
|
|
| assert EngineState.from_json(state.to_json()) == state |
|
|
|
|
| def test_ready_omitted_pending_install_remains_bound_to_prior_snapshot() -> None: |
| current = _plan_capability("load", name="current") |
| installing = _plan_capability("install", name="installing") |
| capability = _capability_state( |
| installing, |
| installation="absent", |
| current_authorized_material=None, |
| leases=(), |
| plan_id="plan-old", |
| catalog_snapshot_id=_digest("c"), |
| ) |
| install_action = _install_action(capability) |
| state = _state( |
| _committed_plan(current), |
| capability, |
| pending_effects=(PendingEffect(action=install_action, effect="install"),), |
| ) |
|
|
| assert EngineState.from_json(state.to_json()) == state |
| assert state.pending_effects[0].action.plan_id == "plan-old" |
|
|
|
|
| def test_degraded_plan_preserves_prior_runtime_leases_and_plan_identity() -> None: |
| prior = _plan_capability("load", name="prior") |
| capability = _capability_state( |
| prior, |
| installation="installed", |
| current_authorized_material=_catalog_material("prior"), |
| active=True, |
| plan_id="plan-old", |
| catalog_snapshot_id=_digest("c"), |
| ) |
| degraded = CommittedPlanV3( |
| plan_id="plan-a", |
| catalog_snapshot_id=_digest("d"), |
| decision_digest=_digest("e"), |
| status="degraded", |
| abstention_code="planner-failed", |
| benefit_audit=None, |
| capabilities=(), |
| ) |
| state = _state(degraded, capability) |
|
|
| assert EngineState.from_json(state.to_json()) == state |
| assert state.capabilities[0].plan_id == "plan-old" |
| assert state.capabilities[0].leases == (_lease(),) |
|
|
| with pytest.raises(StateValidationError, match="omitted.*mint"): |
| _state( |
| degraded, |
| _capability_state( |
| prior, |
| installation="installed", |
| current_authorized_material=_catalog_material("prior"), |
| active=True, |
| ), |
| ) |
|
|
|
|
| def test_omitted_runtime_cannot_claim_current_plan_identity_for_rollback() -> None: |
| current = _plan_capability("load", name="current") |
| omitted = _plan_capability("load", name="omitted") |
| capability = _capability_state( |
| omitted, |
| installation="installed", |
| current_authorized_material=_catalog_material("omitted"), |
| rollback_held=True, |
| leases=(), |
| ) |
|
|
| with pytest.raises(StateValidationError, match="omitted.*current-plan"): |
| _state( |
| _committed_plan(current), |
| capability, |
| rollback_requested_capability_ids=(capability.capability_id,), |
| ) |
|
|
|
|
| def test_pending_activation_rejects_active_or_self_rollback_target() -> None: |
| new_row = _plan_capability("load", name="new") |
| old_row = _plan_capability("load", name="old") |
| new = _capability_state( |
| new_row, |
| installation="installed", |
| current_authorized_material=_catalog_material("new"), |
| ) |
| old = _capability_state( |
| old_row, |
| installation="installed", |
| current_authorized_material=_catalog_material("old"), |
| active=True, |
| rollback_held=True, |
| leases=(), |
| ) |
| activation = _material_action(new, action_id="activate-new") |
|
|
| with pytest.raises(StateValidationError, match="invalid rollback"): |
| _state( |
| _committed_plan(new_row, old_row), |
| new, |
| old, |
| pending_effects=( |
| PendingEffect( |
| action=activation, |
| effect="activate", |
| rollback_capability_id=old.capability_id, |
| ), |
| ), |
| ) |
| with pytest.raises(StateValidationError, match="invalid rollback"): |
| self_target = _capability_state( |
| new_row, |
| installation="installed", |
| current_authorized_material=_catalog_material("new"), |
| rollback_held=True, |
| ) |
| _state( |
| _committed_plan(new_row), |
| self_target, |
| pending_effects=( |
| PendingEffect( |
| action=activation, |
| effect="activate", |
| rollback_capability_id=self_target.capability_id, |
| ), |
| ), |
| ) |
|
|
|
|
| def test_blocked_install_descriptor_requires_current_or_retained_authority() -> None: |
| load = _plan_capability("load") |
| loaded = _capability_state( |
| load, |
| installation="installed", |
| current_authorized_material=_catalog_material(), |
| ) |
| with pytest.raises(StateValidationError, match="blocked install descriptor"): |
| _state( |
| _committed_plan(load), |
| loaded, |
| blocked_install_descriptor_digests=(_digest("0"),), |
| ) |
|
|
| install = _plan_capability("install", name="installing") |
| installing = _capability_state( |
| install, |
| installation="absent", |
| current_authorized_material=None, |
| ) |
| descriptor_digest = _install_descriptor("installing").descriptor_digest |
| state = _state( |
| _committed_plan(install), |
| installing, |
| blocked_install_descriptor_digests=(descriptor_digest,), |
| ) |
| assert EngineState.from_json(state.to_json()) == state |
|
|
|
|
| def test_ready_plan_rejects_leased_unselected_runtime_capability() -> None: |
| selected = _plan_capability("load") |
| other = _plan_capability("load", name="other") |
| capability = _capability_state( |
| other, |
| installation="installed", |
| current_authorized_material=_catalog_material("other"), |
| plan_id="plan-old", |
| catalog_snapshot_id=_digest("c"), |
| ) |
|
|
| with pytest.raises(StateValidationError, match="unselected.*leases"): |
| _state(_committed_plan(selected), capability) |
|
|
|
|
| def test_inactive_unselected_capability_cannot_survive_persisted_ready_state() -> None: |
| selected = _plan_capability("load") |
| other = _plan_capability("load", name="other") |
| capability = _capability_state( |
| other, |
| installation="installed", |
| current_authorized_material=_catalog_material("other"), |
| leases=(), |
| plan_id="plan-old", |
| catalog_snapshot_id=_digest("c"), |
| ) |
| state = _state(_committed_plan(selected), capability) |
|
|
| with pytest.raises(StateValidationError, match="inactive unselected"): |
| state.to_json() |
|
|
|
|
| def test_promotion_rejects_installed_lineage_from_another_descriptor() -> None: |
| row = _plan_capability("install") |
| other_descriptor = _install_descriptor("other") |
| material = _material_identity() |
| wrong_lineage = InstalledMaterialLineage.create( |
| capability_id=material.capability_id, |
| kind=material.kind, |
| catalog_identity_digest=_catalog_identity().identity_digest, |
| material_identity_digest=material.identity_digest, |
| origin_install_descriptor_digest=other_descriptor.descriptor_digest, |
| install_action_content_digest=_digest("6"), |
| install_receipt_content_digest=_digest("7"), |
| ) |
|
|
| with pytest.raises(StateValidationError, match="descriptor|promotion"): |
| _capability_state( |
| row, |
| installation="installed", |
| current_authorized_material=AuthorizedMaterial.from_installed(wrong_lineage), |
| ) |
|
|
