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

411 lines
26 KiB
Python

from django.contrib.auth import get_user_model
from django.test import TestCase, Client, override_settings
from django.core.exceptions import ValidationError
from django.urls import reverse
from django.http import HttpResponse, Http404
from django.utils import timezone
from unittest.mock import patch
from .models import Activity, Card, CardRevision, CardComment, CardAttachment, Column, Membership, Profile, Tag
from .forms import ProfileForm
from .middleware import ProfileTimezoneMiddleware
from .services import RevisionConflict, bulk_update_cards, card_for, create_card, create_project, move_card, move_card_to_project, update_card, update_column
class ProjectWorkflowTests(TestCase):
def setUp(self):
users = get_user_model()
self.owner = users.objects.create_user('owner', password='test-password')
self.other = users.objects.create_user('other', password='test-password')
self.project = create_project(self.owner, name='BoomCast', git_repository_url='https://example.com/repo')
def test_default_card_and_revision_conflict(self):
card = create_card(self.owner, self.project, title='Field notes', markdown='# Notes\n\n```py\nprint(1)\n```')
self.assertEqual(card.priority, 'medium')
self.assertTrue(card.column.is_default)
self.assertEqual(CardRevision.objects.get(card=card).markdown, card.description_markdown)
update_card(self.owner, card, expected_revision=1, description_markdown='# Revised')
with self.assertRaises(RevisionConflict):
update_card(self.owner, card, expected_revision=1, description_markdown='# Overwritten')
self.assertEqual(Card.objects.get(pk=card.pk).description_markdown, '# Revised')
def test_idempotent_spec_creation(self):
first = create_card(self.owner, self.project, title='Spec', markdown='# Exact\n', idempotency_key='client-request-1')
second = create_card(self.owner, self.project, title='Spec', markdown='# Exact\n', idempotency_key='client-request-1')
self.assertEqual(first.pk, second.pk)
with self.assertRaises(ValidationError):
create_card(self.owner, self.project, title='Different', idempotency_key='client-request-1')
def test_access_and_move(self):
card = create_card(self.owner, self.project, title='A')
self.assertEqual(self.client.get(reverse('projects:board', args=[self.project.pk])).status_code, 302)
self.client.force_login(self.other)
self.assertEqual(self.client.get(reverse('projects:board', args=[self.project.pk])).status_code, 404)
self.client.force_login(self.owner)
done = self.project.board.columns.get(is_done=True)
move_card(self.owner, card, done)
card.refresh_from_db()
self.assertIsNotNone(card.completed_at)
def test_cross_project_move_preserves_identity_and_children_and_maps_project_data(self):
destination = create_project(self.owner, name='Destination')
card = create_card(self.owner, self.project, title='Keep me', markdown='# Keep this')
source_sibling = create_card(self.owner, self.project, title='Source sibling')
destination_sibling = create_card(self.owner, destination, title='Destination sibling')
original_updated_at = card.updated_at
card.assignee = self.other
card.save(update_fields=['assignee'])
Membership.objects.create(project=destination, user=self.other, role='viewer')
comment = CardComment.objects.create(card=card, author=self.owner, body='Progress note')
attachment = CardAttachment.objects.create(card=card, comment=comment, file='card-attachments/test.txt',
original_filename='test.txt', title='Source file', mime_type='text/plain', byte_size=4, sha256='a' * 64)
source_tag = Tag.objects.create(project=self.project, name='Roadmap')
target_tag = Tag.objects.create(project=destination, name='roadmap')
card.tags.add(source_tag)
old_activity = card.activity.first()
destination_column = destination.board.columns.get(is_default=True)
moved, result = move_card_to_project(self.owner, card, destination,
target_column=destination_column, expected_revision=card.revision, idempotency_key='move-preserve')
moved.refresh_from_db()
self.assertEqual(moved.pk, card.pk)
self.assertEqual(moved.project_id, destination.pk)
self.assertEqual(moved.column_id, destination_column.pk)
self.assertEqual(moved.position, 1)
source_sibling.refresh_from_db()
self.assertEqual(source_sibling.position, 0)
destination_sibling.refresh_from_db()
self.assertEqual(destination_sibling.position, 0)
self.assertEqual(moved.revision, card.revision + 1)
self.assertEqual(moved.description_markdown, '# Keep this')
self.assertEqual(moved.updated_at, original_updated_at)
self.assertEqual(moved.assignee_id, self.other.pk)
self.assertEqual(list(moved.revisions.order_by('revision').values_list('revision', flat=True)), [1, 2])
self.assertEqual(list(moved.tags.all()), [target_tag])
self.assertEqual(moved.comments.get(pk=comment.pk).body, 'Progress note')
self.assertEqual(moved.attachments.get(pk=attachment.pk).file.name, 'card-attachments/test.txt')
old_activity.refresh_from_db()
self.assertEqual(old_activity.project_id, destination.pk)
self.assertTrue(moved.activity.filter(action='card.moved_project').exists())
source_event = Activity.objects.get(project=self.project, action='card.moved_project_out')
self.assertEqual(source_event.detail['card_id'], str(card.pk))
self.assertEqual(result['source_project_id'], str(self.project.pk))
self.assertEqual(result['revision'], moved.revision)
def test_cross_project_move_clears_invalid_assignee_and_tags_with_warnings(self):
destination = create_project(self.owner, name='Destination')
card = create_card(self.owner, self.project, title='Transfer')
card.assignee = self.other
card.save(update_fields=['assignee'])
tag = Tag.objects.create(project=self.project, name='Only here')
card.tags.add(tag)
moved, result = move_card_to_project(self.owner, card, destination, expected_revision=card.revision)
self.assertIsNone(moved.assignee_id)
self.assertFalse(moved.tags.exists())
self.assertEqual(len(result['warnings']), 2)
def test_cross_project_move_validates_access_column_revision_and_idempotency(self):
destination = create_project(self.owner, name='Destination')
private_destination = create_project(self.other, name='Private destination')
archived_destination = create_project(self.owner, name='Archived destination')
archived_destination.archived = True
archived_destination.save(update_fields=['archived'])
card = create_card(self.owner, self.project, title='Transfer')
foreign_column = private_destination.board.columns.get(is_default=True)
with self.assertRaises(ValidationError):
move_card_to_project(self.owner, card, destination, target_column=foreign_column, expected_revision=1)
with self.assertRaises(RevisionConflict):
move_card_to_project(self.owner, card, destination, expected_revision=0)
with self.assertRaises(Http404):
move_card_to_project(self.owner, card, private_destination, expected_revision=1)
with self.assertRaises(ValidationError):
move_card_to_project(self.owner, card, archived_destination, expected_revision=1)
moved, _ = move_card_to_project(self.owner, card, destination, expected_revision=1, idempotency_key='retry-1')
replay, result = move_card_to_project(self.owner, card, destination, expected_revision=1, idempotency_key='retry-1')
self.assertEqual(replay.pk, moved.pk)
self.assertEqual(result['revision'], moved.revision)
with self.assertRaises(ValidationError):
move_card_to_project(self.owner, card, private_destination, expected_revision=1, idempotency_key='retry-1')
def test_cross_project_move_ui_requires_csrf_and_shows_success_or_stale_feedback(self):
destination = create_project(self.owner, name='Destination')
card = create_card(self.owner, self.project, title='Transfer')
browser = Client(enforce_csrf_checks=True)
browser.force_login(self.owner)
detail = browser.get(reverse('projects:card', args=[card.pk]))
self.assertContains(detail, 'Move to project')
self.assertContains(detail, 'Destination')
csrf = browser.cookies['csrftoken'].value
move_url = reverse('projects:card_move_project', args=[card.pk])
payload = {'target_project_id': str(destination.pk), 'target_column_id': '',
'expected_revision': str(card.revision), 'idempotency_key': 'web-move-1'}
self.assertEqual(browser.post(move_url, payload).status_code, 403)
stale = browser.post(move_url, {**payload, 'expected_revision': '0', 'idempotency_key': 'web-stale'}, HTTP_X_CSRFTOKEN=csrf)
self.assertEqual(stale.status_code, 302)
stale_detail = browser.get(reverse('projects:card', args=[card.pk]))
self.assertContains(stale_detail, 'This card changed before it could be moved.')
response = browser.post(move_url, payload, HTTP_X_CSRFTOKEN=csrf)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], reverse('projects:card', args=[card.pk]))
self.assertEqual(Card.objects.get(pk=card.pk).project_id, destination.pk)
self.assertContains(browser.get(reverse('projects:card', args=[card.pk])), 'Moved “Transfer” from BoomCast to Destination.')
def test_cross_project_move_rolls_back_when_revision_creation_fails(self):
destination = create_project(self.owner, name='Destination')
card = create_card(self.owner, self.project, title='Transfer')
with patch.object(CardRevision.objects, 'create', side_effect=RuntimeError('revision store unavailable')):
with self.assertRaises(RuntimeError):
move_card_to_project(self.owner, card, destination, expected_revision=card.revision)
card.refresh_from_db()
self.assertEqual(card.project_id, self.project.pk)
self.assertEqual(card.revision, 1)
self.assertFalse(Activity.objects.filter(action='card.moved_project_out').exists())
def test_board_filters_and_escaped_markdown(self):
card = create_card(self.owner, self.project, title='Danger', markdown='<script>alert(1)</script>\n\n# Safe')
self.client.force_login(self.owner)
response = self.client.get(reverse('projects:board', args=[self.project.pk]), {'priority': 'medium'})
visible = [card for column in response.context['columns'] for card in column.visible_cards]
self.assertEqual([item.pk for item in visible], [card.pk])
response = self.client.get(reverse('projects:board', args=[self.project.pk]), {'priority': 'high'})
visible = [item for column in response.context['columns'] for item in column.visible_cards]
self.assertEqual(visible, [])
response = self.client.get(reverse('projects:card', args=[card.pk]))
self.assertNotContains(response, '<script>alert(1)</script>', html=False)
self.assertContains(response, '<h1>Safe</h1>', html=False)
def test_board_archive_filter_and_mobile_filter_sheet(self):
active = create_card(self.owner, self.project, title='Active card')
archived = create_card(self.owner, self.project, title='Archived card')
archived.archived = True
archived.save(update_fields=['archived'])
self.client.force_login(self.owner)
response = self.client.get(reverse('projects:board', args=[self.project.pk]))
visible = [card for column in response.context['columns'] for card in column.visible_cards]
self.assertEqual([card.pk for card in visible], [active.pk])
self.assertContains(response, 'role="dialog"')
self.assertContains(response, 'Show archived cards')
response = self.client.get(reverse('projects:board', args=[self.project.pk]), {'archived': '1'})
visible = [card for column in response.context['columns'] for card in column.visible_cards]
self.assertEqual([card.pk for card in visible], [archived.pk])
def test_board_progress_is_zero_safe_and_activity_is_human_readable(self):
self.client.force_login(self.owner)
response = self.client.get(reverse('projects:board', args=[self.project.pk]))
self.assertEqual(response.context['progress_percent'], 0)
self.assertContains(response, '0 / 0')
card = create_card(self.owner, self.project, title='Timeline card')
for index in range(5):
Activity.objects.create(project=self.project, card=card, actor=self.owner,
action='card.moved', detail={'sequence': index})
response = self.client.get(reverse('projects:board', args=[self.project.pk]))
self.assertEqual(len(response.context['recent_activity']), 3)
self.assertGreater(len(response.context['older_activity']), 0)
self.assertContains(response, 'moved a card')
self.assertContains(response, 'View all')
def test_card_detail_uses_responsive_layout_and_readable_history(self):
card = create_card(self.owner, self.project, title='Detail view card', markdown='# Description\n\nCard detail text.')
self.client.force_login(self.owner)
response = self.client.get(reverse('projects:card', args=[card.pk]))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'projects/card_detail.css')
self.assertContains(response, 'Description')
self.assertContains(response, 'Card info')
self.assertContains(response, 'Progress notes')
self.assertContains(response, 'View raw Markdown')
self.assertContains(response, 'created this card')
self.assertContains(response, 'Edit card')
self.assertContains(response, 'Add a progress note')
def test_card_detail_preserves_viewer_read_only_permissions(self):
card = create_card(self.owner, self.project, title='Viewer detail card', markdown='Readable for the team.')
Membership.objects.create(project=self.project, user=self.other, role='viewer')
self.client.force_login(self.other)
response = self.client.get(reverse('projects:card', args=[card.pk]))
self.assertContains(response, 'Readable for the team.')
self.assertContains(response, 'Card info')
self.assertNotContains(response, 'Edit card')
self.assertNotContains(response, 'Add a progress note')
self.assertNotContains(response, 'Add card files')
def test_projects_index_preserves_search_access_and_archived_view(self):
finished = create_card(self.owner, self.project, title='Searchable milestone')
move_card(self.owner, finished, self.project.board.columns.get(is_done=True))
archived_card = create_card(self.owner, self.project, title='Old milestone')
archived_card.archived = True
archived_card.save(update_fields=['archived'])
private_project = create_project(self.other, name='Private workspace')
self.client.force_login(self.owner)
url = reverse('projects:list')
response = self.client.get(url)
self.assertContains(response, 'projects/project_list.css')
self.assertContains(response, 'BoomCast')
self.assertNotContains(response, 'Private workspace')
project = next(item for item in response.context['projects'] if item.pk == self.project.pk)
self.assertEqual(project.card_count, 2)
self.assertEqual(project.active_card_count, 1)
self.assertEqual(project.done_card_count, 1)
self.assertEqual(project.progress_percent, 100)
response = self.client.get(url, {'q': 'Searchable'})
self.assertContains(response, 'BoomCast')
self.assertContains(response, 'Open board')
response = self.client.get(url, {'q': 'Searchable'}, HTTP_HX_REQUEST='true')
self.assertContains(response, 'BoomCast')
self.assertEqual(response.context['query'], 'Searchable')
self.project.archived = True
self.project.save(update_fields=['archived'])
response = self.client.get(url, {'archived': '1'})
self.assertContains(response, 'Archived')
self.assertContains(response, 'BoomCast')
self.assertNotContains(response, 'Private workspace')
def test_completion_flag_updates_existing_cards(self):
card = create_card(self.owner, self.project, title='Complete later')
column = card.column
update_column(self.owner, column, is_done=True)
card.refresh_from_db()
self.assertIsNotNone(card.completed_at)
update_column(self.owner, column, is_done=False)
card.refresh_from_db()
self.assertIsNone(card.completed_at)
def test_preview_sanitizes_script(self):
self.client.force_login(self.owner)
response = self.client.post(reverse('projects:preview'), {'description_markdown': '# Hello\n\n<script>alert(1)</script>'})
self.assertEqual(response.status_code, 200)
self.assertIn('<h1>Hello</h1>', response.content.decode())
self.assertNotIn('<script>', response.content.decode())
def test_preview_renders_read_only_checklist(self):
self.client.force_login(self.owner)
response = self.client.post(reverse('projects:preview'), {'description_markdown': '- [ ] Pending\n- [x] Done'})
self.assertContains(response, '<input type="checkbox" disabled="">', html=False)
self.assertContains(response, '<input type="checkbox" disabled="" checked="">', html=False)
def test_existing_dashboard_requires_login(self):
self.assertEqual(self.client.get('/').status_code, 302)
self.client.force_login(self.owner)
self.assertEqual(self.client.get('/').status_code, 200)
def test_profile_timezone_applies_to_requests(self):
Profile.objects.create(user=self.owner, timezone='America/New_York')
observed = []
def capture(request):
observed.append(timezone.get_current_timezone_name())
return HttpResponse('ok')
request = type('Request', (), {'user': self.owner})()
response = ProfileTimezoneMiddleware(capture)(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(observed, ['America/New_York'])
self.assertEqual(timezone.get_current_timezone_name(), 'Europe/Amsterdam')
self.assertFalse(ProfileForm(data={'timezone': 'Not/A_Timezone'}).is_valid())
def test_profile_mcp_url_uses_validated_https_origin(self):
self.client.force_login(self.owner)
public = 'https://projects.jorendegraaf.eu/mcp'
headers = {'HTTP_HOST': 'projects.jorendegraaf.eu', 'HTTP_X_FORWARDED_PROTO': 'https'}
with override_settings(MCP_PUBLIC_URL='https://other.example/mcp'):
response = self.client.get(reverse('projects:profile'), **headers)
self.assertEqual(response.context['mcp_url'], public)
self.assertContains(response, 'This address differs from the configured OAuth resource URL.')
with override_settings(MCP_PUBLIC_URL=public, OAUTH_ISSUER_URL='https://projects.jorendegraaf.eu/'):
response = self.client.get(reverse('projects:profile'), **headers)
self.assertEqual(response.context['mcp_url'], public)
self.assertNotContains(response, 'This address differs from the configured OAuth resource URL.')
metadata = self.client.get('/.well-known/oauth-authorization-server', **headers).json()
self.assertEqual(metadata['issuer'], 'https://projects.jorendegraaf.eu/')
with override_settings(MCP_PUBLIC_URL='http://127.0.0.1:8766/mcp'):
local = self.client.get(reverse('projects:profile'), HTTP_HOST='127.0.0.1:8765')
self.assertEqual(local.context['mcp_url'], 'http://127.0.0.1:8766/mcp')
rejected = self.client.get(reverse('projects:profile'), HTTP_HOST='untrusted.example')
self.assertEqual(rejected.status_code, 400)
def test_login_throttles_failed_attempts(self):
for _ in range(5):
self.assertEqual(self.client.post('/accounts/login/', {'username': 'owner', 'password': 'wrong'}).status_code, 200)
self.assertEqual(self.client.post('/accounts/login/', {'username': 'owner', 'password': 'wrong'}).status_code, 429)
def test_viewer_can_read_but_cannot_move_or_edit(self):
Membership.objects.create(project=self.project, user=self.other, role='viewer')
card = create_card(self.owner, self.project, title='Visible')
self.client.force_login(self.other)
response = self.client.get(reverse('projects:board', args=[self.project.pk]))
self.assertContains(response, 'Visible')
self.assertNotContains(response, 'New card')
response = self.client.post(reverse('projects:card_move', args=[card.pk]), {'column_id': str(card.column_id)})
self.assertEqual(response.status_code, 403)
def test_bulk_preview_apply_and_idempotent_retry_for_twenty_cards(self):
cards = [create_card(self.owner, self.project, title=f'Card {number}') for number in range(21)]
ids = [str(card.pk) for card in cards]
revisions = {identifier: 1 for identifier in ids}
done = self.project.board.columns.get(is_done=True)
changes = {'column_id': str(done.pk), 'priority': 'high'}
preview = bulk_update_cards(self.owner, self.project, ids, revisions, changes, dry_run=True)
self.assertEqual(preview['changed_count'], 21)
self.assertEqual(CardRevision.objects.filter(card__in=cards).count(), 21)
result = bulk_update_cards(self.owner, self.project, ids, revisions, changes, idempotency_key='bulk-21')
self.assertEqual(result['changed_count'], 21)
self.assertEqual(Card.objects.filter(pk__in=ids, column=done, priority='high', revision=2).count(), 21)
self.assertEqual(CardRevision.objects.filter(card__in=cards).count(), 42)
self.assertEqual(Activity.objects.filter(card__in=cards, action='card.bulk_updated').count(), 21)
self.assertEqual(bulk_update_cards(self.owner, self.project, ids, revisions, changes, idempotency_key='bulk-21'), result)
self.assertEqual(Activity.objects.filter(card__in=cards, action='card.bulk_updated').count(), 21)
def test_bulk_rejects_duplicates_conflicts_cross_project_and_invalid_field(self):
first = create_card(self.owner, self.project, title='First')
second = create_card(self.owner, self.project, title='Second')
another = create_project(self.owner, name='Other board')
foreign = create_card(self.owner, another, title='Foreign')
ids = [str(first.pk), str(second.pk)]
revisions = {identifier: 1 for identifier in ids}
with self.assertRaises(ValidationError):
bulk_update_cards(self.owner, self.project, ids + ids[:1], revisions, {'priority': 'high'})
with self.assertRaises(ValidationError):
bulk_update_cards(self.owner, self.project, ids, {ids[0]: 0, ids[1]: 1}, {'priority': 'high'})
with self.assertRaises(ValidationError):
bulk_update_cards(self.owner, self.project, ids + [str(foreign.pk)], revisions, {'priority': 'high'})
with self.assertRaises(ValidationError):
bulk_update_cards(self.owner, self.project, ids, revisions, {'priority': 'high', 'tag_ids': [9999]})
self.assertEqual(Card.objects.filter(pk__in=ids, priority='medium').count(), 2)
def test_bulk_web_preview_and_apply(self):
card = create_card(self.owner, self.project, title='For bulk edit')
self.client.force_login(self.owner)
url = reverse('projects:cards_bulk_edit', args=[self.project.pk])
self.assertContains(self.client.get(url, {'card': str(card.pk)}), 'For bulk edit')
data = {'card': [str(card.pk)], 'expected_revisions': __import__('json').dumps({str(card.pk): 1}),
'change_priority': '1', 'priority': 'high', 'action': 'preview'}
response = self.client.post(url, data)
self.assertContains(response, 'Apply changes to 1 card')
card.refresh_from_db(); self.assertEqual(card.priority, 'medium')
data.update({'action': 'apply', 'preview_token': response.context['preview_token'], 'idempotency_key': 'web-bulk-1'})
self.assertContains(self.client.post(url, data), 'Updated 1 card')
card.refresh_from_db(); self.assertEqual(card.priority, 'high')
def test_bulk_rolls_back_if_a_write_fails(self):
cards = [create_card(self.owner, self.project, title=title) for title in ('A', 'B')]
ids = [str(card.pk) for card in cards]
revisions = {identifier: 1 for identifier in ids}
original = Activity.objects.create
calls = 0
def fail_on_second_bulk_activity(*args, **kwargs):
nonlocal calls
if kwargs.get('action') == 'card.bulk_updated':
calls += 1
if calls == 2:
raise RuntimeError('Simulated activity storage failure')
return original(*args, **kwargs)
with patch.object(Activity.objects, 'create', side_effect=fail_on_second_bulk_activity):
with self.assertRaises(RuntimeError):
bulk_update_cards(self.owner, self.project, ids, revisions, {'priority': 'high'}, idempotency_key='rollback-check')
self.assertEqual(Card.objects.filter(pk__in=ids, priority='medium', revision=1).count(), 2)
self.assertEqual(CardRevision.objects.filter(card__in=cards).count(), 2)
self.assertEqual(Activity.objects.filter(card__in=cards, action='card.bulk_updated').count(), 0)