141 lines
8.5 KiB
Python
141 lines
8.5 KiB
Python
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)
|