"""Tiny local fixtures test evidence plumbing, never original/native gameplay.""" import concurrent.futures import hashlib import importlib import json from pathlib import Path import subprocess import sys import tempfile import unittest from unittest import mock ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tools/recon')) try: receipts = importlib.import_module('fidelity_receipts') except ModuleNotFoundError: receipts = None class FidelitySessions(unittest.TestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() self.addCleanup(self.tmp.cleanup) self.base = Path(self.tmp.name) self.original = self.base / 'Original' self.original.mkdir() (self.original / 'game.exe').write_bytes(b'fixture original, not executable') self.files = [{'path': 'game.exe', 'size': 32, 'sha256': hashlib.sha256((self.original / 'game.exe').read_bytes()).hexdigest(), 'header': (self.original / 'game.exe').read_bytes()[:16].hex()}] self.files[0]['size'] = (self.original / 'game.exe').stat().st_size self.manifest = self.base / 'manifest.json' self.manifest.write_text(json.dumps({'files': self.files})) self.output = self.base / 'sessions' def api(self): self.assertIsNotNone(receipts, 'preserved-session receipt API must exist') return receipts def stage(self, session='test-session', output=None): return self.api().stage_original(self.original, self.manifest, output or self.output, session) def cli(self, *args): return subprocess.run([sys.executable, str(ROOT / 'tools/recon/fidelity.py'), *map(str, args)], capture_output=True, text=True, timeout=15) def fixture_receipt(self, receipt_id='test-pair'): api = self.api() bundle = self.base / 'synthetic-pair' bundle.mkdir(exist_ok=True) for name in ('original.txt', 'port.txt'): (bundle / name).write_text('explicitly synthetic paired media fixture') artifacts = [dict(api.identify_file(bundle / name), role=role, path=name, synthetic=True) for name, role in [('original.txt', 'original_video'), ('port.txt', 'port_video')]] value = {'schema_version': 1, 'receipt_id': receipt_id, 'session_id': 'test-session', 'case_id': 'test-only', 'evidence_kind': 'synthetic', 'status': 'captured', 'platform': {'os': 'test', 'execution': 'synthetic'}, 'scope': 'tooling-test', 'historical': False, 'identity': {}, 'invocation': {'argv': ['fixture'], 'cwd': '.'}, 'clocks': {'wall_start': '2026-01-01T00:00:00Z', 'wall_end': '2026-01-01T00:00:01Z', 'monotonic_start': 0, 'monotonic_end': 1}, 'artifacts': artifacts, 'derivatives': [], 'events': [], 'limitations': ['Synthetic plumbing only'], 'missing_evidence': [], 'acceptance': {'state': 'open', 'remaining': ['Real captures required']}} path = bundle / 'receipt.json' path.write_text(json.dumps(value)) return bundle, path, value def test_cli_round_trip(self): staged = self.cli('stage', '--source', self.original, '--manifest', self.manifest, '--output', self.output, '--session-id', 'test-session') self.assertEqual(staged.returncode, 0, staged.stderr) session = self.output / 'test-session' identified = self.cli('identify', session / 'game') self.assertEqual(identified.returncode, 0, identified.stderr) self.assertEqual(json.loads(identified.stdout)['files'], self.files) bundle, path, _ = self.fixture_receipt() imported = self.cli('import', path, '--root', bundle, '--output', self.base / 'test-index') self.assertEqual(imported.returncode, 0, imported.stderr) target = self.base / 'test-index/test-pair/receipt.json' result = self.cli('validate', target, '--root', target.parent, '--allow-open') self.assertEqual(result.returncode, 0, result.stderr) self.assertIn('synthetic', result.stdout) self.assertIn('OPEN', result.stdout) self.assertTrue((target.parent / 'receipt.sha256').is_file()) strict = self.cli('validate', target, '--root', target.parent, '--require-complete') self.assertNotEqual(strict.returncode, 0) self.assertEqual((self.original / 'game.exe').read_bytes(), b'fixture original, not executable') def test_single_file_pristine_copy(self): result = self.stage() self.assertEqual(result['source_pre']['files'], self.files) self.assertEqual(result['copy_pre']['files'], self.files) self.assertNotEqual(result['source_root'], result['copy_root']) self.assertEqual(result['status'], 'staged') def test_changed_original(self): (self.original / 'game.exe').write_bytes(b'changed') with self.assertRaises(ValueError): self.stage() self.assertFalse(self.output.exists()) def test_missing_original(self): (self.original / 'game.exe').unlink() with self.assertRaises(ValueError): self.stage() def test_added_original(self): (self.original / 'extra').write_bytes(b'added') with self.assertRaises(ValueError): self.stage() def test_empty_and_missing_inventory(self): self.manifest.write_text('{"files": []}') with self.assertRaises(ValueError): self.stage() self.manifest.unlink() with self.assertRaises(ValueError): self.stage() def test_equal_and_both_nested_outputs_rejected_before_write(self): for output in (self.original, self.original / 'new', self.base): with self.assertRaises(ValueError): self.stage(output=output) self.assertEqual(list(self.original.iterdir()), [self.original / 'game.exe']) def test_sibling_prefix_is_distinct(self): result = self.stage(output=self.base / 'Original-copy') self.assertEqual(result['status'], 'staged') def test_symlink_output_alias(self): alias = self.base / 'alias' alias.symlink_to(self.original, target_is_directory=True) with self.assertRaises(ValueError): self.stage(output=alias) def test_symlink_source_member_rejected(self): (self.original / 'external').symlink_to(self.manifest) with self.assertRaises(ValueError): self.stage() def test_windows_case_alias_and_drive_reference_rejected(self): with self.assertRaises(ValueError): self.stage(output=self.base / 'original') api = self.api() for value in ('C:/secret', 'C:secret', '\\\\server\\share', '../secret', '/secret', 'nested\\..\\secret', 'https://example.org/a'): with self.assertRaises(ValueError): api.contained_path(self.base, value) def test_case_collisions_fail_and_manifest_order_is_canonical(self): api = self.api() (self.original / 'GAME.EXE').write_bytes(b'collision') with self.assertRaises(ValueError): api.identify_tree(self.original) (self.original / 'GAME.EXE').unlink() (self.original / 'A').write_bytes(b'a') (self.original / 'z').write_bytes(b'z') paths = [f['path'] for f in api.identify_tree(self.original)['files']] self.assertEqual(paths, ['A', 'game.exe', 'z']) def test_shell_characters_are_inert(self): result = self.stage(output=self.base / 'copy;$(touch SHOULD_NOT_EXIST)') self.assertEqual(result['status'], 'staged') self.assertFalse((ROOT / 'SHOULD_NOT_EXIST').exists()) def test_reuse_is_rejected(self): self.stage() with self.assertRaises(ValueError): self.stage() def test_concurrent_allocation_has_one_winner(self): self.api() def attempt(_): try: self.stage(); return True except ValueError: return False with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool: self.assertEqual(sorted(pool.map(attempt, range(2))), [False, True]) def test_interrupted_stage_has_diagnostic_without_completed_session(self): api = self.api() with mock.patch.object(api.shutil, 'copyfile', side_effect=KeyboardInterrupt): with self.assertRaises(KeyboardInterrupt): self.stage() self.assertFalse((self.output / 'test-session/session.json').exists()) diagnostics = list(self.output.glob('*/incomplete.json')) self.assertEqual(len(diagnostics), 1) self.assertEqual(json.loads(diagnostics[0].read_text())['status'], 'incomplete') def test_postrun_copy_mutations_separate_from_source(self): api = self.api() self.stage() (self.output / 'test-session/game/save.dat').write_bytes(b'normal runtime write') result = api.postflight_session(self.output / 'test-session', self.original, self.manifest) self.assertEqual(result['source_post']['files'], self.files) self.assertEqual(result['copy_changes']['added'], ['save.dat']) def test_tampered_artifact_rejected(self): bundle, _, value = self.fixture_receipt() (bundle / 'original.txt').write_text('tampered') with self.assertRaises(ValueError): self.api().validate_receipt(value, bundle) def test_duplicate_import_identical_only(self): bundle, path, value = self.fixture_receipt() out = self.base / 'test-index' first = self.api().import_receipt(path, bundle, out) second = self.api().import_receipt(path, bundle, out) self.assertEqual(first['receipt_sha256'], second['receipt_sha256']) value['limitations'].append('different content') path.write_text(json.dumps(value)) with self.assertRaises(ValueError): self.api().import_receipt(path, bundle, out) def test_interrupted_import_retains_incomplete_diagnostic(self): bundle, path, _ = self.fixture_receipt() api = self.api() out = self.base / 'test-index' with mock.patch.object(api.shutil, 'copyfile', side_effect=OSError('interrupted')): with self.assertRaises(OSError): api.import_receipt(path, bundle, out) self.assertFalse((out / 'test-pair/receipt.json').exists()) self.assertEqual(len(list(out.glob('*/incomplete.json'))), 1) def test_native_acceptance_rejects_narrow_classifications(self): bundle, _, value = self.fixture_receipt() for kind in ('synthetic', 'component', 'wine', 'cross_publish', 'port_fixture'): value['evidence_kind'] = kind value['platform']['execution'] = kind value['acceptance']['state'] = 'accepted' with self.assertRaises(ValueError): self.api().validate_receipt(value, bundle) def test_synthetic_relabel_as_native_rejected(self): bundle, _, value = self.fixture_receipt() value.update(evidence_kind='native_port', status='reviewed') value['platform'] = {'os': 'windows', 'execution': 'native'} with self.assertRaises(ValueError): self.api().validate_receipt(value, bundle) def test_failed_and_incomplete_remain_open(self): bundle, _, value = self.fixture_receipt() for status in ('failed', 'incomplete'): value['status'] = status self.assertFalse(self.api().validate_receipt(value, bundle)['accepted']) def test_relative_artifact_symlink_escape_rejected(self): bundle, _, value = self.fixture_receipt() (bundle / 'original.txt').unlink() (bundle / 'original.txt').symlink_to(self.manifest) with self.assertRaises(ValueError): self.api().validate_receipt(value, bundle) def test_bad_schema_and_oversized_json_rejected_by_cli(self): bundle, path, value = self.fixture_receipt() value['schema_version'] = 99 path.write_text(json.dumps(value)) self.assertNotEqual(self.cli('validate', path, '--root', bundle).returncode, 0) path.write_bytes(b' ' * (4 * 1024 * 1024 + 1)) self.assertNotEqual(self.cli('validate', path, '--root', bundle).returncode, 0) if __name__ == '__main__': unittest.main()