Files
Neutron/tests/test_fidelity_checkpoint.py
T
UnixNight aa4b862a12 fix(01-05): retain executable permissions in offline copies
Preserve source read/write/execute bits without privileged mode bits. Verify copied Linux apphost byte identity and permissions.
2026-11-13 11:43:51 -05:00

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 ('tests/fidelity-windows.Tests.ps1', 'docs/evidence/windows-session.md',
'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()