Files
kefu/wechat_rpa/test_knowledge_full_publish.py
T
2026-11-16 09:28:25 +08:00

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)