test_aff_unit.py
file-level
1
files
1
commits
0
hotspots
0
🧊 dead
0
💥 blast risk
| 1 | """Unit tests for AFF ledger kind + Mode E resolution (§AFF.14).""" |
| 2 | |
| 3 | from __future__ import annotations |
| 4 | |
| 5 | from pathlib import Path |
| 6 | from typing import get_args |
| 7 | |
| 8 | import pytest |
| 9 | import yaml |
| 10 | |
| 11 | from adapters.config import ADVERSARIAL_FREEZE_MODES, HONESTY_KEYS, HonestyConfig, load_config |
| 12 | from tests.fixtures.aff import AFF_DIGEST_PLACEHOLDER, AFF_FREEZE_REL, aff_body, load_aff_entry |
| 13 | from tests.support import seed_honesty_repo |
| 14 | from tools.adversarial_freeze import ( |
| 15 | aff_hold_bypassed, |
| 16 | aggregate_adversarial_authorization_states, |
| 17 | author_loop_complete, |
| 18 | frv_authorizing_freeze_paths, |
| 19 | ) |
| 20 | from tools.honesty.ledger import verify_chain |
| 21 | from tools.honesty.status import HonestyStatusOptions, _resolve_mode |
| 22 | from tools.honesty.types import AFF_POSTURES, AFF_VERDICTS, ENTRY_KINDS, HonestyErrorToken |
| 23 | from tools.honesty.validate import ( |
| 24 | EntryValidationError, |
| 25 | find_latest_adversarial_freeze_verdict, |
| 26 | find_matching_adversarial_freeze_pass, |
| 27 | find_matching_adversarial_freeze_skip, |
| 28 | validate_append_body, |
| 29 | ) |
| 30 | |
| 31 | |
| 32 | def _minimal(**overrides) -> dict: |
| 33 | body = load_aff_entry("aff-pass.json") |
| 34 | body.update(overrides) |
| 35 | return body |
| 36 | |
| 37 | |
| 38 | def test_aff_in_entry_kinds() -> None: |
| 39 | assert "adversarial_freeze" in ENTRY_KINDS |
| 40 | assert AFF_VERDICTS == frozenset({"pass", "findings", "blocked", "skip"}) |
| 41 | assert AFF_POSTURES == frozenset({"attack"}) |
| 42 | |
| 43 | |
| 44 | @pytest.mark.parametrize( |
| 45 | "fixture", |
| 46 | ["aff-pass.json", "aff-findings.json", "aff-blocked.json"], |
| 47 | ) |
| 48 | def test_validate_accepts_minimal_pass_findings_blocked(fixture: str) -> None: |
| 49 | validated = validate_append_body(kind="adversarial_freeze", body=load_aff_entry(fixture)) |
| 50 | assert validated["kind"] == "adversarial_freeze" |
| 51 | assert validated["aff_posture"] == "attack" |
| 52 | assert validated["reviewer_model"] == "thinking-high" |
| 53 | assert validated["producer_session_id"] == "aff-a-author-session" |
| 54 | assert validated["actor_session_id"] != validated["producer_session_id"] |
| 55 | |
| 56 | |
| 57 | def test_validate_accepts_minimal_skip() -> None: |
| 58 | validated = validate_append_body(kind="adversarial_freeze", body=load_aff_entry("aff-skip.json")) |
| 59 | assert validated["aff_verdict"] == "skip" |
| 60 | assert "aff_posture" not in validated |
| 61 | |
| 62 | |
| 63 | def test_client_v_true_exit_2() -> None: |
| 64 | with pytest.raises(EntryValidationError) as exc: |
| 65 | validate_append_body(kind="adversarial_freeze", body=_minimal(v=True)) |
| 66 | assert exc.value.exit_code == 2 |
| 67 | |
| 68 | |
| 69 | @pytest.mark.parametrize("bad_v", [0, 2, -1, 1.0, "1"]) |
| 70 | def test_client_v_not_exact_one_exit_2(bad_v) -> None: |
| 71 | with pytest.raises(EntryValidationError) as exc: |
| 72 | validate_append_body(kind="adversarial_freeze", body=_minimal(v=bad_v)) |
| 73 | assert exc.value.exit_code == 2 |
| 74 | |
| 75 | |
| 76 | def test_supplied_empty_ts_exit_2() -> None: |
| 77 | with pytest.raises(EntryValidationError) as exc: |
| 78 | validate_append_body(kind="adversarial_freeze", body=_minimal(ts="")) |
| 79 | assert exc.value.exit_code == 2 |
| 80 | |
| 81 | |
| 82 | def test_supplied_non_string_ts_exit_2() -> None: |
| 83 | with pytest.raises(EntryValidationError) as exc: |
| 84 | validate_append_body(kind="adversarial_freeze", body=_minimal(ts=123)) |
| 85 | assert exc.value.exit_code == 2 |
| 86 | |
| 87 | |
| 88 | def test_omitted_ts_accepted_for_server_fill() -> None: |
| 89 | body = _minimal() |
| 90 | body.pop("ts", None) |
| 91 | validated = validate_append_body(kind="adversarial_freeze", body=body) |
| 92 | assert "ts" not in validated or validated.get("ts") |
| 93 | |
| 94 | |
| 95 | def test_verify_chain_rejects_missing_ts() -> None: |
| 96 | entry = { |
| 97 | "v": 1, |
| 98 | "kind": "genesis", |
| 99 | "prev_hash": "0" * 64, |
| 100 | "entry_hash": "1" * 64, |
| 101 | } |
| 102 | assert verify_chain([entry]) == 22 |
| 103 | |
| 104 | |
| 105 | def test_verify_chain_rejects_v_true() -> None: |
| 106 | from tools.honesty.canonical import compute_entry_hash |
| 107 | from tools.honesty.genesis import GENESIS_PREV |
| 108 | |
| 109 | entry = {"v": True, "ts": "2026-01-01T00:00:00Z", "kind": "genesis", "prev_hash": GENESIS_PREV} |
| 110 | entry["entry_hash"] = compute_entry_hash(entry) |
| 111 | assert verify_chain([entry]) == 22 |
| 112 | |
| 113 | |
| 114 | @pytest.mark.parametrize( |
| 115 | "kind,extra", |
| 116 | [ |
| 117 | ( |
| 118 | "verification_evidence", |
| 119 | { |
| 120 | "bv_verdict": "pass", |
| 121 | "artifacts": [{"type": "test_output", "sha256": "b" * 64}], |
| 122 | }, |
| 123 | ), |
| 124 | ( |
| 125 | "independent_second_review", |
| 126 | {"isr_verdict": "pass", "producer_session_id": "p"}, |
| 127 | ), |
| 128 | ( |
| 129 | "freeze_review", |
| 130 | { |
| 131 | "gate": "substantive", |
| 132 | "freeze_verdict": "pass", |
| 133 | "artifact_digest": AFF_DIGEST_PLACEHOLDER, |
| 134 | "reviewer_model": "thinking-high", |
| 135 | }, |
| 136 | ), |
| 137 | ("adversarial_freeze", {"aff_verdict": "pass", "aff_posture": "attack", |
| 138 | "artifact_digest": AFF_DIGEST_PLACEHOLDER, |
| 139 | "producer_session_id": "p", "reviewer_model": "m"}), |
| 140 | ], |
| 141 | ) |
| 142 | def test_round_true_rejected_on_round_bearing_kinds(kind: str, extra: dict) -> None: |
| 143 | body = { |
| 144 | "actor_role": "verifier", |
| 145 | "actor_session_id": "a", |
| 146 | "phase_id": "X", |
| 147 | "frozen_spec": "docs/x.md", |
| 148 | "round": True, |
| 149 | **extra, |
| 150 | } |
| 151 | if kind == "adversarial_freeze": |
| 152 | body["actor_session_id"] = "a" |
| 153 | body["producer_session_id"] = "p" |
| 154 | with pytest.raises(EntryValidationError) as exc: |
| 155 | validate_append_body(kind=kind, body=body) |
| 156 | assert exc.value.exit_code == 2 |
| 157 | |
| 158 | |
| 159 | def test_missing_reviewer_model_exit_2() -> None: |
| 160 | body = _minimal() |
| 161 | del body["reviewer_model"] |
| 162 | with pytest.raises(EntryValidationError) as exc: |
| 163 | validate_append_body(kind="adversarial_freeze", body=body) |
| 164 | assert exc.value.exit_code == 2 |
| 165 | |
| 166 | |
| 167 | def test_same_session_ids_exit_2() -> None: |
| 168 | with pytest.raises(EntryValidationError) as exc: |
| 169 | validate_append_body( |
| 170 | kind="adversarial_freeze", |
| 171 | body=_minimal(actor_session_id="same", producer_session_id="same"), |
| 172 | ) |
| 173 | assert exc.value.exit_code == 2 |
| 174 | |
| 175 | |
| 176 | def test_missing_producer_session_on_pass_exit_2() -> None: |
| 177 | body = _minimal() |
| 178 | del body["producer_session_id"] |
| 179 | with pytest.raises(EntryValidationError) as exc: |
| 180 | validate_append_body(kind="adversarial_freeze", body=body) |
| 181 | assert exc.value.exit_code == 2 |
| 182 | |
| 183 | |
| 184 | def test_missing_aff_posture_on_pass_exit_2() -> None: |
| 185 | body = _minimal() |
| 186 | del body["aff_posture"] |
| 187 | with pytest.raises(EntryValidationError) as exc: |
| 188 | validate_append_body(kind="adversarial_freeze", body=body) |
| 189 | assert exc.value.exit_code == 2 |
| 190 | |
| 191 | |
| 192 | def test_aff_posture_not_attack_exit_2() -> None: |
| 193 | with pytest.raises(EntryValidationError) as exc: |
| 194 | validate_append_body(kind="adversarial_freeze", body=_minimal(aff_posture="defend")) |
| 195 | assert exc.value.exit_code == 2 |
| 196 | |
| 197 | |
| 198 | def test_skip_with_aff_posture_exit_2() -> None: |
| 199 | body = load_aff_entry("aff-skip.json") |
| 200 | body["aff_posture"] = "attack" |
| 201 | with pytest.raises(EntryValidationError) as exc: |
| 202 | validate_append_body(kind="adversarial_freeze", body=body) |
| 203 | assert exc.value.exit_code == 2 |
| 204 | |
| 205 | |
| 206 | def test_skip_non_owner_exit_23() -> None: |
| 207 | body = load_aff_entry("aff-skip.json") |
| 208 | body["actor_role"] = "verifier" |
| 209 | with pytest.raises(EntryValidationError) as exc: |
| 210 | validate_append_body(kind="adversarial_freeze", body=body) |
| 211 | assert exc.value.exit_code == 23 |
| 212 | |
| 213 | |
| 214 | def test_pass_non_verifier_exit_23() -> None: |
| 215 | with pytest.raises(EntryValidationError) as exc: |
| 216 | validate_append_body(kind="adversarial_freeze", body=_minimal(actor_role="producer")) |
| 217 | assert exc.value.exit_code == 23 |
| 218 | |
| 219 | |
| 220 | def test_bad_aff_verdict_exit_2() -> None: |
| 221 | with pytest.raises(EntryValidationError) as exc: |
| 222 | validate_append_body(kind="adversarial_freeze", body=_minimal(aff_verdict="ok")) |
| 223 | assert exc.value.exit_code == 2 |
| 224 | |
| 225 | |
| 226 | def test_round_lt_1_exit_2() -> None: |
| 227 | with pytest.raises(EntryValidationError) as exc: |
| 228 | validate_append_body(kind="adversarial_freeze", body=_minimal(round=0)) |
| 229 | assert exc.value.exit_code == 2 |
| 230 | |
| 231 | |
| 232 | def test_round_non_int_exit_2() -> None: |
| 233 | with pytest.raises(EntryValidationError) as exc: |
| 234 | validate_append_body(kind="adversarial_freeze", body=_minimal(round="1")) |
| 235 | assert exc.value.exit_code == 2 |
| 236 | |
| 237 | |
| 238 | def test_digest_not_sha256_hex_exit_2() -> None: |
| 239 | with pytest.raises(EntryValidationError) as exc: |
| 240 | validate_append_body( |
| 241 | kind="adversarial_freeze", |
| 242 | body=_minimal(artifact_digest="sha256:ZZZZ"), |
| 243 | ) |
| 244 | assert exc.value.exit_code == 2 |
| 245 | |
| 246 | |
| 247 | def test_genesis_forbid_aff_keys() -> None: |
| 248 | for key in ("aff_verdict", "aff_posture", "bound_freeze_review_hash", "side_check_path"): |
| 249 | with pytest.raises(EntryValidationError) as exc: |
| 250 | validate_append_body(kind="genesis", body={key: "x"}) |
| 251 | assert exc.value.exit_code == 2 |
| 252 | |
| 253 | |
| 254 | def test_adversarial_freeze_config_parse(repo_root: Path) -> None: |
| 255 | seed_honesty_repo(repo_root) |
| 256 | cfg_path = repo_root / ".overseer" / "config.yaml" |
| 257 | data = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) |
| 258 | data["freeze_contract"] = { |
| 259 | "enabled": True, |
| 260 | "reviewer": "human", |
| 261 | "human_escalation": [], |
| 262 | } |
| 263 | for mode in ADVERSARIAL_FREEZE_MODES: |
| 264 | data["honesty"]["adversarial_freeze"] = mode |
| 265 | cfg_path.write_text(yaml.safe_dump(data), encoding="utf-8") |
| 266 | assert load_config(cfg_path).honesty.adversarial_freeze == mode |
| 267 | |
| 268 | data["honesty"]["adversarial_freeze"] = "maybe" |
| 269 | cfg_path.write_text(yaml.safe_dump(data), encoding="utf-8") |
| 270 | with pytest.raises(Exception, match="adversarial_freeze"): |
| 271 | load_config(cfg_path) |
| 272 | |
| 273 | |
| 274 | def test_derived_suggest_from_security(repo_root: Path) -> None: |
| 275 | seed_honesty_repo(repo_root) |
| 276 | cfg_path = repo_root / ".overseer" / "config.yaml" |
| 277 | data = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) |
| 278 | data["honesty"].pop("adversarial_freeze", None) |
| 279 | data["freeze_contract"] = { |
| 280 | "enabled": True, |
| 281 | "reviewer": "human", |
| 282 | "human_escalation": ["security"], |
| 283 | } |
| 284 | cfg_path.write_text(yaml.safe_dump(data), encoding="utf-8") |
| 285 | assert load_config(cfg_path).honesty.adversarial_freeze == "suggest" |
| 286 | |
| 287 | |
| 288 | def test_derived_off_without_security(repo_root: Path) -> None: |
| 289 | seed_honesty_repo(repo_root) |
| 290 | cfg_path = repo_root / ".overseer" / "config.yaml" |
| 291 | data = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) |
| 292 | data["honesty"].pop("adversarial_freeze", None) |
| 293 | data["freeze_contract"] = { |
| 294 | "enabled": True, |
| 295 | "reviewer": "human", |
| 296 | "human_escalation": [], |
| 297 | } |
| 298 | cfg_path.write_text(yaml.safe_dump(data), encoding="utf-8") |
| 299 | assert load_config(cfg_path).honesty.adversarial_freeze == "off" |
| 300 | |
| 301 | |
| 302 | def test_explicit_off_wins_over_security(repo_root: Path) -> None: |
| 303 | seed_honesty_repo(repo_root) |
| 304 | cfg_path = repo_root / ".overseer" / "config.yaml" |
| 305 | data = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) |
| 306 | data["honesty"]["adversarial_freeze"] = "off" |
| 307 | data["freeze_contract"] = { |
| 308 | "enabled": True, |
| 309 | "reviewer": "human", |
| 310 | "human_escalation": ["security"], |
| 311 | } |
| 312 | cfg_path.write_text(yaml.safe_dump(data), encoding="utf-8") |
| 313 | assert load_config(cfg_path).honesty.adversarial_freeze == "off" |
| 314 | |
| 315 | |
| 316 | def test_require_never_derived(repo_root: Path) -> None: |
| 317 | seed_honesty_repo(repo_root) |
| 318 | cfg_path = repo_root / ".overseer" / "config.yaml" |
| 319 | data = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) |
| 320 | data["honesty"].pop("adversarial_freeze", None) |
| 321 | data["freeze_contract"] = { |
| 322 | "enabled": True, |
| 323 | "reviewer": "human", |
| 324 | "human_escalation": ["security"], |
| 325 | } |
| 326 | cfg_path.write_text(yaml.safe_dump(data), encoding="utf-8") |
| 327 | assert load_config(cfg_path).honesty.adversarial_freeze != "require" |
| 328 | |
| 329 | |
| 330 | def test_adversarial_freeze_in_honesty_keys() -> None: |
| 331 | assert "adversarial_freeze" in HONESTY_KEYS |
| 332 | |
| 333 | |
| 334 | def test_honesty_config_field_default_suggest() -> None: |
| 335 | assert HonestyConfig().adversarial_freeze == "suggest" |
| 336 | |
| 337 | |
| 338 | def test_error_token_includes_missing_adversarial_freeze() -> None: |
| 339 | assert "missing_adversarial_freeze" in get_args(HonestyErrorToken) |
| 340 | |
| 341 | |
| 342 | def test_resolve_mode_e_invariants() -> None: |
| 343 | assert ( |
| 344 | _resolve_mode( |
| 345 | HonestyStatusOptions( |
| 346 | hook=None, |
| 347 | artifact=None, |
| 348 | adversarial_freeze="AFF", |
| 349 | frozen_spec="docs/x.md", |
| 350 | ) |
| 351 | ) |
| 352 | == "mode_e" |
| 353 | ) |
| 354 | assert ( |
| 355 | _resolve_mode( |
| 356 | HonestyStatusOptions( |
| 357 | hook=None, |
| 358 | artifact=None, |
| 359 | adversarial_freeze="AFF", |
| 360 | producer_session="author", |
| 361 | ) |
| 362 | ) |
| 363 | == "mode_e" |
| 364 | ) |
| 365 | assert ( |
| 366 | _resolve_mode( |
| 367 | HonestyStatusOptions( |
| 368 | hook=None, |
| 369 | artifact=None, |
| 370 | adversarial_freeze="AFF", |
| 371 | producer_session="author", |
| 372 | frozen_spec="docs/x.md", |
| 373 | ) |
| 374 | ) |
| 375 | == "mode_e" |
| 376 | ) |
| 377 | assert ( |
| 378 | _resolve_mode(HonestyStatusOptions(hook=None, artifact=None, adversarial_freeze="AFF")) |
| 379 | == "mode_e" |
| 380 | ) |
| 381 | assert ( |
| 382 | _resolve_mode( |
| 383 | HonestyStatusOptions( |
| 384 | hook=None, |
| 385 | artifact=None, |
| 386 | adversarial_freeze="AFF", |
| 387 | frozen_spec="docs/x.md", |
| 388 | artifact_digest=AFF_DIGEST_PLACEHOLDER, |
| 389 | ) |
| 390 | ) |
| 391 | == "mode_e" |
| 392 | ) |
| 393 | # digest without Mode E → usage |
| 394 | assert ( |
| 395 | _resolve_mode( |
| 396 | HonestyStatusOptions( |
| 397 | hook=None, |
| 398 | artifact=None, |
| 399 | artifact_digest=AFF_DIGEST_PLACEHOLDER, |
| 400 | ) |
| 401 | ) |
| 402 | is None |
| 403 | ) |
| 404 | # Mode E + digest without frozen-spec → usage |
| 405 | assert ( |
| 406 | _resolve_mode( |
| 407 | HonestyStatusOptions( |
| 408 | hook=None, |
| 409 | artifact=None, |
| 410 | adversarial_freeze="AFF", |
| 411 | artifact_digest=AFF_DIGEST_PLACEHOLDER, |
| 412 | ) |
| 413 | ) |
| 414 | is None |
| 415 | ) |
| 416 | # Mode E + Mode D → usage |
| 417 | assert ( |
| 418 | _resolve_mode( |
| 419 | HonestyStatusOptions( |
| 420 | hook=None, |
| 421 | artifact=None, |
| 422 | adversarial_freeze="AFF", |
| 423 | independent_second_review="ISR-b", |
| 424 | ) |
| 425 | ) |
| 426 | is None |
| 427 | ) |
| 428 | # existing non-regular frozen-spec + valid digest still Mode E at resolve layer |
| 429 | assert ( |
| 430 | _resolve_mode( |
| 431 | HonestyStatusOptions( |
| 432 | hook=None, |
| 433 | artifact=None, |
| 434 | adversarial_freeze="AFF", |
| 435 | frozen_spec="/tmp", # path shape only; resolve_mode does not stat |
| 436 | artifact_digest=AFF_DIGEST_PLACEHOLDER, |
| 437 | ) |
| 438 | ) |
| 439 | == "mode_e" |
| 440 | ) |
| 441 | |
| 442 | |
| 443 | def _eligible_entries() -> list[dict]: |
| 444 | digest = AFF_DIGEST_PLACEHOLDER |
| 445 | path = AFF_FREEZE_REL |
| 446 | pass1 = aff_body(artifact_digest=digest, round=1, entry_hash="p1" * 32) |
| 447 | findings = aff_body( |
| 448 | "aff-findings.json", |
| 449 | artifact_digest=digest, |
| 450 | round=2, |
| 451 | actor_session_id="adv-3", |
| 452 | entry_hash="f1" * 32, |
| 453 | ) |
| 454 | blocked = aff_body( |
| 455 | "aff-blocked.json", |
| 456 | artifact_digest=digest, |
| 457 | round=2, |
| 458 | actor_session_id="adv-4", |
| 459 | entry_hash="b1" * 32, |
| 460 | ) |
| 461 | skip = aff_body( |
| 462 | "aff-skip.json", |
| 463 | artifact_digest=digest, |
| 464 | round=2, |
| 465 | entry_hash="s1" * 32, |
| 466 | ) |
| 467 | return pass1, findings, blocked, skip, path, digest |
| 468 | |
| 469 | |
| 470 | def test_auto_hold_match_ignores_phase_id() -> None: |
| 471 | pass1, _, _, _, path, digest = _eligible_entries() |
| 472 | pass1["phase_id"] = "AFF" # not AFF-b |
| 473 | winner = find_matching_adversarial_freeze_pass( |
| 474 | [pass1], frozen_spec=path, artifact_digest=digest, phase_id=None |
| 475 | ) |
| 476 | assert winner is not None |
| 477 | assert winner["phase_id"] == "AFF" |
| 478 | |
| 479 | |
| 480 | def test_mode_e_optional_phase_pin() -> None: |
| 481 | pass1, _, _, _, path, digest = _eligible_entries() |
| 482 | assert ( |
| 483 | find_latest_adversarial_freeze_verdict( |
| 484 | [pass1], frozen_spec=path, artifact_digest=digest, phase_id="OTHER" |
| 485 | ) |
| 486 | is None |
| 487 | ) |
| 488 | assert ( |
| 489 | find_latest_adversarial_freeze_verdict( |
| 490 | [pass1], frozen_spec=path, artifact_digest=digest, phase_id="AFF" |
| 491 | ) |
| 492 | is not None |
| 493 | ) |
| 494 | |
| 495 | |
| 496 | def test_skip_match_ignores_producer_session() -> None: |
| 497 | _, _, _, skip, path, digest = _eligible_entries() |
| 498 | winner = find_matching_adversarial_freeze_skip( |
| 499 | [skip], frozen_spec=path, artifact_digest=digest, phase_id=None |
| 500 | ) |
| 501 | assert winner is not None |
| 502 | # producer pin is ignored by skip wrapper (not passed through as filter on skip body) |
| 503 | latest = find_latest_adversarial_freeze_verdict( |
| 504 | [skip], |
| 505 | frozen_spec=path, |
| 506 | artifact_digest=digest, |
| 507 | producer_session="ignored-author", |
| 508 | ) |
| 509 | assert latest is not None |
| 510 | assert latest["aff_verdict"] == "skip" |
| 511 | |
| 512 | |
| 513 | def test_pass_then_findings_never_returns_older_pass() -> None: |
| 514 | pass1, findings, _, _, path, digest = _eligible_entries() |
| 515 | assert ( |
| 516 | find_matching_adversarial_freeze_pass( |
| 517 | [pass1, findings], frozen_spec=path, artifact_digest=digest |
| 518 | ) |
| 519 | is None |
| 520 | ) |
| 521 | latest = find_latest_adversarial_freeze_verdict( |
| 522 | [pass1, findings], frozen_spec=path, artifact_digest=digest |
| 523 | ) |
| 524 | assert latest is not None |
| 525 | assert latest["aff_verdict"] == "findings" |
| 526 | |
| 527 | |
| 528 | def test_pass_then_blocked_never_returns_older_pass() -> None: |
| 529 | pass1, _, blocked, _, path, digest = _eligible_entries() |
| 530 | assert ( |
| 531 | find_matching_adversarial_freeze_pass( |
| 532 | [pass1, blocked], frozen_spec=path, artifact_digest=digest |
| 533 | ) |
| 534 | is None |
| 535 | ) |
| 536 | |
| 537 | |
| 538 | def test_pass_then_skip_never_returns_older_pass() -> None: |
| 539 | pass1, _, _, skip, path, digest = _eligible_entries() |
| 540 | assert ( |
| 541 | find_matching_adversarial_freeze_pass( |
| 542 | [pass1, skip], frozen_spec=path, artifact_digest=digest |
| 543 | ) |
| 544 | is None |
| 545 | ) |
| 546 | assert ( |
| 547 | find_matching_adversarial_freeze_skip( |
| 548 | [pass1, skip], frozen_spec=path, artifact_digest=digest |
| 549 | ) |
| 550 | is not None |
| 551 | ) |
| 552 | |
| 553 | |
| 554 | def test_author_loop_complete_predicates() -> None: |
| 555 | digest = AFF_DIGEST_PLACEHOLDER |
| 556 | assert author_loop_complete("substantive", stamp_digest=None, current_digest=digest) is True |
| 557 | assert ( |
| 558 | author_loop_complete("mechanical_only", stamp_digest=digest, current_digest=digest) |
| 559 | is True |
| 560 | ) |
| 561 | assert ( |
| 562 | author_loop_complete("mechanical_only", stamp_digest=None, current_digest=digest) is False |
| 563 | ) |
| 564 | other = "sha256:" + ("b" * 64) |
| 565 | assert ( |
| 566 | author_loop_complete("mechanical_only", stamp_digest=other, current_digest=digest) is False |
| 567 | ) |
| 568 | assert author_loop_complete("absent", stamp_digest=digest, current_digest=digest) is False |
| 569 | |
| 570 | |
| 571 | def test_aff_hold_bypassed(repo_root: Path) -> None: |
| 572 | from tests.fixtures.aff import seed_aff_repo |
| 573 | |
| 574 | cfg = seed_aff_repo(repo_root, adversarial_freeze="suggest", honesty_enabled=True) |
| 575 | assert aff_hold_bypassed(cfg) is False |
| 576 | cfg_off = seed_aff_repo(repo_root, adversarial_freeze="off", honesty_enabled=True) |
| 577 | assert aff_hold_bypassed(cfg_off) is True |
| 578 | cfg_dis = seed_aff_repo(repo_root, adversarial_freeze="suggest", honesty_enabled=False) |
| 579 | assert aff_hold_bypassed(cfg_dis) is True |
| 580 | cfg_req = seed_aff_repo(repo_root, adversarial_freeze="require", honesty_enabled=True) |
| 581 | assert aff_hold_bypassed(cfg_req) is False |
| 582 | |
| 583 | |
| 584 | def test_helper_off_never_pending(repo_root: Path) -> None: |
| 585 | from tests.fixtures.aff import seed_aff_repo |
| 586 | from tools.adversarial_freeze import adversarial_authorization_state |
| 587 | |
| 588 | cfg = seed_aff_repo(repo_root, adversarial_freeze="off") |
| 589 | auth = adversarial_authorization_state(repo_root, repo_root / AFF_FREEZE_REL, config=cfg) |
| 590 | assert auth.state == "off" |
| 591 | assert auth.state != "pending" |
| 592 | |
| 593 | |
| 594 | def test_resolver_eligibility_rejects_malformed() -> None: |
| 595 | path = AFF_FREEZE_REL |
| 596 | digest = AFF_DIGEST_PLACEHOLDER |
| 597 | base = aff_body(artifact_digest=digest) |
| 598 | |
| 599 | empty_phase = {**base, "phase_id": ""} |
| 600 | assert ( |
| 601 | find_latest_adversarial_freeze_verdict( |
| 602 | [empty_phase], frozen_spec=path, artifact_digest=digest |
| 603 | ) |
| 604 | is None |
| 605 | ) |
| 606 | |
| 607 | bool_round = {**base, "round": True} |
| 608 | assert ( |
| 609 | find_latest_adversarial_freeze_verdict( |
| 610 | [bool_round], frozen_spec=path, artifact_digest=digest |
| 611 | ) |
| 612 | is None |
| 613 | ) |
| 614 | |
| 615 | no_model = {**base} |
| 616 | del no_model["reviewer_model"] |
| 617 | assert ( |
| 618 | find_latest_adversarial_freeze_verdict( |
| 619 | [no_model], frozen_spec=path, artifact_digest=digest |
| 620 | ) |
| 621 | is None |
| 622 | ) |
| 623 | |
| 624 | skip_bad_phase = aff_body("aff-skip.json", artifact_digest=digest, phase_id="") |
| 625 | assert ( |
| 626 | find_latest_adversarial_freeze_verdict( |
| 627 | [skip_bad_phase], frozen_spec=path, artifact_digest=digest |
| 628 | ) |
| 629 | is None |
| 630 | ) |
| 631 | |
| 632 | |
| 633 | def test_frv_authorizing_freeze_paths_only_substantive(repo_root: Path) -> None: |
| 634 | from tests.fixtures.aff import seed_aff_repo, write_mechanical_stamp |
| 635 | from tools.honesty.ledger import append_entry |
| 636 | from tools.honesty.types import LedgerAppendOptions |
| 637 | |
| 638 | cfg = seed_aff_repo(repo_root, adversarial_freeze="suggest") |
| 639 | digest = write_mechanical_stamp(repo_root) |
| 640 | path = repo_root / AFF_FREEZE_REL |
| 641 | # mechanical only — not substantive |
| 642 | only_mech = frv_authorizing_freeze_paths( |
| 643 | repo_root, [path], phase_id="AFF-b", config=cfg |
| 644 | ) |
| 645 | assert only_mech == [] |
| 646 | |
| 647 | append_entry( |
| 648 | config=cfg, |
| 649 | repo_root=repo_root, |
| 650 | options=LedgerAppendOptions( |
| 651 | kind="freeze_review", |
| 652 | body={ |
| 653 | "actor_role": "verifier", |
| 654 | "actor_session_id": "frv-1", |
| 655 | "phase_id": "AFF-b", |
| 656 | "frozen_spec": AFF_FREEZE_REL, |
| 657 | "round": 1, |
| 658 | "gate": "substantive", |
| 659 | "freeze_verdict": "pass", |
| 660 | "artifact_digest": digest, |
| 661 | "reviewer_model": "thinking-high", |
| 662 | }, |
| 663 | ), |
| 664 | ) |
| 665 | authorizing = frv_authorizing_freeze_paths( |
| 666 | repo_root, [path], phase_id="AFF-b", config=cfg |
| 667 | ) |
| 668 | assert authorizing == [path] |
| 669 | |
| 670 | |
| 671 | def test_aggregate_rank_absent_pending_skipped_pass() -> None: |
| 672 | assert aggregate_adversarial_authorization_states(["pass", "pending"]) == "pending" |
| 673 | assert aggregate_adversarial_authorization_states(["pass", "absent"]) == "absent" |
| 674 | assert aggregate_adversarial_authorization_states(["skipped", "pass"]) == "skipped" |
| 675 | assert aggregate_adversarial_authorization_states(["pass", "pass"]) == "pass" |
| 676 | assert ( |
| 677 | aggregate_adversarial_authorization_states(["absent", "pending", "skipped", "pass"]) |
| 678 | == "absent" |
| 679 | ) |