367 lines
23 KiB
Python
367 lines
23 KiB
Python
"""Full-scope review snapshot, permissions, transactions and pagination."""
|
|
import json
|
|
from unittest import TestCase, mock
|
|
|
|
import test_knowledge as fixtures
|
|
from archive_store import ArchiveStore, new_id
|
|
from knowledge_access import KnowledgeAccessDenied
|
|
from knowledge_assignments import KnowledgeAssignments
|
|
from knowledge_review import KnowledgeReviewStore, KnowledgeReviewWorker
|
|
|
|
|
|
class FullReviewTest(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
|
|
|
|
def seed(self, count=75, tenant='default', *, assign=True):
|
|
self.process(tenant)
|
|
original = self.first(tenant)
|
|
original['conditions'] = '仅用于虚构门店测试'
|
|
with self.db.connect() as db:
|
|
self.store._save_item(db, self.store._item(db, tenant, original['id']), original['revision'],
|
|
self.store._edit_fields(original), self.actor, '')
|
|
original = self.store.detail(tenant, original['id'])
|
|
ids = [original['id']]
|
|
with self.db.connect() as db:
|
|
for index in range(count - 1):
|
|
item_id = new_id(); ids.append(item_id)
|
|
db.execute("""INSERT INTO knowledge_item(id,tenant_id,job_id,dedup_hash,title,question,answer,conditions,
|
|
category,kind,flags_json,status,revision,valid_until,created_at,updated_at)
|
|
SELECT ?,tenant_id,job_id,?,title||?,question,answer,conditions,category,kind,flags_json,
|
|
status,revision,valid_until,created_at,updated_at FROM knowledge_item WHERE id=?""",
|
|
(item_id, item_id, str(index), original['id']))
|
|
db.execute('INSERT INTO knowledge_source SELECT ?,message_id,version_no,role,content,sent_at '
|
|
'FROM knowledge_source WHERE item_id=?', (item_id, original['id']))
|
|
if assign:
|
|
KnowledgeAssignments(self.store).assign(tenant, [{'id': item_id, 'revision': original['revision']}
|
|
for item_id in ids], self.actor, self.actor, '')
|
|
return ids
|
|
|
|
def test_all_pages_approve_without_publishing_or_model_calls(self):
|
|
self.seed(237)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
preview = reviews.preview('*', -1, self.actor, '')
|
|
self.assertEqual((preview['total'], preview['preview']['eligible']), (237, 237))
|
|
self.assertEqual(len(self.store.list_items('default')['items']), 30)
|
|
self.assertEqual(self.store.stats('default').get('approved', 0), 0)
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(preview['id'], 'start', self.actor, '', False)
|
|
reviews.action(preview['id'], 'start', self.actor, '', True)
|
|
reviews.action(preview['id'], 'start', self.actor, '', True)
|
|
worker = KnowledgeReviewWorker(self.store)
|
|
with mock.patch('model_gateway.call_outlet', side_effect=AssertionError('No model call allowed')):
|
|
worker.step()
|
|
self.assertEqual(reviews.get(preview['id'], self.actor)['processed'], 100)
|
|
worker.step(); worker.step()
|
|
result = reviews.get(preview['id'], self.actor)
|
|
self.assertEqual((result['status'], result['approved'], result['skipped'], result['progress_percent']), ('completed', 237, 0, 100))
|
|
self.assertEqual(self.store.stats('default'), {'approved': 237})
|
|
with self.db.connect() as db:
|
|
self.assertEqual(db.execute('SELECT COUNT(*) FROM knowledge_fts').fetchone()[0], 0)
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_revision WHERE action='approve'").fetchone()[0], 237)
|
|
results = reviews.results(preview['id'], self.actor, '*', 'approved', 8, 30)
|
|
self.assertEqual((results['total'], len(results['items'])), (237, 27))
|
|
|
|
def test_preview_reports_missing_conditions_fields_expiry_and_sources(self):
|
|
ids = self.seed(6)
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE knowledge_item SET conditions='' WHERE id=?", (ids[0],))
|
|
db.execute("UPDATE knowledge_item SET question='' WHERE id=?", (ids[1],))
|
|
db.execute("UPDATE knowledge_item SET valid_until='2000-01-01' WHERE id=?", (ids[2],))
|
|
db.execute('DELETE FROM knowledge_source WHERE item_id=?', (ids[3],))
|
|
db.execute('UPDATE knowledge_source SET version_no=99 WHERE item_id=?', (ids[4],))
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
self.assertEqual((job['total'], job['preview']['eligible'], job['preview']['blocked']), (5, 1, 4))
|
|
self.assertEqual({reason['code'] for reason in job['preview']['reasons']},
|
|
{'missing_conditions', 'invalid_fields', 'expired', 'missing_source'})
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
final = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((final['approved'], final['skipped']), (1, 4))
|
|
self.assertEqual(self.store.stats('default'), {'approved': 1, 'draft': 5})
|
|
|
|
def test_changed_deleted_and_new_items_are_not_approved_from_old_snapshot(self):
|
|
ids = self.seed(4)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
edit = self.store.detail('default', ids[0]); edit['answer'] = '已经编辑的新答案,需要重新审核。'
|
|
with self.db.connect() as db:
|
|
self.store._save_item(db, self.store._item(db, 'default', ids[0]), edit['revision'],
|
|
self.store._edit_fields(edit), self.actor, '')
|
|
db.execute('DELETE FROM knowledge_source WHERE item_id=?', (ids[1],))
|
|
db.execute('DELETE FROM knowledge_revision WHERE item_id=?', (ids[1],))
|
|
db.execute('DELETE FROM knowledge_item WHERE id=?', (ids[1],))
|
|
db.execute("UPDATE knowledge_item SET status='rejected' WHERE id=?", (ids[2],))
|
|
self.seed(1, 'new-tenant')
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
final = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((final['total'], final['approved'], final['skipped']), (1, 1, 0))
|
|
self.assertEqual(self.store.stats('new-tenant'), {'draft': 1})
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*')['items'], [])
|
|
|
|
def test_snapshot_excludes_unassigned_and_later_assigned_drafts(self):
|
|
self.seed(33); self.seed(4, 'other', assign=False)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
self.seed(2, 'later')
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(self.store.stats('default'), {'approved': 33})
|
|
self.assertEqual(self.store.stats('other'), {'draft': 4})
|
|
self.assertEqual(self.store.stats('later'), {'draft': 2})
|
|
|
|
def test_assignor_with_no_assignment_has_empty_preview_in_both_modes(self):
|
|
self.seed(2, assign=False)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
for mode in ('approve', 'approve_publish'):
|
|
with self.subTest(mode=mode):
|
|
job = reviews.preview('*', -1, self.actor, '', mode)
|
|
self.assertEqual((job['total'], job['preview']['eligible'], job['preview']['accounts']), (0, 0, []))
|
|
self.assertEqual(reviews.results(job['id'], self.actor, '*', ''), {'items': [], 'total': 0})
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
self.assertEqual(self.store.stats('default'), {'draft': 2})
|
|
|
|
def test_legacy_unscoped_jobs_hidden_untouched_and_do_not_block_new_work(self):
|
|
ids = self.seed(2, assign=False)
|
|
with self.db.connect() as db:
|
|
for status in ('preview', 'queued', 'running', 'completed', 'expired'):
|
|
db.execute("""INSERT INTO knowledge_review_job(id,created_by,account_id,scope_label,status,total,
|
|
preview_json,expires_at,created_at,updated_at) VALUES (?,?,-1,'legacy-account',?,1,'{}',0,'2000','2000')""",
|
|
(status, self.actor, status))
|
|
db.execute("""INSERT INTO knowledge_review_target(job_id,item_id,tenant_id,revision,item_updated_at)
|
|
SELECT ?,id,tenant_id,revision,updated_at FROM knowledge_item WHERE id=?""", (status, ids[0]))
|
|
self.store.initialize()
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
self.assertEqual(reviews.jobs(self.actor), [])
|
|
for job_id in ('preview', 'queued', 'running', 'completed', 'expired'):
|
|
with self.assertRaises(KeyError):
|
|
reviews.get(job_id, self.actor)
|
|
with self.assertRaises(KeyError):
|
|
reviews.results(job_id, self.actor, '*', '')
|
|
for action in ('start', 'resume', 'pause', 'cancel'):
|
|
with self.assertRaises(KeyError):
|
|
reviews.action(job_id, action, self.actor, '', True)
|
|
KnowledgeAssignments(self.store).assign('*', [{'id': ids[1], 'revision': 2}], self.actor, self.actor, '')
|
|
current = reviews.preview('*', -1, self.actor, '')
|
|
reviews.action(current['id'], 'start', self.actor, '', True)
|
|
worker = KnowledgeReviewWorker(self.store)
|
|
self.assertTrue(worker.step())
|
|
self.assertFalse(worker.step())
|
|
self.assertEqual(self.store.detail('default', ids[0])['status'], 'draft')
|
|
self.assertEqual(self.store.detail('default', ids[1])['status'], 'approved')
|
|
with self.db.connect() as db:
|
|
old = db.execute("SELECT id,status FROM knowledge_review_job WHERE created_at='2000'").fetchall()
|
|
self.assertEqual(len(old), 5)
|
|
self.assertTrue(all(row['id'] == row['status'] for row in old))
|
|
self.assertEqual(db.execute("SELECT COUNT(*) FROM knowledge_review_target WHERE item_id=? AND result='pending'",
|
|
(ids[0],)).fetchone()[0], 5)
|
|
|
|
def test_pause_resume_cancel_and_new_worker_are_durable(self):
|
|
self.seed(7)
|
|
reviews = KnowledgeReviewStore(self.store)
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step(2)
|
|
reviews.action(job['id'], 'pause', self.actor, '')
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step())
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
KnowledgeReviewWorker(self.store).step(2)
|
|
reviews.action(job['id'], 'cancel', self.actor, '')
|
|
self.assertFalse(KnowledgeReviewWorker(self.store).step())
|
|
result = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((result['status'], result['approved'], result['processed']), ('cancelled', 4, 4))
|
|
self.assertEqual(self.store.stats('default'), {'approved': 4, 'draft': 3})
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
|
|
def test_batch_failure_rolls_back_status_results_and_audit_together(self):
|
|
self.seed(4)
|
|
reviews = KnowledgeReviewStore(self.store); job = reviews.preview('*', -1, self.actor, '')
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
original = self.store._record; calls = []
|
|
def broken(*args, **kwargs):
|
|
calls.append(1)
|
|
if len(calls) == 2:
|
|
raise RuntimeError('Simulated crash')
|
|
return original(*args, **kwargs)
|
|
with mock.patch.object(self.store, '_record', side_effect=broken), self.assertRaises(RuntimeError):
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(self.store.stats('default'), {'draft': 4})
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['processed'], 0)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['approved'], 4)
|
|
|
|
def test_reviewer_permission_revoked_mid_job_stops_further_approvals(self):
|
|
self.seed(5)
|
|
reviews = KnowledgeReviewStore(self.store); job = reviews.preview('*', -1, self.actor, '')
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step(2)
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review'")
|
|
KnowledgeReviewWorker(self.store).step()
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
reviews.get(job['id'], self.actor)
|
|
with self.db.connect() as db:
|
|
db.execute("INSERT INTO role_permissions VALUES ('admin','knowledge:review')")
|
|
result = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((result['status'], result['approved']), ('failed', 2))
|
|
reviews.action(job['id'], 'resume', self.actor, '')
|
|
KnowledgeReviewWorker(self.store).step()
|
|
self.assertEqual(reviews.get(job['id'], self.actor)['approved'], 5)
|
|
|
|
def test_expiry_and_replaced_previews(self):
|
|
self.seed(2)
|
|
reviews = KnowledgeReviewStore(self.store); old = reviews.preview('*', -1, self.actor, '')
|
|
job = reviews.preview('*', -1, self.actor, '')
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(old['id'], 'start', self.actor, '', True)
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE knowledge_review_job SET expires_at=0 WHERE id=?', (job['id'],))
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
while KnowledgeReviewWorker(self.store).step():
|
|
pass
|
|
with self.assertRaises(KeyError):
|
|
reviews.get(job['id'], self.actor)
|
|
self.assertEqual(self.store.stats('default'), {'draft': 2})
|
|
|
|
|
|
def test_disabled_reviewer_cannot_start_or_continue(self):
|
|
self.seed(3)
|
|
reviews = KnowledgeReviewStore(self.store); job = reviews.preview('*', -1, self.actor, '')
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE users SET active=0 WHERE id=?', (self.actor,))
|
|
with self.assertRaises(ValueError):
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE users SET active=1 WHERE id=?', (self.actor,))
|
|
reviews.action(job['id'], 'start', self.actor, '', True)
|
|
KnowledgeReviewWorker(self.store).step(1)
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE users SET active=0 WHERE id=?', (self.actor,))
|
|
KnowledgeReviewWorker(self.store).step()
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
reviews.get(job['id'], self.actor)
|
|
with self.db.connect() as db:
|
|
db.execute('UPDATE users SET active=1 WHERE id=?', (self.actor,))
|
|
final = reviews.get(job['id'], self.actor)
|
|
self.assertEqual((final['status'], final['approved']), ('failed', 1))
|
|
self.assertEqual(self.store.stats('default'), {'approved': 1, 'draft': 2})
|
|
|
|
|
|
class FullReviewApiTest(TestCase):
|
|
payload = FullReviewTest.payload
|
|
start_job = FullReviewTest.start_job
|
|
process = FullReviewTest.process
|
|
first = FullReviewTest.first
|
|
seed = FullReviewTest.seed
|
|
setUp = fixtures.KnowledgeApiTest.setUp
|
|
tearDown = fixtures.KnowledgeApiTest.tearDown
|
|
|
|
def test_existing_session_rechecks_review_and_assignment_permissions_independently(self):
|
|
knowledge = '/api/v2/knowledge'
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review'")
|
|
for endpoint in ('my-reviews', 'review-tasks'):
|
|
response = self.client.get(f'{knowledge}/{endpoint}', headers=self.headers)
|
|
self.assertEqual(response.status_code, 403, endpoint)
|
|
for endpoint in ('items', 'retrievals', 'export'):
|
|
response = self.client.get(f'{knowledge}/{endpoint}', headers=self.headers)
|
|
self.assertEqual(response.status_code, 200, endpoint)
|
|
with self.db.connect() as db:
|
|
db.execute("DELETE FROM role_permissions WHERE role_code='admin' AND permission_code='knowledge:review:assign'")
|
|
overview = self.client.get(knowledge + '/overview', headers=self.headers)
|
|
self.assertEqual(overview.status_code, 200)
|
|
self.assertEqual(overview.json()['counts'], {})
|
|
for endpoint in ('items', 'items/unknown', 'my-reviews', 'review-tasks', 'retrievals', 'export'):
|
|
response = self.client.get(f'{knowledge}/{endpoint}', headers=self.headers)
|
|
self.assertEqual(response.status_code, 403, endpoint)
|
|
for method, endpoint, body in (
|
|
('post', 'review-tasks/preview', {}),
|
|
('post', 'items/unknown/restore', {'revision': 1, 'restore_revision': 1}),
|
|
('post', 'review-assignees', {'items': [{'id': 'unknown', 'revision': 1}]}),
|
|
('put', 'items/unknown', {'revision': 1, 'title': '合成', 'question': '合成',
|
|
'answer': '合成', 'conditions': '合成'}),
|
|
):
|
|
response = getattr(self.client, method)(f'{knowledge}/{endpoint}', headers=self.headers, json=body)
|
|
self.assertEqual(response.status_code, 403, endpoint)
|
|
|
|
def test_auth_confirmation_owner_and_read_only_pagination(self):
|
|
url = '/api/v2/knowledge/review-tasks'
|
|
self.assertEqual(self.client.post(url + '/preview').status_code, 401)
|
|
response = self.client.post(url + '/preview?account_id=-1', headers=self.headers)
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
job = response.json()
|
|
self.assertEqual(job['total'], 0)
|
|
self.assertEqual(self.client.post(url + '/' + job['id'] + '/start', headers=self.headers,
|
|
json={'confirmed': False}).status_code, 400)
|
|
self.assertEqual(self.client.get(url + '/' + job['id'] + '/results?page_size=1000', headers=self.headers).status_code, 422)
|
|
actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
|
self.db.create_user('reviewer', 'InitialReader123', 'viewer', actor, '')
|
|
user_id = self.db.authenticate('reviewer', 'InitialReader123')['id']
|
|
self.db.change_password(user_id, 'InitialReader123', 'ChangedReader@2026', '')
|
|
login = self.client.post('/api/v2/auth/login', json={'username': 'reviewer', 'password': 'ChangedReader@2026'})
|
|
headers = {'Authorization': 'Bearer ' + login.json()['access_token']}
|
|
self.assertEqual(self.client.post(url + '/preview', headers=headers).status_code, 403)
|
|
with self.db.connect() as db:
|
|
db.executemany("INSERT OR IGNORE INTO role_permissions VALUES ('viewer',?)", [(p,) for p in ('knowledge:read','knowledge:review','knowledge:review:auto','im:content:read')])
|
|
self.assertEqual(self.client.get(url + '/' + job['id'], headers=headers).status_code, 404)
|
|
self.assertEqual(self.client.post(url + '/' + job['id'] + '/cancel', headers=headers, json={}).status_code, 404)
|
|
|
|
|
|
def test_explicit_cross_account_assignments_only_and_withdrawal_after_queueing(self):
|
|
self.actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
|
|
self.store = self.client.app.state.knowledge_store
|
|
self.archive = ArchiveStore(self.db)
|
|
accounts, ids = [], []
|
|
for index in range(3):
|
|
_, account = self.db.create_desktop_session(
|
|
{'user_id': f'full-review-{index}', 'sn': f'REV{index}', 'nickname': f'测试账号{index}'},
|
|
f'review-device-{index}', 'Review QA', '1.0', '')
|
|
accounts.append(account)
|
|
ids.append(self.seed(2, account['tenant_id'], assign=False))
|
|
self.db.create_user('limited-reviewer', 'InitialReader123', 'viewer', self.actor, '')
|
|
reviewer = self.db.authenticate('limited-reviewer', 'InitialReader123')['id']
|
|
self.db.change_password(reviewer, 'InitialReader123', 'ChangedReader@2026', '')
|
|
with self.db.connect() as db:
|
|
db.executemany("INSERT OR IGNORE INTO role_permissions VALUES ('viewer',?)",
|
|
[(p,) for p in ('knowledge:read','knowledge:review','knowledge:review:auto','im:content:read')])
|
|
self.db.set_desktop_account_admins(accounts[0]['id'], [reviewer], self.actor, '')
|
|
login = self.client.post('/api/v2/auth/login', json={'username': 'limited-reviewer', 'password': 'ChangedReader@2026'})
|
|
headers = {'Authorization': 'Bearer ' + login.json()['access_token']}
|
|
url = '/api/v2/knowledge/review-tasks'
|
|
self.assertEqual(self.client.post(url + '/preview?account_id=' + str(accounts[2]['id']), headers=headers).status_code, 400)
|
|
empty = self.client.post(url + '/preview?account_id=-1', headers=headers)
|
|
self.assertEqual(empty.json()['total'], 0)
|
|
assignments = KnowledgeAssignments(self.store)
|
|
own = {'id': ids[0][0], 'revision': 2}
|
|
delegated = {'id': ids[2][0], 'revision': 2}
|
|
assignments.assign('*', [own, delegated], reviewer, self.actor, '')
|
|
snapshot = self.client.post(url + '/preview?account_id=-1', headers=headers)
|
|
self.assertEqual(snapshot.status_code, 200, snapshot.text)
|
|
job = snapshot.json()
|
|
self.assertEqual(job['total'], 2)
|
|
self.assertEqual(job['preview']['accounts'], [])
|
|
pending = self.client.get(url + '/' + job['id'] + '/results?result=pending', headers=headers).json()
|
|
self.assertEqual({row['item_id'] for row in pending['items']}, {own['id'], delegated['id']})
|
|
self.assertTrue(all({'tenant_id', 'account_id', 'account_name'}.isdisjoint(row) for row in pending['items']))
|
|
response = self.client.post(url + '/' + job['id'] + '/start', headers=headers, json={'confirmed': True})
|
|
self.assertEqual(response.status_code, 200, response.text)
|
|
assignments.assign('*', [own], None, self.actor, '')
|
|
self.assertEqual(self.client.get(url + '/' + job['id'], headers=headers).json()['total'], 1)
|
|
KnowledgeReviewWorker(self.store).step()
|
|
final = self.client.get(url + '/' + job['id'], headers=headers).json()
|
|
self.assertEqual((final['status'], final['total'], final['approved'], final['skipped']), ('completed', 1, 1, 0))
|
|
self.assertEqual(self.store.stats(accounts[0]['tenant_id']), {'draft': 2})
|
|
self.assertEqual(self.store.stats(accounts[1]['tenant_id']), {'draft': 2})
|
|
self.assertEqual(self.store.stats(accounts[2]['tenant_id']), {'approved': 1, 'draft': 1})
|
|
results = self.client.get(url + '/' + job['id'] + '/results?result=', headers=headers).json()
|
|
self.assertEqual([row['item_id'] for row in results['items']], [delegated['id']])
|