| """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() | |