168 lines
7.7 KiB
Python
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/level1/scene.json',
|
|
'scenes/animations/jimstop/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()
|