523 lines
31 KiB
Python
523 lines
31 KiB
Python
"""Synthetic durable full-draft approval/publication; no live records or network."""
|
|
import json
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from threading import Barrier, Event
|
|
from unittest import TestCase, mock
|
|
|
|
import httpx
|
|
|
|
import test_knowledge as fixtures
|
|
import test_knowledge_own_scope as own_fixtures
|
|
import test_knowledge_review as review_fixtures
|
|
from archive_store import ArchiveStore
|
|
from knowledge_assignments import KnowledgeAssignments
|
|
from knowledge_retriever import KnowledgeRetriever
|
|
from knowledge_review import KnowledgeReviewStore, KnowledgeReviewWorker, PUBLISH_PERMISSIONS
|
|
|
|
|
|
class FullPublishTest(TestCase):
|
|
setUp = fixtures.KnowledgeTest.setUp
|
|
tearDown = fixtures.KnowledgeTest.tearDown
|
|
payload = fixtures.KnowledgeTest.payload
|
|
start_job = fixtures.KnowledgeTest.start_job
|
|
process = fixtures.KnowledgeTest.process
|
|
first = fixtures.KnowledgeTest.first
|
|
seed = review_fixtures.FullReviewTest.seed
|
|
|
|
def launch(self, count=3):
|
|
ids = self.seed(count)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
return ids, reviews, job
|
|
|
|
def unpublished(self, ids):
|
|
with self.db.connect() as db:
|
|
placeholders = ','.join('?' for _ in ids)
|
|
self.assertEqual(db.execute(f"SELECT COUNT(*) FROM knowledge_item WHERE id IN ({placeholders}) "
|
|
"AND status IN ('approved','published')", ids).fetchone()[0], 0)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action IN ('approve','publish')").fetchone()[0], 0)
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_fts').fetchone()[0], 0)
|
|
|
|
def test_cross_page_success_published_results_counts_index_and_exact_audits(self):
|
|
ids, reviews, job = self.launch(103)
|
|
self.assertEqual(job['mode'], 'approve_publish')
|
|
self.assertEqual(job['published'], 0)
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.return_value = 'synthetic-vector-profile'
|
|
worker = KnowledgeReviewWorker(self.store)
|
|
worker.step(17)
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['processed'], current['approved'], current['published']), (17, 17, 17))
|
|
while worker.step(17):
|
|
pass
|
|
self.assertEqual(index.return_value.publish.call_count, 103)
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['status'], current['processed'], current['approved'], current['published'],
|
|
current['skipped'], current['progress_percent']), ('completed', 103, 103, 103, 0, 100))
|
|
page = reviews.results(job['id'], self.actor, '*', 'published', 4, 30)
|
|
self.assertEqual((page['total'], len(page['items'])), (103, 13))
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', 'approved')['total'], 0)
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_item WHERE vector_status='ready' "
|
|
"AND vector_profile='synthetic-vector-profile'").fetchone()[0], 103)
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_fts').fetchone()[0], 103)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM audit_log WHERE action='knowledge.approve'").fetchone()[0], 103)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM audit_log WHERE action='knowledge.publish'").fetchone()[0], 103)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM audit_log WHERE action='knowledge.review.complete'").fetchone()[0], 1)
|
|
self.assertTrue(KnowledgeRetriever(self.store).search('default', '预约挂号材料')['hits'])
|
|
self.assertEqual(set(ids), {r['item_id'] for r in reviews.results(job['id'], self.actor, '*', '', 1, 200)['items']})
|
|
|
|
def test_each_required_permission_is_rechecked_at_preview_start_resume(self):
|
|
self.seed(1)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
for permission in PUBLISH_PERMISSIONS:
|
|
with self.subTest(permission=permission):
|
|
job = reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code=?", (permission,))
|
|
with self.assertRaises(ValueError):
|
|
reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
with self.db.connect() as db:
|
|
db.execute("INSERT INTO role_permissions VALUES ('admin',?)", (permission,))
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
reviews.action(job['id'], 'pause', self.actor, '')
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code=?", (permission,))
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
with self.db.connect() as db:
|
|
db.execute("INSERT INTO role_permissions VALUES ('admin',?)", (permission,))
|
|
reviews.action(job['id'], 'cancel', self.actor, '')
|
|
|
|
def test_strict_confirmation_and_repeated_start_are_idempotent(self):
|
|
ids = self.seed(1)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
for value in (False, None, 'true', 'yes', 1, 0):
|
|
with self.subTest(value=value), self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'start', self.actor, '', value)
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step())
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 1)
|
|
|
|
def test_revocation_after_network_preserves_pending_then_manual_resume(self):
|
|
ids, reviews, job = self.launch(1)
|
|
for permission in sorted(PUBLISH_PERMISSIONS):
|
|
with self.subTest(permission=permission):
|
|
def revoke(_draft):
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code=?", (permission,))
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = revoke
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.unpublished(ids)
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT result FROM knowledge_review_target WHERE job_id=?', (job['id'],)).fetchone()[0], 'pending')
|
|
db.execute("INSERT INTO role_permissions VALUES ('admin',?)", (permission,))
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['status'], current['processed'], current['published']), ('failed', 0, 0))
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 1)
|
|
|
|
def test_pause_resume_inside_network_fences_old_upload(self):
|
|
ids, reviews, job = self.launch(1)
|
|
def pause_resume(_draft):
|
|
reviews.action(job['id'], 'pause', self.actor, '')
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = pause_resume
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.unpublished(ids)
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['processed'], 0)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 1)
|
|
|
|
def test_cancel_inside_network_blocks_commit(self):
|
|
ids, reviews, job = self.launch(1)
|
|
def cancel(_draft):
|
|
reviews.action(job['id'], 'cancel', self.actor, '')
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = cancel
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.unpublished(ids)
|
|
self.assertEqual((reviews.get(job['id'], self.actor)['status'], reviews.get(job['id'], self.actor)['processed']), ('cancelled', 0))
|
|
|
|
def test_source_revision_and_expiry_changes_during_network_are_skipped(self):
|
|
for change in ('source', 'revision', 'expiry'):
|
|
with self.subTest(change=change):
|
|
# Each case has an independent synthetic database.
|
|
self.tearDown(); self.setUp()
|
|
ids, reviews, job = self.launch(1)
|
|
def mutate(draft):
|
|
with self.db.connect() as db:
|
|
if change == 'source':
|
|
db.execute('UPDATE knowledge_source SET version_no=999 WHERE item_id=?', (draft['id'],))
|
|
elif change == 'revision':
|
|
db.execute('UPDATE knowledge_item SET revision=revision+1 WHERE id=?', (draft['id'],))
|
|
else:
|
|
db.execute("UPDATE knowledge_item SET valid_until='2000-01-01' WHERE id=?", (draft['id'],))
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = mutate
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.unpublished(ids)
|
|
current = reviews.get(job['id'], self.actor)
|
|
expected = 1 if change == 'expiry' else 0
|
|
self.assertEqual((current['status'], current['processed'], current['skipped'], current['published']),
|
|
('completed', expected, expected, 0))
|
|
|
|
def test_withdrawal_and_reassignment_back_during_indexing_fence_old_job(self):
|
|
for change in ('withdraw', 'reassign-back'):
|
|
with self.subTest(change=change):
|
|
self.tearDown(); self.setUp()
|
|
ids, reviews, job = self.launch(1)
|
|
assignment = KnowledgeAssignments(self.store)
|
|
selection = [{'id': ids[0], 'revision': 2}]
|
|
self.db.create_user('other-reviewer', 'InitialReader123', 'admin', self.actor, '')
|
|
other = self.db.authenticate('other-reviewer', 'InitialReader123')['id']
|
|
|
|
def revoke(_draft):
|
|
assignment.assign('*', selection, other if change == 'reassign-back' else None, self.actor, '')
|
|
if change == 'reassign-back':
|
|
assignment.assign('*', selection, self.actor, self.actor, '')
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', ''), {'items': [], 'total': 0})
|
|
return 'synthetic-profile'
|
|
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = revoke
|
|
KnowledgeReviewWorker(self.store).step()
|
|
index.return_value.publish.assert_called_once()
|
|
self.unpublished(ids)
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['status'], current['total'], current['published']), ('completed', 0, 0))
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', ''), {'items': [], 'total': 0})
|
|
if change == 'reassign-back':
|
|
new = reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
self.assertEqual(new['total'], 1)
|
|
reviews.action(new['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(new['id'], self.actor)['published'], 1)
|
|
|
|
def test_issuer_revocation_before_indexing_excludes_queued_target(self):
|
|
ids, reviews, job = self.launch(1)
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review:assign'")
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
KnowledgeReviewWorker(self.store).step()
|
|
index.assert_not_called()
|
|
self.unpublished(ids)
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['status'], current['total'], current['published']), ('completed', 0, 0))
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', ''), {'items': [], 'total': 0})
|
|
|
|
def test_completed_result_hides_when_issuer_loses_assignment_authority(self):
|
|
ids, reviews, job = self.launch(1)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', 'published')['items'][0]['item_id'], ids[0])
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review:assign'")
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', ''), {'items': [], 'total': 0})
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 0)
|
|
|
|
def test_expiry_crossed_after_network_is_rechecked_without_edit(self):
|
|
ids, reviews, job = self.launch(1)
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE knowledge_item SET valid_until='2099-01-01' WHERE id=?", (ids[0],))
|
|
day = ['2099-01-01']
|
|
def upload(_draft):
|
|
day[0] = '2099-01-02'
|
|
return 'synthetic-profile'
|
|
with mock.patch.object(KnowledgeRetriever, '_today', side_effect=lambda: day[0]), mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = upload
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.unpublished(ids)
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*')['items'][0]['reason'], 'expired')
|
|
|
|
def test_missing_source_versions_and_invalid_dates_do_not_upload(self):
|
|
ids, reviews, job = self.launch(3)
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE knowledge_item SET valid_until='2099-02-30' WHERE id=?", (ids[0],))
|
|
db.execute("UPDATE knowledge_item SET valid_until='20990101' WHERE id=?", (ids[1],))
|
|
db.execute('DELETE FROM archive_message_version')
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
KnowledgeReviewWorker(self.store).step()
|
|
index.assert_not_called()
|
|
self.unpublished(ids)
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['skipped'], 3)
|
|
|
|
def test_partial_network_failure_continues_without_automatic_retry(self):
|
|
ids, reviews, job = self.launch(4)
|
|
calls = []
|
|
def upload(draft):
|
|
calls.append(draft['id'])
|
|
if len(calls) == 2:
|
|
raise httpx.ConnectError('Synthetic remote error body must not leak')
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = upload
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step())
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((len(calls), current['published'], current['skipped'], current['processed']), (4, 3, 1, 4))
|
|
reasons = reviews.results(job['id'], self.actor, '*')['items']
|
|
self.assertEqual(reasons[0]['reason'], 'index_failed')
|
|
self.assertNotIn('remote error', json.dumps(reasons))
|
|
|
|
def test_stop_after_partial_success_then_new_worker_resumes_only_pending(self):
|
|
ids, reviews, job = self.launch(5)
|
|
KnowledgeReviewWorker(self.store).step(2)
|
|
reviews.action(job['id'], 'pause', self.actor, '')
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step())
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 2)
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 5)
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action='publish'").fetchone()[0], 5)
|
|
|
|
def test_crash_after_publication_before_target_update_rolls_back_everything(self):
|
|
ids, reviews, job = self.launch(1)
|
|
worker = KnowledgeReviewWorker(self.store)
|
|
def crash(db, _job, _target, reason=''):
|
|
# An independent reader must still see the original draft and pending target.
|
|
with self.db.connect() as observer:
|
|
self.assertEqual(observer.execute('SELECT status FROM knowledge_item WHERE id=?', (ids[0],)).fetchone()[0], 'draft')
|
|
self.assertEqual(observer.execute('SELECT processed FROM knowledge_review_job WHERE id=?', (job['id'],)).fetchone()[0], 0)
|
|
self.assertEqual(observer.execute('SELECT result FROM knowledge_review_target WHERE job_id=?', (job['id'],)).fetchone()[0], 'pending')
|
|
raise RuntimeError('Synthetic process crash before target completion')
|
|
with mock.patch.object(worker, '_finish_target', side_effect=crash), self.assertRaisesRegex(RuntimeError, 'Synthetic process crash'):
|
|
worker.step()
|
|
self.unpublished(ids)
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['processed'], 0)
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step(), 'Unexpired crash lease fences immediate duplicate work')
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE knowledge_review_claim SET lease_until=0 WHERE job_id=?', (job['id'],))
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 1)
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step())
|
|
|
|
def test_concurrent_workers_skip_active_lease_and_upload_without_writer_lock(self):
|
|
ids, reviews, job = self.launch(1)
|
|
entered, release = Event(), Event()
|
|
def upload(_draft):
|
|
# A writer is possible while this upload is in flight.
|
|
with self.db.connect() as db:
|
|
db.execute('BEGIN IMMEDIATE')
|
|
db.execute("INSERT INTO knowledge_config(key,value_json,updated_at) VALUES ('synthetic_write_probe','true',?)", ('2026-11-05',))
|
|
entered.set()
|
|
self.assertTrue(release.wait(10))
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = upload
|
|
with ThreadPoolExecutor(max_workers=2) as pool:
|
|
first = pool.submit(KnowledgeReviewWorker(self.store).step)
|
|
self.assertTrue(entered.wait(10))
|
|
second = pool.submit(KnowledgeReviewWorker(self.store).step)
|
|
self.assertFalse(second.result(timeout=10))
|
|
release.set()
|
|
self.assertTrue(first.result(timeout=10))
|
|
index.return_value.publish.assert_called_once()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['published'], 1)
|
|
|
|
def test_expired_lease_takeover_fences_late_original_worker(self):
|
|
ids, reviews, job = self.launch(1)
|
|
calls = []
|
|
def upload(_draft):
|
|
calls.append(1)
|
|
if len(calls) == 1:
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE knowledge_review_claim SET lease_until=0 WHERE job_id=?', (job['id'],))
|
|
KnowledgeReviewWorker(self.store).step()
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = upload
|
|
KnowledgeReviewWorker(self.store).step()
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((len(calls), current['processed'], current['published']), (2, 1, 1))
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action='approve'").fetchone()[0], 1)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action='publish'").fetchone()[0], 1)
|
|
|
|
def test_different_jobs_sharing_snapshot_publish_item_once(self):
|
|
ids, reviews, first_job = self.launch(1)
|
|
other = reviews.preview('*', -1, self.actor, '', 'approve_publish')
|
|
reviews.action(other['id'], 'start', self.actor, '', True)
|
|
ready = Barrier(2)
|
|
def upload(_draft):
|
|
ready.wait(timeout=10)
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = upload
|
|
with ThreadPoolExecutor(max_workers=2) as pool:
|
|
work = [pool.submit(KnowledgeReviewWorker(self.store).step) for _ in range(2)]
|
|
self.assertTrue(all(f.result(timeout=15) for f in work))
|
|
jobs = [reviews.get(j['id'], self.actor) for j in (first_job, other)]
|
|
self.assertEqual(sum(j['processed'] for j in jobs), 1)
|
|
self.assertEqual(sum(j['published'] for j in jobs), 1)
|
|
self.assertEqual(sum(j['skipped'] for j in jobs), 0)
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT SUM(skipped) FROM knowledge_review_job').fetchone()[0], 1)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action IN ('approve','publish')").fetchone()[0], 2)
|
|
|
|
def test_additive_migration_recreates_claim_table_and_preserves_old_job(self):
|
|
self.seed(1)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
with self.db.connect() as db:
|
|
db.execute('DROP TABLE knowledge_review_claim')
|
|
db.execute("UPDATE knowledge_review_job SET preview_json=json_remove(preview_json,'$.mode') WHERE id=?", (job['id'],))
|
|
self.store.initialize()
|
|
self.store.initialize()
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['mode'], current['total'], current['published']), ('approve', 1, 0))
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_review_claim').fetchone()[0], 0)
|
|
|
|
def test_assignment_bound_preview_without_mode_defaults_to_approval_only(self):
|
|
self.seed(2)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
with self.db.connect() as db:
|
|
old_preview = json.loads(db.execute('SELECT preview_json FROM knowledge_review_job WHERE id=?', (job['id'],)).fetchone()[0])
|
|
old_preview.pop('mode')
|
|
db.execute('UPDATE knowledge_review_job SET preview_json=? WHERE id=?', (json.dumps(old_preview), job['id']))
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:publish'")
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
KnowledgeReviewWorker(self.store).step()
|
|
index.assert_not_called()
|
|
current = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((current['mode'], current['approved'], current['published']), ('approve', 2, 0))
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', 'approved')['total'], 2)
|
|
|
|
|
|
class FullPublishApiTest(TestCase):
|
|
setUp = fixtures.KnowledgeApiTest.setUp
|
|
tearDown = fixtures.KnowledgeApiTest.tearDown
|
|
|
|
def test_mode_validation_permission_and_legacy_read_contract(self):
|
|
url = '/api/v2/knowledge/review-tasks'
|
|
self.assertEqual(self.client.post(url + '/preview?mode=unknown', headers=self.headers).status_code, 422)
|
|
response = self.client.post(url + '/preview?mode=approve_publish', headers=self.headers)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
combined = response.json()
|
|
self.assertEqual((combined['mode'], combined['published']), ('approve_publish', 0))
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:publish'")
|
|
for method, suffix, body in [('post', '/preview?mode=approve_publish', None),
|
|
('post', '/' + combined['id'] + '/start', {'confirmed': True})]:
|
|
response = getattr(self.client, method)(url + suffix, headers=self.headers, json=body)
|
|
self.assertEqual(response.status_code, 403, response.text)
|
|
for suffix in ('/' + combined['id'], '/' + combined['id'] + '/results?result=published', ''):
|
|
self.assertEqual(self.client.get(url + suffix, headers=self.headers).status_code, 200)
|
|
response = self.client.post(url + '/preview', headers=self.headers)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
self.assertEqual(response.json()['mode'], 'approve')
|
|
self.assertEqual(self.client.post(url + '/' + combined['id'] + '/cancel', headers=self.headers, json={}).status_code, 400)
|
|
|
|
def test_combined_strict_confirmation_but_legacy_boolean_coercion_unchanged(self):
|
|
url = '/api/v2/knowledge/review-tasks'
|
|
combined = self.client.post(url + '/preview?mode=approve_publish', headers=self.headers).json()
|
|
for value in ('true', 1):
|
|
response = self.client.post(url + '/' + combined['id'] + '/start', headers=self.headers, json={'confirmed': value})
|
|
self.assertEqual(response.status_code, 400, response.text)
|
|
self.assertIn('明确确认', response.json()['detail'])
|
|
legacy = self.client.post(url + '/preview', headers=self.headers).json()
|
|
response = self.client.post(url + '/' + legacy['id'] + '/start', headers=self.headers, json={'confirmed': 'true'})
|
|
self.assertEqual(response.status_code, 400, response.text)
|
|
self.assertIn('没有待审核草稿', response.json()['detail'])
|
|
|
|
|
|
class FullPublishOwnScopeTest(TestCase):
|
|
setUp = own_fixtures.OwnKnowledgeTest.setUp
|
|
tearDown = own_fixtures.OwnKnowledgeTest.tearDown
|
|
payload = own_fixtures.OwnKnowledgeTest.payload
|
|
start_job = own_fixtures.OwnKnowledgeTest.start_job
|
|
process = own_fixtures.OwnKnowledgeTest.process
|
|
first = own_fixtures.OwnKnowledgeTest.first
|
|
|
|
def assign(self, *keys):
|
|
assignments = KnowledgeAssignments(self.store)
|
|
selections = []
|
|
with self.db.connect() as db:
|
|
for key in keys:
|
|
item_id = self.ids[key]
|
|
revision = db.execute('SELECT revision FROM knowledge_item WHERE id=?', (item_id,)).fetchone()[0]
|
|
selections.append({'id': item_id, 'revision': revision})
|
|
assignments.assign('*', selections, self.users['alice'], self.actor, '')
|
|
|
|
def test_own_account_trusted_mapping_does_not_grant_unassigned_drafts(self):
|
|
self.assign('alice')
|
|
url = self.url + '/review-tasks'
|
|
response = self.client.post(url + '/preview?mode=approve_publish', headers=self.alice)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
job = response.json()
|
|
self.assertEqual(job['total'], 1)
|
|
response = self.client.post(url + '/' + job['id'] + '/start', headers=self.alice, json={'confirmed': True})
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
result = self.client.get(url + '/' + job['id'], headers=self.alice).json()
|
|
self.assertEqual((result['published'], result['approved'], result['skipped']), (1, 1, 0))
|
|
self.assertEqual(self.store.detail(self.other_tenant, self.ids['cross'])['status'], 'draft')
|
|
rows = self.client.get(url + '/' + job['id'] + '/results?result=published', headers=self.alice).json()
|
|
self.assertEqual(rows['total'], 1)
|
|
|
|
def test_recipient_tenant_binding_revocation_does_not_revoke_explicit_assignment(self):
|
|
self.assign('alice')
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
actor = self.users['alice']
|
|
job = reviews.preview('*', -1, actor, '', 'approve_publish')
|
|
reviews.action(job['id'], 'start', actor, '', True)
|
|
def revoke(_draft):
|
|
with self.db.connect() as db:
|
|
db.execute('DELETE FROM group_sso_bindings WHERE user_id=?', (actor,))
|
|
return 'synthetic-profile'
|
|
with mock.patch('knowledge_retriever.VectorIndex') as index:
|
|
index.return_value.configured = True
|
|
index.return_value.publish.side_effect = revoke
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(self.store.stats(self.tenant), {'draft': 4, 'published': 1})
|
|
result = reviews.get(job['id'], actor)
|
|
self.assertEqual((result['total'], result['published']), (1, 1))
|
|
self.assertEqual(reviews.results(job['id'], actor, '*', '')['total'], 1)
|
|
|
|
def test_publish_revocation_still_allows_owned_pause_cancel_and_reads(self):
|
|
self.assign('alice')
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
actor = self.users['alice']
|
|
job = reviews.preview('*', -1, actor, '', 'approve_publish')
|
|
reviews.action(job['id'], 'start', actor, '', True)
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='cleaner' AND permission_code='knowledge:publish'")
|
|
url = self.url + '/review-tasks/' + job['id']
|
|
self.assertEqual(self.client.post(url + '/pause', headers=self.alice, json={}).status_code, 200)
|
|
self.assertEqual(self.client.get(url, headers=self.alice).status_code, 200)
|
|
self.assertEqual(self.client.get(url + '/results', headers=self.alice).status_code, 200)
|
|
self.assertEqual(self.client.post(url + '/resume', headers=self.alice, json={}).status_code, 403)
|
|
self.assertEqual(self.client.post(url + '/cancel', headers=self.alice, json={}).status_code, 200)
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='cleaner' AND permission_code='knowledge:review'")
|
|
for suffix in ('', '/results'):
|
|
self.assertEqual(self.client.get(url + suffix, headers=self.alice).status_code, 403)
|