File size: 12,696 Bytes
3a9c13f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | """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()
|