"""Regression tests for the narrowly registered F insertion supplement.""" import copy import csv import hashlib import importlib.util import json import subprocess import sys import tempfile import unittest from pathlib import Path TOOLS = Path(__file__).resolve().parent ROOT = TOOLS.parent LABEL = '2026-10-25.0938.BallpointPen.Ink.Paper.9x12' PACKET = 'Standard_Time_Lapses/Provenance/2026-10-29/fragment_sequence_relationships.csv' REGISTRY = 'Standard_Time_Lapses/Provenance/Sequence_Insertions/registry.json' MANIFEST = 'Standard_Time_Lapses/Provenance/Sequence_Insertions/2026-10-29-F/sequence.json' BASE = '4f563085afacfc454496ac2d61606614268b2cb8' REV = 'b' * 40 class SequenceInsertionTests(unittest.TestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() self.addCleanup(self.tmp.cleanup) self.root = Path(self.tmp.name) target = self.root / PACKET target.parent.mkdir(parents=True) target.write_bytes((ROOT / PACKET).read_bytes()) with target.open(encoding='utf-8', newline='') as f: old = [r for r in csv.DictReader(f) if r['fragment_set_label'] == LABEL and r['object_role'] == 'canonical_fragment'] self.members = [{k: r[k] for k in ('record_id', 'file_path', 'sha256', 'hub_xet_hash', 'size_bytes', 'sequence_position')} for r in old] for r in self.members: r['size_bytes'] = int(r['size_bytes']) additions = [] for i, suffix in enumerate(('03a', '03b'), 100): member = {'record_id': f'tla-{i:016x}', 'file_path': f'Standard_Time_Lapses/{LABEL}.Rec{suffix}.mp4', 'sha256': hashlib.sha256(str(i).encode()).hexdigest(), 'hub_xet_hash': hashlib.sha256(f'xet{i}'.encode()).hexdigest(), 'size_bytes': i} self.members.insert(i - 97, member) additions.append(member['record_id']) for i, member in enumerate(self.members, 1): member['sequence_position'] = i self.manifest = {'schema_version': 1, 'fragment_set_label': LABEL, 'source_hub_revision': REV, 'predecessor': {'path': PACKET, 'sha256': hashlib.sha256(target.read_bytes()).hexdigest(), 'source_hub_revision': BASE}, 'additions': additions, 'members': self.members, 'sequence_completeness': 'unknown', 'evidence': {'membership': 'owner-confirmed', 'order': 'visual-inference-with-device-metadata-corroboration', 'gapless_capture': 'not-established'}, 'notes': 'Eleven retained source recordings; unobserved intervals remain unknown.'} self.rows = [{'record_id': r['record_id'], 'file_name': r['file_path'], 'hub_xet_hash': r['hub_xet_hash'], 'size_bytes': str(r['size_bytes']), 'date': '2026-10-25', 'time': '09:38', 'work_id': '', 'acquisition_protocol_version': 'standard-2026-08-27'} for r in self.members] self.inventory = {'sha': REV, 'siblings': [{'rfilename': r['file_path'], 'size': r['size_bytes'], 'lfs': {'sha256': r['sha256'], 'size': r['size_bytes']}, 'xetHash': r['hub_xet_hash'], 'repoCommit': REV} for r in self.members], 'validationFiles': {}} self.write() def write(self): path = self.root / MANIFEST path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(self.manifest), encoding='utf-8') registry = {'schema_version': 1, 'sequences': [{'manifest_path': MANIFEST, 'sha256': hashlib.sha256(path.read_bytes()).hexdigest()}]} (self.root / REGISTRY).write_text(json.dumps(registry), encoding='utf-8') with (self.root / 'metadata.csv').open('w', encoding='utf-8', newline='') as f: w = csv.DictWriter(f, fieldnames=self.rows[0].keys()); w.writeheader(); w.writerows(self.rows) data = (self.root / 'metadata.csv').read_bytes() self.inventory['validationFiles']['metadata.csv'] = {'sha256': hashlib.sha256(data).hexdigest(), 'size': len(data), 'repoCommit': REV} (self.root / 'inventory.json').write_text(json.dumps(self.inventory), encoding='utf-8') def validate(self, **kwargs): spec = importlib.util.spec_from_file_location('sequence_insertions', TOOLS / 'sequence_insertions.py') self.assertTrue(spec.origin and Path(spec.origin).is_file(), 'registered insertion validator is not implemented') module = importlib.util.module_from_spec(spec); spec.loader.exec_module(module) return module.validate_insertions(self.root, self.root / 'metadata.csv', inventory=self.inventory, **kwargs) def test_valid_expansion_keeps_old_order_and_only_adds_two_members(self): result = self.validate() self.assertEqual(result['errors'], []) self.assertEqual(len(result['sequences'][0]['members']), 11) self.assertEqual(result['verification_level'], 'pinned_repository_inventory') def test_rejects_duplicate_missing_reordered_or_changed_old_member(self): original = copy.deepcopy(self.manifest) for kind in ('duplicate', 'missing', 'reorder', 'path', 'hash', 'xet', 'size'): with self.subTest(kind=kind): self.manifest = copy.deepcopy(original) members = self.manifest['members'] if kind == 'duplicate': members[1] = copy.deepcopy(members[0]) elif kind == 'missing': members.pop(0) elif kind == 'reorder': members[0], members[1] = members[1], members[0] else: members[0][{'path':'file_path', 'hash':'sha256', 'xet':'hub_xet_hash', 'size':'size_bytes'}[kind]] = 1 if kind == 'size' else 'changed' self.write() self.assertTrue(self.validate()['errors']) def test_rejects_invalid_pins_receipts_and_unbound_inventory(self): for kind in ('revision', 'inventory_revision', 'metadata_hash', 'media_hash', 'media_revision', 'missing_media', 'duplicate_media', 'predecessor_pin', 'predecessor_bytes'): with self.subTest(kind=kind): manifest, inventory = copy.deepcopy(self.manifest), copy.deepcopy(self.inventory) if kind == 'revision': self.manifest['source_hub_revision'] = 'main' elif kind == 'inventory_revision': self.inventory['sha'] = 'c' * 40 elif kind == 'predecessor_pin': self.manifest['predecessor']['source_hub_revision'] = 'c' * 40 elif kind == 'predecessor_bytes': p = self.root / PACKET; p.write_bytes(p.read_bytes() + b'\n'); self.manifest['predecessor']['sha256'] = hashlib.sha256(p.read_bytes()).hexdigest() self.write() if kind == 'metadata_hash': self.inventory['validationFiles']['metadata.csv']['sha256'] = '0' * 64 elif kind == 'media_hash': self.inventory['siblings'][0]['lfs']['sha256'] = '0' * 64 elif kind == 'media_revision': self.inventory['siblings'][0]['repoCommit'] = 'c' * 40 elif kind == 'missing_media': self.inventory['siblings'].pop() elif kind == 'duplicate_media': self.inventory['siblings'].append(self.inventory['siblings'][0]) self.assertTrue(self.validate()['errors']) self.manifest, self.inventory = manifest, inventory (self.root / PACKET).write_bytes((ROOT / PACKET).read_bytes()) def test_rejects_unregistered_suffix_wrong_date_and_work_label(self): for field, value in [('file_path', f'Standard_Time_Lapses/{LABEL}.Rec03c.mp4'), ('date', '2026-10-24'), ('work_id', 'invented-work')]: with self.subTest(field=field): rows, manifest = copy.deepcopy(self.rows), copy.deepcopy(self.manifest) if field == 'file_path': self.manifest['members'][3][field] = value; self.rows[3]['file_name'] = value else: self.rows[3][field] = value self.write(); self.assertTrue(self.validate()['errors']) self.rows, self.manifest = rows, manifest def test_rejects_bad_registry_hash_and_duplicate_active_version(self): registry = json.loads((self.root / REGISTRY).read_text()) registry['sequences'][0]['sha256'] = '0' * 64 (self.root / REGISTRY).write_text(json.dumps(registry)) self.assertTrue(self.validate()['errors']) self.write() registry = json.loads((self.root / REGISTRY).read_text()); registry['sequences'] *= 2 (self.root / REGISTRY).write_text(json.dumps(registry)) self.assertTrue(self.validate()['errors']) def test_pending_remote_values_are_local_only_and_only_for_additions(self): self.manifest['source_hub_revision'] = None for i in (3, 4): self.manifest['members'][i]['hub_xet_hash'] = None; self.rows[i]['hub_xet_hash'] = '' self.write() self.assertTrue(self.validate()['errors']) result = self.validate(prepublication=True) self.assertEqual(result['errors'], []) self.assertEqual(result['verification_level'], 'prepublication_unbound') self.manifest['members'][0]['hub_xet_hash'] = None; self.write() self.assertTrue(self.validate(prepublication=True)['errors']) def test_membership_loader_adds_only_new_ids_without_duplicates(self): from validate_metadata import load_fragment_protocol_membership errors = [] ids, groups, count = load_fragment_protocol_membership( self.root / 'Standard_Time_Lapses/Provenance', errors) self.assertEqual(errors, []) self.assertEqual(count, 1) self.assertEqual(groups['2026-10-29/' + LABEL], [m['record_id'] for m in self.members]) self.assertTrue(set(self.manifest['additions']).issubset(ids)) self.manifest['members'][0]['sha256'] = '0' * 64; self.write() errors = [] ids, groups, count = load_fragment_protocol_membership( self.root / 'Standard_Time_Lapses/Provenance', errors) self.assertTrue(errors) self.assertFalse(set(self.manifest['additions']).intersection(ids)) def test_metadata_rejects_unregistered_lettered_suffix_even_without_sidecar_check(self): from validate_metadata import validate for row in self.rows: row['duration_seconds'] = '10' self.write() result = validate(self.root / 'metadata.csv', None, None, None) self.assertTrue(any('unregistered lettered Rec suffix' in e for e in result['errors'])) def test_dated_packet_does_not_authorize_an_unregistered_lettered_suffix(self): from validate_metadata import validate (self.root / REGISTRY).unlink() packet = self.root / PACKET text = packet.read_text().replace('.Rec01.mp4', '.Rec01a.mp4') packet.write_text(text) for row in self.rows: row['duration_seconds'] = '10' row['file_name'] = row['file_name'].replace('.Rec01.mp4', '.Rec01a.mp4') with (self.root / 'metadata.csv').open('w', newline='') as handle: writer = csv.DictWriter(handle, fieldnames=self.rows[0]); writer.writeheader(); writer.writerows(self.rows) result = validate(self.root / 'metadata.csv', None, None, None, self.root / 'Standard_Time_Lapses/Provenance') self.assertTrue(any(self.rows[0]['file_name'] in e and 'unregistered lettered Rec suffix' in e for e in result['errors'])) def test_rejects_duplicate_xet_and_missing_strict_inventory(self): saved = self.inventory self.inventory = None self.assertTrue(self.validate()['errors']) self.inventory = saved self.members[4]['hub_xet_hash'] = self.members[3]['hub_xet_hash'] self.rows[4]['hub_xet_hash'] = self.rows[3]['hub_xet_hash'] self.inventory['siblings'][4]['xetHash'] = self.members[3]['hub_xet_hash'] self.write() self.assertTrue(self.validate()['errors']) def test_malformed_documents_report_errors_without_tracebacks(self): for value in ([], None, {'schema_version': 1, 'sequences': [None]}, {'schema_version': 1, 'sequences': [{'manifest_path': '../escape', 'sha256': 'x'}]}): (self.root / REGISTRY).write_text(json.dumps(value)) self.assertTrue(self.validate()['errors']) process = subprocess.run([sys.executable, str(TOOLS / 'sequence_insertions.py'), '--root', str(self.root), '--metadata', str(self.root / 'metadata.csv')], capture_output=True, text=True) self.assertEqual(process.returncode, 1) self.assertNotIn('Traceback', process.stderr) self.assertTrue(json.loads(process.stdout)['errors']) if __name__ == '__main__': unittest.main()