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

187 lines
11 KiB
Python

"""Isolated API, store and RBAC coverage for the separate task and search pages."""
from unittest import TestCase, mock
import rbac
import test_knowledge_own_scope as fixtures
from archive_store import utc_now
from knowledge_access import OWN_CODE, TASKS_READ, KnowledgeAccessDenied
SEARCH = 'knowledge:search'
ROLE = 'knowledge-sections'
TASK_ACTIONS = {'knowledge:run', 'knowledge:run:control', 'knowledge:watch'}
class KnowledgeSectionsTest(TestCase):
tearDown = fixtures.OwnKnowledgeTest.tearDown
payload = fixtures.OwnKnowledgeTest.payload
start_job = fixtures.OwnKnowledgeTest.start_job
process = fixtures.OwnKnowledgeTest.process
first = fixtures.OwnKnowledgeTest.first
approve_fixture = fixtures.OwnKnowledgeTest.approve_fixture
def setUp(self):
fixtures.OwnKnowledgeTest.setUp(self)
self.reader = self.users['alice']
self.account_id = self.accounts[0]['id']
self.scope = f'?account_id={self.account_id}'
now = utc_now()
with self.db.connect() as db:
db.execute('INSERT INTO roles VALUES (?,?,?,?,?)', (ROLE, '合成菜单测试', 0, now, now))
db.execute('UPDATE users SET role=? WHERE id=?', (ROLE, self.reader))
db.execute('INSERT INTO admin_account_scope VALUES (?,?,?)', (self.reader, self.account_id, now))
self.source = db.execute('SELECT id FROM archive_source_account WHERE tenant_id=?', (self.tenant,)).fetchone()[0]
for tenant, source in [(self.tenant, self.source), (self.other_tenant, 'other-source')]:
db.execute('INSERT INTO knowledge_watch VALUES (?,?,1,?)', (tenant, source, self.actor))
db.execute('INSERT INTO knowledge_dirty VALUES (?,?,?,?)', (tenant, source, 'conversation', now))
db.execute('INSERT INTO knowledge_job(id,tenant_id,status,options_json,cutoff_at,created_by,created_at,'
'updated_at,run_id,created_items) VALUES (?,?,?,?,?,?,?,?,?,?)',
('auto-' + source, tenant, 'completed', '{}', now, self.actor, now, now, 'auto', 2))
def grant(self, *permissions):
with self.db.connect() as db:
rbac.grant(db, ROLE, permissions, utc_now())
def request(self, method, path, status=200, **kwargs):
response = self.client.request(method, self.url + path, headers=self.alice, **kwargs)
self.assertEqual(response.status_code, status, response.text[:500])
return response.json()
def test_task_page_alone_reads_scoped_tasks(self):
self.grant(TASKS_READ)
jobs = self.request('GET', '/jobs?account_id=-1')['items']
expected = {self.jobs['alice'], self.jobs['bob']}
self.assertEqual({job['id'] for job in jobs}, expected)
runs = self.request('GET', '/runs')
self.assertEqual({run['id'] for run in runs['items']}, {'job:' + job for job in expected})
self.assertEqual(runs['auto'], {'jobs_24h': 1, 'created_24h': 2, 'failed_24h': 0,
'waiting_conversations': 0, 'watching_sources': 0})
overview = self.request('GET', '/overview' + self.scope)
self.assertEqual(overview['counts'], {})
self.assertEqual(overview['source_accounts'], [])
self.assertEqual(overview['watches'], [])
self.assertIsNone(overview['settings'])
self.request('GET', '/items?account_id=-1', 403)
self.request('GET', '/config', 403)
self.request('POST', '/search' + self.scope, 403, json={'query': '预约挂号'})
self.request('GET', f'/jobs?account_id={self.accounts[1]["id"]}', 403)
with self.assertRaises(KeyError):
self.store.job(self.other_tenant, self.jobs['cross'], actor=self.reader)
with self.assertRaises(KnowledgeAccessDenied):
self.store.watches('*', actor=self.reader)
self.grant(TASKS_READ, 'im:content:read')
overview = self.request('GET', '/overview?account_id=-1')
self.assertEqual([item['id'] for item in overview['source_accounts']], [self.source])
self.assertEqual([watch['source_account_id'] for watch in overview['watches']], [self.source])
auto = self.request('GET', '/runs')['auto']
self.assertEqual((auto['waiting_conversations'], auto['watching_sources']), (1, 1))
self.assertEqual(self.store.auto_summary('*', actor=self.reader), auto)
def test_task_actions_require_page_and_existing_permissions(self):
job = self.jobs['bob']
run = 'job:' + job
job_body = {'source_account_id': self.source, 'engine': 'rules', 'staff_confirmed': True}
run_body = {'account_ids': [self.account_id], 'engine': 'rules', 'staff_confirmed': True}
config = {'engine': 'rules'}
endpoints = [
('POST', '/jobs/preview' + self.scope, job_body),
('POST', '/jobs' + self.scope, job_body),
('POST', f'/jobs/{job}/pause' + self.scope, None),
('PUT', f'/jobs/{job}/config' + self.scope, config),
('POST', '/runs/preview', run_body),
('POST', '/runs', run_body),
('POST', f'/runs/{run}/pause', None),
('PUT', f'/runs/{run}/config', config),
('PUT', '/watch/' + self.source + self.scope, {'enabled': False}),
]
for permissions in [(TASKS_READ,), (*TASK_ACTIONS, 'im:content:read')]:
self.grant(*permissions)
for method, path, body in endpoints:
with self.subTest(permissions=permissions, path=path):
self.request(method, path, 403, json=body)
self.grant(TASKS_READ, *TASK_ACTIONS, 'im:content:read')
self.request('POST', '/jobs/preview' + self.scope, json=job_body)
self.request('POST', '/runs/preview', json=run_body)
self.request('GET', '/config')
self.assertEqual(self.request('POST', f'/jobs/{job}/pause' + self.scope)['status'], 'paused')
self.request('PUT', f'/runs/{run}/config', json=config)
self.assertEqual(self.request('PUT', '/watch/' + self.source + self.scope, json={'enabled': False}),
{'enabled': False})
self.grant('knowledge:read', *TASK_ACTIONS, 'im:content:read')
overview = self.request('GET', '/overview' + self.scope)
self.assertEqual(overview['source_accounts'], [])
self.assertEqual(overview['watches'], [])
self.request('GET', '/jobs' + self.scope, 403)
self.request('GET', '/runs', 403)
checks = [
lambda: self.store.job(self.tenant, job, actor=self.reader, required=()),
lambda: self.store.jobs('*', actor=self.reader),
lambda: self.store.run('*', run, actor=self.reader),
lambda: self.store.auto_summary('*', actor=self.reader),
lambda: self.store.preview_job(self.tenant, job_body, actor=self.reader),
lambda: self.store.preview_run([self.tenant], run_body, actor=self.reader),
lambda: self.store.create_job(self.tenant, job_body, self.reader, ''),
lambda: self.store.create_run([self.tenant], run_body, self.reader, ''),
lambda: self.store.configure_job(self.tenant, job, config, self.reader, ''),
lambda: self.store.run_action('*', run, 'resume', self.reader, ''),
lambda: self.store.set_watch(self.tenant, self.source, True, self.reader, ''),
]
for check in checks:
with self.assertRaises(KnowledgeAccessDenied):
check()
self.assertEqual(self.store.job(self.tenant, job)['status'], 'paused')
def test_search_page_alone_uses_published_only_and_scoped_search(self):
for key, tenant in [('alice', self.tenant), ('cross', self.other_tenant)]:
item = self.store.detail(tenant, self.ids[key])
self.approve_fixture(item)
self.store.publish(tenant, item['id'], item['revision'], self.actor, '')
self.grant(SEARCH, OWN_CODE)
with mock.patch('knowledge_api.VectorIndex') as vector:
vector.return_value.configured = True
overview = self.request('GET', '/overview?account_id=-1')
self.assertEqual(overview, {'knowledge_scope': {'mode': 'zyt_account', 'account_ids': [self.account_id]},
'counts': {}, 'source_accounts': [], 'watches': [], 'settings': None,
'semantic_configured': True})
body = {'query': '预约挂号材料'}
hits = self.request('POST', '/search' + self.scope, json=body)['hits']
self.assertEqual([item['id'] for item in hits], [self.ids['alice']])
self.request('POST', f'/search?account_id={self.accounts[1]["id"]}', 403, json=body)
self.request('GET', '/items?account_id=-1', 403)
self.request('GET', '/jobs?account_id=-1', 403)
self.request('GET', '/runs', 403)
self.grant(OWN_CODE)
self.request('POST', '/search' + self.scope, 403, json=body)
self.request('GET', '/overview?account_id=-1', 403)
def test_seed_preserves_search_grants_and_backfills_tasks_once(self):
now = utc_now()
with self.db.connect() as db:
for code, permissions in [('zyt_basic', ('knowledge:read',)), (ROLE, (SEARCH, 'knowledge:run'))]:
rbac.grant(db, code, permissions, now)
db.execute('DELETE FROM permissions WHERE code=?', (TASKS_READ,))
db.execute("UPDATE permissions SET page_name='知识加工与检索', kind='action' WHERE code=?", (SEARCH,))
old_sort = db.execute('SELECT sort_order FROM permissions WHERE code=?', (SEARCH,)).fetchone()[0]
last_sort = db.execute('SELECT MAX(sort_order) FROM permissions').fetchone()[0]
old_search = db.execute('SELECT role_code FROM role_permissions WHERE permission_code=? ORDER BY 1',
(SEARCH,)).fetchall()
rbac.seed(db, now)
for code, name, page, order in [(SEARCH, '检索测试', '检索测试', old_sort),
(TASKS_READ, '整理任务', '整理任务', last_sort + 1)]:
row = db.execute('SELECT name,group_name,page_name,kind,sort_order FROM permissions WHERE code=?',
(code,)).fetchone()
self.assertEqual(tuple(row), (name, '知识中心', page, 'page', order))
self.assertEqual(db.execute('SELECT role_code FROM role_permissions WHERE permission_code=? ORDER BY 1',
(SEARCH,)).fetchall(), old_search)
self.assertEqual(rbac.permissions_of(db, 'zyt_basic'), {'knowledge:read', TASKS_READ})
self.assertIn(TASKS_READ, rbac.permissions_of(db, 'cleaner'))
self.assertNotIn(TASKS_READ, rbac.permissions_of(db, ROLE))
rbac.grant(db, 'zyt_basic', ('knowledge:read',), now)
rbac.grant(db, ROLE, ('knowledge:read',), now)
rbac.seed(db, now)
self.assertEqual(rbac.permissions_of(db, 'zyt_basic'), {'knowledge:read'})
self.assertEqual(rbac.permissions_of(db, ROLE), {'knowledge:read'})
self.assertIn(TASKS_READ, rbac.permissions_of(db, 'admin'))