"""Temporary artificial formatting fixtures; no task answers or study inputs.""" import copy import json from pathlib import Path import subprocess import sys import tempfile import unittest from unittest import mock import assemble_observation as assembler class ObservationTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory(prefix="artificial-observation-fixture-") self.addCleanup(self.temp.cleanup) self.root = Path(self.temp.name) self.manifest_path = self.root/"PRIVATE-COORDINATOR-MANIFEST.json" self.model = self.root/"model-only" self.audit = self.root/"coordinator-only" self.template_bytes = (Path(assembler.__file__).resolve().parent.parent/"treatment-ablations"/"treatment-reference.txt").read_bytes() template = self.put("matched-template.txt", self.template_bytes) self.task_text = "# FIXTURE-TASK: Artificial parser fixture\r\n\r\n- **R1:** Artificial public requirement label; no task answer.\r\n\r\n### S1 — Artificial source fixture\r\n- **L1:** Synthetic source text for formatting checks only.\r\n" self.current_text = 'Artificial current text. Café.\r\nQuotes: "x"; tab:\t. [S1:L1]\r\n' current = dict(artifact_id="a3", sequence=3, **self.put("PRIVATE-CURRENT-PATH.txt", self.current_text.encode())) earlier = [dict(artifact_id=f"a{i}", sequence=i, **self.put(f"older-{i}.txt", f"Artificial earlier text {i}.\r\n".encode())) for i in (1, 2)] instructions = [dict(instruction_id=f"i{i}", sequence=i, **self.put(f"directive-{i}.txt", f"Artificial directive {i}.\r\n".encode())) for i in (1, 2, 3)] defaults = json.loads((Path(assembler.__file__).resolve().parent/"manifest.template.json").read_text())["bounds"] self.manifest = dict(manifest_version="1.0", assembly_id="PRIVATE-ASSEMBLY-IDENTITY", template=template, task_packet=dict(task_id="FIXTURE-TASK", **self.put("public-packet.txt", self.task_text.encode())), current_artifact=current, earlier_artifacts=earlier, previous_instructions=instructions, memory=dict(**self.put("memory.json", b"[]"), token_attestation=None), bounds=defaults) def put(self, filename, content): path = self.root/filename path.parent.mkdir(parents=True, exist_ok=True) path.write_bytes(content) return dict(path=filename, sha256=assembler.sha(content)) def assemble(self, model=None, audit=None): self.manifest_path.write_bytes(json.dumps(self.manifest).encode()) return assembler.assemble(self.manifest_path, model or self.model, audit or self.audit) def field(self, name, model=None): rendered = ((model or self.model)/"planner-input.txt").read_bytes().decode() return json.loads(rendered.split(name+"\n", 1)[1].split("\n", 1)[0]) def set_memory(self, evidence=None): memory = [dict(id="m1", kind="observation", statement="Artificial attributable note; no study observation.", evidence=evidence or [dict(artifact_id="a2", location="line 1")], status="unresolved")] content = json.dumps(memory, indent=2).encode() value = assembler.canonical(memory).encode() self.manifest["memory"] = dict(**self.put("memory.json", content), token_attestation=dict(tokenizer="artificial-fixture-attestation-not-a-tokenizer", serialized_sha256=assembler.sha(value), token_count=100)) return memory def assert_no_outputs(self): self.assertFalse(self.model.exists()) self.assertFalse(self.audit.exists()) def test_deterministic_rendering_and_template_contract_unchanged(self): self.assemble() second = self.root/"second-model" self.assemble(second, self.root/"second-audit") first_bytes = (self.model/"planner-input.txt").read_bytes() self.assertEqual(first_bytes, (second/"planner-input.txt").read_bytes()) expected = self.template_bytes.decode() values = dict(TASK_PACKET_JSON=self.task_text, CURRENT_ARTIFACT_JSON=dict(artifact_id="a3", text=self.current_text), EARLIER_ARTIFACTS_JSON=[dict(artifact_id=f"a{i}", text=f"Artificial earlier text {i}.\r\n") for i in (1, 2)], PREVIOUS_INSTRUCTIONS_JSON=[dict(instruction_id=f"i{i}", text=f"Artificial directive {i}.\r\n") for i in (1, 2, 3)], PERSISTENT_MEMORY_JSON=[]) for name, value in values.items(): expected = expected.replace("{{"+name+"}}", assembler.canonical(value)) self.assertEqual(first_bytes.decode(), expected) self.assertIn(b"within 800 tokens", first_bytes) self.assertIn(b"within 1,200 tokens", first_bytes) def test_supplied_text_and_provenance_separation(self): self.assemble() self.assertEqual(self.field("CURRENT_ARTIFACT_JSON"), dict(artifact_id="a3", text=self.current_text)) self.assertEqual(self.field("IMMUTABLE_TASK_PACKET_JSON"), self.task_text) self.assertEqual(self.field("PREVIOUS_WORKER_INSTRUCTIONS_JSON")[0]["text"], "Artificial directive 1.\r\n") self.assertEqual(set(self.field("CURRENT_ARTIFACT_JSON")), {"artifact_id", "text"}) model_bytes = (self.model/"planner-input.txt").read_bytes() self.assertNotIn(b"PRIVATE-", model_bytes) self.assertNotIn(self.manifest["current_artifact"]["sha256"].encode(), model_bytes) self.assertEqual([p.name for p in self.model.iterdir()], ["planner-input.txt"]) record = json.loads((self.audit/"assembly-record.json").read_text()) self.assertFalse(record["semantic_provenance_validated"]) self.assertEqual(record["model_input_sha256"], assembler.sha(model_bytes)) self.assertEqual((self.root/"PRIVATE-CURRENT-PATH.txt").read_bytes(), self.current_text.encode()) def test_empty_initial_history_and_memory(self): self.manifest["current_artifact"]["sequence"] = 1 self.manifest["earlier_artifacts"] = [] self.manifest["previous_instructions"] = [] self.assemble() for field in ("EARLIER_ARTIFACTS_JSON", "PREVIOUS_WORKER_INSTRUCTIONS_JSON", "PERSISTENT_MEMORY_JSON"): self.assertEqual(self.field(field), []) def test_typed_memory_and_declared_token_count_binding(self): memory = self.set_memory([dict(artifact_id="a2", location="line 1"), dict(source_id="S1", location="L1"), dict(requirement_id="R1", location="public requirement")]) self.assemble() self.assertEqual(self.field("PERSISTENT_MEMORY_JSON"), memory) record = json.loads((self.audit/"assembly-record.json").read_text()) self.assertFalse(record["token_count_independently_verified"]) self.assertEqual(record["memory_token_attestation"]["token_count"], 100) def test_invalid_evidence_references_rejected(self): cases = [dict(artifact_id="not-supplied", location="line 1"), dict(source_id="S9", location="L1"), dict(requirement_id="R9", location="requirement"), dict(artifact_id="a2", source_id="S1", location="line 1"), dict(artifact_id="a2"), dict(artifact_id="a2", location="")] for evidence in cases: self.set_memory([evidence]) with self.subTest(evidence=evidence), self.assertRaises(assembler.AssemblyError): self.assemble() self.assert_no_outputs() def test_excess_history_is_rejected_not_trimmed(self): for bound, value in (("max_earlier_artifacts", 1), ("max_previous_instructions", 2)): original = self.manifest["bounds"][bound] self.manifest["bounds"][bound] = value with self.subTest(bound=bound), self.assertRaisesRegex(assembler.AssemblyError, "excess/invalid"): self.assemble() self.manifest["bounds"][bound] = original self.assert_no_outputs() self.manifest["bounds"]["max_earlier_artifacts"] = 3 with self.assertRaisesRegex(assembler.AssemblyError, "at most two"): self.assemble() def test_byte_memory_entry_and_token_bounds(self): self.manifest["bounds"]["max_artifact_bytes"] = len(self.current_text.encode())-1 with self.assertRaisesRegex(assembler.AssemblyError, "byte bound"): self.assemble() self.manifest["bounds"]["max_artifact_bytes"] = 262144 self.set_memory() self.manifest["bounds"]["max_memory_entries"] = 0 with self.assertRaisesRegex(assembler.AssemblyError, "memory entries"): self.assemble() self.manifest["bounds"]["max_memory_entries"] = 32 self.manifest["memory"]["token_attestation"]["token_count"] = 1201 with self.assertRaisesRegex(assembler.AssemblyError, "token cap"): self.assemble() self.manifest["memory"]["token_attestation"]["token_count"] = 100 self.manifest["memory"]["token_attestation"]["serialized_sha256"] = "0"*64 with self.assertRaisesRegex(assembler.AssemblyError, "not bound"): self.assemble() self.assert_no_outputs() def test_excluded_metadata_fields_rejected(self): for field in ("ratings", "worker_reports", "execution_traces", "resource_records", "planner_responses"): self.manifest[field] = [] with self.subTest(field=field), self.assertRaisesRegex(assembler.AssemblyError, "excluded/unknown"): self.assemble() del self.manifest[field] self.set_memory() memory = json.loads((self.root/"memory.json").read_text()) memory[0]["score"] = 0 self.manifest["memory"].update(self.put("memory.json", json.dumps(memory).encode())) with self.assertRaisesRegex(assembler.AssemblyError, "excluded/unknown"): self.assemble() self.assert_no_outputs() def test_recognizable_assessor_path_is_not_read(self): self.manifest["current_artifact"].update(self.put("assessor-only/fixture-guide.txt", b"Artificial excluded-path fixture")) with self.assertRaisesRegex(assembler.AssemblyError, "excluded assessment/operational path"): self.assemble() self.assert_no_outputs() def test_chronology_future_instructions_and_unique_ids(self): original = copy.deepcopy(self.manifest) self.manifest["earlier_artifacts"].reverse() with self.assertRaisesRegex(assembler.AssemblyError, "chronological"): self.assemble() self.manifest = copy.deepcopy(original) self.manifest["previous_instructions"][2]["sequence"] = 4 with self.assertRaisesRegex(assembler.AssemblyError, "already submitted"): self.assemble() self.manifest = copy.deepcopy(original) self.manifest["previous_instructions"][0]["instruction_id"] = "a1" with self.assertRaisesRegex(assembler.AssemblyError, "duplicate/ambiguous"): self.assemble() self.assert_no_outputs() def test_utf8_hash_and_unresolved_placeholders(self): descriptor = self.manifest["current_artifact"] descriptor.update(self.put("PRIVATE-CURRENT-PATH.txt", b"\xff")) with self.assertRaises(UnicodeError): self.assemble() descriptor.update(self.put("PRIVATE-CURRENT-PATH.txt", b"Artificial {{UNRESOLVED}} text")) with self.assertRaisesRegex(assembler.AssemblyError, "unresolved placeholder"): self.assemble() descriptor["sha256"] = "0"*64 with self.assertRaisesRegex(assembler.AssemblyError, "hash mismatch"): self.assemble() self.assert_no_outputs() def test_modified_template_is_not_accepted(self): content = self.template_bytes.replace(b"Principles:", b"Altered principles:") self.manifest["template"] = self.put("changed-template.txt", content) with self.assertRaisesRegex(assembler.AssemblyError, "unchanged matched treatment"): self.assemble() self.assert_no_outputs() def test_only_explicit_input_files_are_read(self): self.manifest_path.write_bytes(json.dumps(self.manifest).encode()) self.put("undeclared-secret.txt", b"Artificial undeclared sentinel, not for loading") expected = {self.manifest_path.resolve()} for value in [self.manifest["template"], self.manifest["task_packet"], self.manifest["current_artifact"], self.manifest["memory"], *self.manifest["earlier_artifacts"], *self.manifest["previous_instructions"]]: expected.add((self.root/value["path"]).resolve()) seen = set() original_open = Path.open def recorded_open(path, mode="r", *args, **kwargs): if mode in ("r", "rb"): seen.add(path.resolve()) return original_open(path, mode, *args, **kwargs) with mock.patch.object(Path, "open", recorded_open): assembler.assemble(self.manifest_path, self.model, self.audit) self.assertEqual(seen, expected) def test_existing_outputs_and_cli_refusal(self): self.assemble() before = (self.model/"planner-input.txt").read_bytes() command = [sys.executable, "-B", str(Path(assembler.__file__).resolve()), "--manifest", str(self.manifest_path), "--model-dir", str(self.model), "--provenance-dir", str(self.audit)] run = subprocess.run(command, capture_output=True, text=True, check=False) self.assertEqual(run.returncode, 2) self.assertEqual(run.stdout, "") self.assertIn("refusing existing output", json.loads(run.stderr)["error"]) self.assertEqual((self.model/"planner-input.txt").read_bytes(), before) if __name__ == "__main__": unittest.main()