"""Temporary artificial B2 parser/archive fixtures; no study inputs or findings.""" import copy import json import unittest from unittest import mock import audit_boundary as audit import b2_contract as b2 import test_initial_contract as fixtures class B2AuditTests(unittest.TestCase): def setUp(self): self.base = fixtures.InitialAuditTests() self.base.setUp() self.addCleanup(self.base.doCleanups) self.f, self.sealer = self.base.f, self.base.sealer self.values = copy.deepcopy(self.base.base.values) self.feedback = "Artificial feedback fixture. Café.\r\nNo task judgment.\r\n".encode() self.row = self.f.manifest["runs"][1] self.run = self.sealer.source["runs"][1] self.critique_id = "artificial-b2-critique" self.revision_id = self.row["request_slots"][-1]["attempt_id"] self.response_id = "artificial-b2-response" self.sealer.add_record("artificial-b2-critique-input", "submitted_prompt", self.render("critique")) self.sealer.add_record(self.response_id, "operational_record", self.feedback) self.run["record_ids"] += ["artificial-b2-critique-input", self.response_id] self.run["attempts"].append(dict(attempt_id=self.critique_id, phase="adaptation", role="critic", status="succeeded", retry_of=None, started_at_utc=None, ended_at_utc=None, record_ids=["artificial-b2-critique-input", self.response_id])) self.row["continuation_input"] = dict(contract=b2.CONTRACT, packet_inventory_complete=True, pairs=[ dict(pair_id="artificial-pair", critique_attempts=[dict(attempt_id=self.critique_id, response_state="available", response_record_id=self.response_id, response_sha256=audit.sealing.sha(self.feedback))], revision_attempts=[dict(attempt_id=self.revision_id, critique_attempt_id=self.critique_id)], revision_coverage="attempted")]) self.row["packets"][-1]["sequence"] = 3 self.row["packets"].insert(1, dict(input_scope="continuation", packet_id="artificial-critique-packet", attempt_id=self.critique_id, sequence=2, record_id="artificial-b2-critique-input", sha256=audit.sealing.sha(self.render("critique")))) self.set_input("revision") self.reseal() @property def pair(self): return self.row["continuation_input"]["pairs"][0] def render(self, role, values=None, feedback=None, pretty=False): fields = copy.deepcopy(self.values if values is None else values) if role == "revision": fields["CURRENT_CRITIQUE_JSON"] = (self.feedback if feedback is None else feedback).decode("utf-8") content = b2.TEMPLATES[role][0].read_bytes().decode() for name, value in fields.items(): content = content.replace("{{"+name+"}}", json.dumps(value, ensure_ascii=False, indent=2 if pretty else None)) return content.encode() def set_input(self, role, raw=None): aid = self.critique_id if role == "critique" else self.revision_id packet = next(p for p in self.row["packets"] if p["attempt_id"] == aid) raw = self.render(role) if raw is None else raw self.base.base.replace_source(packet["record_id"], raw) self.f.packet_bytes[packet["record_id"]] = raw packet["sha256"] = audit.sealing.sha(raw) def reseal(self): self.base.base.reseal() def validate(self, role, raw): return b2.validate_input(raw, self.base.base.bounds, self.base.base.tid, self.base.base.public_hash, role) def result(self, value=0): return self.base.result(self.base.completed(value)) def b2_result(self, report): return report["series"]["independent:artificial-reviewer-a"]["by_condition"]["B1"] def add_revision_retry(self): original = next(a for a in self.run["attempts"] if a["attempt_id"] == self.revision_id) retry_id = "artificial-revision-retry" self.run["attempts"].append(dict(original, attempt_id=retry_id, retry_of=self.revision_id, status="failed")) self.row["request_slots"].append(dict(attempt_id=retry_id, kind="continuation")) self.pair["revision_attempts"].append(dict(attempt_id=retry_id, critique_attempt_id=self.critique_id)) self.row["packets"].append(dict(self.row["packets"][-1], packet_id="revision-retry-packet", attempt_id=retry_id, sequence=4)) def add_second_pair(self): values = copy.deepcopy(self.values) values["CURRENT_ARTIFACT_JSON"]["text"] += "\nArtificial second-pair context." feedback = b"Second artificial feedback fixture, no study judgment.\n" for role, rid, kind, content in (("critique", "second-critique-input", "submitted_prompt", self.render("critique", values)), ("response", "second-response", "operational_record", feedback), ("revision", "second-revision-input", "submitted_prompt", self.render("revision", values, feedback))): self.sealer.add_record(rid, kind, content) self.run["record_ids"].append(rid) for role in ("critique", "revision"): aid = "second-"+role record_ids = [aid+"-input"]+(["second-response"] if role == "critique" else []) self.run["attempts"].append(dict(attempt_id=aid, phase="adaptation", role="critic" if role == "critique" else "worker", status="succeeded", retry_of=None, started_at_utc=None, ended_at_utc=None, record_ids=record_ids)) raw = self.render(role, values, feedback) self.row["packets"].append(dict(input_scope="continuation", packet_id=aid+"-packet", attempt_id=aid, sequence=4 if role == "critique" else 5, record_id=aid+"-input", sha256=audit.sealing.sha(raw))) self.row["request_slots"].append(dict(attempt_id="second-revision", kind="continuation")) self.row["continuation_input"]["pairs"].append(dict(pair_id="second-pair", revision_coverage="attempted", critique_attempts=[dict(attempt_id="second-critique", response_state="available", response_record_id="second-response", response_sha256=audit.sealing.sha(feedback))], revision_attempts=[dict(attempt_id="second-revision", critique_attempt_id="second-critique")])) self.reseal() def test_valid_wrappers_noncanonical_json_and_text_preservation(self): for role in ("critique", "revision"): for pretty in (False, True): values = self.validate(role, self.render(role, pretty=pretty)) self.assertEqual({k: values[k] for k in b2.CONTEXT}, self.values) if role == "revision": self.assertEqual(values["CURRENT_CRITIQUE_JSON"].encode(), self.feedback) else: self.assertNotIn("CURRENT_CRITIQUE_JSON", values) def test_mixed_combined_audit_copies_only_requests_and_separates_condition_coverage(self): context = self.f.prepare() kinds = [c["kind"] for c in context["copies"]] self.assertIn("b2_critique_input", kinds) self.assertIn("b2_revision_input", kinds) self.assertNotIn(self.feedback, [(self.f.output/c["path"]).read_bytes() for c in context["copies"]]) report = self.result() stats = self.b2_result(report)["b2_pair_coverage"] self.assertEqual(stats["fully_linked_pair_count"], 1) self.assertEqual(stats["assigned_run_denominator"], 1) self.assertEqual(report["series"]["independent:artificial-reviewer-a"]["overall"]["assigned_run_denominator"], 2) self.assertNotIn("b2_pair_coverage", report["series"]["independent:artificial-reviewer-a"]["by_condition"]["C"]) self.assertFalse(report["whole_run_compliance_certified"]) self.assertFalse(report["semantic_absence_of_restricted_information_certified"]) def test_altered_wrappers_extra_memory_prose_and_stale_critique_fields_rejected(self): for role in ("critique", "revision"): valid = self.render(role) for invalid in (b"extra\n"+valid, valid+b"extra", valid[:-1], valid+b"\nPERSISTENT_MEMORY_JSON\n[]\n"): with self.assertRaises(ValueError): self.validate(role, invalid) with self.assertRaises(ValueError): self.validate("critique", self.render("critique")+b'\nCURRENT_CRITIQUE_JSON\n"old"\n') def test_public_packet_hash_history_bounds_identity_and_invalid_json_rejected(self): for field in ("packet", "history", "identity", "instructions"): values = copy.deepcopy(self.values) if field == "packet": values["TASK_PACKET_JSON"] += "\nchanged" elif field == "history": values["EARLIER_ARTIFACTS_JSON"] += [dict(artifact_id="a0", text="Artificial extra")] elif field == "identity": values["CURRENT_ARTIFACT_JSON"]["artifact_id"] = "R1" else: values["PREVIOUS_INSTRUCTIONS_JSON"] *= 5 with self.assertRaises(ValueError): self.validate("critique", self.render("critique", values)) raw = self.render("critique").replace(b'"artifact_id": "a3"', b'"artifact_id":"a3","artifact_id":"a4"') with self.assertRaises(ValueError): self.validate("critique", raw) for bad in (self.render("critique")+b"\xff", self.render("critique").replace(b'"a3"', b'"{{UNRESOLVED}}"')): with self.assertRaises(ValueError): self.validate("critique", bad) def test_paired_context_mismatch_rejected_before_output(self): values = copy.deepcopy(self.values) values["CURRENT_ARTIFACT_JSON"]["text"] += "\nArtificial change between critique and revision." self.set_input("revision", self.render("revision", values)) self.reseal() with self.assertRaisesRegex(ValueError, "context mismatch"): self.f.prepare() self.assertFalse(self.f.output.exists()) def test_exact_response_binding_preserves_crlf_and_never_strips_text(self): self.set_input("revision", self.render("revision", feedback=self.feedback.replace(b"\r\n", b"\n"))) self.reseal() with self.assertRaisesRegex(ValueError, "exact linked archived response"): self.f.prepare() def test_response_hash_kind_and_attempt_identity_mismatches_rejected(self): self.pair["critique_attempts"][0]["response_sha256"] = "0"*64 with self.assertRaisesRegex(ValueError, "response hash"): self.f.prepare() self.pair["critique_attempts"][0]["response_sha256"] = audit.sealing.sha(self.feedback) attempt = next(a for a in self.run["attempts"] if a["attempt_id"] == self.critique_id) attempt["record_ids"].remove(self.response_id) self.reseal() with self.assertRaisesRegex(ValueError, "not linked"): self.f.prepare() attempt["record_ids"].append(self.response_id) record = next(r for r in self.sealer.source["records"] if r["record_id"] == self.response_id) record["kind"] = "artifact" self.reseal() with self.assertRaisesRegex(ValueError, "never a delivered artifact"): self.f.prepare() def test_missing_critique_response_is_unknown_not_recovered_from_revision(self): self.pair["critique_attempts"][0].update(response_state="unavailable", response_record_id=None, response_sha256=None) self.f.prepare() stats = self.b2_result(self.result()) self.assertEqual(stats["counts"]["unassessed"], 1) self.assertEqual(stats["b2_pair_coverage"]["unavailable_response_count"], 1) self.assertEqual(stats["b2_pair_coverage"]["fully_linked_pair_count"], 0) def test_missing_input_requests_keep_unknown_and_explicit_denominators(self): self.row["packets"][1].update(record_id=None, sha256=None) self.f.prepare() report = self.result() stats = self.b2_result(report) self.assertEqual(stats["counts"]["unassessed"], 1) self.assertEqual(stats["b2_pair_coverage"]["missing_input_count"], 1) self.assertEqual(report["series"]["independent:artificial-reviewer-a"]["overall"]["assigned_run_denominator"], 2) def test_failed_revision_retry_kept_without_filtering(self): self.add_revision_retry() self.reseal() self.f.prepare() report = self.result() row = report["series"]["independent:artificial-reviewer-a"]["runs"][1] pair = row["b2_pair_coverage"]["pairs"][0] self.assertEqual(pair["revision_attempt_count"], 2) self.assertEqual(pair["attempt_status_counts"]["failed"], 1) self.assertEqual(pair["verified_revision_link_count"], 2) self.assertEqual(row["status"], "compliant") def test_critic_transport_retry_with_declared_no_response_keeps_both_attempts(self): original = next(a for a in self.run["attempts"] if a["attempt_id"] == self.critique_id) retry_id = "artificial-critique-retry" self.run["attempts"].append(dict(original, attempt_id=retry_id, retry_of=self.critique_id)) original["status"] = "failed" original["record_ids"] = ["artificial-b2-critique-input"] self.pair["critique_attempts"].append(dict(self.pair["critique_attempts"][0], attempt_id=retry_id)) self.pair["critique_attempts"][0].update(response_state="not_produced", response_record_id=None, response_sha256=None) self.pair["revision_attempts"][0]["critique_attempt_id"] = retry_id self.row["packets"][-1]["sequence"] = 4 self.row["packets"].insert(2, dict(self.row["packets"][1], packet_id="critic-retry-packet", attempt_id=retry_id, sequence=3)) self.reseal() self.f.prepare() stats = self.b2_result(self.result())["b2_pair_coverage"] self.assertEqual(stats["declared_not_produced_response_count"], 1) self.assertEqual(stats["fully_linked_pair_count"], 1) def remove_revision(self, coverage="not_attempted"): self.run["attempts"] = [a for a in self.run["attempts"] if a["attempt_id"] != self.revision_id] self.row["request_slots"] = [s for s in self.row["request_slots"] if s["attempt_id"] != self.revision_id] self.row["packets"] = [p for p in self.row["packets"] if p["attempt_id"] != self.revision_id] self.pair.update(revision_attempts=[], revision_coverage=coverage) self.reseal() def test_known_critique_without_revision_is_separate_from_unknown_revision_history(self): self.remove_revision() self.f.prepare() stats = self.b2_result(self.result()) self.assertEqual(stats["b2_pair_coverage"]["critique_without_revision_count"], 1) self.assertEqual(stats["b2_pair_coverage"]["fully_linked_pair_count"], 0) self.assertEqual(stats["counts"]["compliant"], 1) # Scoped inputs only, not task/method completion. def test_unknown_revision_history_withholds_scoped_compliance(self): self.remove_revision("unknown") self.f.prepare() stats = self.b2_result(self.result()) self.assertEqual(stats["counts"]["unassessed"], 1) self.assertEqual(stats["b2_pair_coverage"]["unknown_revision_coverage_pair_count"], 1) def test_revision_cannot_link_unproduced_response_or_other_pair(self): self.pair["critique_attempts"][0].update(response_state="not_produced", response_record_id=None, response_sha256=None) with self.assertRaisesRegex(ValueError, "unproduced response"): self.f.prepare() self.pair["critique_attempts"][0].update(response_state="available", response_record_id=self.response_id, response_sha256=audit.sealing.sha(self.feedback)) self.pair["revision_attempts"][0]["critique_attempt_id"] = "another-pair-attempt" with self.assertRaisesRegex(ValueError, "own pair"): self.f.prepare() def test_missing_designations_duplicate_pairs_and_unsupported_contract_rejected(self): original = copy.deepcopy(self.row["continuation_input"]) for case in ("missing", "duplicate", "version", "extra"): with self.subTest(case=case): if case == "missing": self.row["continuation_input"]["pairs"] = [] elif case == "duplicate": self.row["continuation_input"]["pairs"].append(copy.deepcopy(self.pair)) elif case == "version": self.row["continuation_input"]["contract"] = "b2-critique-revision/2.0" else: self.pair["scores"] = [] with self.assertRaises(ValueError): self.f.prepare() self.row["continuation_input"] = copy.deepcopy(original) def test_continuation_only_and_initial_only_scope_do_not_imply_whole_run_compliance(self): self.base.select_scope("continuation-only") self.f.prepare() report = self.result() row = report["series"]["independent:artificial-reviewer-a"]["runs"][1] self.assertEqual(row["audit_scope"], "continuation-only") self.assertFalse(row["input_scope_coverage"]["initial"]["in_scope"]) self.assertFalse(row["whole_run_compliance_certified"]) def test_initial_only_does_not_silently_audit_b2_inputs(self): self.base.select_scope("initial-only") self.f.prepare() report = self.result() row = report["series"]["independent:artificial-reviewer-a"]["runs"][1] self.assertNotIn("b2_pair_coverage", row) self.assertEqual(row["audit_scope"], "initial-only") self.assertFalse(row["whole_run_compliance_certified"]) def test_human_violation_survives_incomplete_pair_evidence_and_other_series_stay_unknown(self): self.pair["critique_attempts"][0].update(response_state="unavailable", response_record_id=None, response_sha256=None) self.f.prepare() report = self.result(1) self.assertEqual(self.b2_result(report)["counts"]["noncompliant"], 1) self.assertEqual(report["series"]["adjudicated"]["overall"]["counts"]["unassessed"], 2) def test_no_overwrites_unsealed_inputs_and_tampered_copies_rejected(self): context = self.f.prepare() with self.assertRaises(ValueError): self.f.prepare() copy_row = next(c for c in context["copies"] if c["kind"] == "b2_revision_input") copied = self.f.output/copy_row["path"] original = copied.read_bytes() copied.write_bytes(original+b"tamper") with self.assertRaises(ValueError): self.result() copied.write_bytes(original) (self.sealer.output/"packet-build-manifest.json").unlink() with self.assertRaisesRegex(ValueError, "unsealed"): self.result() def test_template_pins_and_revision_critique_type(self): with mock.patch.dict(b2.TEMPLATES, {"critique": (b2.TEMPLATES["critique"][0], "0"*64)}): with self.assertRaisesRegex(ValueError, "template hash"): self.validate("critique", self.render("critique")) raw = self.render("revision") raw = raw.rsplit(b"CURRENT_CRITIQUE_JSON\n", 1)[0]+b"CURRENT_CRITIQUE_JSON\n{}\n" with self.assertRaisesRegex(ValueError, "JSON string"): self.validate("revision", raw) def test_multiple_pairs_allow_distinct_contexts_without_cross_pair_response_reuse(self): self.add_second_pair() self.f.prepare() stats = self.b2_result(self.result())["b2_pair_coverage"] self.assertEqual(stats["pair_denominator"], 2) self.assertEqual(stats["fully_linked_pair_count"], 2) self.assertEqual(stats["assigned_run_denominator"], 1) def test_cross_pair_response_record_and_valid_foreign_attempt_links_rejected(self): self.add_second_pair() other = self.row["continuation_input"]["pairs"][1] other["revision_attempts"][0]["critique_attempt_id"] = self.critique_id with self.assertRaisesRegex(ValueError, "own pair"): self.f.prepare() other["revision_attempts"][0]["critique_attempt_id"] = "second-critique" other["critique_attempts"][0].update(response_record_id=self.response_id, response_sha256=audit.sealing.sha(self.feedback)) with self.assertRaisesRegex(ValueError, "reused across pairs"): self.f.prepare() def test_linked_critique_must_precede_revision_without_inferred_stages(self): critic, revision = self.row["packets"][1:] critic["sequence"], revision["sequence"] = 3, 2 self.row["packets"][1:] = [revision, critic] with self.assertRaisesRegex(ValueError, "must precede"): self.f.prepare() def test_missing_revision_input_and_omitted_retry_are_not_hidden(self): self.add_revision_retry() self.reseal() original = self.pair["revision_attempts"].pop() with self.assertRaises(ValueError): self.f.prepare() self.pair["revision_attempts"].append(original) self.row["packets"][-1].update(record_id=None, sha256=None) self.f.prepare() stats = self.b2_result(self.result()) self.assertEqual(stats["counts"]["unassessed"], 1) self.assertEqual(stats["b2_pair_coverage"]["missing_input_count"], 1) def test_wrong_role_response_linkage_and_repeated_attempts_rejected(self): original = self.pair["critique_attempts"][0]["attempt_id"] self.pair["critique_attempts"][0]["attempt_id"] = self.revision_id with self.assertRaisesRegex(ValueError, "wrong-role"): self.f.prepare() self.pair["critique_attempts"][0]["attempt_id"] = original self.pair["critique_attempts"].append(copy.deepcopy(self.pair["critique_attempts"][0])) with self.assertRaisesRegex(ValueError, "duplicate B2 attempt"): self.f.prepare() def test_adjudicated_and_independent_series_stay_separate(self): self.f.prepare() forms = [self.base.completed(0), self.base.completed(1, "independent-2.blank.json"), self.base.completed(0, "adjudicated.blank.json")] for row in forms[-1]["ratings"]: row.update(independent_judgments=[0, 1], resolution_note="Artificial resolution fixture, no study judgment.") paths = [self.f.write_form(form, str(i)+".json") for i, form in enumerate(forms)] report = self.f.summarize(paths) self.assertEqual(self.b2_result(report)["counts"]["compliant"], 1) self.assertEqual(report["series"]["independent:artificial-reviewer-b"]["by_condition"]["B1"]["counts"]["noncompliant"], 1) self.assertEqual(report["series"]["adjudicated"]["by_condition"]["B1"]["counts"]["compliant"], 1) if __name__ == "__main__": unittest.main()