93 lines
7.4 KiB
Python
93 lines
7.4 KiB
Python
import base64
|
|
import copy
|
|
import gzip
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
|
|
from paper_atlas.collectors import ismir2026 as c
|
|
|
|
|
|
class ISMIR2026Test(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.fixture=json.loads(gzip.decompress((Path(__file__).parent/'fixtures/ismir2026-source.json.gz').read_bytes()))
|
|
cls.files={name:base64.b64decode(raw) for name,raw in cls.fixture['files'].items()}
|
|
cls.program=json.loads(cls.files['ismir2026-json-research-v1/papers.json'])
|
|
cls.accepted=cls.files['remaining2026-listings-research-v2/ismir-accepted.html']
|
|
|
|
def materialize(self,root):
|
|
for name,raw in self.files.items():
|
|
p=root/name;p.parent.mkdir(parents=True,exist_ok=True);p.write_bytes(raw)
|
|
|
|
def test140_source_versions_and_review_optins_against_independent_gold(self):
|
|
listing=c.accepted_listing(self.accepted);observations=c.program_observations(self.program,listing)
|
|
self.assertEqual(len(observations),140)
|
|
for observation,gold in zip(observations,self.fixture['independent_gold']):
|
|
r=observation['original'];v=r['content'];official=observation['accepted_listing']
|
|
self.assertEqual((r['id'],r['forum'],v['title'],v['authors'],v['abstract']),(gold['program_id'],gold['forum_literal'],gold['title'],gold['authors'],gold['abstract']))
|
|
self.assertEqual(official,{'title':gold['official_title'],'authors_literal':gold['official_authors_literal'],'author_names':gold['official_author_names']})
|
|
self.assertEqual(v['session'],gold['session_literal']);self.assertEqual(v['paper_presentation'],gold['presentation_literal']);self.assertEqual(v['keywords'],gold['keywords'])
|
|
self.assertEqual(sum('program_and_accepted_title_literal_versions_differ' in r['review_flags'] for r in observations),2)
|
|
self.assertEqual({r['original']['id'] for r in observations if 'program_and_accepted_author_sequence_versions_differ' in r['review_flags']},{'60','126','433'})
|
|
self.assertEqual(sum(r['original']['reviews']['publish_reviews']=='Yes' for r in observations),101)
|
|
|
|
def test_full_collection_keeps_abstract_bytes_review_text_tags_and_no_inferred_ids(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root=Path(tmp);src=root/'src';self.materialize(src);out=root/'out';report=c.collect(out,snapshots=src)
|
|
self.assertEqual((report['records'],report['missing_abstract_count'],report['review_optin_yes'],report['review_optin_no']),(140,0,101,39))
|
|
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_rejected_availability'],'unknown_accepted_program_reviews_are_not_a_rejected_export')
|
|
manifest,=report['files'];raw=Path(manifest['file']).read_bytes();self.assertEqual(hashlib.sha256(raw).hexdigest(),manifest['file_sha256']);self.assertEqual(manifest['status'],'partial')
|
|
rows=[json.loads(l) for l in raw.splitlines()];self.assertEqual(len(rows),140)
|
|
for row,original,gold in zip(rows,self.program,self.fixture['independent_gold']):
|
|
self.assertEqual(row['metadata']['program_entry'],original);self.assertEqual(row['abstract'],gold['abstract']);self.assertEqual(row['title'],gold['title']);self.assertEqual(row['authors'],gold['authors'])
|
|
self.assertEqual(row['external_id'],'2026/'+gold['program_id']);self.assertEqual(row['identifiers'],{});self.assertEqual(row['submission_identifiers'],[])
|
|
self.assertEqual(row['status'],'accepted');self.assertEqual(row['track'],'program_unclassified');self.assertIsNone(row['metadata']['paper_type']);self.assertFalse(row['metadata']['original_decision_signature_verified'])
|
|
tags=[{'namespace':'ismir_program:presentation','value':gold['presentation_literal']}]+[{'namespace':'ismir_program:keyword','value':v} for v in dict.fromkeys(' '.join(k.split()) for k in gold['keywords'] if k.strip())]
|
|
self.assertEqual(row['tags'],tags);self.assertTrue(all(t['value'] for t in row['tags']))
|
|
if original['reviews']['publish_reviews']=='No':self.assertFalse(any(v for k,v in row['metadata']['program_entry']['reviews'].items() if k!='publish_reviews'))
|
|
for name,body in self.files.items():self.assertEqual((out/'evidence'/name).read_bytes(),body)
|
|
with self.assertRaisesRegex(ValueError,'Output exists'):c.collect(out,snapshots=src)
|
|
|
|
def test_duplicate_and_malformed_locator_or_incomplete_census_rejected(self):
|
|
listing=c.accepted_listing(self.accepted)
|
|
for kind in ('repeat','forum','non_numeric','missing_row'):
|
|
rows=copy.deepcopy(self.program)
|
|
if kind=='repeat':rows[1]['id']=rows[0]['id'];rows[1]['forum']=rows[0]['forum']
|
|
if kind=='forum':rows[0]['forum']='OriginalOpenReviewID'
|
|
if kind=='non_numeric':rows[0]['id']='abc';rows[0]['forum']='abc'
|
|
if kind=='missing_row':rows.pop()
|
|
with self.subTest(kind=kind),self.assertRaises(ValueError):c.program_observations(rows,listing)
|
|
|
|
def test_empty_fields_foreign_title_and_session_disagree_rejected(self):
|
|
listing=c.accepted_listing(self.accepted)
|
|
for field,value in [('authors',[]),('abstract',''),('title','A foreign paper'),('session',['99']),('keywords',[42])]:
|
|
rows=copy.deepcopy(self.program);rows[0]['content'][field]=value
|
|
with self.subTest(field=field),self.assertRaises(ValueError):c.program_observations(rows,listing)
|
|
|
|
def test_source_optin_no_cannot_publish_review_text(self):
|
|
rows=copy.deepcopy(self.program);r=next(r for r in rows if r['reviews']['publish_reviews']=='No');r['reviews']['meta_review']='Do not infer a negative decision'
|
|
with self.assertRaisesRegex(ValueError,'preference'):c.program_observations(rows,c.accepted_listing(self.accepted))
|
|
|
|
def test_parenthesized_affiliation_semicolons_do_not_split_people(self):
|
|
self.assertEqual(c.author_names('A Person (University A; Lab (X)); B Person (Institute B)'),['A Person','B Person'])
|
|
for raw in ['A Person (Broken','; A Person (Lab)','A Person )']:
|
|
with self.assertRaises(ValueError):c.author_names(raw)
|
|
|
|
def test_ambiguous_official_title_is_not_fused(self):
|
|
source=self.accepted.replace(b'FusID: Modality-Fused Semantic IDs for Generative Music Recommendation',b'Off-Manifold Robustness in Synthesizer Inversion with Joint Distribution Flow Matching',1)
|
|
with self.assertRaisesRegex(ValueError,'ambiguous'):c.accepted_listing(source)
|
|
|
|
def test_tamper_missing_file_and_symlink_fail_without_success_report(self):
|
|
for kind in ('manifest','body','missing','symlink'):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root=Path(tmp);src=root/'src';self.materialize(src);path=src/'ismir2026-json-research-v1'/('manifest.json' if kind=='manifest' else 'papers.json')
|
|
if kind=='missing':path.unlink()
|
|
elif kind=='symlink':other=root/'actual.json';path.rename(other);path.symlink_to(other)
|
|
else:path.write_bytes(path.read_bytes()+b' ')
|
|
with self.subTest(kind=kind),self.assertRaises((ValueError,FileNotFoundError)):c.collect(root/'out',snapshots=src)
|
|
self.assertTrue((root/'out/failed.json').exists());self.assertFalse((root/'out/collection-report.json').exists())
|