def setUp(self):
homepage = Page.objects.get(url_path='/home/').specific
self.page = homepage.add_child(instance=SimplePage(
title="A simple page"))
self.page_revision = self.page.save_revision()
self.reviewer = ReviewerFactory.create_external()
self.token = Token(self.reviewer, self.page_revision)
self.share = Share.objects.create(
external_user=self.reviewer.external,
page=self.page,
can_comment=True,
shared_by=User.objects.get(username="******"),
)
def test_post_review_token_for_different_task(self):
# This may happen if someone uses an old token (clicked from email history) and the page happens
# to be in another review task
past_workflow_state = WorkflowState.objects.create(
workflow=self.workflow,
page=self.page_revision.page,
status=WorkflowState.STATUS_APPROVED,
)
past_task_state = ReviewTaskState.objects.create(
workflow_state=past_workflow_state,
task=self.workflow_task,
page_revision=self.page_revision,
status=ReviewTaskState.STATUS_APPROVED,
)
past_workflow_state.current_task_state = past_task_state
past_workflow_state.save(update_fields=['current_task_state'])
post_data = {
'taskAction': 'approve',
'comment': "This is the comment",
}
response = self.client.post(reverse('wagtail_review:api:respond'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
past_task_state).encode())
self.assertEqual(response.status_code, 403)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(
response.json(),
{'detail': "The provided token isn't for the current task."})
def test_post_new_comment(self):
post_data = {
'quote': "This is a test",
'text': "blah blah blah",
'content_path': "title",
'start_xpath': "/foo",
'start_offset': 1,
'end_xpath': "/foo",
'end_offset': 10,
}
response = self.client.post(reverse('wagtail_review:api:comment_list'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 201)
self.assertEqual(response['Content-Type'], 'application/json')
comment = Comment.objects.get(text="blah blah blah")
check_comment_api_representation(self, comment, response.json())
self.assertEqual(comment.page_revision, self.page_revision)
self.assertEqual(comment.reviewer, self.reviewer)
def setUp(self):
homepage = Page.objects.get(url_path='/home/').specific
self.page = homepage.add_child(instance=SimplePage(
title="A simple page"))
self.page_revision = self.page.save_revision()
self.reviewer = ReviewerFactory.create_external()
self.token = Token(self.reviewer, self.page_revision)
self.share = Share.objects.create(
external_user=self.reviewer.external,
page=self.page,
can_comment=True,
shared_by=User.objects.get(username="******"),
)
# Need to update site record so the hostname matches what Django will sent to the view
# This prevents a 400 (Bad Request) error when the preview is generated
Site.objects.update(hostname="testserver")
def test_can_unresolve_comment_from_another_reviewer(self):
response = self.client.delete(
reverse('wagtail_review:api:comment_resolved',
args=[self.comment_from_another_reviewer.id]),
HTTP_X_REVIEW_TOKEN=Token(self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 200)
def test_delete_comment(self):
response = self.client.delete(reverse('wagtail_review:api:comment',
args=[self.comment.id]),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 204)
self.assertFalse(Comment.objects.filter(id=self.comment.id).exists())
class TestReviewView(TestCase):
fixtures = ['test.json']
def setUp(self):
homepage = Page.objects.get(url_path='/home/').specific
self.page = homepage.add_child(instance=SimplePage(
title="A simple page"))
self.page_revision = self.page.save_revision()
self.reviewer = ReviewerFactory.create_external()
self.token = Token(self.reviewer, self.page_revision)
self.share = Share.objects.create(
external_user=self.reviewer.external,
page=self.page,
can_comment=True,
shared_by=User.objects.get(username="******"),
)
# Need to update site record so the hostname matches what Django will sent to the view
# This prevents a 400 (Bad Request) error when the preview is generated
Site.objects.update(hostname="testserver")
def test_get_review(self):
response = self.client.get(
reverse('wagtail_review:review', args=[self.token.encode()]))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'tests/simple_page.html')
self.share.refresh_from_db()
self.assertTrue(self.share.first_accessed_at)
self.assertTrue(self.share.last_accessed_at)
def test_get_review_without_share(self):
self.share.delete()
response = self.client.get(
reverse('wagtail_review:review', args=[self.token.encode()]))
self.assertEqual(response.status_code, 403)
def test_get_review_with_expired_share(self):
self.share.expires_at = timezone.now()
self.share.save()
response = self.client.get(
reverse('wagtail_review:review', args=[self.token.encode()]))
self.assertEqual(response.status_code, 403)
def test_get_reply_comment_id_must_be_correct_in_url(self):
response = self.client.get(
reverse('wagtail_review:api:commentreply',
args=[self.other_comment.id, self.reply.id]),
HTTP_X_REVIEW_TOKEN=Token(self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 404)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.json(), {'detail': 'Not found.'})
def test_cant_unresolve_comment_on_another_revision(self):
response = self.client.delete(
reverse('wagtail_review:api:comment_resolved',
args=[self.comment_on_another_revision.id]),
HTTP_X_REVIEW_TOKEN=Token(self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 404)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.json(), {'detail': 'Not found.'})
def test_get_without_comments(self):
Share.objects.update(can_comment=False)
response = self.client.get(reverse('wagtail_review:api:base'),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertFalse(response.json()['can_comment'])
self.assertFalse(response.json()['can_review'])
def test_get_comment(self):
response = self.client.get(reverse('wagtail_review:api:comment',
args=[self.comment.id]),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
check_comment_api_representation(self, self.comment, response.json())
def test_cant_delete_comment_from_another_reviewer(self):
response = self.client.delete(
reverse('wagtail_review:api:comment',
args=[self.comment_from_another_reviewer.id]),
HTTP_X_REVIEW_TOKEN=Token(self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 403)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(
response.json(),
{'detail': 'You do not have permission to perform this action.'})
def test_get_comments(self):
response = self.client.get(reverse('wagtail_review:api:comment_list'),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(set(comment['id'] for comment in response.json()),
{self.comment_a.id, self.comment_b.id})
check_comment_api_representation(self, self.comment_a,
response.json()[0])
def test_post_long_comment(self):
post_data = {
'status': 'approved',
'comment': "A" * 201,
}
response = self.client.post(reverse('wagtail_review:api:respond'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
self.review_request).encode())
self.assertEqual(response.status_code, 400)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.json(), {'comment': ['TODO']})
def test_get_with_review_request(self):
review_request = ReviewRequest.objects.create(
page_revision=self.page_revision,
submitted_by=User.objects.get(username="******"),
)
response = self.client.get(reverse('wagtail_review:api:base'),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
review_request).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertTrue(response.json()['can_comment'])
self.assertTrue(response.json()['can_review'])
def test_post_invalid_status(self):
post_data = {
'status': 'foo',
'comment': "This is the comment",
}
response = self.client.post(reverse('wagtail_review:api:respond'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
self.review_request).encode())
self.assertEqual(response.status_code, 400)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.json(),
{'status': ['"foo" is not a valid choice.']})
def test_post_invalid_action(self):
post_data = {
'taskAction': 'foo',
'comment': "This is the comment",
}
response = self.client.post(reverse('wagtail_review:api:respond'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
self.task_state).encode())
self.assertEqual(response.status_code, 403)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(
response.json(),
{'detail': 'You do not have permission to perform this action.'})
def test_get(self):
response = self.client.get(reverse('wagtail_review:api:base'),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(
response.json(), {
'you': {
'id': self.reviewer.id,
'name': self.reviewer.get_name(),
},
'can_comment': True,
'can_review': False,
})
def test_update_comment(self):
data = self.get_update_comment_data()
previous_updated_at = self.comment.updated_at
response = self.client.put(reverse('wagtail_review:api:comment',
args=[self.comment.id]),
data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.comment.refresh_from_db()
self.assertEqual(self.comment.text, "This is the new text")
self.assertNotEqual(self.comment.updated_at, previous_updated_at)
def test_post_needs_changes_response(self):
post_data = {
'taskAction': 'reject',
'comment': "This is the comment",
}
response = self.client.post(reverse('wagtail_review:api:respond'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
self.task_state).encode())
self.assertEqual(response.status_code, 200)
self.task_state.refresh_from_db()
self.assertEqual(self.task_state.reviewer, self.reviewer)
self.assertTrue(self.task_state.finished_at)
self.assertEqual(self.task_state.status, 'rejected')
self.assertEqual(self.task_state.comment, "This is the comment")
def test_post_new_reply(self):
post_data = {
'text': "blah blah blah",
}
response = self.client.post(
reverse('wagtail_review:api:commentreply_list',
args=[self.comment.id]),
post_data,
HTTP_X_REVIEW_TOKEN=Token(self.reviewer,
self.page_revision).encode())
self.assertEqual(response.status_code, 201)
self.assertEqual(response['Content-Type'], 'application/json')
reply = CommentReply.objects.get(text="blah blah blah")
check_comment_reply_api_representation(self, reply, response.json())
self.assertEqual(reply.comment, self.comment)
self.assertEqual(reply.reviewer, self.reviewer)
def test_post_needs_changes_response(self):
post_data = {
'status': 'needs-changes',
'comment': "This is the comment",
}
response = self.client.post(reverse('wagtail_review:api:respond'),
post_data,
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
self.review_request).encode())
self.assertEqual(response.status_code, 201)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(response.json(), {
'comment': 'This is the comment',
'status': 'needs-changes'
})
review_reponse = ReviewResponse.objects.get()
self.assertEqual(review_reponse.request, self.review_request)
self.assertEqual(review_reponse.submitted_by, self.reviewer)
self.assertEqual(review_reponse.status, 'needs-changes')
self.assertEqual(review_reponse.comment, "This is the comment")
def test_get_with_task_state(self):
workflow_state = WorkflowState.objects.create(
workflow=self.workflow,
page=self.page_revision.page,
)
task_state = ReviewTaskState.objects.create(
workflow_state=workflow_state,
task=self.workflow_task,
page_revision=self.page_revision,
)
workflow_state.current_task_state = task_state
workflow_state.save(update_fields=['current_task_state'])
response = self.client.get(reverse('wagtail_review:api:base'),
HTTP_X_REVIEW_TOKEN=Token(
self.reviewer, self.page_revision,
task_state).encode())
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertTrue(response.json()['can_comment'])
self.assertTrue(response.json()['can_review'])
