def test_get_diff_comment_not_modified(self):
        """Testing the GET review-requests/<id>/reviews/<id>/diff-comments/<id>/ API with Not Modified response"""
        review = self._create_diff_review()
        comment = Comment.objects.all()[0]

        self._testHttpCaching(
            get_review_diff_comment_item_url(review, comment.id),
            check_last_modified=True)

    def test_delete_diff_comment_with_site(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/diff-comments/<id>/ API with a local site"""
        review = self.test_post_diff_comments_with_site()
        comment = review.comments.all()[0]
        comment_count = review.comments.count()

        self.apiDelete(get_review_diff_comment_item_url(review, comment.id,
                                                        self.local_site_name))

        self.assertEqual(review.comments.count(), comment_count - 1)

    def test_remove_issue_opened(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API, removing the issue_opened state"""
        comment, review, review_request = self._create_diff_review_with_issue()

        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {'issue_opened': False},
            expected_mimetype=review_diff_comment_item_mimetype)
        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['diff_comment']['issue_status'], '')

    def setup_basic_delete_test(self, user, with_local_site, local_site_name):
        review_request = self.create_review_request(
            create_repository=True, with_local_site=with_local_site, submitter=user, publish=True
        )
        diffset = self.create_diffset(review_request)
        filediff = self.create_filediff(diffset)
        review = self.create_review(review_request, user=user)
        comment = self.create_diff_comment(review, filediff)

        return (get_review_diff_comment_item_url(review, comment.pk, local_site_name), [comment, review])

    def test_update_diff_comment_issue_status_after_publish(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API with an issue, after review is published"""
        comment, review, review_request = self._create_diff_review_with_issue(
            publish=True)

        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {'issue_status': 'resolved'},
            expected_mimetype=review_diff_comment_item_mimetype)
        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['diff_comment']['issue_status'], 'resolved')

    def setup_review_request_child_test(self, review_request):
        if not review_request.repository_id:
            # The group tests don't create a repository by default.
            review_request.repository = self.create_repository()
            review_request.save()

        diffset = self.create_diffset(review_request)
        filediff = self.create_filediff(diffset)
        review = self.create_review(review_request, publish=True)
        comment = self.create_diff_comment(review, filediff)

        return (get_review_diff_comment_item_url(review, comment.pk), review_diff_comment_item_mimetype)

    def test_delete_diff_comment_with_site_no_access(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/diff-comments/<id>/ API with a local site and Permission Denied error"""
        review = self.test_post_diff_comments_with_site()
        comment = review.comments.all()[0]

        self._login_user()

        rsp = self.apiDelete(
            get_review_diff_comment_item_url(review, comment.id,
                                             self.local_site_name),
            expected_status=403)
        self.assertEqual(rsp['stat'], 'fail')
        self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)

    def test_update_diff_comment_issue_status_before_publish(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API with an issue, before review is published"""
        comment, review, review_request = self._create_diff_review_with_issue()

        # The issue_status should not be able to be changed while the review is
        # unpublished.
        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {'issue_status': 'resolved'},
            expected_mimetype=review_diff_comment_item_mimetype)
        self.assertEqual(rsp['stat'], 'ok')

        # The issue_status should still be "open"
        self.assertEqual(rsp['diff_comment']['issue_status'], 'open')

    def test_delete_diff_comment_with_interdiff(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/diff-comments/<id>/ API"""
        comment_text = "This is a test comment."

        comment, review_request, review, interdiff_revision = \
            self._common_post_interdiff_comments(comment_text)

        self.apiDelete(get_review_diff_comment_item_url(review, comment.pk))

        rsp = self.apiGet(get_review_diff_comment_list_url(review),
                          expected_mimetype=review_diff_comment_list_mimetype)
        self.assertEqual(rsp['stat'], 'ok')
        self.assertTrue('diff_comments' in rsp)
        self.assertEqual(len(rsp['diff_comments']), 0)

    def test_put_with_remove_issue_opened(self):
        """Testing the
        PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API,
        removing the issue_opened state
        """
        comment, review, review_request = self._create_diff_review_with_issue()

        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {"issue_opened": False},
            expected_mimetype=review_diff_comment_item_mimetype,
        )
        self.assertEqual(rsp["stat"], "ok")
        self.assertEqual(rsp["diff_comment"]["issue_status"], "")

    def test_put_issue_status_after_publish(self):
        """Testing the
        PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API
        with an issue, after review is published
        """
        comment, review, review_request = self._create_diff_review_with_issue(publish=True)

        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {"issue_status": "resolved"},
            expected_mimetype=review_diff_comment_item_mimetype,
        )
        self.assertEqual(rsp["stat"], "ok")
        self.assertEqual(rsp["diff_comment"]["issue_status"], "resolved")

    def setup_basic_put_test(self, user, with_local_site, local_site_name, put_valid_data):
        review_request = self.create_review_request(
            create_repository=True, with_local_site=with_local_site, submitter=user, publish=True
        )
        diffset = self.create_diffset(review_request)
        filediff = self.create_filediff(diffset)
        review = self.create_review(review_request, user=user)
        comment = self.create_diff_comment(review, filediff)

        return (
            get_review_diff_comment_item_url(review, comment.pk, local_site_name),
            review_diff_comment_item_mimetype,
            {"text": "My new text"},
            comment,
            [],
        )

    def test_delete_with_site(self):
        """Testing the
        DELETE review-requests/<id>/reviews/<id>/diff-comments/<id>/ API
        with a local site
        """
        review_request, filediff = \
            self._create_diff_review_request(with_local_site=True)
        user = self._login_user(local_site=True)
        review = self.create_review(review_request, user=user)
        comment = self.create_diff_comment(review, filediff)

        self.assertEqual(review.comments.count(), 1)

        self.apiDelete(get_review_diff_comment_item_url(review, comment.pk,
                                                        self.local_site_name))

        self.assertEqual(review.comments.count(), 0)

    def test_put_issue_status_before_publish(self):
        """Testing the
        PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API
        with an issue, before review is published
        """
        comment, review, review_request = self._create_diff_review_with_issue()

        # The issue_status should not be able to be changed while the review is
        # unpublished.
        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {"issue_status": "resolved"},
            expected_mimetype=review_diff_comment_item_mimetype,
        )
        self.assertEqual(rsp["stat"], "ok")

        # The issue_status should still be "open"
        self.assertEqual(rsp["diff_comment"]["issue_status"], "open")

    def test_update_diff_comment_issue_status_by_issue_creator(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API permissions for issue creator"""
        comment, review, review_request = self._create_diff_review_with_issue(
            publish=True)

        # Change the owner of the review request so that it's not owned by
        # self.user.
        review_request.submitter = User.objects.get(username='doc')
        review_request.save()

        # The review/comment (and therefore issue) is still owned by self.user,
        # so we should be able to change the issue status.
        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {'issue_status': 'dropped'},
            expected_mimetype=review_diff_comment_item_mimetype)
        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['diff_comment']['issue_status'], 'dropped')

    def test_update_diff_comment_issue_status_by_uninvolved_user(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API permissions for an uninvolved user"""
        comment, review, review_request = self._create_diff_review_with_issue(
            publish=True)

        # Change the owner of the review request and review so that they're
        # not owned by self.user.
        new_owner = User.objects.get(username='doc')
        review_request.submitter = new_owner
        review_request.save()
        review.user = new_owner
        review.save()

        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.id),
            {'issue_status': 'dropped'},
            expected_status=403)
        self.assertEqual(rsp['stat'], 'fail')
        self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)

    def test_delete_with_site_no_access(self):
        """Testing the
        DELETE review-requests/<id>/reviews/<id>/diff-comments/<id>/ API
        with a local site and Permission Denied error
        """
        review_request, filediff = \
            self._create_diff_review_request(with_local_site=True)
        user = self._login_user(local_site=True)
        review = self.create_review(review_request, user=user)
        comment = self.create_diff_comment(review, filediff)

        self._login_user()

        rsp = self.apiDelete(
            get_review_diff_comment_item_url(review, comment.id,
                                             self.local_site_name),
            expected_status=403)
        self.assertEqual(rsp['stat'], 'fail')
        self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)

    def test_put_with_extra_fields(self):
        """Testing the
        PUT review-requests/<id>/reviews/<id>/diff-comments/<id>/ API
        with extra fields
        """
        extra_fields = {
            'extra_data.foo': 'abc',
            'extra_data.bar': '',
            'ignored': 'foo',
        }

        comment_text = "This is a test comment."

        review_request = self.create_review_request(create_repository=True,
                                                    submitter=self.user,
                                                    publish=True)
        diffset = self.create_diffset(review_request)
        filediff = self.create_filediff(diffset)
        review = self.create_review(review_request, user=self.user)
        comment = self.create_diff_comment(
            review,
            filediff,
            text=comment_text,
            extra_fields={
                'foo': '123',
                'bar': '456',
            })

        rsp = self.apiPut(
            get_review_diff_comment_item_url(review, comment.pk),
            extra_fields,
            expected_mimetype=review_diff_comment_item_mimetype)
        self.assertEqual(rsp['stat'], 'ok')

        comment = Comment.objects.get(pk=rsp['diff_comment']['id'])

        self.assertTrue('foo' in comment.extra_data)
        self.assertFalse('bar' in comment.extra_data)
        self.assertFalse('ignored' in comment.extra_data)
        self.assertEqual(len(comment.extra_data), 1)
        self.assertEqual(comment.extra_data['foo'],
                         extra_fields['extra_data.foo'])

    def test_get_with_dvcs_enabled(self):
        """Testing the GET <URL> API when DVCS feature enabled"""
        with override_feature_check(dvcs_feature.feature_id, enabled=True):
            review_request = self.create_review_request(
                create_repository=True,
                publish=True)

            diffset = self.create_diffset(review_request)
            commit = self.create_diffcommit(diffset=diffset)

            filediff = self.create_filediff(diffset=diffset, commit=commit)

            review = self.create_review(review_request, user=self.user)
            comment = self.create_diff_comment(review, filediff)

            rsp = self.api_get(
                get_review_diff_comment_item_url(review, comment.pk),
                expected_mimetype=review_diff_comment_item_mimetype)

            self.assertEqual(rsp['stat'], 'ok')
            self.assertIn('diff_comment', rsp)

            item_rsp = rsp['diff_comment']
            self.compare_item(item_rsp, comment)