| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import traceback |
| from collections.abc import Iterator, Sequence |
| from dataclasses import dataclass, field, replace |
| from pathlib import Path |
| from typing import cast, overload |
|
|
| import pytest |
|
|
| from ctx.engine.benefit import NetBenefitPolicy |
| from ctx.engine.planner import CapabilityCandidate, PlannerValidationError, WorkObservation |
| from ctx.runtime.benefit_closure import ( |
| BenefitClosureError, |
| EligibleCatalogClaim, |
| QueryCapabilityEligibility, |
| QueryHostPolicyAuthority, |
| ReviewedBenefitAuthorities, |
| ReviewedBenefitProfiles, |
| catalog_candidate_entry_claim_digest, |
| eligible_catalog_claim_digest, |
| load_reviewed_benefit_profiles, |
| load_reviewed_benefit_profiles_bytes, |
| prepare_query_benefit_closure, |
| ) |
| from ctx.runtime.planning_v3 import normalize_candidate_pool |
|
|
|
|
| def _digest(value: str) -> str: |
| return hashlib.sha256(value.encode("utf-8")).hexdigest() |
|
|
|
|
| def _canonical_bytes(value: object) -> bytes: |
| return json.dumps( |
| value, |
| ensure_ascii=True, |
| allow_nan=False, |
| separators=(",", ":"), |
| sort_keys=True, |
| ).encode("utf-8") |
|
|
|
|
| CALIBRATION_DIGEST = _digest("reviewed-calibration") |
| CATALOG_SNAPSHOT_DIGEST = _digest("eligible-catalog-snapshot") |
| ELIGIBILITY_DIGEST = _digest("eligible-catalog-index") |
| HOST_POLICY_DIGEST = _digest("query-host-policy") |
| POLICY = NetBenefitPolicy(calibration_digest=CALIBRATION_DIGEST, minimum_relevance_ppm=1) |
|
|
|
|
| def _profile_record( |
| *, |
| capability_id: str = "skill:ctx-python-testing", |
| actionability: str = "manual", |
| entry_claim_digest: str | None = None, |
| minimum_matching_signals: int = 2, |
| minimum_non_language_matching_signals: int = 1, |
| allowed_signals: list[str] | None = None, |
| ) -> dict[str, object]: |
| kind, name = capability_id.split(":", 1) |
| return { |
| "actionability": actionability, |
| "capability_id": capability_id, |
| "catalog_entry_claim_digest": entry_claim_digest |
| or catalog_candidate_entry_claim_digest( |
| _candidate(capability_id=capability_id, actionability=actionability) |
| ), |
| "complements": [], |
| "conflicts": [], |
| "costs": { |
| "approval_prompts": 0, |
| "child_agent_units": 0, |
| "context_tokens": 180, |
| "credential_burden_units": 0, |
| "permission_burden_units": 0, |
| "process_units": 0, |
| "runtime_millis": 0, |
| "tool_schema_tokens": 0, |
| }, |
| "coverage_keys": [f"coverage-{name}"], |
| "expected_task_benefit_ppm": 500_000, |
| "kind": kind, |
| "match_policy": { |
| "allowed_equivalence_keys": [], |
| "allowed_reason_codes": ["graph-match", "signal-match"], |
| "allowed_signals": allowed_signals or ["python", "testing"], |
| "minimum_matching_signals": minimum_matching_signals, |
| "minimum_non_language_matching_signals": minimum_non_language_matching_signals, |
| "required_any_signals": ["testing"], |
| }, |
| "maximum_relevance_ppm": 700_000, |
| "name": name, |
| "profile_id": f"profile-{name}", |
| "review_basis_digest": _digest(f"review-basis:{capability_id}"), |
| "security_approved": True, |
| "source_trusted": True, |
| "trust_ppm": 900_000, |
| } |
|
|
|
|
| def _manifest( |
| *profiles: dict[str, object], |
| authority_id: str = "ctx-release", |
| authority_kind: str = "ctx-release", |
| catalog_layer_kind: str = "ctx", |
| sequence: int = 1, |
| ) -> dict[str, object]: |
| ordered = sorted( |
| profiles or (_profile_record(),), |
| key=lambda value: ( |
| str(value["capability_id"]), |
| str(value["actionability"]), |
| str(value["profile_id"]), |
| ), |
| ) |
| return { |
| "authority": { |
| "authority_digest": _digest(f"benefit-authority:{authority_id}:{sequence}"), |
| "authority_id": authority_id, |
| "authority_kind": authority_kind, |
| "catalog_layer_kind": catalog_layer_kind, |
| "sequence": sequence, |
| }, |
| "bindings": { |
| "calibration_digest": CALIBRATION_DIGEST, |
| "candidate_projection_version": "ctx.catalog-entry.graph-v4", |
| "catalog_artifact_sha256": _digest(f"eligible-catalog-artifact:{authority_id}"), |
| "catalog_namespace_digest": _digest(f"catalog-namespace:{authority_id}"), |
| "catalog_provenance_digest": _digest(f"catalog-provenance:{authority_id}"), |
| "catalog_retrieval_snapshot_digest": _digest(f"catalog-retrieval:{authority_id}"), |
| "installation_snapshot_digest": None, |
| "material_snapshot_digest": None, |
| "policy_digest": POLICY.policy_digest, |
| }, |
| "profiles": ordered, |
| "schema": "ctx.reviewed-benefit-profiles-v2", |
| } |
|
|
|
|
| def _authority( |
| *records: dict[str, object], |
| authority_id: str = "ctx-release", |
| authority_kind: str = "ctx-release", |
| catalog_layer_kind: str = "ctx", |
| sequence: int = 1, |
| ) -> ReviewedBenefitProfiles: |
| body = _canonical_bytes( |
| _manifest( |
| *records, |
| authority_id=authority_id, |
| authority_kind=authority_kind, |
| catalog_layer_kind=catalog_layer_kind, |
| sequence=sequence, |
| ) |
| ) |
| return load_reviewed_benefit_profiles_bytes(body, hashlib.sha256(body).hexdigest()) |
|
|
|
|
| def _authorities(*values: ReviewedBenefitProfiles) -> ReviewedBenefitAuthorities: |
| return ReviewedBenefitAuthorities.create(values or (_authority(),)) |
|
|
|
|
| def _candidate( |
| *, |
| capability_id: str = "skill:ctx-python-testing", |
| matching_signals: tuple[str, ...] = ("python", "testing"), |
| actionability: str = "manual", |
| reason_codes: tuple[str, ...] = ("graph-match", "signal-match"), |
| ) -> CapabilityCandidate: |
| kind, name = capability_id.split(":", 1) |
| return CapabilityCandidate( |
| capability_id=capability_id, |
| kind=kind, |
| name=name, |
| source_digest=_digest(f"source:{capability_id}:{actionability}"), |
| normalized_score_ppm=700_000, |
| matching_signals=matching_signals, |
| reason_codes=reason_codes, |
| actionability=actionability, |
| install_descriptor_digest=( |
| _digest(f"install-descriptor:{capability_id}") if actionability == "install" else None |
| ), |
| install_plan_digest=( |
| _digest(f"install-plan:{capability_id}") if actionability == "install" else None |
| ), |
| ) |
|
|
|
|
| def _observation( |
| *, |
| signals: tuple[str, ...] = ("testing",), |
| languages: tuple[str, ...] = ("python",), |
| baseline: tuple[str, ...] = (), |
| rejected: tuple[str, ...] = (), |
| ) -> WorkObservation: |
| return WorkObservation( |
| signals=signals, |
| languages=languages, |
| baseline_capability_ids=baseline, |
| rejected_capability_ids=rejected, |
| requested_limit=5, |
| ) |
|
|
|
|
| @dataclass |
| class _EligibleSource: |
| candidates: object |
| claims: dict[str, EligibleCatalogClaim] |
| catalog_snapshot_digest: str |
| catalog_retrieval_snapshot_digest: str |
| catalog_namespace_digest: str |
| catalog_provenance_digest: str |
| catalog_artifact_sha256: str |
| candidate_projection_version: str |
| material_snapshot_digest: str | None |
| installation_snapshot_digest: str | None |
| profile_snapshot_digest: str |
| authority_snapshot_digest: str |
| eligibility_snapshot_digest: str |
| calibration_digest: str |
| policy_digest: str |
| close_calls: int = 0 |
| cleanup_failure: bool = False |
| retrieve_calls: int = 0 |
| claim_calls: int = 0 |
| candidate_rounds: tuple[object, ...] = () |
| claim_rounds: dict[str, tuple[EligibleCatalogClaim, ...]] = field(default_factory=dict) |
| drift_binding_on_retrieve: bool = False |
| drift_binding_on_claim: bool = False |
| explode_at: str | None = None |
| leak_cleanup_class: bool = False |
|
|
| def retrieve(self, _observation: WorkObservation) -> Sequence[CapabilityCandidate]: |
| if self.explode_at == "retrieve": |
| raise RuntimeError("/Users/alice/private-repo sk-live-secret") |
| self.retrieve_calls += 1 |
| value = ( |
| self.candidate_rounds[min(self.retrieve_calls - 1, len(self.candidate_rounds) - 1)] |
| if self.candidate_rounds |
| else self.candidates |
| ) |
| if self.drift_binding_on_retrieve: |
| self.catalog_provenance_digest = _digest("drifted-during-retrieve") |
| return cast(Sequence[CapabilityCandidate], value) |
|
|
| def entry_claim(self, presentation: CapabilityCandidate) -> EligibleCatalogClaim: |
| if self.explode_at == "claim": |
| raise RuntimeError("/Users/alice/private-repo sk-live-secret") |
| self.claim_calls += 1 |
| rounds = self.claim_rounds.get(presentation.capability_id, ()) |
| value = ( |
| rounds[min(self.claim_calls - 1, len(rounds) - 1)] |
| if rounds |
| else self.claims[presentation.capability_id] |
| ) |
| if self.drift_binding_on_claim: |
| self.catalog_provenance_digest = _digest("drifted-during-claim") |
| return value |
|
|
| def close(self) -> None: |
| self.close_calls += 1 |
| if self.leak_cleanup_class: |
| raise Alice_private_repo_sk_live_secret |
| if self.explode_at == "close": |
| raise RuntimeError("/Users/alice/private-repo sk-live-secret") |
| if self.cleanup_failure: |
| raise RuntimeError("cleanup sentinel") |
|
|
|
|
| class Alice_private_repo_sk_live_secret(RuntimeError): |
| pass |
|
|
|
|
| class _ExplodingAttributeSource: |
| def __init__(self, source: _EligibleSource, attribute: str) -> None: |
| self._source = source |
| self._attribute = attribute |
|
|
| def __getattr__(self, name: str) -> object: |
| if name == self._attribute: |
| raise RuntimeError("/Users/alice/private-repo sk-live-secret") |
| return getattr(self._source, name) |
|
|
|
|
| def _source( |
| profiles: ReviewedBenefitAuthorities, |
| *candidates: CapabilityCandidate, |
| claim_authorities: dict[str, ReviewedBenefitProfiles] | None = None, |
| ) -> _EligibleSource: |
| values = candidates or (_candidate(),) |
| authority_by_id = claim_authorities or { |
| candidate.capability_id: profiles.authorities[0] for candidate in values |
| } |
| claims = { |
| candidate.capability_id: EligibleCatalogClaim.create( |
| authority_by_id[candidate.capability_id], |
| presentation=candidate, |
| ) |
| for candidate in values |
| } |
| return _EligibleSource( |
| candidates=values, |
| claims=claims, |
| catalog_snapshot_digest=CATALOG_SNAPSHOT_DIGEST, |
| catalog_retrieval_snapshot_digest=profiles.catalog_retrieval_snapshot_digest, |
| catalog_namespace_digest=profiles.catalog_namespace_digest, |
| catalog_provenance_digest=profiles.catalog_provenance_digest, |
| catalog_artifact_sha256=profiles.catalog_artifact_sha256, |
| candidate_projection_version=profiles.candidate_projection_version, |
| material_snapshot_digest=profiles.material_snapshot_digest, |
| installation_snapshot_digest=profiles.installation_snapshot_digest, |
| profile_snapshot_digest=profiles.profile_snapshot_digest, |
| authority_snapshot_digest=profiles.authority_snapshot_digest, |
| eligibility_snapshot_digest=ELIGIBILITY_DIGEST, |
| calibration_digest=profiles.calibration_digest, |
| policy_digest=profiles.policy_digest, |
| ) |
|
|
|
|
| @dataclass |
| class _HostPolicy: |
| host_policy_snapshot_digest: str = HOST_POLICY_DIGEST |
| available: bool = True |
| permissions_allowed: bool = True |
| credentials_available: bool = True |
| return_none: bool = False |
| drift: bool = False |
| claim_digest_override: str | None = None |
| explode: bool = False |
| calls: int = 0 |
|
|
| def eligibility_for( |
| self, |
| presentation: CapabilityCandidate, |
| claim: EligibleCatalogClaim, |
| ) -> QueryCapabilityEligibility | None: |
| if self.explode: |
| raise RuntimeError("/Users/alice/private-repo sk-live-secret") |
| self.calls += 1 |
| if self.return_none: |
| return None |
| result = QueryCapabilityEligibility( |
| presentation_digest=_presentation_digest(presentation), |
| catalog_entry_claim_digest=claim.catalog_entry_claim_digest, |
| catalog_claim_digest=( |
| self.claim_digest_override or eligible_catalog_claim_digest(claim) |
| ), |
| available=self.available, |
| permissions_allowed=self.permissions_allowed, |
| credentials_available=self.credentials_available, |
| ) |
| if self.drift: |
| self.host_policy_snapshot_digest = _digest("drifted-host-policy") |
| return result |
|
|
|
|
| def _presentation_digest(candidate: CapabilityCandidate) -> str: |
| from ctx.runtime.authenticated_benefit import capability_presentation_digest |
|
|
| return capability_presentation_digest(candidate) |
|
|
|
|
| def _prepare( |
| profiles: ReviewedBenefitAuthorities, |
| source: _EligibleSource, |
| *, |
| observation: WorkObservation | object | None = None, |
| host_policy: _HostPolicy | None = None, |
| ): |
| return prepare_query_benefit_closure( |
| source=source, |
| observation=observation if observation is not None else _observation(), |
| profiles=profiles, |
| policy=POLICY, |
| host_policy=host_policy or _HostPolicy(), |
| ) |
|
|
|
|
| def test_reviewed_profiles_load_from_exact_file_and_frozen_bytes(tmp_path: Path) -> None: |
| body = _canonical_bytes(_manifest()) |
| expected_sha256 = hashlib.sha256(body).hexdigest() |
| path = tmp_path / "reviewed-benefit-profiles.json" |
| path.write_bytes(body) |
| path.chmod(0o444) |
|
|
| from_path = load_reviewed_benefit_profiles(path, expected_sha256) |
| from_bytes = load_reviewed_benefit_profiles_bytes(body, expected_sha256) |
|
|
| assert from_path == from_bytes |
| assert from_path.profile_snapshot_digest == expected_sha256 |
| assert from_path.policy_digest == POLICY.policy_digest |
| assert len(from_path.profiles) == 1 |
|
|
|
|
| @pytest.mark.parametrize( |
| "mutation", |
| ["unknown-root", "wrong-layer", "duplicate-profile", "unreviewed-signal"], |
| ) |
| def test_reviewed_profiles_reject_non_closed_cross_authority_or_ambiguous_input( |
| mutation: str, |
| ) -> None: |
| manifest = _manifest() |
| if mutation == "unknown-root": |
| manifest["description"] = "catalog prose is not profile authority" |
| elif mutation == "wrong-layer": |
| manifest["authority"]["catalog_layer_kind"] = "user" |
| elif mutation == "duplicate-profile": |
| manifest["profiles"] = [manifest["profiles"][0], manifest["profiles"][0]] |
| else: |
| manifest["profiles"][0]["match_policy"]["required_any_signals"] = ["secret"] |
| body = _canonical_bytes(manifest) |
|
|
| with pytest.raises(BenefitClosureError): |
| load_reviewed_benefit_profiles_bytes(body, hashlib.sha256(body).hexdigest()) |
|
|
|
|
| def test_query_closure_freezes_exact_presentations_authorities_policy_and_facts() -> None: |
| profiles = _authorities() |
| observation = _observation() |
| raw_source = _source(profiles) |
|
|
| closure = _prepare(profiles, raw_source, observation=observation) |
|
|
| assert raw_source.close_calls == 1 |
| assert raw_source.retrieve_calls == 2 |
| assert closure.source.retrieve(observation) == (_candidate(),) |
| facts = closure.benefit_facts.benefit_candidate(_candidate(), observation) |
| assert facts is not None |
| assert facts.expected_task_benefit_ppm == 500_000 |
| assert facts.relevance_ppm == 700_000 |
| assert facts.costs is not None and facts.costs.context_tokens == 180 |
| assert closure.authority_snapshot_digest == profiles.authority_snapshot_digest |
| assert closure.policy is POLICY |
| assert closure.policy_digest == POLICY.policy_digest |
| assert closure.upstream_host_policy_snapshot_digest == HOST_POLICY_DIGEST |
| assert ( |
| closure.host_policy_snapshot_digest |
| == closure.host_policy_authority.host_policy_snapshot_digest |
| ) |
| assert closure.closure_snapshot_digest == closure.source.catalog_snapshot_digest |
|
|
| with pytest.raises(PlannerValidationError, match="observation mismatch"): |
| closure.source.retrieve(WorkObservation(signals=("security",), languages=("python",))) |
| closure.source.close() |
| with pytest.raises(PlannerValidationError, match="closed"): |
| closure.source.retrieve(observation) |
|
|
|
|
| def test_query_closure_value_recomputes_its_public_pins() -> None: |
| profiles = _authorities() |
| closure = _prepare(profiles, _source(profiles)) |
|
|
| with pytest.raises(TypeError, match="closure factory"): |
| replace(closure, policy_digest=_digest("substituted-policy")) |
|
|
|
|
| def test_reviewed_values_recompute_profile_and_manifest_membership() -> None: |
| authority = _authority() |
|
|
| with pytest.raises(BenefitClosureError, match="profile_digest"): |
| replace(authority.profiles[0], source_trusted=False) |
| with pytest.raises(BenefitClosureError, match="profile_snapshot_digest"): |
| replace(authority, sequence=2) |
|
|
|
|
| def test_query_closure_rejects_forged_claim_outside_advertised_authorities() -> None: |
| profiles = _authorities() |
| closure = _prepare(profiles, _source(profiles)) |
| candidate = closure.source.retrieve(_observation())[0] |
| user_authority = _authority( |
| authority_id="local-user", |
| authority_kind="user", |
| catalog_layer_kind="user", |
| ) |
| forged_claim = EligibleCatalogClaim.create(user_authority, presentation=candidate) |
| forged_host_fact = replace( |
| closure.host_eligibilities[0], |
| catalog_entry_claim_digest=forged_claim.catalog_entry_claim_digest, |
| catalog_claim_digest=eligible_catalog_claim_digest(forged_claim), |
| ) |
|
|
| with pytest.raises(TypeError, match="closure factory"): |
| replace( |
| closure, |
| catalog_claims=(forged_claim,), |
| host_eligibilities=(forged_host_fact,), |
| ) |
|
|
|
|
| @pytest.mark.parametrize( |
| "field_name", |
| [ |
| "catalog_entry_claim_digest", |
| "presentation_digest", |
| ], |
| ) |
| def test_query_closure_rechecks_claim_on_reconstruction(field_name: str) -> None: |
| profiles = _authorities() |
| closure = _prepare(profiles, _source(profiles)) |
| original_claim = closure.catalog_claims[0] |
| forged_claim = replace(original_claim, **{field_name: _digest(f"other-{field_name}")}) |
| forged_host_fact = replace( |
| closure.host_eligibilities[0], |
| catalog_claim_digest=eligible_catalog_claim_digest(forged_claim), |
| ) |
|
|
| with pytest.raises(TypeError, match="closure factory"): |
| replace( |
| closure, |
| catalog_claims=(forged_claim,), |
| host_eligibilities=(forged_host_fact,), |
| ) |
|
|
|
|
| def test_query_closure_supports_independent_ctx_and_user_authorities() -> None: |
| ctx_authority = _authority() |
| user_candidate = _candidate(capability_id="agent:user-reviewer") |
| user_claim = catalog_candidate_entry_claim_digest(user_candidate) |
| user_authority = _authority( |
| _profile_record( |
| capability_id=user_candidate.capability_id, |
| entry_claim_digest=user_claim, |
| ), |
| authority_id="local-user", |
| authority_kind="user", |
| catalog_layer_kind="user", |
| ) |
| profiles = _authorities(ctx_authority, user_authority) |
| source = _source( |
| profiles, |
| _candidate(), |
| user_candidate, |
| claim_authorities={ |
| "skill:ctx-python-testing": ctx_authority, |
| user_candidate.capability_id: user_authority, |
| }, |
| ) |
|
|
| closure = _prepare(profiles, source) |
|
|
| assert {item.capability_id for item in closure.source.retrieve(_observation())} == { |
| "skill:ctx-python-testing", |
| "agent:user-reviewer", |
| } |
|
|
|
|
| def test_host_policy_cannot_reuse_same_entry_digest_across_authorities() -> None: |
| candidate = _candidate() |
| ctx_authority = _authority() |
| user_authority = _authority( |
| authority_id="local-user", |
| authority_kind="user", |
| catalog_layer_kind="user", |
| ) |
| profiles = _authorities(ctx_authority, user_authority) |
| source = _source( |
| profiles, |
| candidate, |
| claim_authorities={candidate.capability_id: ctx_authority}, |
| ) |
| user_claim = EligibleCatalogClaim.create(user_authority, presentation=candidate) |
|
|
| with pytest.raises(BenefitClosureError, match="cross-authority"): |
| _prepare( |
| profiles, |
| source, |
| host_policy=_HostPolicy( |
| claim_digest_override=eligible_catalog_claim_digest(user_claim) |
| ), |
| ) |
|
|
|
|
| def test_query_closure_abstains_on_unobserved_or_unreviewed_presentation_tokens() -> None: |
| profiles = _authorities() |
| unobserved = _candidate(matching_signals=("testing",)) |
| source = _source(profiles, unobserved) |
| observation = _observation(signals=("security",), languages=("python",)) |
|
|
| closure = _prepare(profiles, source, observation=observation) |
| assert closure.source.retrieve(observation) == () |
|
|
| private_reason = _candidate(reason_codes=("graph-match", "sk-live-secret-token")) |
| source = _source(profiles, private_reason) |
| closure = _prepare(profiles, source) |
| assert closure.source.retrieve(_observation()) == () |
|
|
|
|
| def test_query_closure_is_deterministic_and_weak_matches_abstain() -> None: |
| profiles = _authorities() |
| observation = _observation() |
| first = _prepare( |
| profiles, |
| _source(profiles, _candidate(matching_signals=("python",))), |
| observation=observation, |
| ) |
| second = _prepare( |
| profiles, |
| _source(profiles, _candidate(matching_signals=("python",))), |
| observation=observation, |
| ) |
|
|
| assert first.source.retrieve(observation) == () |
| assert first.benefit_facts.presentation_digests == () |
| assert first.closure_snapshot_digest == second.closure_snapshot_digest |
|
|
|
|
| @pytest.mark.parametrize("excluded", ["baseline", "rejected"]) |
| def test_query_closure_applies_shared_eligibility_before_requiring_profiles(excluded: str) -> None: |
| profiles = _authorities() |
| unprofiled = _candidate(capability_id="agent:unprofiled-reviewer") |
| observation = _observation( |
| baseline=(unprofiled.capability_id,) if excluded == "baseline" else (), |
| rejected=(unprofiled.capability_id,) if excluded == "rejected" else (), |
| ) |
| source = _source(profiles, unprofiled) |
|
|
| closure = _prepare(profiles, source, observation=observation) |
|
|
| assert closure.source.retrieve(observation) == () |
| assert source.claim_calls == 0 |
| assert source.close_calls == 1 |
|
|
|
|
| def test_query_closure_rejects_unreviewed_or_authority_substituted_claim() -> None: |
| profiles = _authorities() |
| unreviewed = _candidate(capability_id="agent:unreviewed") |
| source = _source(profiles, unreviewed) |
|
|
| with pytest.raises(BenefitClosureError, match="without an exact reviewed profile"): |
| _prepare(profiles, source) |
| assert source.close_calls == 1 |
|
|
| user_authority = _authority( |
| authority_id="local-user", |
| authority_kind="user", |
| catalog_layer_kind="user", |
| ) |
| substituted = _source(profiles) |
| substituted.claims["skill:ctx-python-testing"] = EligibleCatalogClaim.create( |
| user_authority, |
| presentation=_candidate(), |
| ) |
| with pytest.raises(BenefitClosureError, match="without an exact reviewed profile"): |
| _prepare(profiles, substituted) |
|
|
|
|
| def test_reviewed_install_claim_rejects_source_and_plan_substitution() -> None: |
| reviewed = _candidate(actionability="install") |
| authority = _authority(_profile_record(actionability="install")) |
| profiles = _authorities(authority) |
| substituted = replace( |
| reviewed, |
| source_digest=_digest("substituted-source"), |
| install_descriptor_digest=_digest("substituted-descriptor"), |
| install_plan_digest=_digest("substituted-plan"), |
| ) |
| source = _source(profiles, substituted) |
|
|
| with pytest.raises(BenefitClosureError, match="without an exact reviewed profile"): |
| _prepare(profiles, source) |
|
|
| assert source.close_calls == 1 |
|
|
|
|
| def test_query_closure_requires_the_exact_reviewed_policy() -> None: |
| manifest = _manifest() |
| manifest["bindings"]["policy_digest"] = _digest("different-reviewed-policy") |
| body = _canonical_bytes(manifest) |
| authority = load_reviewed_benefit_profiles_bytes(body, hashlib.sha256(body).hexdigest()) |
| profiles = _authorities(authority) |
| source = _source(profiles) |
|
|
| with pytest.raises(BenefitClosureError, match="policy does not match"): |
| _prepare(profiles, source) |
|
|
| assert source.close_calls == 1 |
|
|
|
|
| @pytest.mark.parametrize("during", ["retrieve", "claim"]) |
| def test_query_closure_rejects_binding_drift_during_source_reads(during: str) -> None: |
| profiles = _authorities() |
| source = _source(profiles) |
| if during == "retrieve": |
| source.drift_binding_on_retrieve = True |
| else: |
| source.drift_binding_on_claim = True |
|
|
| with pytest.raises(BenefitClosureError, match="binding drift"): |
| _prepare(profiles, source) |
| assert source.close_calls == 1 |
|
|
|
|
| def test_query_closure_rejects_same_digest_candidate_or_claim_drift() -> None: |
| profiles = _authorities() |
| candidate = _candidate() |
| changed = _candidate(matching_signals=("python",)) |
| source = _source(profiles, candidate) |
| source.candidate_rounds = ((candidate,), (changed,)) |
| with pytest.raises( |
| BenefitClosureError, |
| match="claim does not match exact presentation|changed candidates or claims", |
| ): |
| _prepare(profiles, source) |
|
|
| source = _source(profiles, candidate) |
| first_claim = source.claims[candidate.capability_id] |
| second_claim = replace(first_claim, authority_digest=_digest("changed-claim-authority")) |
| source.claim_rounds[candidate.capability_id] = (first_claim, second_claim) |
| with pytest.raises(BenefitClosureError, match="changed candidates or claims"): |
| _prepare(profiles, source) |
|
|
|
|
| def test_host_policy_is_query_scoped_exact_and_not_install_consent() -> None: |
| profiles = _authorities() |
| source = _source(profiles) |
| denied = _HostPolicy(permissions_allowed=False, credentials_available=False) |
|
|
| closure = _prepare(profiles, source, host_policy=denied) |
| benefit = closure.benefit_facts.benefit_candidate(_candidate(), _observation()) |
|
|
| assert benefit is not None |
| assert benefit.permissions_allowed is False |
| assert benefit.credentials_available is False |
| assert denied.calls == 2 |
|
|
| source = _source(profiles) |
| unavailable = _prepare( |
| profiles, |
| source, |
| host_policy=_HostPolicy(available=False), |
| ) |
| assert unavailable.source.retrieve(_observation()) == () |
|
|
| source = _source(profiles) |
| with pytest.raises(BenefitClosureError, match="no exact query eligibility"): |
| _prepare(profiles, source, host_policy=_HostPolicy(return_none=True)) |
|
|
| source = _source(profiles) |
| with pytest.raises(BenefitClosureError, match="drift"): |
| _prepare(profiles, source, host_policy=_HostPolicy(drift=True)) |
|
|
|
|
| def test_query_closure_rejects_reconstructed_allow_after_host_denial() -> None: |
| profiles = _authorities() |
| closure = _prepare( |
| profiles, |
| _source(profiles), |
| host_policy=_HostPolicy(permissions_allowed=False, credentials_available=False), |
| ) |
| denied = closure.host_eligibilities[0] |
| forged_allow = replace( |
| denied, |
| permissions_allowed=True, |
| credentials_available=True, |
| ) |
|
|
| with pytest.raises(TypeError, match="closure factory"): |
| replace(closure, host_eligibilities=(forged_allow,)) |
|
|
|
|
| def test_query_closure_closes_owned_source_on_invalid_arguments() -> None: |
| profiles = _authorities() |
| source = _source(profiles) |
|
|
| with pytest.raises(TypeError, match="observation"): |
| _prepare(profiles, source, observation=object()) |
|
|
| assert source.close_calls == 1 |
|
|
|
|
| def test_query_closure_preserves_primary_error_when_cleanup_also_fails() -> None: |
| profiles = _authorities() |
| source = _source(profiles, _candidate(capability_id="agent:unreviewed")) |
| source.cleanup_failure = True |
|
|
| with pytest.raises(BenefitClosureError, match="without an exact reviewed profile") as exc: |
| _prepare(profiles, source) |
|
|
| assert any("cleanup also failed" in note for note in (exc.value.__notes__ or [])) |
|
|
|
|
| @pytest.mark.parametrize("boundary", ["retrieve", "claim", "host-policy", "close"]) |
| def test_query_closure_redacts_injected_boundary_exception_messages(boundary: str) -> None: |
| profiles = _authorities() |
| source = _source(profiles) |
| host_policy = _HostPolicy(explode=boundary == "host-policy") |
| if boundary != "host-policy": |
| source.explode_at = boundary |
|
|
| with pytest.raises(BenefitClosureError) as exc: |
| _prepare(profiles, source, host_policy=host_policy) |
|
|
| assert "alice" not in str(exc.value) |
| assert "sk-live-secret" not in str(exc.value) |
| assert exc.value.__suppress_context__ is True |
|
|
|
|
| class _ExplodingSnapshotHostPolicy: |
| @property |
| def host_policy_snapshot_digest(self) -> str: |
| raise BenefitClosureError("/Users/alice/private-repo sk-live-secret") |
|
|
| def eligibility_for( |
| self, |
| _presentation: CapabilityCandidate, |
| _claim: EligibleCatalogClaim, |
| ) -> QueryCapabilityEligibility | None: |
| raise AssertionError("snapshot access must fail before eligibility lookup") |
|
|
|
|
| class _ExplodingEligibilityAttributeHostPolicy: |
| host_policy_snapshot_digest = HOST_POLICY_DIGEST |
|
|
| def __getattribute__(self, name: str) -> object: |
| if name == "eligibility_for": |
| raise RuntimeError("/Users/alice/private-repo sk-live-secret") |
| return super().__getattribute__(name) |
|
|
|
|
| def test_query_closure_redacts_host_policy_snapshot_property_errors() -> None: |
| profiles = _authorities() |
| source = _source(profiles) |
|
|
| with pytest.raises(BenefitClosureError) as exc: |
| prepare_query_benefit_closure( |
| source=source, |
| observation=_observation(), |
| profiles=profiles, |
| policy=POLICY, |
| host_policy=_ExplodingSnapshotHostPolicy(), |
| ) |
|
|
| assert "alice" not in str(exc.value) |
| assert "sk-live-secret" not in str(exc.value) |
| assert exc.value.__suppress_context__ is True |
|
|
|
|
| @pytest.mark.parametrize("attribute", ["retrieve", "entry_claim"]) |
| def test_query_closure_redacts_source_callable_attribute_errors(attribute: str) -> None: |
| profiles = _authorities() |
| source = _source(profiles) |
|
|
| with pytest.raises(BenefitClosureError) as exc: |
| prepare_query_benefit_closure( |
| source=_ExplodingAttributeSource(source, attribute), |
| observation=_observation(), |
| profiles=profiles, |
| policy=POLICY, |
| host_policy=_HostPolicy(), |
| ) |
|
|
| assert "alice" not in str(exc.value) |
| assert "sk-live-secret" not in str(exc.value) |
| assert exc.value.__suppress_context__ is True |
|
|
|
|
| def test_query_closure_redacts_host_policy_callable_attribute_errors() -> None: |
| profiles = _authorities() |
|
|
| with pytest.raises(BenefitClosureError) as exc: |
| prepare_query_benefit_closure( |
| source=_source(profiles), |
| observation=_observation(), |
| profiles=profiles, |
| policy=POLICY, |
| host_policy=cast( |
| QueryHostPolicyAuthority, |
| _ExplodingEligibilityAttributeHostPolicy(), |
| ), |
| ) |
|
|
| assert "alice" not in str(exc.value) |
| assert "sk-live-secret" not in str(exc.value) |
| assert exc.value.__suppress_context__ is True |
|
|
|
|
| def test_query_closure_cleanup_note_does_not_expose_injected_exception_class() -> None: |
| profiles = _authorities() |
| source = _source(profiles, _candidate(capability_id="agent:unreviewed")) |
| source.leak_cleanup_class = True |
|
|
| with pytest.raises(BenefitClosureError) as exc: |
| _prepare(profiles, source) |
|
|
| notes = exc.value.__notes__ or [] |
| assert notes == ["CTX eligible-source cleanup also failed"] |
| assert "Alice" not in " ".join(notes) |
|
|
|
|
| class _LyingSequence(Sequence[CapabilityCandidate]): |
| def __init__(self, candidate: CapabilityCandidate, actual: int) -> None: |
| self.candidate = candidate |
| self.actual = actual |
|
|
| def __len__(self) -> int: |
| return 1 |
|
|
| @overload |
| def __getitem__(self, index: int) -> CapabilityCandidate: ... |
|
|
| @overload |
| def __getitem__(self, index: slice) -> Sequence[CapabilityCandidate]: ... |
|
|
| def __getitem__( |
| self, index: int | slice |
| ) -> CapabilityCandidate | Sequence[CapabilityCandidate]: |
| if isinstance(index, slice): |
| return ((self.candidate,) * self.actual)[index] |
| if index < 0 or index >= self.actual: |
| raise IndexError(index) |
| return self.candidate |
|
|
| def __iter__(self) -> Iterator[CapabilityCandidate]: |
| return iter((self.candidate,) * self.actual) |
|
|
|
|
| def test_shared_candidate_bound_uses_realized_iteration_not_reported_length() -> None: |
| with pytest.raises(PlannerValidationError, match="candidate pool limit"): |
| normalize_candidate_pool(_LyingSequence(_candidate(), 513), _observation()) |
|
|
|
|
| class _LyingAuthoritySequence(Sequence[ReviewedBenefitProfiles]): |
| def __init__(self, authority: ReviewedBenefitProfiles, actual: int) -> None: |
| self.authority = authority |
| self.actual = actual |
|
|
| def __len__(self) -> int: |
| return 1 |
|
|
| @overload |
| def __getitem__(self, index: int) -> ReviewedBenefitProfiles: ... |
|
|
| @overload |
| def __getitem__(self, index: slice) -> Sequence[ReviewedBenefitProfiles]: ... |
|
|
| def __getitem__( |
| self, index: int | slice |
| ) -> ReviewedBenefitProfiles | Sequence[ReviewedBenefitProfiles]: |
| if isinstance(index, slice): |
| return ((self.authority,) * self.actual)[index] |
| if index < 0 or index >= self.actual: |
| raise IndexError(index) |
| return self.authority |
|
|
| def __iter__(self) -> Iterator[ReviewedBenefitProfiles]: |
| return iter((self.authority,) * self.actual) |
|
|
|
|
| def test_reviewed_authority_bound_uses_realized_iteration_not_reported_length() -> None: |
| with pytest.raises(BenefitClosureError, match="bounded item limit"): |
| ReviewedBenefitAuthorities.create(_LyingAuthoritySequence(_authority(), 65)) |
|
|
|
|
| def test_profile_path_failures_redact_sensitive_locations_from_traceback() -> None: |
| sensitive = "/private/clients/acme-secret/reviewed-benefit.json" |
|
|
| with pytest.raises(BenefitClosureError) as exc: |
| load_reviewed_benefit_profiles(Path(sensitive), "a" * 64) |
|
|
| rendered = "".join( |
| traceback.format_exception(type(exc.value), exc.value, exc.value.__traceback__) |
| ) |
| assert sensitive not in rendered |
| assert "acme-secret" not in rendered |
| assert exc.value.__cause__ is None |
| assert exc.value.__suppress_context__ is True |
|
|
