349 lines
21 KiB
Python
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)
|