Files
Neutron/tests/test_fidelity_sessions.py

296 lines
15 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
import wave
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.wav', 'port.wav'):
with wave.open(str(bundle / name), 'wb') as audio:
audio.setparams((1, 2, 8000, 0, 'NONE', 'not compressed'))
audio.writeframes(b'\0\0' * 800)
artifacts = [dict(api.identify_file(bundle / name), role=role, path=name,
synthetic=True) for name, role in
[('original.wav', 'original_audio'), ('port.wav', 'port_audio')]]
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.wav').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.wav').unlink()
(bundle / 'original.wav').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_import_rejects_case_aliased_directory_components(self):
bundle, _, value = self.fixture_receipt()
(bundle / 'Media').mkdir()
(bundle / 'media').mkdir()
(bundle / 'Media/a.wav').write_bytes(b'a')
(bundle / 'media/b.wav').write_bytes(b'b')
value['artifacts'] = [dict(self.api().identify_file(bundle / path), path=path,
role='test', synthetic=True)
for path in ('Media/a.wav', 'media/b.wav')]
with self.assertRaises(ValueError): self.api().validate_receipt(value, bundle)
def test_imported_receipt_metadata_tampering_fails_cli(self):
bundle, path, _ = self.fixture_receipt()
out = self.base / 'test-index'
result = self.api().import_receipt(path, bundle, out)
stored = Path(result['path'])
value = json.loads(stored.read_text())
value['limitations'].append('changed metadata')
stored.write_text(json.dumps(value))
self.assertNotEqual(self.cli('validate', stored, '--root', stored.parent).returncode, 0)
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.wav').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()