187 lines
11 KiB
Python
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'))
|