177 lines
11 KiB
Python
177 lines
11 KiB
Python
"""API regressions for the standalone knowledge assignment menu."""
|
|
import sqlite3
|
|
from unittest import TestCase, mock
|
|
|
|
import rbac
|
|
import test_knowledge_own_scope as fixtures
|
|
from archive_store import utc_now
|
|
from knowledge_access import KnowledgeAccessDenied
|
|
|
|
|
|
ASSIGN = 'knowledge:review:assign'
|
|
ROLE = 'dispatch'
|
|
ITEM_CONTENT = {'question', 'answer', 'conditions', 'sources', 'history', 'job_id'}
|
|
|
|
|
|
class AssignmentMenuTest(TestCase):
|
|
tearDown = fixtures.OwnKnowledgeTest.tearDown
|
|
payload = fixtures.OwnKnowledgeTest.payload
|
|
start_job = fixtures.OwnKnowledgeTest.start_job
|
|
process = fixtures.OwnKnowledgeTest.process
|
|
first = fixtures.OwnKnowledgeTest.first
|
|
|
|
def setUp(self):
|
|
fixtures.OwnKnowledgeTest.setUp(self)
|
|
self.item_id = self.ids['alice']
|
|
self.item = self.store.detail(self.tenant, self.item_id)
|
|
self.selection = {'id': self.item_id, 'revision': self.item['revision']}
|
|
self.dispatcher = self.users['alice']
|
|
self.bob = self.tokens['bob']
|
|
self.account_id = self.accounts[0]['id']
|
|
now = utc_now()
|
|
with self.db.connect() as db:
|
|
db.execute('INSERT INTO roles VALUES (?,?,?,?,?)', (ROLE, '合成指派员', 0, now, now))
|
|
rbac.grant(db, ROLE, [ASSIGN], now)
|
|
db.execute('UPDATE users SET role=? WHERE id=?', (ROLE, self.dispatcher))
|
|
db.execute('INSERT INTO admin_account_scope VALUES (?,?,?)', (self.dispatcher, self.account_id, now))
|
|
|
|
def request(self, method, path, expected=200, *, headers=None, **kwargs):
|
|
response = self.client.request(method, self.url + path, headers=headers or self.alice, **kwargs)
|
|
self.assertEqual(response.status_code, expected, response.text[:500])
|
|
return response.json()
|
|
|
|
def assign(self, assignee, expected=200, selection=None):
|
|
return self.request('PUT', '/review-assignments?account_id=-1', expected,
|
|
json={'items': [selection or self.selection], 'assignee_id': assignee})
|
|
|
|
def test_page_catalog_refresh_preserves_role_grants(self):
|
|
with self.db.connect() as db:
|
|
original = db.execute('SELECT sort_order FROM permissions WHERE code=?', (ASSIGN,)).fetchone()[0]
|
|
db.execute("UPDATE permissions SET name='分配知识审核(含改派、撤回)', "
|
|
"page_name='知识加工与检索', kind='action' WHERE code=?", (ASSIGN,))
|
|
grants = db.execute('SELECT * FROM role_permissions ORDER BY role_code,permission_code').fetchall()
|
|
rbac.seed(db, utc_now())
|
|
updated = db.execute('SELECT name,group_name,page_name,kind,sort_order FROM permissions WHERE code=?',
|
|
(ASSIGN,)).fetchone()
|
|
self.assertEqual(tuple(updated), ('指派管理(分配、改派、撤回)', '知识中心', '指派管理', 'page', original))
|
|
self.assertEqual(db.execute('SELECT * FROM role_permissions ORDER BY role_code,permission_code').fetchall(),
|
|
grants)
|
|
self.assertEqual(rbac.permissions_of(db, ROLE), {ASSIGN})
|
|
|
|
def test_standalone_assign_reassign_and_withdraw_for_scoped_drafts(self):
|
|
result = self.request('GET', '/items?account_id=-1')
|
|
self.assertEqual(len(result['items']), 5)
|
|
self.assertEqual({item['account_id'] for item in result['items']}, {self.account_id})
|
|
self.assertTrue(all(ITEM_CONTENT.isdisjoint(item) for item in result['items']))
|
|
self.request('GET', f'/items?account_id={self.accounts[1]["id"]}', 403)
|
|
self.assign(self.users['bob'], 404, {'id': self.ids['cross'], 'revision': 1})
|
|
candidates = self.request('POST', '/review-assignees?account_id=-1', json={'items': [self.selection]})['items']
|
|
self.assertIn(self.users['bob'], {user['id'] for user in candidates})
|
|
self.assertNotIn(self.dispatcher, {user['id'] for user in candidates})
|
|
self.assertEqual(self.assign(self.users['bob']), {'updated': 1})
|
|
with self.db.connect() as db:
|
|
issuer = db.execute('SELECT assignor_id FROM knowledge_review_assignment WHERE item_id=?',
|
|
(self.item_id,)).fetchone()[0]
|
|
self.assertEqual(issuer, self.dispatcher)
|
|
inbox = '/my-reviews'
|
|
path = f'{inbox}/{self.item_id}'
|
|
delegated = self.request('GET', path, headers=self.bob)
|
|
old_assignment = delegated['review_assignment']['id']
|
|
action = {'revision': self.item['revision'], 'assignment_id': old_assignment, 'confirmed': True}
|
|
for route in (inbox, path):
|
|
self.request('GET', route, 403)
|
|
for operation in ('approve', 'reject', 'approve_publish'):
|
|
self.request('POST', f'{path}/{operation}', 403, json=action)
|
|
self.assertEqual(self.assign(self.actor), {'updated': 1})
|
|
self.request('POST', f'{path}/approve', 404, headers=self.bob, json=action)
|
|
self.assertEqual(self.assign(None), {'updated': 1})
|
|
self.request('GET', path, 404, headers=self.headers)
|
|
self.assertEqual(self.assign(self.users['bob']), {'updated': 1})
|
|
delegated = self.request('GET', path, headers=self.bob)
|
|
action['assignment_id'] = delegated['review_assignment']['id']
|
|
self.assertEqual(self.request('POST', f'{path}/approve', headers=self.bob, json=action), {'status': 'approved'})
|
|
|
|
def test_assignment_summary_and_overview_hide_content_and_maintenance(self):
|
|
with self.db.connect() as db:
|
|
db.execute("UPDATE knowledge_item SET status='approved',question=? WHERE id=?", ('隐藏正文', self.item_id))
|
|
db.execute("UPDATE knowledge_item SET status='stale' WHERE id=?", (self.ids['bob'],))
|
|
db.execute('INSERT INTO knowledge_settings VALUES (?,?,?)', (self.tenant, 1, utc_now()))
|
|
db.execute('INSERT INTO knowledge_watch VALUES (?,?,?,?)', (self.tenant, 'synthetic-watch', 1, self.actor))
|
|
scope = f'?account_id={self.account_id}'
|
|
reader_overview = self.request('GET', '/overview' + scope, headers=self.headers)
|
|
for field in ('source_accounts', 'watches', 'settings'):
|
|
self.assertTrue(reader_overview[field], field)
|
|
overview = self.request('GET', '/overview' + scope)
|
|
self.assertEqual(overview['counts'], {'draft': 3, 'approved': 1, 'stale': 1})
|
|
self.assertEqual(overview['source_accounts'], [])
|
|
self.assertEqual(overview['watches'], [])
|
|
self.assertIsNone(overview['settings'])
|
|
self.assertFalse(overview['semantic_configured'])
|
|
self.assertEqual(self.request('GET', '/items', params={'account_id': -1, 'query': '隐藏正文'})['total'], 0)
|
|
for actor_headers in (self.alice, self.headers):
|
|
stale = self.request('GET', '/items', headers=actor_headers,
|
|
params={'account_id': -1, 'status': 'stale'})['items'][0]
|
|
self.assertTrue(ITEM_CONTENT.isdisjoint(stale))
|
|
summary = self.request('GET', '/items?account_id=-1&status=approved')['items'][0]
|
|
self.assertTrue(ITEM_CONTENT.isdisjoint(summary))
|
|
admin_list = '/items?account_id=-1&status=approved'
|
|
self.assertEqual(self.request('GET', admin_list, headers=self.headers)['items'][0]['question'], '隐藏正文')
|
|
large_summary = self.request('GET', admin_list + '&page_size=2000', headers=self.headers)['items'][0]
|
|
self.assertTrue(ITEM_CONTENT.isdisjoint(large_summary))
|
|
path = f'/items/{self.item_id}'
|
|
edit = {field: self.item[field] for field in ('title', 'question', 'answer', 'conditions', 'revision')}
|
|
edit['question'] = '更新后的测试问题'
|
|
action = {'revision': self.item['revision'], 'confirmed': True}
|
|
# Action grants alone must not bypass the shared content permission check.
|
|
action_permissions = [ASSIGN, 'knowledge:write', 'knowledge:restore', 'knowledge:publish', 'knowledge:disable',
|
|
'knowledge:delete', 'knowledge:export', 'stats:read']
|
|
with self.db.connect() as db:
|
|
rbac.grant(db, ROLE, action_permissions, utc_now())
|
|
for suffix in (path, '/export', '/retrievals'):
|
|
self.request('GET', suffix + scope, 403)
|
|
self.request('PUT', path + scope, 403, json=edit)
|
|
for operation in ('publish', 'disable', 'delete', 'restore'):
|
|
self.request('POST', f'{path}/{operation}{scope}', 403, json=action)
|
|
with self.assertRaises(KnowledgeAccessDenied):
|
|
self.store.save(self.tenant, self.item_id, edit, self.dispatcher, '')
|
|
with self.db.connect() as db:
|
|
rbac.grant(db, ROLE, [*action_permissions, 'knowledge:read', 'im:content:read'], utc_now())
|
|
self.assertEqual(self.request('GET', path + scope)['question'], '隐藏正文')
|
|
self.assertEqual(self.request('PUT', path + scope, json=edit)['status'], 'draft')
|
|
self.request('GET', '/my-reviews', 403)
|
|
|
|
def test_list_pagination_accepts_custom_sizes_up_to_2000(self):
|
|
now = utc_now()
|
|
rows = [(f'page-{index:04d}', self.tenant, f'page-{index:04d}', 'page-test', 'private question', 'private answer',
|
|
now, now) for index in range(2001)]
|
|
with self.db.connect() as db:
|
|
db.executemany('INSERT INTO knowledge_item(id,tenant_id,dedup_hash,title,question,answer,created_at,updated_at) '
|
|
'VALUES (?,?,?,?,?,?,?,?)', rows)
|
|
db.executemany('INSERT INTO knowledge_review_assignment VALUES (?,?,1,?,?,?)',
|
|
[(row[0], 'assignment-' + row[0], self.users['bob'], self.dispatcher, now) for row in rows])
|
|
connect = type(self.db).connect
|
|
|
|
def limited_connection(database):
|
|
db = connect(database)
|
|
db.setlimit(sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER, 999)
|
|
return db
|
|
|
|
with mock.patch.object(type(self.db), 'connect', limited_connection):
|
|
path = '/items?account_id=-1&query=page-test'
|
|
for size in (1, 50, 100, 500, 1000, 1537, 2000):
|
|
result = self.request('GET', path + f'&page_size={size}')
|
|
self.assertEqual(result['total'], 2001)
|
|
self.assertEqual(len(result['items']), size)
|
|
self.assertEqual(result['items'][-1]['review_assignment']['id'], f'assignment-page-{size - 1:04d}')
|
|
self.assertEqual(len(self.request('GET', path)['items']), 30)
|
|
next_page = self.request('GET', path + '&page=2&page_size=2000')
|
|
self.assertEqual(next_page['total'], 2001)
|
|
self.assertEqual([item['id'] for item in next_page['items']], ['page-2000'])
|
|
self.assertEqual(self.request('GET', path + '&page=10000000000000000000000&page_size=2000'),
|
|
{'items': [], 'total': 2001})
|
|
for size in ('0', '-1', '2001', '12.5', 'invalid'):
|
|
self.request('GET', path + f'&page_size={size}', 422)
|
|
self.request('GET', '/my-reviews?page_size=101', 422, headers=self.bob)
|
|
self.request('PUT', '/review-assignments?account_id=-1', 422,
|
|
json={'items': [{'id': row[0], 'revision': 1} for row in rows[:101]], 'assignee_id': None})
|