UnisKB/apps/system_manage/test_mcp_engine.py

349 lines
21 KiB
Python

import asyncio
import json
from datetime import timedelta
from types import SimpleNamespace
from unittest import TestCase
from unittest.mock import patch
from django.db import connection
from django.utils import timezone
from django.core.files.uploadedfile import SimpleUploadedFile
from rest_framework.exceptions import ValidationError, PermissionDenied, NotFound
from system_manage import mcp_registry as registry, mcp_scheduler as scheduler, mcp_runtime as runtime, mcp_workflows
from system_manage import ai_hub as hub
from system_manage.models import SystemSetting
from system_manage.models.ai_hub import AITask, AIFlow, AIService, AIParserResource
from users.models import User
class EngineTests(TestCase):
def setUp(self):
from system_manage.models.platform_access import PlatformRole, PlatformRoleMember
self.admin = User.objects.create(username='CODEX_ENGINE_ADMIN', nick_name='测试管理员', role='ADMIN')
self.other = User.objects.create(username='CODEX_ENGINE_OTHER', nick_name='测试用户', role='USER')
role, _ = PlatformRole.objects.get_or_create(id='00000000-0000-0000-0000-000000000002', defaults={'name':'测试管理员'})
PlatformRoleMember.objects.create(role=role, user=self.admin)
from application.models import ApplicationFolder
ApplicationFolder.objects.get_or_create(id='default', defaults={'name':'默认'})
def tearDown(self):
# This is a disposable local SQLite file created by check_mcp_engine.py.
with connection.cursor() as cursor:
cursor.execute('PRAGMA foreign_keys=OFF')
for table in connection.introspection.table_names():
cursor.execute('DELETE FROM ' + connection.ops.quote_name(table))
cursor.execute('PRAGMA foreign_keys=ON')
def task(self, key='mindmap-engine', priority=5, **kwargs):
return AITask.objects.create(owner_id=self.admin.id, workspace_id='default', name='CODEX_ENGINE_TEST',
snapshot={'engine':True,'resources':[key],'priority':priority,**kwargs})
def configure(self, key='mindmap-engine', state='ENABLED', capacity=1):
meta = registry.resolve('default',self.admin,key,check=False)[0]
return registry.configure('default',self.admin,key,{'state':state,'capacity':capacity,'revision':meta['revision']})
def test_catalogue_has_core_components_and_no_secrets(self):
rows = registry.catalogue('default',self.admin)
self.assertTrue(set(registry.BUILTINS) <= {r['id'] for r in rows})
self.assertTrue(all(r['source'] == 'system' for r in rows if r['id'] in registry.BUILTINS))
self.assertNotIn('credential',json.dumps(rows))
def test_referenced_parser_and_mcp_are_custom_sources(self):
resource = SimpleNamespace(name='resource', enabled=True, is_active=True,
updated_at=timezone.now(), update_time=timezone.now())
with patch.object(hub, 'one', return_value=resource), patch.object(hub, 'require_use'), \
patch.object(registry, 'tool_for', return_value=resource):
for key in ('parser:test', 'mcp:test'):
self.assertEqual(registry.resolve('default', self.admin, key, check=False)[0]['source'], 'custom')
def test_markdown_and_mindmap_have_distinct_structured_outputs(self):
text='# 标题42\n\n| A | B |\n| --- | --- |\n| 1 | 2 |'
parsed=runtime.invoke('default',self.admin,'markdown-parser',{'text':text})
graph=runtime.invoke('default',self.admin,'mindmap-engine',{'text':text})
self.assertEqual(parsed['structured']['headings'][0]['text'],'标题42')
self.assertTrue(any(item['type']=='table_open' for item in parsed['structured']['tokens']))
self.assertEqual(graph['structured']['children'][0]['text'],'标题42')
def test_config_permissions_revision_and_disabled_admission(self):
with self.assertRaises(PermissionDenied): registry.configure('default',self.other,'mindmap-engine',{})
self.configure(state='DISABLED')
with self.assertRaises(ValidationError): registry.resolve('default',self.admin,'mindmap-engine')
with self.assertRaises(ValidationError): registry.configure('default',self.admin,'mindmap-engine',{'state':'ENABLED','capacity':1,'revision':1})
task=self.task();self.assertIsNone(scheduler.admit());task.refresh_from_db();self.assertEqual(task.status,'FAILED')
def test_priority_fifo_capacity_and_release(self):
self.configure()
low=self.task(priority=1);first=self.task(priority=9);second=self.task(priority=9)
self.assertEqual(scheduler.admit().id,first.id)
self.assertIsNone(scheduler.admit())
scheduler.finish(first,'SUCCESS',{})
self.assertEqual(scheduler.admit().id,second.id)
scheduler.finish(second,'SUCCESS',{})
self.assertEqual(scheduler.admit().id,low.id)
def test_global_capacity_and_resource_independence(self):
row=registry.settings_row();row.meta['capacity']=1;row.save()
first=self.task();self.task('markdown-parser')
self.assertEqual(scheduler.admit().id,first.id);self.assertIsNone(scheduler.admit())
def test_wait_aging_and_inline_worker_share_priority(self):
old=self.task(priority=0)
AITask.objects.filter(pk=old.id).update(created_at=timezone.now()-timedelta(minutes=60))
high=self.task(priority=9,dispatch='inline')
self.assertEqual(scheduler.admit().id,old.id)
scheduler.finish(old,'SUCCESS',{})
self.assertIsNone(scheduler.admit())
self.assertEqual(scheduler.admit('inline',high.id).id,high.id)
def test_cancel_only_queued_recovery_requires_stale_heartbeat(self):
task=self.task();scheduler.cancel(task);task.refresh_from_db();self.assertEqual(task.status,'CANCELLED')
other=self.task();scheduler.admit()
with self.assertRaises(ValidationError): scheduler.cancel(other)
self.assertEqual(scheduler.recover(),0)
AITask.objects.filter(pk=other.id).update(updated_at=timezone.now()-timedelta(minutes=31))
self.assertEqual(scheduler.recover(),1)
def test_inline_task_records_result_and_failure(self):
value=scheduler.inline('default',self.admin,'mindmap-engine',lambda:{'text':'result42'})
self.assertEqual(AITask.objects.get(pk=value['task_id']).status,'SUCCESS')
with self.assertRaises(ValueError): scheduler.inline('default',self.admin,'mindmap-engine',lambda:(_ for _ in ()).throw(ValueError('private error')))
self.assertFalse(AITask.objects.filter(status='RUNNING').exists())
self.assertNotIn('private',AITask.objects.filter(status='FAILED').first().error)
def test_draining_allows_inflight_reservation_and_blocks_new(self):
task=self.task();scheduler.admit();self.configure(state='DRAINING')
value=scheduler.inline('default',self.admin,'mindmap-engine',lambda:{'text':'done'},parent=task.id)
self.assertEqual(value['text'],'done')
self.assertEqual(value['task_id'],str(task.id))
with self.assertRaises(ValidationError): scheduler.inline('default',self.admin,'mindmap-engine',lambda:{})
def test_cross_workspace_mcp_and_disabled_tool(self):
from tools.models import Tool, ToolFolder
ToolFolder.objects.create(id='default',name='默认')
tool=Tool.objects.create(name='测试MCP',tool_type='MCP',workspace_id='other',user=self.admin,code='{}')
with self.assertRaises(NotFound): registry.resolve('default',self.admin,'mcp:'+str(tool.id))
tool.workspace_id='default';tool.is_active=False;tool.save()
with self.assertRaises(ValidationError): registry.resolve('default',self.admin,'mcp:'+str(tool.id))
def test_connection_protocols_and_invalid_address(self):
for raw in ['invalid',{}, {'x':{'transport':'stdio','command':'sh'}}, {'x':{'transport':'sse','url':'file:///private'}}]:
with self.subTest(raw=raw),self.assertRaises(ValidationError):runtime.connections(raw)
def test_management_api_audit_does_not_store_inputs_or_credentials(self):
from system_manage.views.mcp_engine import EngineView
from system_manage.models import Log
request=SimpleNamespace(user=self.admin, path='/mcp_engine/capacity', META={'REMOTE_ADDR':'127.0.0.1'},
FILES={},data={'capacity':3,'question':'private document','api_key':'private credential'})
EngineView().post(request,workspace_id='default',kind='capacity')
self.assertEqual(registry.settings_row().meta['capacity'],3)
self.assertNotIn('private',json.dumps(Log.objects.first().details))
def test_mcp_structured_and_non_text_results(self):
class Content:
def model_dump(self,**kwargs):return {'type':'image','data':'test','mimeType':'image/png'}
response=SimpleNamespace(isError=False,content=[Content()],structuredContent={'count':42})
class Session:
async def __aenter__(self):return self
async def __aexit__(self,*args):pass
async def call_tool(self,*args):return response
class Client:
def __init__(self,*args):pass
def session(self,*args):return Session()
with patch('langchain_mcp_adapters.client.MultiServerMCPClient',Client):
value=runtime.call_mcp({'test':{'transport':'sse','url':'http://example.test/sse'}},'test','count',{})
self.assertEqual(value['structured'],{'count':42});self.assertEqual(value['content'][0]['type'],'image')
response.isError=True
with self.assertRaises(ValidationError):runtime.call_mcp({'test':{'transport':'sse','url':'http://example.test/sse'}},'test','count',{},retries=2)
def test_mcp_timeout_cancels_and_does_not_expose_remote_error(self):
class Session:
async def __aenter__(self):return self
async def __aexit__(self,*args):pass
async def call_tool(self,*args):await asyncio.sleep(10)
class Client:
def __init__(self,*args):pass
def session(self,*args):return Session()
with patch('langchain_mcp_adapters.client.MultiServerMCPClient',Client),self.assertRaises(ValidationError):
runtime.call_mcp({'test':{'transport':'sse','url':'http://example.test/sse'}},'test','slow',{},timeout=1)
def test_workflow_template_frozen_version_and_actual_execution(self):
from application.models import ApplicationVersion
app=mcp_workflows.new_template('default',self.admin,{'name':'CODEX_FLOW'})
from pathlib import Path
output = Path(__file__).resolve().parents[3] / '.codex_tmp' / 'mcp-engine' / 'mock-flow.json'
if output.parent.exists():
output.write_text(json.dumps(app.work_flow), encoding='utf-8')
version=ApplicationVersion.objects.create(application=app,work_flow=app.work_flow,user=self.admin,application_name=app.name)
app.is_publish=True;app.save()
task=mcp_workflows.submit('default',self.admin,{'application_id':str(app.id),'question':'# 测试42\n## 内容'})
original=task.snapshot['work_flow'];app.work_flow={};app.save()
self.assertEqual(task.snapshot['work_flow'],original)
self.assertEqual(task.snapshot['application_version'],str(version.id))
from system_manage.ai_hub_worker import execute
execute(scheduler.admit());task.refresh_from_db()
self.assertEqual(task.status,'SUCCESS',task.error)
self.assertIn('测试42',task.result['text'])
self.assertTrue(any(step['type']=='component-node' for step in task.steps))
def test_original_document_to_mindmap_default_still_works(self):
task=hub.submit('default',self.admin,{'nodes':[{'type':'parse','processor':'builtin'},{'type':'render'}]},SimpleUploadedFile('test.txt','# 原文42'.encode()))
from system_manage.ai_hub_worker import execute
execute(scheduler.admit());task.refresh_from_db()
self.assertEqual(task.status,'SUCCESS',task.error);self.assertIn('42',task.result['markdown'])
self.assertTrue(task.result['tree']['children'])
def test_file_template_runs_uploaded_document(self):
from application.models import ApplicationVersion
app=mcp_workflows.new_template('default',self.admin,{'name':'CODEX_FILE_FLOW','with_file':True})
ApplicationVersion.objects.create(application=app,work_flow=app.work_flow,user=self.admin,application_name=app.name)
app.is_publish=True;app.save()
task=mcp_workflows.submit('default',self.admin,{'application_id':str(app.id)},SimpleUploadedFile('sample.md','# 文件42\n正文'.encode()))
from system_manage.ai_hub_worker import execute
execute(scheduler.admit());task.refresh_from_db()
self.assertEqual(task.status,'SUCCESS',task.error)
self.assertIn('文件42',task.result['text'])
def test_interactive_file_scope_is_current_chat_or_application(self):
from unittest.mock import Mock
query=Mock();query.first.return_value=SimpleNamespace(file_name='test.md',get_bytes=lambda:b'# text42')
with patch('knowledge.models.File.objects.filter',return_value=query) as selected:
value=runtime.invoke('default',self.admin,'file-reader',{'documents':[{'file_id':'fake'}]},application_id='app42',chat_id='chat42')
self.assertIn('text42',value['text'])
scope=selected.call_args.args[0]
self.assertIn('chat42',str(scope));self.assertIn('app42',str(scope))
def test_task_query_rejects_invalid_uuid(self):
from system_manage.views.mcp_engine import EngineView
request=SimpleNamespace(user=self.admin,query_params={'id':'invalid'})
with self.assertRaises(ValidationError):EngineView().get(request,'default','tasks')
def test_consumer_stop_during_admission_does_not_start_new_work(self):
import signal
from system_manage.management.commands.ai_hub_worker import Command
task=self.task()
def claimed():
AITask.objects.filter(pk=task.id).update(status='RUNNING',started_at=timezone.now())
signal.raise_signal(signal.SIGTERM)
return task
original=signal.getsignal(signal.SIGTERM)
try:
with patch('system_manage.management.commands.ai_hub_worker.claim',side_effect=claimed), patch('system_manage.management.commands.ai_hub_worker.execute') as execute:
Command().handle(once=True,recover=False,concurrency=1)
execute.assert_not_called()
finally:
signal.signal(signal.SIGTERM,original)
task.refresh_from_db();self.assertEqual(task.status,'PENDING');self.assertIsNone(task.started_at)
def test_parallel_nodes_share_one_parent_resource_slot(self):
import time
import threading
from concurrent.futures import ThreadPoolExecutor
task=self.task();scheduler.admit()
counter={'active':0,'peak':0};guard=threading.Lock()
def invoke():
with guard:
counter['active']+=1;counter['peak']=max(counter['peak'],counter['active'])
time.sleep(.05)
with guard:counter['active']-=1
return {'text':'done'}
def call():
try:return scheduler.inline('default',self.admin,'mindmap-engine',invoke,parent=task.id)
finally:connection.close()
with ThreadPoolExecutor(max_workers=2) as pool:
results=list(pool.map(lambda _:call(),range(2)))
self.assertEqual(counter['peak'],1)
self.assertTrue(all(item['task_id']==str(task.id) for item in results))
def test_parallel_batch_reservation_blocks_other_task_on_same_resource(self):
self.configure(capacity=2)
first = self.task(resource_slots={'mindmap-engine': 2})
second = self.task()
self.assertEqual(scheduler.admit().id, first.id)
self.assertIsNone(scheduler.admit())
scheduler.finish(first, 'SUCCESS', {})
self.assertEqual(scheduler.admit().id, second.id)
def test_parallel_batch_reservation_respects_global_interactive_reserve(self):
self.configure(capacity=4)
first = self.task(resource_slots={'mindmap-engine': 3})
interactive = self.task('markdown-parser', dispatch='inline')
self.assertEqual(scheduler.admit().id, first.id)
self.assertEqual(scheduler.admit('inline', interactive.id).id, interactive.id)
self.assertIsNone(scheduler.admit())
def test_parallel_batch_cannot_exceed_component_capacity(self):
self.configure(capacity=1)
task = self.task(resource_slots={'mindmap-engine': 2})
self.assertIsNone(scheduler.admit())
task.refresh_from_db()
self.assertEqual(task.status, 'PENDING')
def test_summary_limit_spans_models_and_workspaces_without_blocking_other_work(self):
row = registry.settings_row(); row.meta.update(capacity=8, interactive_reserve=0); row.save()
SystemSetting.objects.create(type=11030, meta={'summary_concurrency_limit': 2})
def summary(key, slots, workspace='default', user=None):
return AITask.objects.create(owner_id=(user or self.admin).id, workspace_id=workspace, name='CODEX_SUMMARY_LIMIT',
snapshot={'resources': [key], 'resource_slots': {key: slots}, 'nodes': [{'type': 'organize', 'model_id': key.split(':', 1)[1]}]})
first = summary('model:first', 2)
second = summary('model:second', 1, 'other', self.other)
other = self.task('markdown-parser')
def resolve(workspace, user, key, **kwargs):
return ({'id': key, 'capacity': 8}, None)
with patch.object(registry, 'resolve', side_effect=resolve):
self.assertEqual(scheduler.admit().id, first.id)
self.assertEqual(scheduler.admit().id, other.id)
self.assertIsNone(scheduler.admit())
scheduler.finish(first, 'SUCCESS', {})
self.assertEqual(scheduler.admit().id, second.id)
def test_lower_summary_limit_drains_running_and_reduces_queued_reservation(self):
row = registry.settings_row(); row.meta.update(capacity=8, interactive_reserve=0); row.save()
SystemSetting.objects.create(type=11030, meta={'summary_concurrency_limit': 1})
def summary(slots, status='PENDING'):
return AITask.objects.create(owner_id=self.admin.id, workspace_id='default', name='CODEX_SUMMARY_LIMIT', status=status,
snapshot={'resources': ['model:first'], 'resource_slots': {'model:first': slots},
'nodes': [{'type': 'organize', 'model_id': 'first'}]})
running = summary(2, 'RUNNING'); queued = summary(4)
with patch.object(registry, 'resolve', return_value=({'id': 'model:first', 'capacity': 8}, None)):
self.assertIsNone(scheduler.admit())
scheduler.finish(running, 'SUCCESS', {})
admitted = scheduler.admit()
self.assertEqual(admitted.id, queued.id)
self.assertEqual(admitted.snapshot['resource_slots']['model:first'], 1)
def test_summary_uses_available_slots_without_waiting_for_full_reservation(self):
row = registry.settings_row(); row.meta.update(capacity=8, interactive_reserve=0); row.save()
SystemSetting.objects.create(type=11030, meta={'summary_concurrency_limit': 3})
def summary(model, slots, status='PENDING'):
key = 'model:' + model
return AITask.objects.create(owner_id=self.admin.id, workspace_id='default', name='CODEX_SUMMARY_LIMIT', status=status,
snapshot={'resources': [key], 'resource_slots': {key: slots}, 'nodes': [{'type': 'organize', 'model_id': model}]})
summary('first', 1, 'RUNNING'); queued = summary('second', 3)
with patch.object(registry, 'resolve', return_value=({'id': 'model:second', 'capacity': 8}, None)):
admitted = scheduler.admit()
self.assertEqual(admitted.id, queued.id)
self.assertEqual(admitted.snapshot['resource_slots']['model:second'], 2)
def test_failed_task_retry_reuses_completed_parse(self):
from system_manage.ai_hub_worker import execute
task = hub.submit('default', self.admin, {'nodes': [{'type': 'parse', 'processor': 'builtin'}, {'type': 'render'}]},
SimpleUploadedFile('retry.md', b'# CODEX retry42'))
original = runtime.invoke
calls = []
def invoke(workspace, user, key, *args, **kwargs):
calls.append(key)
if key == 'mindmap-engine' and calls.count(key) == 1:
raise ValueError('temporary render failure')
return original(workspace, user, key, *args, **kwargs)
with patch('system_manage.mcp_runtime.invoke', side_effect=invoke):
execute(scheduler.admit())
task.refresh_from_db()
self.assertEqual(task.status, 'FAILED')
self.assertIn('parse_checkpoint', task.result)
task.status = 'PENDING'; task.attempt += 1; task.save()
execute(scheduler.admit())
task.refresh_from_db()
self.assertEqual(task.status, 'SUCCESS', task.error)
self.assertEqual(calls.count('file-reader'), 1)