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

352 lines
23 KiB
Python

"""Synthetic management ownership checks; no business database or network required."""
import asyncio
import json
from types import SimpleNamespace
from unittest import TestCase, mock
import rbac
import test_knowledge as fixtures
from archive_store import ArchiveStore, utc_now
from knowledge_access import OWN_CODE, current_access
from knowledge_assignments import KnowledgeAssignments
from knowledge_retriever import KnowledgeRetriever
from knowledge_review import KnowledgeReviewStore, KnowledgeReviewWorker
GROUP = 'https://group.synthetic.invalid/adminapi'
DESKTOP = 'https://desktop.synthetic.invalid'
BRIDGE = json.dumps({'group_api_url': GROUP, 'desktop_api_url': DESKTOP, 'namespace': 'admin'})
class OwnKnowledgeTest(TestCase):
tearDown = fixtures.KnowledgeApiTest.tearDown
payload = fixtures.KnowledgeTest.payload
start_job = fixtures.KnowledgeTest.start_job
process = fixtures.KnowledgeTest.process
first = fixtures.KnowledgeTest.first
def setUp(self):
fixtures.KnowledgeApiTest.setUp(self)
self.actor = self.db.authenticate('admin', 'ChangedAdmin@2026')['id']
self.store = self.client.app.state.knowledge_store
self.archive = ArchiveStore(self.db)
self.env = mock.patch.dict('os.environ', {'KNOWLEDGE_QDRANT_URL': '', 'KNOWLEDGE_EMBEDDING_URL': '',
'KNOWLEDGE_EMBEDDING_MODEL': ''})
self.env.start(); self.addCleanup(self.env.stop)
now = utc_now()
with self.db.connect() as db:
db.execute('INSERT INTO roles VALUES (?,?,?,?,?)', ('cleaner', '测试清洗员', 0, now, now))
rbac.grant(db, 'cleaner', sorted({p for p in rbac.PERMISSION_CODES if p.startswith('knowledge:')}
| {'im:content:read', 'stats:read'}), now)
self.users, self.tokens = {}, {}
for name in ('alice', 'bob'):
self.db.create_user(name, 'InitialReader123', 'cleaner', self.actor, '')
uid = self.db.authenticate(name, 'InitialReader123')['id']
self.db.change_password(uid, 'InitialReader123', 'ChangedReader@2026', '')
login = self.client.post('/api/v2/auth/login', json={'username': name, 'password': 'ChangedReader@2026'})
self.users[name] = uid
self.tokens[name] = {'Authorization': 'Bearer ' + login.json()['access_token']}
self.accounts = []
for index in range(2):
_, account = self.db.create_desktop_session({'user_id': f'admin:{165 + index}', 'sn': f'OWN{index}',
'nickname': f'合成账号{index}'}, f'own-device-{index}', 'Synthetic QA', '1.0', '')
self.accounts.append(account)
self.tenant = self.accounts[0]['tenant_id']
self.other_tenant = self.accounts[1]['tenant_id']
self.process(self.tenant)
original = self.first(self.tenant)
original['conditions'] = '仅适用于合成测试'
with self.db.connect() as db:
self.store._save_item(db, self.store._item(db, self.tenant, original['id']), original['revision'],
self.store._edit_fields(original), self.actor, '')
original = self.store.detail(self.tenant, original['id'])
self.ids = {'alice': original['id']}
self.jobs = {'alice': original['job_id']}
with self.db.connect() as db:
for key, tenant, owner in [('bob', self.tenant, self.users['bob']),
('cross', self.other_tenant, self.users['alice'])]:
self.jobs[key] = 'job-' + key
db.execute('INSERT INTO knowledge_job(id,tenant_id,options_json,cutoff_at,created_by,created_at,updated_at) '
'SELECT ?,?,options_json,cutoff_at,?,created_at,updated_at FROM knowledge_job WHERE id=?',
(self.jobs[key], tenant, owner, original['job_id']))
for key, job, tenant in [('bob', self.jobs['bob'], self.tenant), ('cross', self.jobs['cross'], self.other_tenant),
('null', None, self.tenant), ('missing', 'lost-job', self.tenant),
('mismatch', self.jobs['cross'], self.tenant)]:
self.ids[key] = 'item-' + key
db.execute('INSERT INTO knowledge_item(id,tenant_id,job_id,dedup_hash,title,question,answer,conditions, '
'category,kind,created_at,updated_at) SELECT ?,?,?,?, ?,question,answer,conditions,category,kind,created_at,updated_at '
'FROM knowledge_item WHERE id=?', (self.ids[key], tenant, job, key, '合成秘密-' + key, original['id']))
if tenant == self.tenant:
db.execute('INSERT INTO knowledge_source SELECT ?,message_id,version_no,role,content,sent_at '
'FROM knowledge_source WHERE item_id=?', (self.ids[key], original['id']))
self.bridge_env = mock.patch.dict('os.environ', {'ZYT_GROUP_API_URL': GROUP, 'ZYT_KNOWLEDGE_ACCOUNT_BRIDGE': BRIDGE})
self.bridge_env.start(); self.addCleanup(self.bridge_env.stop)
with self.db.connect() as db:
db.execute('UPDATE model_config SET config_json=? WHERE id=1', (json.dumps({'ZYT_LOGIN_API_URL': DESKTOP}),))
for index, name in enumerate(('alice', 'bob')):
db.execute('INSERT INTO group_sso_bindings VALUES (?,?,?,?,?,?,?,?,?)',
('zyt_group', 'gid_' + ('a' if index == 0 else 'b') * 32, self.users[name], 165 + index,
'synthetic-' + name, 'Synthetic', 1, now, now))
self.url = '/api/v2/knowledge'
self.alice = self.tokens['alice']
def scope_flag(self, enabled):
with self.db.connect() as db:
if enabled:
db.execute("INSERT OR IGNORE INTO role_permissions VALUES ('cleaner',?)", (OWN_CODE,))
else:
db.execute("DELETE FROM role_permissions WHERE role_code='cleaner' AND permission_code=?", (OWN_CODE,))
def total(self):
response = self.client.get(self.url + '/items?account_id=-1', headers=self.alice)
self.assertEqual(response.status_code, 200, response.text)
return response.json()['total']
def test_old_token_flag_grant_revoke_and_same_account_creator_independence(self):
self.assertEqual(self.total(), 5)
self.scope_flag(False)
self.assertEqual(self.total(), 6)
self.scope_flag(True)
self.assertEqual(self.total(), 5)
self.assertEqual(self.client.get(self.url + '/items?account_id=-1', headers=self.tokens['bob']).json()['total'], 1)
overview = self.client.get(self.url + '/overview?account_id=-1', headers=self.alice).json()
self.assertEqual(overview['counts'], {'draft': 5})
self.assertEqual(overview['knowledge_scope'], {'mode': 'zyt_account', 'account_ids': [self.accounts[0]['id']]})
self.assertEqual(self.client.get(self.url + '/overview?account_id=-1', headers=self.headers).json()['knowledge_scope'],
{'mode': 'existing', 'account_ids': []})
pages = [self.client.get(self.url + '/items', params={'account_id': -1, 'page_size': 2, 'page': p},
headers=self.alice).json()['items'] for p in range(1, 4)]
self.assertEqual(len({i['id'] for page in pages for i in page}), 5)
def test_same_tenant_admin_other_missing_creator_detail_edit_review(self):
for key in ('alice', 'bob', 'null', 'missing', 'mismatch'):
item_id = self.ids[key]
url = self.url + '/my-reviews/' + item_id
self.assertEqual(self.client.get(url, headers=self.alice).status_code, 404)
assignment = KnowledgeAssignments(self.store)
item = self.store.detail(self.tenant, item_id)
assignment.assign('*', [{'id': item_id, 'revision': item['revision']}], self.users['alice'], self.actor, '')
response = self.client.get(url, headers=self.alice)
self.assertEqual(response.status_code, 200, response.text)
assigned = response.json()
edit = {k: assigned[k] for k in ('revision','title','question','answer','conditions','category','kind','valid_until')}
edit['assignment_id'] = assigned['review_assignment']['id']
response = self.client.put(url, headers=self.alice, json=edit)
self.assertEqual(response.status_code, 200, response.text)
response = self.client.post(url + '/approve', headers=self.alice, json={
'assignment_id': edit['assignment_id'], 'revision': response.json()['revision'], 'confirmed': True})
self.assertEqual(response.status_code, 200, response.text)
def test_known_other_tenant_ids_actions_preview_export_search_rejected(self):
item = self.store.detail(self.tenant, self.ids['alice'])
edit = {k: item[k] for k in ('revision','title','question','answer','conditions','category','kind','valid_until')}
for account in (-1, self.accounts[0]['id'], self.accounts[1]['id']):
params = {'account_id': account}
url = self.url + '/items/' + self.ids['cross']
self.assertIn(self.client.get(url, params=params, headers=self.alice).status_code, (403, 404))
self.assertIn(self.client.put(url, params=params, headers=self.alice, json=edit).status_code, (403, 404))
for action in ('approve', 'reject', 'publish', 'disable', 'restore', 'delete'):
response = self.client.post(url + '/' + action, params=params, headers=self.alice,
json={'revision': 1, 'confirmed': True, 'restore_revision': 1})
self.assertIn(response.status_code, (403, 404), (action, response.text))
params = {'account_id': self.accounts[1]['id']}
for suffix, body in (('/search', {'query': '预约挂号材料'}),
('/jobs/preview', {'source_account_id': 'known-cross-source'})):
self.assertEqual(self.client.post(self.url + suffix, params=params, headers=self.alice, json=body).status_code, 403)
self.assertEqual(self.client.post(self.url + '/review-tasks/preview', params=params, headers=self.alice).status_code, 400)
self.assertEqual(self.client.get(self.url + '/export', params=params, headers=self.alice).status_code, 403)
self.assertEqual(self.client.post(self.url + '/runs/preview', headers=self.alice,
json={'account_ids': [self.accounts[1]['id']]}).status_code, 403)
self.assertEqual(KnowledgeRetriever(self.store).search(self.other_tenant, '预约挂号材料',
management_actor=self.users['alice'])['hits'], [])
def test_review_queue_uses_exact_assignments_and_stays_private_through_resume(self):
reviews = KnowledgeReviewStore(self.store)
self.scope_flag(False)
self.assertEqual(reviews.preview('*', -1, self.users['alice'], '')['total'], 0)
for key in ('alice', 'bob'):
item = self.store.detail(self.tenant, self.ids[key])
KnowledgeAssignments(self.store).assign('*', [{'id': item['id'], 'revision': item['revision']}],
self.users['alice'], self.actor, '')
wide = reviews.preview('*', -1, self.users['alice'], '')
self.assertEqual(wide['total'], 2)
reviews.action(wide['id'], 'start', self.users['alice'], '', True)
self.scope_flag(True)
self.assertEqual(reviews.get(wide['id'], self.users['alice'])['total'], 2)
with self.assertRaises(KeyError):
reviews.get(wide['id'], self.users['bob'])
worker = KnowledgeReviewWorker(self.store)
worker.step(1)
reviews.action(wide['id'], 'pause', self.users['alice'], '')
reviews.action(wide['id'], 'resume', self.users['alice'], '')
while worker.step():
pass
self.assertEqual(self.store.detail(self.other_tenant, self.ids['cross'])['status'], 'draft')
for key in ('alice', 'bob', 'null', 'missing', 'mismatch'):
self.assertEqual(self.store.detail(self.tenant, self.ids[key])['status'],
'approved' if key in ('alice', 'bob') else 'draft')
self.assertEqual(reviews.get(wide['id'], self.users['alice'])['approved'], 2)
self.assertEqual(reviews.results(wide['id'], self.users['alice'], '*', '')['total'], 2)
def approve_fixture(self, item):
assignments = KnowledgeAssignments(self.store)
assignments.assign('*', [{'id': item['id'], 'revision': item['revision']}], self.actor, self.actor, '')
assigned = assignments.detail(self.actor, item['id'])
assignments.transition(self.actor, item['id'], item['revision'], assigned['review_assignment']['id'], 'approve', '', True)
def publish_two(self):
for key in ('alice', 'bob'):
item = self.store.detail(self.tenant, self.ids[key])
self.approve_fixture(item)
self.store.publish(self.tenant, item['id'], item['revision'], self.actor, '')
def test_search_export_and_customer_default_same_tenant_include_admin_drafts(self):
self.publish_two()
params = {'account_id': self.accounts[0]['id']}
expected = {self.ids['alice'], self.ids['bob']}
result = self.client.post(self.url + '/search', params=params, headers=self.alice, json={'query': '预约挂号材料'})
self.assertEqual({i['id'] for i in result.json()['hits']}, expected)
exported = self.client.get(self.url + '/export', params=params, headers=self.alice)
self.assertEqual({json.loads(line)['id'] for line in exported.text.splitlines()}, expected)
self.assertEqual({i['id'] for i in KnowledgeRetriever(self.store).search(self.tenant, '预约挂号材料')['hits']}, expected)
def test_jobs_runs_watches_same_tenant_different_creator_and_cross_controls(self):
self.assertEqual({i['id'] for i in self.client.get(self.url + '/jobs?account_id=-1', headers=self.alice).json()['items']},
{self.jobs['alice'], self.jobs['bob']})
with self.db.connect() as db:
now = utc_now()
for key, tenants in [('alice', [self.tenant]), ('bob', [self.tenant]), ('cross', [self.other_tenant]),
('mixed', [self.tenant, self.other_tenant])]:
db.execute('INSERT INTO knowledge_run VALUES (?,?,?,?,?,?,?,?)', ('run-' + key, '合成批次', 'paused',
'{}', json.dumps(tenants), self.actor, now, now))
if key != 'mixed':
db.execute("UPDATE knowledge_job SET run_id=?,status='paused' WHERE id=?", ('run-' + key, self.jobs[key]))
source = db.execute('SELECT id FROM archive_source_account WHERE tenant_id=?', (self.tenant,)).fetchone()[0]
db.execute('INSERT INTO knowledge_watch VALUES (?,?,1,?)', (self.tenant, source, self.actor))
self.assertEqual({r['id'] for r in self.client.get(self.url + '/runs', headers=self.alice).json()['items']},
{'run-alice', 'run-bob'})
config = {'engine': 'rules', 'max_model_calls': 100}
for key in ('alice', 'bob'):
response = self.client.put(self.url + '/runs/run-' + key + '/config', headers=self.alice, json=config)
self.assertEqual(response.status_code, 200, response.text)
for key in ('cross', 'mixed'):
self.assertEqual(self.client.post(self.url + '/runs/run-' + key + '/resume', headers=self.alice).status_code, 404)
self.assertEqual(self.client.put(self.url + '/runs/run-' + key + '/config', headers=self.alice, json=config).status_code, 404)
self.assertEqual(self.client.post(self.url + '/jobs/job-cross/resume', headers=self.alice,
params={'account_id': self.accounts[0]['id']}).status_code, 404)
response = self.client.put(self.url + '/watch/' + source, params={'account_id': self.accounts[0]['id']},
headers=self.alice, json={'enabled': False})
self.assertEqual(response.status_code, 200, response.text)
def test_zero_scope_rows_and_all_permission_intersect_trusted_account_only(self):
self.assertEqual(self.total(), 5)
uid = self.users['alice']
with self.db.connect() as db:
db.execute('INSERT INTO admin_account_scope VALUES (?,?,?)', (uid, self.accounts[1]['id'], utc_now()))
self.assertEqual(self.total(), 0)
with self.db.connect() as db:
db.execute("INSERT INTO role_permissions VALUES ('cleaner','desktop-account:all')")
self.assertEqual(self.total(), 5)
with self.db.connect() as db:
db.execute("DELETE FROM role_permissions WHERE role_code='cleaner' AND permission_code='desktop-account:all'")
db.execute('DELETE FROM admin_account_scope WHERE admin_user_id=?', (uid,))
self.assertEqual(self.total(), 5)
def test_unbound_invalid_gid_provider_source_or_disabled_account_fail_closed(self):
uid = self.users['alice']
with self.db.connect() as db:
original = dict(db.execute('SELECT * FROM group_sso_bindings WHERE user_id=?', (uid,)).fetchone())
for key, value in [('provider', 'native'), ('gid', 'bad'), ('source_admin_id', 0), ('source_admin_id', 999)]:
with self.subTest(key=key, value=value):
with self.db.connect() as db:
db.execute(f'UPDATE group_sso_bindings SET {key}=? WHERE user_id=?', (value, uid))
self.assertEqual(self.total(), 0)
with self.db.connect() as db:
db.execute(f'UPDATE group_sso_bindings SET {key}=? WHERE user_id=?', (original[key], uid))
for identity in ('165', 'user:165', str(uid)):
with self.db.connect() as db:
db.execute('UPDATE desktop_accounts SET zyt_user_id=? WHERE id=?', (identity, self.accounts[0]['id']))
self.assertEqual(self.total(), 0)
with self.db.connect() as db:
db.execute("UPDATE desktop_accounts SET zyt_user_id='admin:165',status='disabled' WHERE id=?", (self.accounts[0]['id'],))
self.assertEqual(self.total(), 0)
with self.db.connect() as db:
db.execute("UPDATE desktop_accounts SET status='active' WHERE id=?", (self.accounts[0]['id'],))
db.execute('DELETE FROM group_sso_bindings WHERE user_id=?', (uid,))
self.assertEqual(self.total(), 0)
self.scope_flag(False)
self.assertEqual(self.total(), 6)
def test_bridge_missing_bad_namespace_current_endpoint_changes_fail_closed(self):
for raw in ('', '{}', '{bad', json.dumps({'group_api_url': GROUP, 'desktop_api_url': DESKTOP, 'namespace': 'user'}),
json.dumps({'group_api_url': GROUP + '/other', 'desktop_api_url': DESKTOP, 'namespace': 'admin'}),
json.dumps({'group_api_url': GROUP, 'desktop_api_url': 'https://other.invalid', 'namespace': 'admin'})):
with self.subTest(raw=raw), mock.patch.dict('os.environ', {'ZYT_KNOWLEDGE_ACCOUNT_BRIDGE': raw}):
self.assertEqual(self.total(), 0)
overview = self.client.get(self.url + '/overview?account_id=-1', headers=self.alice).json()
self.assertEqual(overview['knowledge_scope']['account_ids'], [])
with self.db.connect() as db:
db.execute('UPDATE model_config SET config_json=? WHERE id=1', (json.dumps({'ZYT_LOGIN_API_URL': 'https://unregistered.invalid'}),))
self.assertEqual(self.total(), 0)
with self.db.connect() as db:
db.execute('UPDATE model_config SET config_json=? WHERE id=1', ('{}',))
with mock.patch('zyt_auth.DEFAULT_ZYT_API_BASE_URL', DESKTOP):
self.assertEqual(self.total(), 5)
with mock.patch.dict('os.environ', {'ZYT_GROUP_API_URL': 'https://changed.invalid/adminapi'}):
self.assertEqual(self.total(), 0)
def revoke_binding(self):
with self.db.connect() as db:
db.execute('UPDATE group_sso_bindings SET source_admin_id=999 WHERE user_id=?', (self.users['alice'],))
def test_stream_export_rechecks_binding_at_each_record(self):
self.publish_two()
endpoint = next(route.endpoint for route in self.client.app.routes if getattr(route, 'path', '') == self.url + '/export')
with self.db.connect() as db:
user = db.execute('SELECT * FROM users WHERE id=?', (self.users['alice'],)).fetchone()
principal = fixtures.admin_api.Principal(user, self.db.permissions_for_user(self.users['alice']))
response = endpoint(SimpleNamespace(headers={}, client=None), self.accounts[0]['id'], principal)
async def consume():
iterator = response.body_iterator
await anext(iterator)
self.revoke_binding()
return [line async for line in iterator]
self.assertEqual(asyncio.run(consume()), [])
self.assertEqual(self.total(), 0)
def test_search_publish_recheck_binding_after_external_work(self):
item = self.store.detail(self.tenant, self.ids['bob'])
self.approve_fixture(item)
def revoke(*_):
self.revoke_binding()
return 'synthetic-profile'
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.publish.side_effect = revoke
with self.assertRaises(KeyError):
self.store.publish(self.tenant, item['id'], item['revision'], self.users['alice'], '')
self.assertEqual(self.store.detail(self.tenant, item['id'])['status'], 'approved')
with self.db.connect() as db:
db.execute('UPDATE group_sso_bindings SET source_admin_id=165 WHERE user_id=?', (self.users['alice'],))
self.store.publish(self.tenant, item['id'], item['revision'], self.actor, '')
with mock.patch('knowledge_retriever.VectorIndex') as index:
index.return_value.configured = True
index.return_value.profile = ''
def during_search(*_):
revoke()
return [{'payload': {'tenant_id': self.tenant, 'item_id': item['id'], 'revision': item['revision']}, 'score': .9}]
index.return_value.search.side_effect = during_search
self.assertEqual(KnowledgeRetriever(self.store).search(self.tenant, '预约挂号材料',
management_actor=self.users['alice'])['hits'], [])
def test_catalog_name_admin_defaults_and_existing_role_grants_preserved(self):
with self.db.connect() as db:
row = db.execute('SELECT name,kind FROM permissions WHERE code=?', (OWN_CODE,)).fetchone()
self.assertEqual(tuple(row), ('数据权限:仅本人账号的知识', 'action'))
self.assertNotIn(OWN_CODE, rbac.permissions_of(db, 'admin'))
before = {r[0]: rbac.permissions_of(db, r[0]) for r in db.execute('SELECT code FROM roles')}
rbac.seed(db, utc_now())
self.assertEqual({r[0]: rbac.permissions_of(db, r[0]) for r in db.execute('SELECT code FROM roles')}, before)
with self.assertRaises(ValueError):
rbac.grant(db, 'admin', sorted(rbac.all_codes(db)), utc_now())