from contextlib import closing, redirect_stdout from hashlib import sha256 import io import json import os from pathlib import Path from tempfile import TemporaryDirectory import unittest import uuid from paper_atlas.audits.source_identity import entity_packet from paper_atlas.cli import main from paper_atlas.db.edition_scopes import resolve from paper_atlas.db.store import Store from paper_atlas.ingestion.publication_reconciliation import PROGRAMME, PUBLISHER, packet_digest from paper_atlas.postgres.client import ReadConnection, connect from paper_atlas.postgres.migration import migrate from paper_atlas.postgres.schema import quote class PublicationReconciliationTests(unittest.TestCase): def setUp(self): directory = TemporaryDirectory() self.addCleanup(directory.cleanup) self.root = Path(directory.name) self.db = self.root / 'db.sqlite' self.store = Store(self.db) self.conn = self.store.conn self.addCleanup(self.conn.close) self.programme_url = 'https://eccv.ecva.net/Conferences/2026/AcceptedPapers' self.publisher_url = 'https://link.springer.com/conference/eccv' programme = self.store.source(PROGRAMME, self.programme_url) publisher = self.store.source(PUBLISHER, self.publisher_url) self.entries = [self.programme_attempt(str(i)) for i in range(1, 4)] title = 'A distinct chapter already integrated in the main track' paper, record = self.store.record(PUBLISHER, 'prior', self.publisher_url, title, 'Text', []) self.target = self.store.accepted(paper, record, 'ECCV', 2026, 'main', 'prior', self.publisher_url) self.original = self.entries[0]['move_from_edition_id'] for entry in self.entries: entry['move_to_edition_id'] = self.target self.conn.executemany('''INSERT INTO edition_sources (edition_id,source_id,list_url,status,expected_count,imported_count) VALUES(?,?,?,'partial',?,?)''', [(self.original, programme, self.programme_url, 2834, 3), (self.target, publisher, self.publisher_url, 2835, 1)]) self.conn.commit() def programme_attempt(self, number): title = 'A programme observation for continuing research ' + number url = self.programme_url + '/' + number authors = ['Ada Example', 'Sam Example'] paper, record = self.store.record(PROGRAMME, number, url, title, 'Programme text', authors) original = self.store.accepted(paper, record, 'ECCV', 2026, 'program_unclassified', number, url) other, old_record = self.store.record('openreview', 'test-' + number, url, title, 'Programme text', authors) self.assertEqual(other, paper) self.store.decision(paper, old_record, 'ICLR', 2025, 'main', 'test-' + number, url, 'rejected', 'Reject') packet = entity_packet(self.conn, paper) attempt = next(row for row in packet['attempts'] if row['source_record_id'] == record) doi = '10.1007/978-3-032-00000-1_' + number chapter = 'https://link.springer.com/chapter/' + doi row = {'source': PUBLISHER, 'external_id': doi, 'url': chapter, 'evidence_url': chapter, 'venue': 'ECCV', 'year': 2026, 'track': 'main', 'status': 'accepted', 'title': title, 'authors': authors, 'abstract': 'Publisher text', 'observed_at': '2026-11-18T00:00:00Z', 'raw_decision': 'Publication observation', 'identifiers': {'doi': doi}, 'submission_identifiers': [{'scheme': 'publication_doi', 'value': doi}], 'metadata': {'publisher_chapter_evidence': {'sha256': 'a' * 64}}, 'tags': [{'namespace': PUBLISHER + ':format', 'value': 'chapter'}]} return {'doi': doi, 'retained_paper_id': paper, 'retained_programme_record_id': record, 'retained_submission_id': attempt['id'], 'retained_programme_decision_id': attempt['decisions'][0]['id'], 'move_from_edition_id': original, 'source_row': row, 'before_packet_sha256': packet_digest(packet)} def run_plan(self, entries, *database): path = self.root / 'plan.json' raw = json.dumps({'status': 'readonly_same_submission_reconciliation_plan', 'database_written': False, 'plans': entries, 'guarded_same_submission_plans': len(entries)}).encode() path.write_bytes(raw) main(['maintain', 'eccv-publication-reconciliation', *(database or ('--db', str(self.db))), '--plan', str(path), '--plan-sha256', sha256(raw).hexdigest(), '--springer-previous-count', '1']) def test_preserves_history_and_updates_all_three_coverage_scopes(self): entry = self.entries[0] before = entity_packet(self.conn, entry['retained_paper_id']) self.run_plan([entry]) packet = entity_packet(self.conn, entry['retained_paper_id']) self.assertEqual(packet['paper'], before['paper']) programme, other = packet['attempts'] self.assertEqual((programme['id'], programme['edition_id']), (entry['retained_submission_id'], self.target)) self.assertEqual(other, before['attempts'][1]) self.assertEqual(programme['decisions'][0], before['attempts'][0]['decisions'][0]) self.assertEqual([row['status'] for row in programme['decisions']], ['accepted', 'accepted']) self.assertEqual({r['source'] for r in programme['sources']}, {PROGRAMME, PUBLISHER}) self.assertEqual(len(packet['source_records']), 3) self.assertEqual(resolve(self.conn, entry['retained_programme_record_id'], '1', 'ECCV', 2026, 'program_unclassified', None), self.target) coverage = {(edition, source): (status, expected, imported) for edition, source, status, expected, imported in self.conn.execute('''SELECT e.track,s.name,c.status,c.expected_count,c.imported_count FROM edition_sources c JOIN editions e ON e.id=c.edition_id JOIN sources s ON s.id=c.source_id''')} self.assertEqual(coverage, {('program_unclassified', PROGRAMME): ('partial', 2834, 2), ('main', PROGRAMME): ('partial', None, 1), ('main', PUBLISHER): ('partial', 2835, 2)}) with self.assertRaisesRegex(ValueError, 'already applied'): self.run_plan([entry]) def test_changed_history_rolls_back_earlier_observation(self): first, second = self.entries[:2] stale = {**second, 'before_packet_sha256': 'b' * 64} packet = entity_packet(self.conn, first['retained_paper_id']) with self.assertRaisesRegex(ValueError, 'Reviewed paper history changed'): self.run_plan([first, stale]) self.assertEqual(entity_packet(self.conn, first['retained_paper_id']), packet) self.assertIsNone(self.conn.execute( "SELECT 1 FROM identifiers WHERE scheme='doi' AND value=?", (first['doi'],)).fetchone()) self.assertEqual(self.conn.execute('SELECT count(*) FROM edition_sources').fetchone()[0], 2) @unittest.skipUnless(os.environ.get('PAPER_ATLAS_TEST_PG_SERVICE'), 'Requires the remote PostgreSQL test service') def test_postgres_write_verifies_history_from_the_read_backend(self): service = os.environ['PAPER_ATLAS_TEST_PG_SERVICE'] schema = 'pa_eccv_' + uuid.uuid4().hex[:12] def cleanup(): with connect(service) as conn: for name, in conn.execute('SELECT nspname FROM pg_namespace WHERE starts_with(nspname,%s)', (schema,)): conn.execute('DROP SCHEMA ' + quote(name) + ' CASCADE') self.addCleanup(cleanup) self.conn.close() with redirect_stdout(io.StringIO()): migrate(self.db, service, self.root / 'migration.json', schema=schema, min_free_gib=0) entry = self.entries[0] with closing(ReadConnection(service, schema)) as conn: before = entity_packet(conn, entry['retained_paper_id']) reviewed = {**entry, 'before_packet_sha256': packet_digest(before)} self.run_plan([reviewed], '--pg-service', service, '--pg-schema', schema) with closing(ReadConnection(service, schema)) as conn: packet = entity_packet(conn, entry['retained_paper_id']) self.assertEqual(packet['attempts'][1], before['attempts'][1]) self.assertEqual(packet['attempts'][0]['id'], entry['retained_submission_id']) self.assertEqual(packet['attempts'][0]['edition_id'], self.target) self.assertEqual(len(packet['attempts'][0]['decisions']), 2)