UnisKB/apps/system_manage/test_ai_hub_service_api.py

147 lines
8.8 KiB
Python

import json
from types import SimpleNamespace
from django.test import SimpleTestCase, TestCase
from django.http import QueryDict
from rest_framework.exceptions import ValidationError
from system_manage.ai_hub_service_api import DEFAULT, get_config, save_config, parse_request, validate
class ConfigChecks(TestCase):
def test_isolated_config_and_delete(self):
custom = {'method': 'GET', 'parameters': [{'name': 'content', 'target': 'markdown', 'type': 'string', 'required': True}]}
save_config('one', custom); save_config('two', custom)
self.assertEqual(get_config('one'), custom)
save_config('one')
self.assertEqual(get_config('one'), DEFAULT)
self.assertEqual(get_config('two'), custom)
def test_validation_and_mapping(self):
config = {'method': 'GET', 'parameters': [{'name': 'content', 'target': 'markdown', 'type': 'string', 'required': True}]}
request = SimpleNamespace(method='GET', META={'QUERY_STRING': 'content=hello'}, query_params=QueryDict('content=hello'), FILES={})
self.assertEqual(parse_request(request, validate(config)), ({'markdown': 'hello'}, None))
request.query_params = QueryDict('content=one&content=two')
with self.assertRaises(ValidationError): parse_request(request, config)
with self.assertRaises(ValidationError): validate({'method': 'GET', 'parameters': [DEFAULT['parameters'][2]]})
with self.assertRaises(ValidationError): validate({'method': 'POST', 'parameters': [DEFAULT['parameters'][0]] * 2})
def test_legacy_multipart(self):
upload = SimpleNamespace(name='test.txt')
request = SimpleNamespace(method='POST', data={'data': json.dumps({'name': 'test'}), 'file': upload}, FILES={'file': upload})
self.assertEqual(parse_request(request, DEFAULT), ({'name': 'test'}, upload))
from unittest import TestCase
from unittest.mock import patch
from contextlib import nullcontext
from django.db import transaction
from django.core.cache import cache
from django.core.files.uploadedfile import SimpleUploadedFile
from rest_framework.test import APIRequestFactory, force_authenticate
from rest_framework.exceptions import AuthenticationFailed
from system_manage.models import Log
from system_manage.models.ai_hub import AIFlow, AIService, AITask
from system_manage.views.ai_hub import PublishedRun, ServiceCalls
from users.models import User
class ServiceAPIViewChecks(TestCase):
def setUp(self):
self.atomic = transaction.atomic(); self.atomic.__enter__()
cache.clear()
self.owner = User.objects.create(username='service_owner', nick_name='owner', role='ADMIN', is_active=True)
self.reader = User.objects.create(username='service_reader', nick_name='reader', role='USER', is_active=True)
self.flow = AIFlow.objects.create(workspace_id='default', owner_id=self.owner.id, name='flow', nodes=[{'type': 'render'}])
self.service = AIService.objects.create(workspace_id='default', owner_id=self.owner.id, name='service', flow=self.flow, allowed_users=[str(self.reader.id)])
self.patches = [
patch('users.serializers.user.get_workspace_list_by_user', return_value=[{'id':'default'}]),
patch('system_manage.platform_access.module_list', return_value=['mindmap']),
patch('system_manage.access_control.enforce_task'),
patch('system_manage.ai_hub.make_snapshot', return_value=[{'type': 'render'}]),
patch('system_manage.mcp_registry.pipeline_resources', return_value=[]),
patch('system_manage.ai_hub_assets.asset_lock', return_value=nullcontext()),
patch('system_manage.ai_hub_assets.normalize', side_effect=lambda text, *a: text),
]
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 call(self, method='post', data=None, user=None, fmt='json', view=PublishedRun, **headers):
factory = APIRequestFactory()
request = getattr(factory, method)('/', data or {}, format=fmt, **headers)
force_authenticate(request, user=user or self.owner)
return view.as_view()(request, workspace_id='default', pk=self.service.id)
def test_success_task_and_safe_log(self):
response = self.call(data={'markdown':'secret body', 'priority': 8})
self.assertEqual(response.status_code, 200)
task = AITask.objects.get(); self.assertEqual(task.snapshot['priority'], 8)
log = Log.objects.get(menu='AI_SERVICE'); self.assertEqual(log.details['status'], 'SUCCESS')
self.assertEqual(log.details['task_id'], str(task.id))
self.assertNotIn('secret body', str(log.details))
def test_legacy_envelope_and_repeated_inputs(self):
response = self.call(data={'data': json.dumps({'markdown':'hello', 'priority': 4})}, fmt='multipart')
self.assertEqual(response.status_code, 200)
self.assertEqual(AITask.objects.get().snapshot['priority'], 4)
upload1 = SimpleUploadedFile('one.txt', b'a'); upload2 = SimpleUploadedFile('two.txt', b'b')
response = self.call(data={'file': [upload1, upload2]}, fmt='multipart')
self.assertGreaterEqual(response.status_code, 400)
self.assertEqual(Log.objects.filter(menu='AI_SERVICE').count(), 2)
def test_failures_are_logged(self):
import hashlib
self.service.key_hash = hashlib.sha256(b'key').hexdigest(); self.service.save()
self.assertGreaterEqual(self.call(data={'markdown':'x'}).status_code, 400)
self.service.key_hash = ''; self.service.save()
self.assertGreaterEqual(self.call(data={'unknown':'x'}).status_code, 400)
self.assertGreaterEqual(self.call(method='get', data={'markdown':'x'}).status_code, 400)
self.assertEqual(self.call(method='put', data={'markdown':'x'}).status_code, 405)
self.service.requests_per_minute = 1; self.service.save()
self.assertGreaterEqual(self.call(data={'markdown':'x'}).status_code, 400)
self.assertEqual(Log.objects.filter(menu='AI_SERVICE', details__status='FAILED').count(), 5)
def test_auth_and_permission_failure(self):
with patch('common.auth.TokenAuth.authenticate', side_effect=AuthenticationFailed('sensitive')):
response = PublishedRun.as_view()(APIRequestFactory().post('/', {}, format='json'), workspace_id='default', pk=self.service.id)
self.assertGreaterEqual(response.status_code, 400)
self.service.allowed_users = []; self.service.save()
response = self.call(data={'markdown':'x'}, user=self.reader)
self.assertGreaterEqual(response.status_code, 400)
logs = list(Log.objects.filter(menu='AI_SERVICE'))
self.assertEqual(len(logs), 2)
self.assertNotIn('sensitive', str([x.details for x in logs]))
def test_log_query_permissions_and_paging(self):
self.call(data={'markdown':'a'}); self.call(data={'markdown':'b'})
denied = self.call(method='get', data={}, user=self.reader, view=ServiceCalls)
denied_body = getattr(denied, 'data', None) or json.loads(denied.content)
self.assertNotEqual(denied_body['code'], 200)
response = self.call(method='get', data={'current_page': 2, 'page_size': 1}, view=ServiceCalls)
payload = json.loads(response.content)['data']
self.assertEqual(payload['total'], 2); self.assertEqual(len(payload['records']), 1)
self.assertEqual(payload['records'][0]['task_status'], 'PENDING')
def test_log_write_failure_rolls_back_task(self):
with patch('system_manage.models.Log.objects.create', side_effect=RuntimeError('private')):
response = self.call(data={'markdown':'x'})
self.assertEqual(response.status_code, 503)
self.assertEqual(AITask.objects.count(), 0)
def test_unhandled_exception_is_safe_and_logged(self):
with patch('system_manage.ai_hub.submit', side_effect=RuntimeError('private')):
response = self.call(data={'markdown':'x'})
self.assertEqual(response.status_code, 500)
self.assertNotIn('private', response.content.decode())
self.assertEqual(Log.objects.get(menu='AI_SERVICE').details['http_status'], 500)
def test_real_token_authentication_errors_keep_401(self):
for headers in ({}, {'HTTP_AUTHORIZATION': 'invalid'}):
request = APIRequestFactory().get('/', **headers)
response = PublishedRun.as_view()(request, workspace_id='default', pk=self.service.id)
self.assertEqual(response.status_code, 401)
self.assertEqual(Log.objects.filter(menu='AI_SERVICE', status=401).count(), 2)
def test_non_object_json_is_a_logged_parameter_error(self):
response = self.call(data=['invalid'])
self.assertEqual(response.status_code, 400)
self.assertEqual(Log.objects.get(menu='AI_SERVICE').details['error'], '任务参数无效')