272 lines
13 KiB
Python
272 lines
13 KiB
Python
"""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)
|
|
|
|
def test_historical_report_hashes_actual_bytes_and_retains_missing(self):
|
|
api = self.api()
|
|
report = self.base / 'report.md'
|
|
report.write_text('Historical Wine/component evidence; native Windows open')
|
|
result = api.identify_report(self.original, report, self.original / 'game.exe',
|
|
self.base / 'missing-resources')
|
|
self.assertTrue(result['historical'])
|
|
self.assertEqual(result['actual']['executable']['sha256'], self.files[0]['sha256'])
|
|
self.assertIn('Historical Wine/component', result['recorded_scope'])
|
|
self.assertTrue(any('resources absent' in s for s in result['missing_evidence']))
|
|
|
|
def test_cli_hostile_output_and_tampering_exit_nonzero(self):
|
|
result = self.cli('stage', '--source', self.original, '--manifest', self.manifest,
|
|
'--output', self.original / 'illegal', '--session-id', 'new')
|
|
self.assertNotEqual(result.returncode, 0)
|
|
self.assertFalse((self.original / 'illegal').exists())
|
|
bundle, path, _ = self.fixture_receipt()
|
|
(bundle / 'port.txt').write_text('changed')
|
|
self.assertNotEqual(self.cli('import', path, '--root', bundle,
|
|
'--output', self.base / 'test-index').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()
|