113 lines
6.6 KiB
Python
113 lines
6.6 KiB
Python
import base64
|
|
import hashlib
|
|
import tempfile
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
from asgiref.sync import async_to_sync
|
|
from mcp.server.mcpserver.exceptions import ToolError
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.exceptions import ValidationError
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
from django.test import TestCase, override_settings
|
|
from django.urls import reverse
|
|
|
|
from . import attachments
|
|
from .models import CardAttachment, CardComment, Membership
|
|
from .services import create_card, create_project
|
|
|
|
|
|
class AttachmentTests(TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.settings = override_settings(MEDIA_ROOT=self.temp.name)
|
|
self.settings.enable()
|
|
self.addCleanup(self.settings.disable)
|
|
users = get_user_model()
|
|
self.owner = users.objects.create_user('attachment-owner')
|
|
self.viewer = users.objects.create_user('attachment-viewer')
|
|
self.stranger = users.objects.create_user('attachment-stranger')
|
|
self.project = create_project(self.owner, name='Attachment board')
|
|
self.card = create_card(self.owner, self.project, title='Files')
|
|
self.note = CardComment.objects.create(card=self.card, author=self.owner, body='Review these')
|
|
|
|
def test_card_and_note_upload_download_and_permissions(self):
|
|
self.client.force_login(self.owner)
|
|
url = reverse('projects:attachment_upload', args=[self.card.pk])
|
|
response = self.client.post(url, {'files': [SimpleUploadedFile(f'{n}.txt', f'content {n}'.encode()) for n in range(3)]})
|
|
self.assertEqual(response.status_code, 302)
|
|
response = self.client.post(url, {'comment_id': self.note.pk, 'files': [SimpleUploadedFile(f'note{n}.md', b'# note') for n in range(2)]})
|
|
self.assertEqual(response.status_code, 302)
|
|
self.assertEqual(self.card.attachments.filter(comment__isnull=True).count(), 3)
|
|
self.assertEqual(self.note.attachments.count(), 2)
|
|
item = self.note.attachments.first()
|
|
page = self.client.get(reverse('projects:card', args=[self.card.pk]))
|
|
self.assertContains(page, 'Card files')
|
|
self.assertContains(page, 'Files on this progress note')
|
|
self.assertContains(page, item.title)
|
|
self.assertEqual(item.sha256, hashlib.sha256(b'# note').hexdigest())
|
|
download = reverse('projects:attachment_download', args=[item.pk])
|
|
self.assertEqual(b''.join(self.client.get(download).streaming_content), b'# note')
|
|
self.assertIn('attachment', self.client.get(download)['Content-Disposition'])
|
|
preview = self.client.get(reverse('projects:attachment_preview', args=[item.pk]))
|
|
self.assertEqual(preview.content, b'# note')
|
|
self.assertIn('sandbox', preview['Content-Security-Policy'])
|
|
self.client.force_login(self.stranger)
|
|
self.assertEqual(self.client.get(download).status_code, 404)
|
|
self.assertEqual(self.client.post(reverse('projects:attachment_delete', args=[item.pk])).status_code, 404)
|
|
Membership.objects.create(project=self.project, user=self.viewer, role='viewer')
|
|
self.client.force_login(self.viewer)
|
|
self.assertEqual(self.client.get(download).status_code, 200)
|
|
self.assertEqual(self.client.post(reverse('projects:attachment_delete', args=[item.pk])).status_code, 403)
|
|
|
|
def test_validation_and_cleanup(self):
|
|
for name, data in [('evil.svg', b'<svg/>'), ('bad.png', b'not-png'), ('bad.txt', b'\x00')]:
|
|
with self.assertRaises(ValidationError):
|
|
attachments.upload_attachment(self.owner, self.card, filename=name, data=data)
|
|
with self.assertRaises(ValidationError):
|
|
attachments.upload_attachment(self.owner, self.card, filename='safe.txt', data=b'hello', comment_id=999)
|
|
item = attachments.upload_attachment(self.owner, self.card, filename='safe.txt', data=b'hello', comment_id=self.note.pk)
|
|
path = Path(item.file.path)
|
|
self.assertTrue(path.exists())
|
|
self.note.delete()
|
|
self.assertFalse(CardAttachment.objects.filter(pk=item.pk).exists())
|
|
self.assertFalse(path.exists())
|
|
|
|
def test_batch_upload_rolls_back_on_invalid_file(self):
|
|
self.client.force_login(self.owner)
|
|
response = self.client.post(reverse('projects:attachment_upload', args=[self.card.pk]), {
|
|
'files': [SimpleUploadedFile('good.txt', b'valid'), SimpleUploadedFile('bad.svg', b'<svg/>')]
|
|
})
|
|
self.assertEqual(response.status_code, 400)
|
|
self.assertFalse(self.card.attachments.exists())
|
|
self.assertFalse(list(Path(self.temp.name).rglob('*.*')))
|
|
|
|
def test_source_snapshot_metadata_and_size_limits(self):
|
|
data = b'function jump() { return true; }\n'
|
|
item = attachments.upload_attachment(self.owner, self.card, filename='companion.js', data=data,
|
|
comment_id=self.note.pk, source='mcp', source_path='dashboard/static/dashboard/companion.js', source_commit='a' * 40)
|
|
self.assertEqual(item.sha256, hashlib.sha256(data).hexdigest())
|
|
self.assertEqual(base64.b64encode(item.file.read()).decode(), base64.b64encode(data).decode())
|
|
with override_settings(PROJECTS_ATTACHMENT_MAX_BYTES=3):
|
|
with self.assertRaises(ValidationError):
|
|
attachments.upload_attachment(self.owner, self.card, filename='large.txt', data=b'four')
|
|
|
|
def test_mcp_upload_fetch_and_card_isolation(self):
|
|
from mcp_server.server import create_server
|
|
server = create_server()
|
|
payload = b'function jump() { return true; }\n'
|
|
with patch('mcp_server.server._actor', return_value=self.owner):
|
|
uploaded = async_to_sync(server.call_tool)('attachments_upload', {
|
|
'card_id': str(self.card.pk), 'filename': 'companion.js',
|
|
'content_base64': base64.b64encode(payload).decode(), 'comment_id': self.note.pk,
|
|
'source_path': 'dashboard/static/dashboard/companion.js', 'source_commit': 'b' * 40,
|
|
}).structured_content
|
|
self.assertEqual(uploaded['sha256'], hashlib.sha256(payload).hexdigest())
|
|
fetched = async_to_sync(server.call_tool)('attachments_fetch', {'attachment_id': uploaded['id']}).structured_content
|
|
self.assertEqual(base64.b64decode(fetched['content_base64']), payload)
|
|
self.assertEqual(fetched['text'], payload.decode())
|
|
with patch('mcp_server.server._actor', return_value=self.stranger):
|
|
with self.assertRaises(ToolError):
|
|
async_to_sync(server.call_tool)('attachments_fetch', {'attachment_id': uploaded['id']})
|