UnisKB/apps/system_manage/test_my_mindmaps.py

190 lines
12 KiB
Python

import json
from contextlib import nullcontext
from unittest import TestCase
from unittest.mock import patch
from django.db import transaction
from rest_framework.test import APIRequestFactory, force_authenticate
from system_manage.models.ai_hub import AIArtifact
from system_manage.models.platform_access import PlatformRole, PlatformRoleMember
from system_manage.platform_access import ADMIN_ROLE_ID
from system_manage.views.ai_hub import HubView
from users.models import User
class MyMindmapsChecks(TestCase):
def setUp(self):
self.atomic = transaction.atomic(); self.atomic.__enter__()
self.user = User.objects.create(username='mindmap_user', nick_name='user', role='USER', is_active=True)
self.other = User.objects.create(username='mindmap_other', nick_name='other', role='USER', is_active=True)
self.admin = User.objects.create(username='mindmap_admin', nick_name='admin', role='ADMIN', is_active=True)
role = PlatformRole.objects.create(id=ADMIN_ROLE_ID, name='test-admin')
PlatformRoleMember.objects.create(role=role, user=self.admin)
self.a = self.create(self.user, 'Alpha')
self.b = self.create(self.user, 'Alpha second')
self.c = self.create(self.other, 'Alpha other')
self.d = self.create(self.user, 'Alpha workspace', 'other')
self.patches = [patch('users.serializers.user.get_workspace_list_by_user', return_value=[{'id': 'default'}, {'id': 'other'}]),
patch('system_manage.platform_access.module_list', return_value=['mindmap']),
patch('system_manage.ai_hub_assets.asset_lock', side_effect=lambda: nullcontext()),
patch('system_manage.ai_hub_assets.normalize', side_effect=lambda value, *a: value)]
for p in self.patches: p.start()
def tearDown(self):
for p in reversed(self.patches): p.stop()
transaction.set_rollback(True); self.atomic.__exit__(None, None, None)
def create(self, owner, name, workspace='default'):
return AIArtifact.objects.create(workspace_id=workspace, owner_id=owner.id, name=name,
original='original', markdown='# original', layout='radial', history=[{'revision': 0, 'markdown': '# old'}])
def api(self, method, user, data=None, pk=None, workspace='default'):
request = getattr(APIRequestFactory(), method)('/', data or {}, format='json')
force_authenticate(request, user=user)
response = HubView.as_view()(request, workspace_id=workspace, kind='artifacts', pk=pk)
return json.loads(response.content) if hasattr(response, 'content') else response.data
def test_mine_admin_and_workspace(self):
result = self.api('get', self.user, {'mine':'true'})['data']
self.assertEqual({x['id'] for x in result['records']}, {str(self.a.id), str(self.b.id)})
own_admin = self.create(self.admin, 'admin')
result = self.api('get', self.admin, {'mine':'true'})['data']
self.assertEqual([x['id'] for x in result['records']], [str(own_admin.id)])
self.assertEqual([x['id'] for x in self.api('get', self.user, {'mine':'true'}, workspace='other')['data']['records']], [str(self.d.id)])
self.assertIsInstance(self.api('get', self.user)['data'], list)
def test_durable_task_result_and_concurrent_changes(self):
from types import SimpleNamespace
from django.core.files.uploadedfile import SimpleUploadedFile
from system_manage import ai_hub as hub
from system_manage.ai_hub_worker import persist_workbench_result
from system_manage.heading_structure import summary_state
nodes = [{'type': 'parse', 'processor': 'builtin'}, {'type': 'render'}]
with patch('system_manage.ai_hub.make_snapshot', return_value=nodes), \
patch('system_manage.mcp_registry.pipeline_resources', return_value=[]), \
patch('system_manage.mcp_registry.settings_row', return_value=SimpleNamespace(meta={})), \
patch('system_manage.access_control.enforce_task'):
task = hub.submit('default', self.user, {'name': 'file.md', 'nodes': nodes, 'workbench_artifact': {}},
SimpleUploadedFile('file.md', b'# source'))
artifact = AIArtifact.objects.get(task=task)
self.assertEqual(hub.serialize(artifact)['file_name'], 'file.md')
self.assertEqual(hub.serialize(artifact)['parse_status'], 'PENDING')
task.result = {'markdown': '# source', 'original': '# source', 'source': {}}
task.status = 'SUCCESS'; task.save()
persist_workbench_result(task)
artifact.refresh_from_db()
self.assertEqual((artifact.markdown, artifact.revision), ('# source', 2))
summary = type(task).objects.create(workspace_id='default', owner_id=self.user.id, name='summary',
snapshot={'nodes': [{'type': 'organize'}], 'workbench_artifact': {'id': str(artifact.id), 'revision': 2}},
input_data={'markdown': '# source'}, result={'markdown': '# summary', 'original': '# source'})
artifact.task = summary
artifact.history = (artifact.history or []) + [{'_type': 'workbench_tasks_v1',
'summary_task_id': str(summary.id), 'parse_task_id': str(task.id), 'file_name': 'file.md'}]
artifact.save()
persist_workbench_result(summary)
artifact.refresh_from_db()
self.assertEqual(summary_state(artifact)['source_markdown'], '# source')
self.assertEqual(summary_state(artifact)['smart_markdown'], '# summary')
artifact.markdown = '# user edit'; artifact.revision += 1; artifact.save()
persist_workbench_result(summary)
artifact.refresh_from_db()
self.assertEqual(artifact.markdown, '# user edit')
state = hub.serialize(artifact)
self.assertTrue(state['task_result_conflict'])
self.assertEqual(state['summary_status'], 'CONFLICT')
self.assertEqual(type(task).objects.get(pk=summary.pk).result['markdown'], '# summary')
artifact.task = task; artifact.save()
before = artifact.history
persist_workbench_result(summary)
artifact.refresh_from_db()
self.assertEqual(artifact.history, before)
self.assertFalse(hub.serialize(artifact)['task_result_conflict'])
def test_list_does_not_fetch_task_payloads(self):
from django.db import connection
from django.test.utils import CaptureQueriesContext
from system_manage.models.ai_hub import AITask
task = AITask.objects.create(workspace_id='default', owner_id=self.user.id, name='large',
file_data=b'x' * 100, snapshot={'workbench_artifact': {'id': str(self.a.id)}})
self.a.task = task
self.a.history = [{'_type': 'workbench_tasks_v1', 'parse_task_id': str(task.id)}]
self.a.save()
with CaptureQueriesContext(connection) as queries:
result = self.api('get', self.user, {'mine': 'true'})['data']
row = next(row for row in result['records'] if row['id'] == str(self.a.id))
self.assertEqual(row['parse_status'], 'PENDING')
self.assertTrue(any('JOIN "system_manage_aitask"' in q['sql'] for q in queries))
for column in ('file_data', 'input_data', 'snapshot', 'result', 'steps'):
for query in queries:
self.assertNotIn('"system_manage_aitask"."' + column + '"', query['sql'])
task.status = 'FAILED'; task.error = 'failed'; task.save()
row = next(row for row in self.api('get', self.user, {'mine': 'true'})['data']['records'] if row['id'] == str(self.a.id))
self.assertEqual((row['parse_status'], row['task_status'], row['task_error']), ('FAILED', 'FAILED', 'failed'))
from system_manage import ai_hub as hub
deferred_task = AITask.objects.defer('snapshot').get(pk=task.pk)
with CaptureQueriesContext(connection) as queries:
data = hub.serialize(deferred_task)
self.assertNotIn('artifact_id', data)
self.assertEqual(len(queries), 0)
def test_pagination_search_and_validation(self):
first = self.api('get', self.user, {'mine':'true','name':'alpha','current_page':1,'page_size':1})['data']
second = self.api('get', self.user, {'mine':'true','name':'alpha','current_page':2,'page_size':1})['data']
self.assertEqual(first['total'], 2); self.assertEqual(second['current'], 2)
self.assertNotEqual(first['records'][0]['id'], second['records'][0]['id'])
for params in ({'page_size':101}, {'current_page':0}, {'page_size':'x'}, {'name':'a'*129}, {'mine':'bad'}):
self.assertNotEqual(self.api('get', self.user, params)['code'], 200)
def test_cross_user_and_workspace_denied(self):
for method, data in [('get', None), ('post', {'action':'rename','name':'bad','revision':1}), ('delete', None)]:
self.assertNotEqual(self.api(method, self.other, data, self.a.id)['code'], 200)
self.assertNotEqual(self.api(method, self.user, data, self.a.id, workspace='other')['code'], 200)
self.a.refresh_from_db(); self.assertEqual(self.a.name, 'Alpha')
def test_rename_revision_and_content_save(self):
before = (self.a.original, self.a.markdown, self.a.layout, self.a.history, self.a.revision)
response = self.api('post', self.user, {'action':'rename','name':'Renamed','revision':1}, self.a.id)
self.assertEqual(response['code'], 200); self.assertEqual(response['data']['name'], 'Renamed')
self.a.refresh_from_db()
self.assertEqual((self.a.original, self.a.markdown, self.a.layout, self.a.history, self.a.revision), before)
self.assertNotEqual(self.api('post', self.user, {'action':'rename','name':'bad','revision':2}, self.a.id)['code'], 200)
self.assertNotEqual(self.api('post', self.user, {'action':'rename','name':'bad','revision':True}, self.a.id)['code'], 200)
self.assertNotEqual(self.api('post', self.user, {'action':'other','name':'bad','revision':1}, self.a.id)['code'], 200)
response = self.api('post', self.user, {'name':'Renamed','markdown':'# changed','layout':'tree','revision':1}, self.a.id)
self.assertEqual(response['code'], 200)
self.a.refresh_from_db(); self.assertEqual(self.a.revision, 2)
self.assertEqual(self.a.history, [{'revision': 0, 'markdown': '# old'}])
self.assertEqual(self.api('post', self.admin, {'action':'rename','name':'Admin rename','revision':2}, self.a.id)['code'], 200)
def test_limit_and_summary(self):
from system_manage import artifact_settings
from rest_framework.exceptions import PermissionDenied, ValidationError
self.assertEqual(artifact_settings.limit(), 10)
with self.assertRaises(PermissionDenied):
artifact_settings.save(self.user, {'limit': 2})
artifact_settings.save(self.admin, {'limit': 2})
self.assertEqual(artifact_settings.limit(), 2)
with self.assertRaises(ValidationError):
artifact_settings.save(self.admin, {'limit': True})
data = {'name': 'new', 'markdown': '# source', 'layout': 'tree'}
limited = self.api('post', self.user, data)
self.assertNotEqual(limited['code'], 200)
self.assertEqual(limited['message'], '最多可保存 2 张导图,请先删除不需要的导图')
self.assertEqual(self.api('post', self.other, data)['code'], 200)
self.assertEqual(self.api('post', self.user, data, workspace='other')['code'], 200)
data.update(revision=1, summary_state={'source_markdown': '# source', 'smart_markdown': '# summary', 'mode': 'source'})
response = self.api('post', self.user, data, self.a.id)
self.assertEqual(response['code'], 200)
self.assertEqual(response['data']['summary_state']['smart_markdown'], '# summary')
data = {'name': 'new', 'markdown': '# updated', 'layout': 'tree', 'revision': 2}
response = self.api('post', self.user, data, self.a.id)
self.assertEqual(response['data']['summary_state']['source_markdown'], '# updated')
self.assertEqual(response['data']['summary_state']['smart_markdown'], '# summary')
def test_existing_history_is_retained_without_new_versions(self):
self.a.history = [{'revision': i, 'markdown': '# old'} for i in range(30)]
self.a.save()
response = self.api('post', self.user, {'name': 'Alpha', 'markdown': '# changed', 'revision': 1}, self.a.id)
self.assertEqual(response['code'], 200)
self.a.refresh_from_db()
self.assertEqual(len(self.a.history), 30)