411 lines
26 KiB
Python
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)
|