Preserve source read/write/execute bits without privileged mode bits. Verify copied Linux apphost byte identity and permissions.
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 ('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()
|