diff --git a/tests/test_fidelity_sessions.py b/tests/test_fidelity_sessions.py new file mode 100644 index 0000000..035a8eb --- /dev/null +++ b/tests/test_fidelity_sessions.py @@ -0,0 +1,250 @@ +"""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()