140 lines
9.6 KiB
Python
140 lines
9.6 KiB
Python
import copy
|
|
import gzip
|
|
import json
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from paper_atlas.collectors import eccv2026 as c
|
|
from paper_atlas.io.html_cache import PublicHTMLCache
|
|
|
|
|
|
class ECCV2026Tests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.bundle = json.loads(gzip.decompress((Path(__file__).parent/'fixtures/eccv2026-source.json.gz').read_bytes()))
|
|
cls.program = c.parse_program(cls.bundle['official_pages']['accepted.html'])
|
|
|
|
def snapshots(self, root):
|
|
official = root/'official'; paper = root/'paper'; official.mkdir(); paper.mkdir()
|
|
for name, raw in self.bundle['official_pages'].items():
|
|
(official/name).write_bytes(raw.encode('utf-8'))
|
|
(official/'manifest.json').write_bytes(self.bundle['official_manifest'].encode('utf-8'))
|
|
for pid, raw in self.bundle['paper_pages'].items():
|
|
(paper/(pid+'.html')).write_bytes(raw.encode('utf-8'))
|
|
(paper/'manifest.json').write_text(json.dumps(self.bundle['paper_manifest']))
|
|
return official, paper
|
|
|
|
def test_complete_program_and_duplicate_occurrences_match_gold(self):
|
|
self.assertEqual(len(self.program), 2834)
|
|
self.assertEqual(sum(len(p['row_ordinals']) for p in self.program.values()), 2851)
|
|
for ordinal, gold in enumerate(self.bundle['inventory']['records'], 1):
|
|
item = self.program[gold['paper_id']]
|
|
self.assertEqual(item['listing'], {k: gold[k] for k in ('title','authors_literal','keywords_literal','presentation_literal')})
|
|
self.assertIn(ordinal, item['row_ordinals'])
|
|
|
|
def test_conflicting_duplicate_not_silently_folded(self):
|
|
title = 'Transferability Between Understanding and Generation in Unified Multimodal Models'
|
|
with self.assertRaisesRegex(ValueError, 'Conflicting'):
|
|
c.parse_program(self.bundle['official_pages']['accepted.html'].replace('href="/virtual/2026/poster/3137">'+title, 'href="/virtual/2026/poster/3137">Conflicting title', 1))
|
|
|
|
def test_missing_member_and_changed_provisional_status_rejected(self):
|
|
html = self.bundle['official_pages']['accepted.html']
|
|
for changed in [html.replace('/virtual/2026/poster/4048', '/virtual/2024/poster/4048', 1),
|
|
html.replace('This paper list is preliminary pending publisher checks.', 'Final archival papers.')]:
|
|
with self.assertRaises(ValueError):
|
|
c.parse_program(changed)
|
|
|
|
def test_public_page_fields_match_independent_sample_review(self):
|
|
for gold in self.bundle['paper_gold']['records']:
|
|
pid = gold['paper_id']; fields = c.parse_paper(self.bundle['paper_pages'][pid], gold['url'], self.program[pid])
|
|
self.assertEqual(fields['title'], gold['title']); self.assertEqual(fields['authors'], gold['authors'])
|
|
self.assertEqual(fields['abstract'], gold['abstract_literal']); self.assertFalse(fields['review_flags'])
|
|
self.assertIn('sig-nal', c.parse_paper(self.bundle['paper_pages']['4048'], self.program['4048']['url'], self.program['4048'])['abstract'])
|
|
|
|
def test_foreign_canonical_and_inconsistent_jsonld_author_rejected(self):
|
|
raw = self.bundle['paper_pages']['4048']; url = self.program['4048']['url']
|
|
for changed in [raw.replace(url, 'https://example.org/other'), raw.replace('Suhyeon Ha', 'Other Author', 1)]:
|
|
with self.assertRaises(ValueError):
|
|
c.parse_paper(changed, url, self.program['4048'])
|
|
|
|
def test_program_and_page_versions_flagged_without_aliases(self):
|
|
program = copy.deepcopy(self.program['4048']); program['listing']['title'] = 'Earlier source title'
|
|
fields = c.parse_paper(self.bundle['paper_pages']['4048'], program['url'], program)
|
|
self.assertEqual(fields['review_flags'], ['program_and_page_title_versions_differ_requires_review'])
|
|
self.assertEqual(fields['title'], self.program['4048']['listing']['title'])
|
|
|
|
def test_partial_snapshot_collection_has_no_inferred_submission_ids(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root = Path(tmp); official, paper = self.snapshots(root)
|
|
report = c.collect(root/'out', official_snapshots=official, paper_snapshots_dir=paper)
|
|
self.assertEqual(report['records'], 3); self.assertEqual(len(report['uncollected_program_ids']), 2831)
|
|
self.assertEqual(report['public_rejected_decision_metadata'], 'unknown'); self.assertFalse(report['database_written'])
|
|
manifest, = report['files']; self.assertEqual(manifest['status'], 'partial'); self.assertEqual(manifest['source_expected_count'], 2834)
|
|
rows = [json.loads(l) for l in Path(manifest['file']).read_text().splitlines()]
|
|
self.assertEqual({r['external_id'] for r in rows}, {'2026/4048','2026/3137','2026/3652'})
|
|
self.assertTrue(all(not r['identifiers'] and not r['submission_identifiers'] and r['track']=='program_unclassified' for r in rows))
|
|
self.assertTrue(all(r['metadata']['publication_state']=='preliminary_pending_publisher_checks' and not r['metadata']['original_decision_signature_verified'] for r in rows))
|
|
self.assertTrue(all(t['namespace']=='eccv_program:keyword' for r in rows for t in r['tags']))
|
|
with self.assertRaisesRegex(ValueError, 'Output exists'):
|
|
c.collect(root/'out', official_snapshots=official, paper_snapshots_dir=paper)
|
|
|
|
def test_zero_network_budget_reuses_immutable_cache_only(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root = Path(tmp); official, _ = self.snapshots(root); client = PublicHTMLCache(root/'cache', c.ORIGIN)
|
|
for r in self.bundle['paper_manifest']['records']:
|
|
body, receipt, _ = client.paths(r['url']); body.write_text(self.bundle['paper_pages'][r['paper_id']]); receipt.write_text(json.dumps({**r,'retrieved_at':self.bundle['paper_manifest']['at']}))
|
|
with patch.object(PublicHTMLCache, 'get', side_effect=AssertionError('network forbidden')):
|
|
report = c.collect(root/'out', official_snapshots=official, cache=root/'cache', max_new_pages=0)
|
|
self.assertEqual((report['records'],report['new_pages'],report['reused_pages']), (3,0,3))
|
|
|
|
def test_tampered_snapshot_preserves_failure_without_success(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root = Path(tmp); official, paper = self.snapshots(root); (paper/'4048.html').write_text('tampered')
|
|
with self.assertRaises(ValueError):
|
|
c.collect(root/'out', official_snapshots=official, paper_snapshots_dir=paper)
|
|
self.assertTrue((root/'out/failed.json').exists()); self.assertFalse((root/'out/collection-report.json').exists())
|
|
|
|
def test_structured_math_markup_requires_explicit_review(self):
|
|
raw = self.bundle['paper_pages']['4048']
|
|
self.assertIn('<p>Proactive tamper', raw)
|
|
fields = c.parse_paper(raw.replace('<p>Proactive tamper', '<p>10<sup>6</sup> Proactive tamper', 1), self.program['4048']['url'], self.program['4048'])
|
|
self.assertIn('structured_abstract_markup_requires_review', fields['review_flags'])
|
|
self.assertEqual(fields['abstract_markup_tags'], ['sup'])
|
|
|
|
def test_fixture_preserves_exact_http_bytes_including_crlf(self):
|
|
import hashlib
|
|
for receipt in json.loads(self.bundle['official_manifest'])['sources']:
|
|
raw = self.bundle['official_pages'][receipt['file']].encode('utf-8')
|
|
self.assertEqual(len(raw), receipt['bytes'])
|
|
self.assertEqual(hashlib.sha256(raw).hexdigest(), receipt['sha256'])
|
|
for receipt in self.bundle['paper_manifest']['records']:
|
|
raw = self.bundle['paper_pages'][receipt['paper_id']].encode('utf-8')
|
|
self.assertEqual(hashlib.sha256(raw).hexdigest(), receipt['sha256'])
|
|
|
|
def test_real_double_encoded_author_requires_exact_visible_agreement(self):
|
|
import hashlib
|
|
sample = self.bundle['encoding_sample']; pid = sample['paper_id']; raw = sample['html']
|
|
self.assertEqual(hashlib.sha256(raw.encode('utf-8')).hexdigest(), sample['receipt']['sha256'])
|
|
self.assertEqual(sample['receipt']['sha256'], 'b575318fa569e83eea5e96f937dd60f078fbed482877318013f797c16a02ff09')
|
|
fields = c.parse_paper(raw, sample['receipt']['url'], self.program[pid])
|
|
self.assertEqual(fields['authors'], sample['gold']['authors'])
|
|
self.assertEqual(fields['jsonld_raw_text']['author_names'][0], 'Zi&#x27;ang Lu')
|
|
self.assertIn('jsonld_display_text_normalized_requires_review', fields['review_flags'])
|
|
# Real changes to the author or an extra encoding layer remain errors.
|
|
for replacement in ('Other Author', 'Zi&amp;#x27;ang Lu'):
|
|
with self.assertRaisesRegex(ValueError, 'authors disagree'):
|
|
c.parse_paper(raw.replace('Zi&#x27;ang Lu', replacement), sample['receipt']['url'], self.program[pid])
|
|
|
|
def test_real_already_agreeing_literal_title_is_not_decoded_again(self):
|
|
import hashlib
|
|
sample = self.bundle['literal_title_sample']; pid = sample['paper_id']; raw = sample['html']
|
|
self.assertEqual(hashlib.sha256(raw.encode('utf-8')).hexdigest(), 'c208525ad5f02b4ca274dff7e24a0392dabdc55bb3620497079a84df81a02a72')
|
|
fields = c.parse_paper(raw, sample['receipt']['url'], self.program[pid])
|
|
self.assertIn('&', fields['title'])
|
|
self.assertEqual(fields['title'], sample['gold']['visible_title'])
|
|
self.assertEqual(fields['jsonld_raw_text']['name'], sample['gold']['jsonld_title_raw'])
|
|
self.assertNotEqual(fields['title'], sample['gold']['blind_double_decoded_title'])
|
|
self.assertNotIn('jsonld_display_text_normalized_requires_review', fields['review_flags'])
|