"""Temporary artificial byte-capture fixtures, never actual study deliverables.""" import io import json from pathlib import Path import subprocess import sys import tempfile import unittest from unittest import mock import capture_text_artifact as capture_tool sys.path.insert(0, str(capture_tool.BASE.parent/"permitted-observations")) import test_assemble_observation as assembly_fixtures import test_seal_runs as sealing_fixtures class CaptureTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory(prefix="artificial-text-capture-") self.addCleanup(self.temp.cleanup) self.root = Path(self.temp.name) self.source = self.root/"PRIVATE-SOURCE-FILENAME.txt" self.payload = b"\xef\xbb\xbf" + 'Artificial capture fixture. Café.\r\nQuotes: "x"; tab:\t.\r\n'.encode() self.source.write_bytes(self.payload) self.artifacts = self.root/"artifact-only" self.records = self.root/"coordinator-only" self.identity = dict(run_id="PRIVATE-RUN-ID", condition_id="PRIVATE-CONDITION-ID", task_id="FIXTURE-TASK", repetition_id="fixture-repetition", turn=3, artifact_id="a3") def capture(self, **overrides): identity = dict(self.identity) identity.update(overrides) return capture_tool.capture(self.source, self.artifacts, self.records, **identity) def record(self): return json.loads((self.records/"capture-record.json").read_text()) def assert_unpublished(self): self.assertFalse((self.records/"capture-record.json").exists()) def test_byte_preservation_identity_and_separate_hash_record(self): result = self.capture() artifact = self.artifacts/"artifact.txt" self.assertEqual(artifact.read_bytes(), self.payload) self.assertEqual(self.source.read_bytes(), self.payload) record = self.record() self.assertEqual(record["identity"], self.identity) self.assertEqual(record["source"]["sha256"], capture_tool.archive.sha(self.payload)) self.assertEqual(record["captured_artifact"]["sha256"], capture_tool.archive.sha(artifact.read_bytes())) self.assertEqual(record["source"]["bytes"], len(self.payload)) self.assertFalse(record["semantic_purity_verified"]) self.assertFalse(record["final_endpoint_selected"]) self.assertTrue(result["capture_complete"]) def test_no_metadata_or_neighbor_selection_in_artifact(self): neighbor = self.root/"different-artifact.txt" neighbor.write_bytes(b"Artificial alternative, not the designated source.") self.capture() self.assertEqual([p.name for p in self.artifacts.iterdir()], ["artifact.txt"]) self.assertNotIn(b"PRIVATE-", (self.artifacts/"artifact.txt").read_bytes()) self.assertIn("PRIVATE-RUN-ID", (self.records/"capture-record.json").read_text()) self.assertEqual((self.artifacts/"artifact.txt").read_bytes(), self.payload) self.assertEqual(neighbor.read_bytes(), b"Artificial alternative, not the designated source.") def test_diagnostic_looking_text_is_not_heuristically_stripped(self): payload = b"Artificial boilerplate-looking fixture.\nArtificial report-looking footer.\n" self.source.write_bytes(payload) self.capture() self.assertEqual((self.artifacts/"artifact.txt").read_bytes(), payload) self.assertFalse(self.record()["semantic_purity_verified"]) def test_empty_utf8_file_remains_empty_without_completion_claim(self): self.source.write_bytes(b"") self.capture() self.assertEqual((self.artifacts/"artifact.txt").read_bytes(), b"") self.assertEqual(self.record()["captured_artifact"]["bytes"], 0) self.assertFalse(self.record()["semantic_purity_verified"]) def test_missing_source_invalid_utf8_and_expected_hash_rejected(self): self.source.unlink() with self.assertRaisesRegex(capture_tool.archive.ValidationError, "missing/non-file"): self.capture() self.source.write_bytes(b"\xff") with self.assertRaises(UnicodeError): self.capture() self.source.write_bytes(self.payload) with self.assertRaisesRegex(capture_tool.archive.ValidationError, "hash mismatch"): self.capture(expected_source_sha256="0"*64) self.assertFalse(self.artifacts.exists()) self.assertFalse(self.records.exists()) def test_invalid_run_turn_and_artifact_identities_rejected(self): for overrides in [dict(run_id=""), dict(run_id=" trailing "), dict(condition_id=None), dict(task_id="x\ny"), dict(artifact_id="bad\x00id"), dict(repetition_id="\t"), dict(turn=0), dict(turn=-1), dict(turn=True), dict(turn=1.0)]: with self.subTest(overrides=overrides), self.assertRaises(capture_tool.archive.ValidationError): self.capture(**overrides) self.assertFalse(self.artifacts.exists()) self.assertFalse(self.records.exists()) def test_existing_destinations_are_not_overwritten(self): self.records.mkdir() sentinel = self.records/"existing.json" sentinel.write_bytes(b"Existing coordinator fixture") with self.assertRaisesRegex(capture_tool.archive.ValidationError, "existing output"): self.capture() self.assertEqual(sentinel.read_bytes(), b"Existing coordinator fixture") self.assertFalse(self.artifacts.exists()) def test_nested_and_broken_symlink_destinations_rejected(self): with self.assertRaises(capture_tool.archive.ValidationError): capture_tool.capture(self.source, self.artifacts, self.artifacts/"metadata", **self.identity) self.artifacts.symlink_to(self.root/"absent") with self.assertRaisesRegex(capture_tool.archive.ValidationError, "existing output"): self.capture() self.assertTrue(self.artifacts.is_symlink()) def test_failed_or_corrupt_payload_write_has_no_success_record(self): original_write = capture_tool.archive.write_bytes def partial(path, content): original_write(path, content[:3]) raise OSError("artificial interrupted payload write") with mock.patch.object(capture_tool.archive, "write_bytes", side_effect=partial): with self.assertRaisesRegex(OSError, "payload write"): self.capture() self.assert_unpublished() self.assertEqual(self.source.read_bytes(), self.payload) self.artifacts, self.records = self.root/"other-artifact", self.root/"other-record" def corrupt(path, content): original_write(path, content+b"artificial corruption") with mock.patch.object(capture_tool.archive, "write_bytes", side_effect=corrupt): with self.assertRaisesRegex(capture_tool.archive.ValidationError, "captured bytes/hash"): self.capture() self.assert_unpublished() def test_record_publication_failure_has_no_success_record(self): with mock.patch.object(capture_tool.os, "link", side_effect=OSError("artificial record commit failure")): with self.assertRaisesRegex(OSError, "commit failure"): self.capture() self.assert_unpublished() self.assertEqual((self.artifacts/"artifact.txt").read_bytes(), self.payload) self.assertFalse(list(self.records.glob(".pending-text-capture-*"))) def test_partial_record_write_is_never_published(self): real_tempfile = capture_tool.tempfile.NamedTemporaryFile class FailedRecord: def __init__(self, **kwargs): self.inner = real_tempfile(**kwargs) self.name = self.inner.name def __enter__(self): return self def write(self, content): self.inner.write(content[:10]) raise OSError("artificial partial metadata write") def __exit__(self, *args): self.inner.close() with mock.patch.object(capture_tool.tempfile, "NamedTemporaryFile", FailedRecord): with self.assertRaisesRegex(OSError, "partial metadata"): self.capture() self.assert_unpublished() self.assertFalse(list(self.records.glob(".pending-text-capture-*"))) def test_observation_assembler_accepts_capture_descriptor(self): fixture = assembly_fixtures.ObservationTests() fixture.setUp() self.addCleanup(fixture.doCleanups) self.capture() fixture.manifest["current_artifact"] = self.record()["observation_artifact"] fixture.assemble() self.assertEqual(fixture.field("CURRENT_ARTIFACT_JSON"), dict(artifact_id="a3", text=self.payload.decode("utf-8"))) def test_run_sealer_accepts_capture_record_without_auto_endpoint_selection(self): fixture = sealing_fixtures.SealingTests() fixture.setUp() self.addCleanup(fixture.doCleanups) run = fixture.source["runs"][0] self.capture(run_id=run["run_id"], condition_id=run["condition_id"], task_id=run["task_id"], repetition_id=run["repetition_id"], artifact_id="fixture-a-endpoint") record = self.record() fixture.source["records"] = [record["sealing_record"] if r["record_id"] == "fixture-a-endpoint" else r for r in fixture.source["records"]] fixture.seal() packet = capture_tool.archive.parse_json((fixture.output/"packet-build-manifest.json").read_bytes(), "fixture packet") endpoint = packet["runs"][0]["final_artifact"] self.assertEqual((fixture.output/endpoint["path"]).read_bytes(), self.payload) self.assertFalse(record["final_endpoint_selected"]) def test_cli_success_refusal_and_interrupt_status(self): command = [sys.executable, "-B", str(capture_tool.BASE/"capture_text_artifact.py"), "--source", str(self.source), "--artifact-dir", str(self.artifacts), "--record-dir", str(self.records), "--run-id", "fixture-run", "--condition-id", "fixture-condition", "--task-id", "FIXTURE-TASK", "--repetition-id", "fixture-repeat", "--artifact-id", "a3", "--turn", "3"] first = subprocess.run(command, capture_output=True, text=True, check=False) self.assertEqual(first.returncode, 0, first.stderr) self.assertTrue(json.loads(first.stdout)["capture_complete"]) repeated = subprocess.run(command, capture_output=True, text=True, check=False) self.assertEqual(repeated.returncode, 2) self.assertEqual(repeated.stdout, "") with mock.patch.object(capture_tool, "capture", side_effect=KeyboardInterrupt()), mock.patch("sys.stderr", new_callable=io.StringIO) as err: self.assertEqual(capture_tool.main(command[3:]), 130) self.assertIn("interrupted", json.loads(err.getvalue())["error"]) if __name__ == "__main__": unittest.main()