Files
2026-10-22 10:24:33 +02:00

133 lines
7.7 KiB
Python

import base64
import hashlib
import json
import asyncio
import os
from urllib.parse import parse_qs, urlparse
from django.contrib.auth import get_user_model
from django.test import TestCase, TransactionTestCase, Client as DjangoClient
from django.conf import settings
from asgiref.sync import async_to_sync
from unittest.mock import patch
from mcp.server.auth.provider import AccessToken as McpAccessToken
from mcp.server.mcpserver.exceptions import ToolError
from oauth2_provider.models import Application
from mcp_server.server import _verified, create_server
from .services import create_project
class OAuthMcpTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user('mcp-user', password='test-password')
self.application = Application.objects.create(
user=self.user, name='Test client', client_type=Application.CLIENT_PUBLIC,
authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE,
redirect_uris='http://localhost:9876/callback',
)
def test_pkce_token_and_revocation(self):
self.client.force_login(self.user)
verifier = 'v' * 64
challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).decode().rstrip('=')
params = {'response_type': 'code', 'client_id': self.application.client_id,
'redirect_uri': 'http://localhost:9876/callback', 'scope': 'projects:read projects:write',
'state': 'test-state', 'code_challenge': challenge, 'code_challenge_method': 'S256',
'resource': settings.MCP_PUBLIC_URL}
response = self.client.get('/o/authorize/', params)
self.assertEqual(response.status_code, 200, response.content[:300])
form = response.context['form']
payload = {field.name: field.value() for field in form if field.field.widget.is_hidden and field.value() is not None}
payload['allow'] = 'Authorize'
response = self.client.post('/o/authorize/', payload)
self.assertEqual(response.status_code, 302, response.content[:300])
code = parse_qs(urlparse(response['Location']).query)['code'][0]
response = self.client.post('/o/token/', {'grant_type': 'authorization_code', 'code': code,
'redirect_uri': 'http://localhost:9876/callback', 'client_id': self.application.client_id,
'code_verifier': verifier, 'resource': settings.MCP_PUBLIC_URL})
self.assertEqual(response.status_code, 200, response.content[:300])
secret = response.json()['access_token']
info = _verified(secret)
self.assertEqual(info['user_id'], self.user.pk)
self.assertIn('projects:write', info['scopes'])
self.client.post(f'/projects/profile/connections/{self.user.oauth2_provider_accesstoken.first().pk}/revoke/')
self.assertIsNone(_verified(secret))
def test_discovery_and_project_access(self):
discovery = self.client.get('/.well-known/oauth-authorization-server')
self.assertEqual(discovery.status_code, 200)
self.assertIn('none', discovery.json()['token_endpoint_auth_methods_supported'])
project = create_project(self.user, name='Private')
self.assertEqual(self.client.get(f'/projects/{project.pk}/').status_code, 302)
def test_cross_project_move_tool_is_registered_with_revision_and_uuid_contract(self):
tool = create_server()._tool_manager.get_tool('cards_move_project')
self.assertIn('another editable project', tool.description)
self.assertEqual(set(tool.parameters['required']), {'card_id', 'target_project', 'expected_revision'})
self.assertIn('idempotency_key', tool.parameters['properties'])
def test_client_registration_requires_authenticated_user_and_csrf(self):
metadata = {'client_name': 'Private test client', 'redirect_uris': ['https://client.example/callback'],
'grant_types': ['authorization_code', 'refresh_token'], 'token_endpoint_auth_method': 'none'}
browser = DjangoClient(enforce_csrf_checks=True)
response = browser.post('/o/register/', data=json.dumps(metadata), content_type='application/json')
self.assertEqual(response.status_code, 401)
browser.force_login(self.user)
response = browser.post('/o/register/', data=json.dumps(metadata), content_type='application/json')
self.assertEqual(response.status_code, 401)
browser.get('/projects/profile/')
csrf = browser.cookies['csrftoken'].value
response = browser.post('/o/register/', data=json.dumps(metadata), content_type='application/json', HTTP_X_CSRFTOKEN=csrf)
self.assertEqual(response.status_code, 201, response.content[:300])
client_id = response.json()['client_id']
registered = Application.objects.get(client_id=client_id)
self.assertEqual(registered.user_id, self.user.pk)
def test_mcp_default_card_and_scope_enforcement(self):
project = create_project(self.user, name='BoomCast', git_repository_url='https://example.com/repo')
server = create_server()
access = McpAccessToken(token='test', client_id='test', scopes=['projects:read', 'projects:write'], subject=str(self.user.pk))
with patch('mcp_server.server.get_access_token', return_value=access):
result = async_to_sync(server.call_tool)('specs_create', {'project': str(project.pk), 'title': 'Field notes', 'markdown': '# Notes\n\n```py\nprint(1)\n```'})
card = result.structured_content
self.assertEqual(card['priority'], 'medium')
self.assertEqual(card['markdown'], '# Notes\n\n```py\nprint(1)\n```')
result = async_to_sync(server.call_tool)('projects_get', {'project': str(project.pk)})
self.assertEqual(result.structured_content['git_repository_url'], 'https://example.com/repo')
read = McpAccessToken(token='test', client_id='test', scopes=['projects:read'], subject=str(self.user.pk))
with patch('mcp_server.server.get_access_token', return_value=read):
with self.assertRaises(ToolError):
async_to_sync(server.call_tool)('cards_set_priority', {'card_id': card['id'], 'priority': 'high', 'expected_revision': 1})
class CrossProjectMoveMcpTests(TransactionTestCase):
def test_cross_project_move_mcp_handler_returns_same_move_result(self):
user = get_user_model().objects.create_user('move-mcp-user', password='test-password')
source = create_project(user, name='MCP source')
destination = create_project(user, name='MCP destination')
from .services import create_card
card = create_card(user, source, title='Move through MCP')
server = create_server()
tool = server._tool_manager.get_tool('cards_move_project')
class InlineAwaitable:
def __init__(self, function):
self.function = function
async def __call__(self):
return self.function()
with patch('mcp_server.server._actor', return_value=user), \
patch('mcp_server.server.sync_to_async', side_effect=lambda function: InlineAwaitable(function)), \
patch.dict(os.environ, {'DJANGO_ALLOW_ASYNC_UNSAFE': 'true'}):
data = asyncio.run(tool.fn(card_id=str(card.pk), target_project=str(destination.pk),
target_column_id=str(destination.board.columns.get(is_default=True).pk),
expected_revision=card.revision))
card.refresh_from_db()
self.assertEqual(data['id'], str(card.pk))
self.assertEqual(data['project_id'], str(destination.pk))
self.assertEqual(data['revision'], 2)
self.assertEqual(data['move']['source_project_id'], str(source.pk))
self.assertEqual(data['move']['target_column_id'], str(card.column_id))