Files
Neutron/tests/test_fidelity_checkpoint.py
T

168 lines
7.7 KiB
Python

"""Offline checkpoint fixtures are tooling tests, never native/reference evidence."""
import concurrent.futures
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'))
import fidelity_receipts as receipts
try:
checkpoint = importlib.import_module('fidelity_checkpoint')
except ModuleNotFoundError:
checkpoint = None
class FidelityCheckpoint(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 / 'Jimmy Neutron.exe').write_bytes(b'synthetic original')
self.manifest = self.base / 'original.json'
self.manifest.write_bytes(receipts.canonical_bytes(receipts.identify_tree(self.original)))
self.packages = {}
for rid in ('linux-x64', 'win-x64'):
package = self.base / rid
package.mkdir()
for name in ('GamePort.exe' if rid == 'win-x64' else 'GamePort',
'GamePort.dll', 'GamePort.runtimeconfig.json', 'GamePort.deps.json',
'SDL3.dll' if rid == 'win-x64' else 'libSDL3.so.0',
'assets/NewGame.tsk', 'scenes/level1b/scene.json',
'scenes/VR04/scene.json', 'scenes/outsideLEV1/scene.json',
'scenes/animations/animation.json', 'audio/music.wav', 'Shaders/test.spv'):
path = package / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(b'synthetic fixture bytes ' + name.encode())
(package / 'BUILD-INFO.txt').write_text('source_commit=fixture\nsource_dirty=yes\n')
self.packages[rid] = package
self.output = self.base / 'checkpoint'
def api(self):
self.assertIsNotNone(checkpoint, 'offline checkpoint preparation API must exist')
return checkpoint
def prepare(self, output=None):
api = self.api()
for rid, path in self.packages.items():
if not (path / 'fidelity-build.json').exists():
api.seal_package(path, rid, {'commit': 'fixture', 'dirty': True,
'diff_sha256': '0' * 64}, tooling=True)
return api.prepare_checkpoint(self.original, self.manifest, self.packages,
output or self.output, tooling=True)
def test_prepare_preflight_fixture_import_roundtrip(self):
self.prepare()
report = self.api().preflight(self.output)
self.assertEqual(report['status'], 'ready')
self.assertEqual(report['acceptance']['state'], 'open')
run = self.base / 'fixture-result'
run.mkdir()
(run / 'raw.mkv').write_bytes(b'synthetic media, deliberately not decodable')
result = self.api().fixture_result(self.output, run, 'test-run',
'fresh-natural-ordinary', 'continuous', ['raw.mkv'])
self.assertEqual(result['evidence_kind'], 'synthetic')
target = self.base / 'test-imports'
imported = receipts.import_receipt(run / 'receipt.json', run, target)
actual = receipts.read_receipt(Path(imported['path']))
self.assertFalse(receipts.validate_receipt(actual, Path(imported['path']).parent)['accepted'])
self.assertEqual(receipts.identify_tree(self.original)['files'],
receipts.read_json(self.manifest)['files'])
def test_actual_package_and_resource_bytes_identified(self):
self.prepare()
manifest = receipts.read_json(self.output / 'manifest.json')
for rid, package in self.packages.items():
self.assertEqual(manifest['packages'][rid]['dll']['sha256'],
receipts.identify_file(package / 'GamePort.dll')['sha256'])
self.assertEqual(manifest['packages'][rid]['resources']['assets']['tree_sha256'],
receipts.identify_tree(package / 'assets')['tree_sha256'])
def test_original_change_rejected_before_output(self):
(self.original / 'Jimmy Neutron.exe').write_bytes(b'changed')
with self.assertRaises(ValueError): self.prepare()
self.assertFalse(self.output.exists())
def test_output_overlap_and_case_alias_rejected(self):
for output in (self.original, self.original / 'nested', self.base / 'original'):
with self.assertRaises(ValueError): self.prepare(output)
def test_output_symlink_rejected(self):
self.output.symlink_to(self.original, target_is_directory=True)
with self.assertRaises(ValueError): self.prepare()
def test_existing_output_never_reused(self):
self.prepare()
before = (self.output / 'manifest.json').read_bytes()
with self.assertRaises(ValueError): self.prepare()
self.assertEqual(before, (self.output / 'manifest.json').read_bytes())
def test_missing_binary_rejected(self):
self.prepare()
(self.output / 'port/win-x64/GamePort.dll').unlink()
with self.assertRaisesRegex(ValueError, 'GamePort.dll'): self.api().preflight(self.output)
def test_stale_binary_rejected(self):
self.prepare()
(self.output / 'port/win-x64/GamePort.dll').write_bytes(b'old binary')
with self.assertRaises(ValueError): self.api().preflight(self.output)
def test_missing_resources_rejected(self):
self.prepare()
(self.output / 'port/win-x64/assets/NewGame.tsk').unlink()
with self.assertRaises(ValueError): self.api().preflight(self.output)
def test_tampered_launcher_rejected(self):
self.prepare()
with (self.output / 'scripts/collect-fidelity-windows.ps1').open('a') as stream:
stream.write('\n#tamper')
with self.assertRaises(ValueError): self.api().preflight(self.output)
def test_tampered_fixture_media_import_rejected(self):
self.prepare()
run = self.base / 'result'
run.mkdir()
(run / 'raw.mkv').write_bytes(b'fixture')
self.api().fixture_result(self.output, run, 'test-media',
'fresh-natural-ordinary', 'continuous', ['raw.mkv'])
(run / 'raw.mkv').write_bytes(b'tampered')
with self.assertRaises(ValueError):
receipts.import_receipt(run / 'receipt.json', run, self.base / 'test-index')
def test_interrupted_assembly_preserves_diagnostics(self):
api = self.api()
with mock.patch.object(api, '_copy_file', side_effect=OSError('simulated interruption')):
with self.assertRaises(OSError): self.prepare()
self.assertFalse(self.output.exists())
self.assertTrue(list(self.base.glob('.checkpoint.incomplete-*')))
with self.assertRaises(ValueError): self.prepare()
def test_concurrent_assembly_has_one_winner(self):
self.prepare(self.base / 'seed') # seal inputs before the concurrent callers
def attempt(_):
try:
self.prepare()
return True
except (ValueError, FileExistsError):
return False
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as pool:
self.assertEqual(list(pool.map(attempt, range(2))).count(True), 1)
def test_missing_local_dependency_is_actionable(self):
self.prepare()
report = self.api().preflight(self.output, dependencies={'dxwnd': self.base / 'missing.exe'})
self.assertEqual(report['status'], 'blocked')
self.assertIn('dxwnd', ' '.join(report['failures']))
self.assertEqual(report['acceptance']['state'], 'open')
if __name__ == '__main__':
unittest.main()