def test_put_with_revoke_ship_it_and_revoke_error(self):
        """Testing the PUT <URL> API with revoking Ship It and handling a
        revocation error
        """
        def on_revoking(**kwargs):
            raise Exception('oh no')

        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request,
                                    user=self.user,
                                    ship_it=True,
                                    publish=True)

        try:
            review_ship_it_revoking.connect(on_revoking)

            rsp = self.api_put(
                get_review_item_url(review_request, review.pk),
                {'ship_it': False},
                expected_status=500)
        finally:
            review_ship_it_revoking.disconnect(on_revoking)

        self.assertEqual(rsp['err']['code'], REVOKE_SHIP_IT_ERROR.code)
        self.assertEqual(rsp['err']['msg'],
                         'Error revoking the Ship It: oh no')

    def test_put_publish(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/?public=1 API"""
        body_top = "My Body Top"
        body_bottom = ""
        ship_it = True

        self.siteconfig.set("mail_send_review_mail", True)
        self.siteconfig.save()

        review_request = self.create_review_request(publish=True)
        mail.outbox = []

        review = self.create_review(review_request, user=self.user)

        self.apiPut(
            get_review_item_url(review_request, review.pk),
            {"public": True, "ship_it": ship_it, "body_top": body_top, "body_bottom": body_bottom},
            expected_mimetype=review_item_mimetype,
        )

        reviews = review_request.reviews.filter(user=self.user)
        self.assertEqual(len(reviews), 1)
        review = reviews[0]

        self.assertEqual(review.ship_it, ship_it)
        self.assertEqual(review.body_top, body_top)
        self.assertEqual(review.body_bottom, body_bottom)
        self.assertEqual(review.public, True)

        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(
            mail.outbox[0].subject, "Re: Review Request %s: %s" % (review_request.display_id, review_request.summary)
        )
        self.assertValidRecipients([review_request.submitter.username, self.user.username])

    def test_delete_review_with_does_not_exist(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/ API with Does Not Exist error"""
        review_request = self.create_review_request(publish=True)

        rsp = self.apiDelete(get_review_item_url(review_request, 919239),
                             expected_status=404)
        self.assertEqual(rsp['stat'], 'fail')
        self.assertEqual(rsp['err']['code'], DOES_NOT_EXIST.code)

    def test_get_not_modified(self):
        """Testing the GET review-requests/<id>/reviews/<id>/ API
        with Not Modified response
        """
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request, publish=True)

        self._testHttpCaching(get_review_item_url(review_request, review.pk), check_last_modified=True)

    def test_put_with_published_review(self):
        """Testing the PUT review-requests/<id>/reviews/<id>/ API
        with pre-published review
        """
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request, user=self.user, publish=True)

        self.apiPut(get_review_item_url(review_request, review.id), {"ship_it": True}, expected_status=403)

    def test_delete_review(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/ API"""
        # Set up the draft to delete.
        review = self.test_put_review()
        review_request = review.review_request

        self.apiDelete(get_review_item_url(review_request, review.id))
        self.assertEqual(review_request.reviews.count(), 0)

    def test_delete_with_published_review(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/ API
        with pre-published review
        """
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request, user=self.user, publish=True)

        self.apiDelete(get_review_item_url(review_request, review.id), expected_status=403)
        self.assertEqual(review_request.reviews.count(), 1)

    def test_delete_review_with_local_site(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/ API with a local site"""
        review = self.test_put_review_with_site()

        local_site = LocalSite.objects.get(name=self.local_site_name)
        review_request = ReviewRequest.objects.public(local_site=local_site)[0]

        self.apiDelete(get_review_item_url(review_request, review.id,
                                           self.local_site_name))
        self.assertEqual(review_request.reviews.count(), 0)

    def setup_basic_delete_test(self, user, with_local_site, local_site_name):
        review_request = self.create_review_request(
            with_local_site=with_local_site,
            submitter=user,
            publish=True)
        review = self.create_review(review_request, user=user)

        return (get_review_item_url(review_request, review.pk,
                                    local_site_name),
                [review, review_request])

    def setup_basic_put_test(self, user, with_local_site, local_site_name, put_valid_data):
        review_request = self.create_review_request(with_local_site=with_local_site, submitter=user, publish=True)
        review = self.create_review(review_request, user=user)

        return (
            get_review_item_url(review_request, review.pk, local_site_name),
            review_item_mimetype,
            {"body_top": "New body top"},
            review,
            [],
        )

    def test_delete_review_with_local_site_no_access(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/ API with a local site and Permission Denied error"""
        review_request = self.create_review_request(with_local_site=True,
                                                    publish=True)
        review = self.create_review(review_request, username='doc')

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

    def compare_item(self, item_rsp, status_update):
        self.assertEqual(item_rsp['id'], status_update.pk)

        if status_update.review_id:
            review_request = status_update.review_request
            local_site_name = (review_request.local_site and
                               review_request.local_site.name)

            review_url = self.base_url + get_review_item_url(
                review_request, status_update.review_id, local_site_name)

            self.assertEqual(item_rsp['links']['review']['href'], review_url)

    def test_put_with_revoke_ship_it_and_no_permission(self):
        """Testing the PUT <URL> API with revoking Ship It and no permission"""
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request,
                                    ship_it=True,
                                    publish=True)
        self.assertNotEqual(review.user, self.user)

        rsp = self.api_put(
            get_review_item_url(review_request, review.pk),
            {'ship_it': False},
            expected_status=403)
        self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)

    def test_delete_review_with_permission_denied(self):
        """Testing the DELETE review-requests/<id>/reviews/<id>/ API with Permission Denied error"""
        # Set up the draft to delete.
        review = self.test_put_review()
        review.user = User.objects.get(username='doc')
        review.save()

        review_request = review.review_request
        old_count = review_request.reviews.count()

        self.apiDelete(get_review_item_url(review_request, review.id),
                       expected_status=403)
        self.assertEqual(review_request.reviews.count(), old_count)

    def test_put_revoke_ship_it_timestamp(self):
        """Testing the PUT <URL> API with revoking Ship It does not update
        timestamp
        """
        # ReviewRequest.last_update is a
        # django.db.fields.ModificationTimestampField, which retrieves its
        # value from datetime.utcnow().replace(tzinfo=utc).
        #
        # django.utils.timezone.now has the same implementation.
        #
        # Unfortunately, we cannot spy on datetime.utcnow since it is a
        # builtin. So we replace get_tz_aware_utcnow with timezone.now and we
        # will replace that with a constant function in the spy_on calls below.
        self.spy_on(get_tz_aware_utcnow, call_fake=lambda: timezone.now())
        creation_timestamp = datetime.fromtimestamp(0, timezone.utc)
        review_timestamp = creation_timestamp + timedelta(hours=1)
        revoke_timestamp = review_timestamp + timedelta(hours=1)

        with spy_on(timezone.now, call_fake=lambda: creation_timestamp):
            review_request = self.create_review_request(publish=True,
                                                        submitter=self.user)

        with spy_on(timezone.now, call_fake=lambda: review_timestamp):
            review = self.create_review(review_request,
                                        body_top=Review.SHIP_IT_TEXT,
                                        ship_it=True,
                                        publish=True,
                                        user=self.user)

        review_request = ReviewRequest.objects.get(pk=review_request.pk)

        self.assertEqual(review_request.time_added, creation_timestamp)
        self.assertEqual(review_request.last_updated, review_timestamp)
        self.assertEqual(review.timestamp, review_timestamp)

        with spy_on(timezone.now, call_fake=lambda: revoke_timestamp):
            rsp = self.api_put(
                get_review_item_url(review_request, review.pk),
                {'ship_it': False},
                expected_mimetype=review_item_mimetype,
            )

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

        review = Review.objects.get(pk=review.pk)
        review_request = ReviewRequest.objects.get(pk=review_request.pk)

        self.assertEqual(review_request.time_added, creation_timestamp)
        self.assertEqual(review_request.last_updated, review_timestamp)
        self.assertEqual(review.timestamp, review_timestamp)

    def test_put_with_public_and_ship_it_true(self):
        """Testing the PUT <URL> API with pre-published review and
        ship_it=true
        """
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request,
                                    user=self.user,
                                    publish=True)

        rsp = self.api_put(
            get_review_item_url(review_request, review.pk),
            {'ship_it': True},
            expected_status=400)
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
        self.assertEqual(rsp['fields'], {
            'ship_it': 'Published reviews cannot be updated with ship_it=true',
        })

    def test_put_with_revoke_ship_it_and_not_ship_it(self):
        """Testing the PUT <URL> API with revoking Ship It on a review not
        marked Ship It
        """
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request,
                                    user=self.user,
                                    publish=True)

        rsp = self.api_put(
            get_review_item_url(review_request, review.pk),
            {'ship_it': False},
            expected_status=400)
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
        self.assertEqual(rsp['fields'], {
            'ship_it': 'This review is not marked Ship It!',
        })

    def test_put_with_revoke_ship_it(self):
        """Testing the PUT <URL> API with revoking Ship It
        """
        review_request = self.create_review_request(publish=True)
        review = self.create_review(review_request,
                                    user=self.user,
                                    body_top=Review.SHIP_IT_TEXT,
                                    ship_it=True,
                                    publish=True)

        rsp = self.api_put(
            get_review_item_url(review_request, review.pk),
            {'ship_it': False},
            expected_mimetype=review_item_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['review']['body_top'],
                         Review.REVOKED_SHIP_IT_TEXT)
        self.assertFalse(rsp['review']['ship_it'])
        self.assertTrue(rsp['review']['extra_data'].get('revoked_ship_it'))

    def test_post_reviews(self):
        """Testing the POST review-requests/<id>/reviews/ API"""
        body_top = ""
        body_bottom = "My Body Bottom"
        ship_it = True

        review_request = self.create_review_request(publish=True)
        mail.outbox = []

        rsp, response = self.api_post_with_response(
            get_review_list_url(review_request),
            {
                'ship_it': ship_it,
                'body_top': body_top,
                'body_bottom': body_bottom,
            },
            expected_mimetype=self.item_mimetype)

        self.assertTrue('stat' in rsp)
        self.assertEqual(rsp['stat'], 'ok')
        self.assertTrue('Location' in response)

        reviews = review_request.reviews.filter(user=self.user)
        self.assertEqual(len(reviews), 1)
        review = reviews[0]

        self.assertEqual(response['Location'],
                         self.base_url +
                         get_review_item_url(review_request, review.id))

        self.assertEqual(review.ship_it, ship_it)
        self.assertEqual(review.body_top, body_top)
        self.assertEqual(review.body_bottom, body_bottom)
        self.assertEqual(review.public, False)

        self.assertEqual(len(mail.outbox), 0)

    def setup_review_request_child_test(self, review_request):
        review = self.create_review(review_request, publish=True)

        return (get_review_item_url(review_request, review.pk), review_item_mimetype)