242 lines
11 KiB
Python
242 lines
11 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')
|
|
|
|
def test_complete_session_materials_and_eighty_windows_obligations(self):
|
|
self.prepare()
|
|
for name in (*self.api().MATERIALS,
|
|
'protocol/annotation-template.json', 'protocol/settings-template.json'):
|
|
self.assertTrue((self.output / name).is_file(), 'complete session material missing: ' + name)
|
|
agenda = receipts.read_json(self.output / 'protocol/agenda.json')
|
|
self.assertEqual(len(agenda['runs']), 80)
|
|
self.assertEqual(len({r['case_id'] for r in agenda['runs']}), 8)
|
|
self.assertEqual(len({r['obligation_id'] for r in agenda['runs']}), 5)
|
|
self.assertEqual({r['side'] for r in agenda['runs']},
|
|
{'original-windows-dxwnd', 'port-windows-native'})
|
|
|
|
def test_package_copy_preserves_source_execution_permissions(self):
|
|
apphost = self.packages['linux-x64'] / 'GamePort'
|
|
apphost.chmod(0o755)
|
|
self.prepare()
|
|
copied = self.output / 'port/linux-x64/GamePort'
|
|
self.assertEqual(copied.stat().st_mode & 0o777, apphost.stat().st_mode & 0o777)
|
|
self.assertEqual(receipts.identify_file(copied), receipts.identify_file(apphost))
|
|
|
|
def test_skip_abort_remain_open_schema_valid_results(self):
|
|
self.prepare()
|
|
for status in ('skipped', 'aborted'):
|
|
run = self.base / status
|
|
run.mkdir()
|
|
record = self.api().fixture_result(self.output, run, 'test-' + status,
|
|
'fresh-skipped-edge', 'bank-left', [], status=status)
|
|
self.assertEqual(record['status'], status)
|
|
self.assertFalse(receipts.validate_receipt(record, run)['accepted'])
|
|
|
|
def test_prepared_materials_never_close_runtime_matrix(self):
|
|
self.prepare()
|
|
protocol = receipts.read_json(self.output / 'protocol/scenarios.json')
|
|
report = receipts.audit_receipt_tree(protocol, self.output / 'results')
|
|
self.assertEqual(report['accepted'], 0)
|
|
self.assertEqual(report['required'], 120)
|
|
self.assertFalse(report['complete'])
|
|
|
|
def test_synthetic_packages_rejected_for_real_checkpoint(self):
|
|
self.prepare()
|
|
with self.assertRaisesRegex(ValueError, 'Synthetic'):
|
|
self.api().prepare_checkpoint(self.original, self.manifest, self.packages,
|
|
self.base / 'runtime', tooling=False)
|
|
|
|
def test_tampered_ready_manifest_rejected(self):
|
|
self.prepare()
|
|
(self.output / 'manifest.json').write_text('{}')
|
|
with self.assertRaisesRegex(ValueError, 'Manifest'): self.api().preflight(self.output)
|
|
|
|
def test_added_immutable_material_rejected(self):
|
|
self.prepare()
|
|
(self.output / 'port/win-x64/unreviewed.exe').write_bytes(b'do not execute')
|
|
with self.assertRaisesRegex(ValueError, 'Unexpected'): self.api().preflight(self.output)
|
|
|
|
def test_mutable_results_allowed_without_weakening_materials(self):
|
|
self.prepare()
|
|
(self.output / 'results/raw.mkv').write_bytes(b'synthetic')
|
|
self.assertEqual(self.api().preflight(self.output)['status'], 'ready')
|
|
|
|
def test_unknown_case_scope_rejected(self):
|
|
self.prepare()
|
|
run = self.base / 'unknown-result'
|
|
run.mkdir()
|
|
with self.assertRaises(ValueError):
|
|
self.api().fixture_result(self.output, run, 'test-unknown', 'invented', 'continuous', [])
|
|
|
|
def test_symlink_ancestor_rejected_before_writes(self):
|
|
alias = self.base / 'alias'
|
|
target = self.base / 'target'
|
|
target.mkdir()
|
|
alias.symlink_to(target, target_is_directory=True)
|
|
with self.assertRaises(ValueError): self.prepare(alias / 'new')
|
|
self.assertFalse((target / 'new').exists())
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|