190 lines
12 KiB
Python
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)
|