import csv import datetime as dt import hashlib import json import shutil import tempfile import threading import unittest from concurrent.futures import ThreadPoolExecutor from pathlib import Path import sys from unittest.mock import patch from pypdf import PdfWriter sys.path.insert(0, str(Path(__file__).resolve().parent)) import workqueue as w class FakeCounts: @staticmethod def build(root, now=None): root=Path(root); jobs=w.jobs(root); defs=json.loads((root/'collections.json').read_text()); mapping=json.loads((root/'planning/collection_subfield_map.json').read_text()).get('collections',{}) verified=[json.loads(x) for x in (root/'data/verified_links.jsonl').read_text().splitlines() if x.strip()] hashes={sid:set() for sid in jobs} for definition in defs: entry=mapping.get(definition['collection'],{}) sids=entry.get('subfield_ids',[]) or ([str(definition['openalex_subfield_id'])] if definition.get('openalex_subfield_id') else []) for sid in sids: hashes.setdefault(str(sid),set()).update(r['sha256'] for r in verified if r['collection']==definition['collection']) rows=[{'subfield_id':sid,'valid_pdf_count':len(hashes.get(sid,set()))} for sid in jobs] return rows,{} @staticmethod def render(root, now=None): root=Path(root); (root/'planning').mkdir(exist_ok=True) counts,_=FakeCounts.build(root,now); rows=[] for j in w.jobs(root).values(): s=w.load_state(root)['tasks'].get(str(j['subfield_id']),{}) count=next(r['valid_pdf_count'] for r in counts if str(r['subfield_id'])==str(j['subfield_id'])) rows.append({'subfield_id':j['subfield_id'],'valid_pdf_count':count,'last_search_at':s.get('last_search_at',''),'availability':'available','owner':s.get('owner',''),'lease_id':s.get('lease_id',''),'generation':s.get('generation',0),'lease_expires_at':s.get('lease_expires_at',''),'cooldown_until':s.get('cooldown_until','')}) with (root/w.CSV).open('w',newline='') as f: cols=list(rows[0]) if rows else ['subfield_id']; wr=csv.DictWriter(f,fieldnames=cols); wr.writeheader(); wr.writerows(rows) (root/w.SUMMARY).write_text(json.dumps({'jobs':len(rows)})) class FakeCAS(RuntimeError): status_code=409 class FakeCatalog: @staticmethod def read_rows(path): return [json.loads(s) for s in Path(path).read_text().splitlines() if s.strip()] @staticmethod def render(root): root=Path(root); defs=json.loads((root/'collections.json').read_text()); rows=FakeCatalog.read_rows(root/'data/verified_links.jsonl') for c in defs: c['verified_entries']=sum(r['collection']==c['collection'] for r in rows); c['legacy_candidates']=0 (root/'collections.json').write_text(json.dumps(defs)) return None @staticmethod def validate(root): return True class FakeBackend: def __init__(self,repo,now): self.repo=Path(repo); self.now=now; self.head_id=1; self.conflict=False; self.commits=0; self.lock=threading.Lock(); self.barrier=None; self.snapshot_count=0 def head(self): return str(self.head_id) def server_now(self): return self.now def snapshot(self,revision,dest): barrier=None with self.lock: self.snapshot_count+=1 if self.barrier is not None and self.snapshot_count<=2: barrier=self.barrier shutil.copytree(self.repo,dest) if barrier: barrier.wait(timeout=5) def commit(self,base,files,message): with self.lock: if str(self.head_id)!=str(base): raise FakeCAS('CAS conflict') if self.conflict: self.conflict=False data=self.repo/'data/verified_links.jsonl' rows=[json.loads(x) for x in data.read_text().splitlines() if x.strip()] rows.append(self.competitor) data.write_text(''.join(json.dumps(x)+'\n' for x in rows)); self.head_id+=1 raise FakeCAS('CAS conflict') for rel,path in files.items(): out=self.repo/rel; out.parent.mkdir(parents=True,exist_ok=True); shutil.copy2(path,out) self.head_id+=1; self.commits+=1 class WorkqueueTests(unittest.TestCase): def fixture(self): td=tempfile.TemporaryDirectory(); root=Path(td.name)/'checkout'; root.mkdir(); (root/'planning').mkdir(); (root/'data').mkdir() jobs=[] for sid in (3200,3201): jobs.append({'subfield_id':str(sid),'field_id':'32','subfield_name':f'Subfield {sid}','suggested_collection':f'{sid}_subfield','suggested_group':'psychology','suggested_public_path':f'psychology/{sid}_subfield','valid_pdf_count':0}) (root/'planning/subfield_jobs.jsonl').write_text(''.join(json.dumps(j)+'\n' for j in jobs)) (root/'planning/collection_subfield_map.json').write_text(json.dumps({'schema_version':1,'collections':{'prior_3200':{'subfield_ids':['3200']},'prior_3201':{'subfield_ids':['3201']}}})) defs=[{'collection':name,'group':'psychology','path':f'psychology/{name}','display_name':name,'verified_entries':1,'legacy_candidates':0} for name in ('prior_3200','prior_3201')] (root/'collections.json').write_text(json.dumps(defs)); (root/'data/legacy_candidates.jsonl').write_text(''); (root/'data/release_summary.json').write_text('{}') now=dt.datetime(2026,1,1,tzinfo=dt.timezone.utc); backend=FakeBackend(root,now) scratch_tmp=tempfile.TemporaryDirectory(prefix='workqueue-test-') self.addCleanup(scratch_tmp.cleanup); scratch=Path(scratch_tmp.name) writer=PdfWriter(); [writer.add_blank_page(width=72,height=72) for _ in range(4)] pdf=scratch/'book.pdf' with pdf.open('wb') as f: writer.write(f) sha=hashlib.sha256(pdf.read_bytes()).hexdigest() rec={k:'' for k in w.FIELDS}; rec.update(record_id='r1',work_id='sha256:'+sha,collection='3200_subfield',group='psychology',title='A textbook',authors='',year=None,work_type='textbook',pages=4,pdf_url='https://example.org/book.pdf',source_url='https://example.org/book',identifier='',status='downloaded_and_screened',checked_at='2026-01-01T00:00:00Z',sha256=sha,verification_note='Complete academic textbook screened.',source_notes='') prior_rows=[] for sid in ('3200','3201'): old=dict(rec); old.update(record_id='prior-'+sid,collection='prior_'+sid,work_id='pdf:'+sha) prior_rows.append(old) (root/'data/verified_links.jsonl').write_text(''.join(json.dumps(r)+'\n' for r in prior_rows)) proof={'local_pdf':str(pdf),'sha256':sha,'pages':4,'decision':'accept','complete':True,'academic_context':True,'public_access':True,'source_verified':True,'source_check_notes':'Institutional source page identifies the download.','pdf_url':rec['pdf_url'],'source_url':rec['source_url'],'reviewed_pages':[{'page':1,'notes':'Title and contents establish book scope.'},{'page':3,'notes':'Middle chapter confirms scope.'},{'page':4,'notes':'Final pages show complete work.'}]} return td,root,scratch,backend,rec,proof,now def test_false_like_completeness_flags_are_never_positive_evidence(self): td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) for bad in (False,None,'false','true',1): with self.subTest(complete=bad): with self.assertRaises(ValueError): w.verify_record(rec,dict(proof,complete=bad),scratch) w.verify_record(rec,proof,scratch) def test_two_claims_get_distinct_available_subfields(self): td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) with patch.dict(sys.modules,{'workqueue_counts':FakeCounts}): a=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) c=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000002'},backend=b,scratch=scratch) self.assertNotEqual(a['subfield_id'],c['subfield_id']) def test_simultaneous_claims_retry_cas_and_get_distinct_subfields(self): td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup); b.barrier=threading.Barrier(2) with patch.dict(sys.modules,{'workqueue_counts':FakeCounts}): with ThreadPoolExecutor(max_workers=2) as pool: fs=[pool.submit(w.remote_lease,'',root,'claim',{'owner':f'00000000-0000-0000-0000-{i:012d}'},backend=b,scratch=scratch) for i in (1,2)] claims=[f.result(timeout=10) for f in fs] self.assertEqual(len({c['subfield_id'] for c in claims}),2) def test_new_definition_and_retry_preserve_concurrent_row(self): td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) with patch.dict(sys.modules,{'workqueue_counts':FakeCounts,'catalog':FakeCatalog}): claim=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) rec2=dict(rec); rec2.update(record_id='competitor',sha256='a'*64,work_id='sha256:'+'a'*64,title='Concurrent accepted work') b.competitor=rec2; b.conflict=True result=w.publish(root,b,claim['subfield_id'],claim['owner'],claim['lease_id'],claim['generation'],[(rec,proof)],scratch) self.assertTrue(result['published']) rows=FakeCatalog.read_rows(root/'data/verified_links.jsonl') self.assertEqual({r['record_id'] for r in rows},{'prior-3200','prior-3201','competitor','r1'}) defs=json.loads((root/'collections.json').read_text()) self.assertEqual(next(d for d in defs if d['collection']=='3200_subfield')['openalex_subfield_id'],'3200') def test_old_expired_lease_cannot_publish_after_new_claim(self): td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) with patch.dict(sys.modules,{'workqueue_counts':FakeCounts,'catalog':FakeCatalog}): a=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) b.now+=dt.timedelta(minutes=31) c=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000002'},backend=b,scratch=scratch) self.assertNotEqual(a['lease_id'],c['lease_id']) with self.assertRaises(ValueError): w.publish(root,b,a['subfield_id'],a['owner'],a['lease_id'],a['generation'],[(rec,proof)],scratch) self.assertEqual(w.load_state(root)['tasks'][a['subfield_id']]['completed_rounds'],0) def test_duplicate_completion_does_not_increment_twice(self): td,root,scratch,b,rec,proof,now=self.fixture(); self.addCleanup(td.cleanup) with patch.dict(sys.modules,{'workqueue_counts':FakeCounts,'catalog':FakeCatalog}): a=w.remote_lease('',root,'claim',{'owner':'00000000-0000-0000-0000-000000000001'},backend=b,scratch=scratch) out=w.publish(root,b,a['subfield_id'],a['owner'],a['lease_id'],a['generation'],[(rec,proof),(rec,proof)],scratch) self.assertEqual(out['new_entries'],1) self.assertEqual(sum(r['record_id']=='r1' for r in FakeCatalog.read_rows(root/'data/verified_links.jsonl')),1) self.assertEqual(w.load_state(root)['tasks'][a['subfield_id']]['last_new_pdfs'],0) with self.assertRaises(ValueError): w.publish(root,b,a['subfield_id'],a['owner'],a['lease_id'],a['generation'],[(rec,proof)],scratch) self.assertEqual(w.load_state(root)['tasks'][a['subfield_id']]['completed_rounds'],1) if __name__=='__main__': unittest.main()