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

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})