Files
paper-atlas/tests/test_mm2026.py
T
codex-bot c8db6118d4
Metadata integrity checks / metadata (push) Successful in 3m39s
Restore all MM 2026 program tracks with complete presentation evidence
2026-11-17 22:28:51 +08:00

147 lines
8.8 KiB
Python

import copy
import gzip
import hashlib
import json
from pathlib import Path
import tempfile
import unittest
from paper_atlas.collectors import mm2026 as c
class MM2026Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.fixture = json.loads(gzip.decompress((Path(__file__).parent/'fixtures/mm2026-source.json.gz').read_bytes()))
cls.files = {name:body.encode('utf-8') for name,body in cls.fixture['files'].items()}
cls.raw = cls.files[c.SNAPSHOT+'/program-data.json']
cls.data = json.loads(cls.raw)
cls.gold = cls.fixture['independent_inventory']
def materialize(self, root):
for name,body in self.files.items():
path = root/name; path.parent.mkdir(parents=True,exist_ok=True); path.write_bytes(body)
def parse_changed(self, data):
return c.parse_program(json.dumps(data,ensure_ascii=False).encode())
def test_all2143_ids_and4326_locations_against_independent_inventory(self):
rows,sessions = c.parse_program(self.raw)
self.assertEqual(len(rows),2143); self.assertEqual(len(sessions),157)
self.assertEqual(sum(len(r['contexts']) for r in rows),4326)
actual = {r['paper_id']:r for r in rows}
self.assertEqual(set(actual),{g['paper_id'] for g in self.gold['inventory']})
for gold in self.gold['inventory']:
r = actual[gold['paper_id']]
self.assertEqual((r['title'],r['authors'],r['track'],r['affiliations']),
(gold['title'],gold['authors'],gold['track_literal'],gold['affiliations']))
self.assertEqual(hashlib.sha256(r['abstract'].encode()).hexdigest(),gold['abstract_sha256'])
self.assertEqual([x['source_pointer'] for x in r['contexts']],gold['locations'])
def test_every_presentation_and_session_context_is_preserved(self):
rows,sessions = c.parse_program(self.raw)
for r in rows:
for context in r['contexts']:
node = self.data
for key in context['source_pointer'].split('/')[1:]:
node = node[int(key)] if isinstance(node,list) else node[key]
self.assertEqual(context['presentation'],{k:node[k] for k in c.PRESENTATION if k in node})
self.assertEqual(r['paper_id'],node['paper_id'])
for i,session in enumerate(sessions):
original = self.data['entries'][i]
self.assertEqual(session['source_pointer'],'/entries/'+str(i))
self.assertEqual(session['track'],'')
for key in original.keys()-{'papers','subsessions'}:
self.assertEqual(session[key],original[key])
for j,sub in enumerate(original.get('subsessions') or []):
saved = session['subsessions'][j]
self.assertEqual(saved['title'],sub['title'])
expected = [x for x in sub.get('items') or [] if 'paper_id' not in x]
self.assertEqual([x['fields'] for x in saved['nonpaper_items']],expected)
def test_all_tracks_retained_without_publication_or_negative_inference(self):
rows,_ = c.parse_program(self.raw)
self.assertEqual({r['track'] for r in rows},set(self.gold['unique_id_track_counts']))
for r in rows:
self.assertFalse(r['approved_for_import']); self.assertFalse(r['final_decision_verified'])
self.assertFalse(r['publication_identity_verified'])
self.assertEqual(r['source_locator'],{'namespace':'mm_program:program_id','value':r['paper_id']})
self.assertEqual(r['tags'],[{'namespace':'mm_program:track','value':r['track']}])
self.assertEqual(r['observed_status'],'listed_in_official_program')
self.assertTrue({'status','identifiers','submission_identifiers','paper_type','emails'}.isdisjoint(r))
missing = [r for r in rows if not r['authors']]
self.assertEqual({r['paper_id'] for r in missing},{'mfp4971','mfp7801'})
self.assertTrue(all(r['missing_fields']==['authors','abstract'] for r in missing))
self.assertEqual(sum(not r['abstract'] for r in rows),216)
def test_collect_evidence_hashes_and_no_contact_arrays_in_normalized_output(self):
with tempfile.TemporaryDirectory() as tmp:
root=Path(tmp);self.materialize(root/'src')
report=c.collect(root/'out',snapshots=root/'src')
self.assertEqual((report['records'],report['program_observations'],report['extra_presentation_observations']),(2143,4326,2183))
self.assertFalse(report['database_written']);self.assertFalse(report['pdfs_downloaded'])
self.assertEqual(report['network_requests'],0);self.assertEqual(report['approved_for_import'],0)
self.assertEqual(report['public_negative_access']['http_statuses'],[403]*4)
self.assertEqual(report['track_counts'],self.gold['unique_id_track_counts'])
for name,body in self.files.items():
self.assertEqual((root/'out/evidence'/Path(name).name).read_bytes(),body)
n=0
for item in report['files']:
raw=Path(item['file']).read_bytes();self.assertEqual(hashlib.sha256(raw).hexdigest(),item['file_sha256'])
self.assertNotIn(b'"emails"',raw);self.assertEqual(len(raw.splitlines()),item['count']);n+=item['count']
self.assertEqual(item['format'],'mm_program_observation_v1_not_ingestion_record')
self.assertEqual(n,2143)
raw=(root/'out/sessions.jsonl').read_bytes()
self.assertEqual(hashlib.sha256(raw).hexdigest(),report['sessions_file_sha256']);self.assertNotIn(b'"emails"',raw)
with self.assertRaisesRegex(ValueError,'Output exists'):c.collect(root/'out',snapshots=root/'src')
def test_conflicting_core_version_is_not_silently_merged(self):
data=copy.deepcopy(self.data)
first=data['entries'][0]['papers'][0]
data['entries'][0]['papers'].append({**first,'abstract':'conflicting abstract'})
with self.assertRaisesRegex(ValueError,'Conflicting core'):self.parse_changed(data)
def test_unknown_nesting_cannot_silently_lose_observations(self):
data=copy.deepcopy(self.data)
moved=data['entries'][0]['papers'].pop()
data['entries'][0]['unreviewed_bucket']=[moved]
with self.assertRaisesRegex(ValueError,'Unhandled'):self.parse_changed(data)
def test_track_drift_unknown_fields_or_missing_title_require_review(self):
for kind in ('outer_track','paper_track','field','title','authors'):
data=copy.deepcopy(self.data);paper=data['entries'][0]['papers'][0]
if kind=='outer_track':data['entries'][0]['track']='Main Track'
elif kind=='paper_track':paper['track']='New Track'
elif kind=='field':paper['doi']='unreviewed'
elif kind=='title':paper['title']=''
else:paper['authors']='Unparsed author string'
with self.subTest(kind=kind),self.assertRaises(ValueError):self.parse_changed(data)
def test_edition_or_census_change_requires_review(self):
for kind in ('edition','count'):
data=copy.deepcopy(self.data)
if kind=='edition':data['generated_at']='2025-11-14T18:36:26.860677+00:00'
else:data['entries'][0]['papers'].pop()
with self.subTest(kind=kind),self.assertRaises(ValueError):self.parse_changed(data)
def test_corruption_missing_evidence_and_symlink_fail_without_completed_report(self):
for kind in ('manifest','program','probe','missing','symlink'):
with tempfile.TemporaryDirectory() as tmp:
root=Path(tmp);self.materialize(root/'src');directory=root/'src'/c.SNAPSHOT
name='manifest.json' if kind=='manifest' else 'openreview-rejected-probe.json' if kind=='probe' else 'program-data.json'
path=directory/name
if kind=='missing':path.unlink()
elif kind=='symlink':
original=directory/'original.json';path.rename(original);path.symlink_to(original)
else:path.write_bytes(path.read_bytes()+b' ')
with self.subTest(kind=kind),self.assertRaises((ValueError,FileNotFoundError)):c.collect(root/'out',snapshots=root/'src')
self.assertTrue((root/'out/failed.json').exists());self.assertFalse((root/'out/collection-report.json').exists())
def test_literal_abstract_math_and_nonpaper_session_events_retained(self):
rows,sessions=c.parse_program(self.raw)
self.assertTrue(any('\\' in r['abstract'] for r in rows))
self.assertTrue(any('\n' in r['abstract'] for r in rows))
self.assertTrue(any(s['type']=='coffee_break' for s in sessions))
self.assertTrue(any(s['type']=='industry_talk' for s in sessions))
self.assertEqual(c.without_emails({'emails':['contact'],'items':[{'emails':['contact'],'title':'talk'}]}),{'items':[{'title':'talk'}]})