147 lines
8.8 KiB
Python
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'}]})
|