diff --git a/reviewboard/reviews/models/review_request.py b/reviewboard/reviews/models/review_request.py
index c42ad9afdd6528ae7354c554e6daf1906d09fa49..2cd53a8c249fafe1e48a38382e07c987d6fd0383 100644
--- a/reviewboard/reviews/models/review_request.py
+++ b/reviewboard/reviews/models/review_request.py
@@ -575,23 +575,8 @@ class ReviewRequest(BaseReviewRequestDetails):
         if self.status == self.PENDING_REVIEW:
             site_profile.decrement_pending_outgoing_request_count()
 
-        if self.public:
-            people = self.target_people.all()
-            groups = self.target_groups.all()
-
-            Group.incoming_request_count.decrement(groups)
-            LocalSiteProfile.direct_incoming_request_count.decrement(
-                LocalSiteProfile.objects.filter(user__in=people,
-                                                local_site=local_site))
-            LocalSiteProfile.total_incoming_request_count.decrement(
-                LocalSiteProfile.objects.filter(
-                    Q(local_site=local_site) &
-                    Q(Q(user__review_groups__in=groups) |
-                      Q(user__in=people))))
-            LocalSiteProfile.starred_public_request_count.decrement(
-                LocalSiteProfile.objects.filter(
-                    profile__starred_review_requests=self,
-                    local_site=local_site))
+            if self.public:
+                self._decrement_reviewer_counts()
 
         super(ReviewRequest, self).delete(**kwargs)
 
@@ -683,8 +668,6 @@ class ReviewRequest(BaseReviewRequestDetails):
         The review request will be mark as public, and signals will be
         emitted for any listeners.
         """
-        from reviewboard.accounts.models import LocalSiteProfile
-
         if not self.is_mutable_by(user):
             raise PermissionError
 
@@ -701,20 +684,7 @@ class ReviewRequest(BaseReviewRequestDetails):
         # Decrement should not happen while publishing
         # a new request or a discarded request
         if self.public:
-            Group.incoming_request_count.decrement(self.target_groups.all())
-            LocalSiteProfile.direct_incoming_request_count.decrement(
-                LocalSiteProfile.objects.filter(
-                    user__in=self.target_people.all(),
-                    local_site=self.local_site))
-            LocalSiteProfile.total_incoming_request_count.decrement(
-                LocalSiteProfile.objects.filter(
-                    Q(local_site=self.local_site) &
-                    Q(Q(user__review_groups__in=self.target_groups.all()) |
-                      Q(user__in=self.target_people.all()))))
-            LocalSiteProfile.starred_public_request_count.decrement(
-                LocalSiteProfile.objects.filter(
-                    profile__starred_review_requests=self,
-                    local_site=self.local_site))
+            self._decrement_reviewer_counts()
 
         if draft is not None:
             # This will in turn save the review request, so we'll be done.
@@ -772,43 +742,54 @@ class ReviewRequest(BaseReviewRequestDetails):
                 site_profile.increment_pending_outgoing_request_count()
 
             if self.public and self.id is not None:
-                groups = self.target_groups.all()
-                people = self.target_people.all()
-
-                Group.incoming_request_count.increment(groups)
-                LocalSiteProfile.direct_incoming_request_count.increment(
-                    LocalSiteProfile.objects.filter(user__in=people,
-                                                    local_site=local_site))
-                LocalSiteProfile.total_incoming_request_count.increment(
-                    LocalSiteProfile.objects.filter(
-                        Q(local_site=local_site) &
-                        Q(Q(user__review_groups__in=groups) |
-                          Q(user__in=people))))
-                LocalSiteProfile.starred_public_request_count.increment(
-                    LocalSiteProfile.objects.filter(
-                        profile__starred_review_requests=self,
-                        local_site=local_site))
-        else:
+                self._increment_reviewer_counts()
+        elif old_status == self.PENDING_REVIEW:
             if old_status != self.status:
                 site_profile.decrement_pending_outgoing_request_count()
 
             if old_public:
-                groups = self.target_groups.all()
-                people = self.target_people.all()
-
-                Group.incoming_request_count.decrement(groups)
-                LocalSiteProfile.direct_incoming_request_count.decrement(
-                    LocalSiteProfile.objects.filter(user__in=people,
-                                                    local_site=local_site))
-                LocalSiteProfile.total_incoming_request_count.decrement(
-                    LocalSiteProfile.objects.filter(
-                        Q(local_site=local_site) &
-                        Q(Q(user__review_groups__in=groups) |
-                          Q(user__in=people))))
-                LocalSiteProfile.starred_public_request_count.decrement(
-                    LocalSiteProfile.objects.filter(
-                        profile__starred_review_requests=self,
-                        local_site=local_site))
+                self._decrement_reviewer_counts()
+
+    def _increment_reviewer_counts(self):
+        from reviewboard.accounts.models import LocalSiteProfile
+
+        groups = self.target_groups.all()
+        people = self.target_people.all()
+
+        Group.incoming_request_count.increment(groups)
+        LocalSiteProfile.direct_incoming_request_count.increment(
+            LocalSiteProfile.objects.filter(user__in=people,
+                                            local_site=self.local_site))
+        LocalSiteProfile.total_incoming_request_count.increment(
+            LocalSiteProfile.objects.filter(
+                Q(local_site=self.local_site) &
+                Q(Q(user__review_groups__in=groups) |
+                  Q(user__in=people))))
+        LocalSiteProfile.starred_public_request_count.increment(
+            LocalSiteProfile.objects.filter(
+                profile__starred_review_requests=self,
+                local_site=self.local_site))
+
+    def _decrement_reviewer_counts(self):
+        from reviewboard.accounts.models import LocalSiteProfile
+
+        groups = self.target_groups.all()
+        people = self.target_people.all()
+
+        Group.incoming_request_count.decrement(groups)
+        LocalSiteProfile.direct_incoming_request_count.decrement(
+            LocalSiteProfile.objects.filter(
+                user__in=people,
+                local_site=self.local_site))
+        LocalSiteProfile.total_incoming_request_count.decrement(
+            LocalSiteProfile.objects.filter(
+                Q(local_site=self.local_site) &
+                Q(Q(user__review_groups__in=groups) |
+                  Q(user__in=people))))
+        LocalSiteProfile.starred_public_request_count.decrement(
+            LocalSiteProfile.objects.filter(
+                profile__starred_review_requests=self,
+                local_site=self.local_site))
 
     def _calculate_approval(self):
         """Calculates the approval information for the review request."""
diff --git a/reviewboard/reviews/tests.py b/reviewboard/reviews/tests.py
index 8f95db09349c57f0c031c63d5df4ba403f236e2c..bce9dc5e19dea255ee60f92828544163fd4a6d22 100644
--- a/reviewboard/reviews/tests.py
+++ b/reviewboard/reviews/tests.py
@@ -1604,100 +1604,74 @@ class ReviewRequestCounterTests(TestCase):
     def test_outgoing_requests(self):
         """Testing counters with creating outgoing review requests"""
         # The review request was already created
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         ReviewRequestDraft.create(self.review_request)
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             starred_public=1)
 
     def test_closing_requests(self, close_type=ReviewRequest.DISCARDED):
         """Testing counters with closing outgoing review requests"""
         # The review request was already created
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
+        self._check_counters(total_outgoing=1, pending_outgoing=1)
 
         draft = ReviewRequestDraft.create(self.review_request)
         draft.target_groups.add(self.group)
         draft.target_people.add(self.user)
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
         self.assertTrue(self.review_request.public)
         self.assertEqual(self.review_request.status,
                          ReviewRequest.PENDING_REVIEW)
-        self.review_request.close(close_type)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self.review_request.close(close_type)
+        self._check_counters(total_outgoing=1)
 
     def test_closing_draft_requests(self, close_type=ReviewRequest.DISCARDED):
         """Testing counters with closing draft review requests"""
         # The review request was already created
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         self.assertFalse(self.review_request.public)
         self.assertEqual(self.review_request.status,
                          ReviewRequest.PENDING_REVIEW)
+
         self.review_request.close(close_type)
+        self._check_counters(total_outgoing=1)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+    def test_closing_closed_requests(self):
+        """Testing counters with closing closed review requests"""
+        # The review request was already created
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
+
+        self.assertFalse(self.review_request.public)
+        self.assertEqual(self.review_request.status,
+                         ReviewRequest.PENDING_REVIEW)
+
+        self.review_request.close(ReviewRequest.DISCARDED)
+        self._check_counters(total_outgoing=1)
+
+        self.review_request.close(ReviewRequest.SUBMITTED)
+        self._check_counters(total_outgoing=1)
 
     def test_closing_draft_requests_with_site(self):
-        """Testing counters with closing draft review requests"""
+        """Testing counters with closing draft review requests on LocalSite"""
         self.review_request.delete()
-        self._reload_objects()
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
+
+        self._check_counters(with_local_site=True)
 
         tool = Tool.objects.get(name='Subversion')
         repository = Repository.objects.create(name='Test1', path='path1',
@@ -1708,86 +1682,71 @@ class ReviewRequestCounterTests(TestCase):
             repository,
             local_site=self.test_site)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
+        self._check_counters(with_local_site=True,
+                             total_outgoing=1,
+                             pending_outgoing=1)
 
         self.assertFalse(self.review_request.public)
         self.assertEqual(self.review_request.status,
                          ReviewRequest.PENDING_REVIEW)
-        self.review_request.close(ReviewRequest.DISCARDED)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
+        self.review_request.close(ReviewRequest.DISCARDED)
+        self._check_counters(with_local_site=True,
+                             total_outgoing=1)
 
     def test_deleting_requests(self):
         """Testing counters with deleting outgoing review requests"""
         # The review request was already created
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         draft = ReviewRequestDraft.create(self.review_request)
         draft.target_groups.add(self.group)
         draft.target_people.add(self.user)
-        self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self.review_request.publish(self.user)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
         self.review_request.delete()
-
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self._check_counters()
 
     def test_deleting_draft_requests(self):
         """Testing counters with deleting draft review requests"""
+        # We're simulating what a DefaultReviewer would do by populating
+        # the ReviewRequest's target users and groups while not public and
+        # without a draft.
+        self.review_request.target_people.add(self.user)
+        self.review_request.target_groups.add(self.group)
+
         # The review request was already created
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         self.review_request.delete()
+        self._check_counters()
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+    def test_deleting_closed_requests(self):
+        """Testing counters with deleting closed review requests"""
+        # We're simulating what a DefaultReviewer would do by populating
+        # the ReviewRequest's target users and groups while not public and
+        # without a draft.
+        self.review_request.target_people.add(self.user)
+        self.review_request.target_groups.add(self.group)
+
+        # The review request was already created
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
+
+        self.review_request.close(ReviewRequest.DISCARDED)
+        self._check_counters(total_outgoing=1)
+
+        self.review_request.delete()
+        self._check_counters()
 
     def test_reopen_discarded_requests(self):
         """Testing counters with reopening discarded outgoing review requests
@@ -1796,36 +1755,19 @@ class ReviewRequestCounterTests(TestCase):
 
         self.review_request.reopen()
         self.assertFalse(self.review_request.public)
-        self.assertTrue(self.review_request.status,
-                        ReviewRequest.PENDING_REVIEW)
+        self.assertEqual(self.review_request.status,
+                         ReviewRequest.PENDING_REVIEW)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         self.review_request.publish(self.user)
-
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
     def test_reopen_submitted_requests(self):
         """Testing counters with reopening submitted outgoing review requests
@@ -1834,36 +1776,23 @@ class ReviewRequestCounterTests(TestCase):
 
         self.review_request.reopen()
         self.assertTrue(self.review_request.public)
-        self.assertTrue(self.review_request.status,
-                        ReviewRequest.PENDING_REVIEW)
+        self.assertEqual(self.review_request.status,
+                         ReviewRequest.PENDING_REVIEW)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
         self.review_request.publish(self.user)
-
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
     def test_reopen_discarded_draft_requests(self):
         """Testing counters with reopening discarded draft review requests"""
@@ -1873,61 +1802,69 @@ class ReviewRequestCounterTests(TestCase):
 
         self.review_request.reopen()
         self.assertFalse(self.review_request.public)
-        self.assertTrue(self.review_request.status,
-                        ReviewRequest.PENDING_REVIEW)
-
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 0)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self.assertEqual(self.review_request.status,
+                         ReviewRequest.PENDING_REVIEW)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
     def test_reopen_submitted_draft_requests(self):
         """Testing counters with reopening submitted draft review requests"""
         self.test_closing_draft_requests(ReviewRequest.SUBMITTED)
 
+        # We're simulating what a DefaultReviewer would do by populating
+        # the ReviewRequest's target users and groups while not public and
+        # without a draft.
+        self.review_request.target_people.add(self.user)
+        self.review_request.target_groups.add(self.group)
+
+        self._check_counters(total_outgoing=1)
+
         self.review_request.reopen()
         self.assertTrue(self.review_request.public)
-        self.assertTrue(self.review_request.status,
-                        ReviewRequest.PENDING_REVIEW)
+        self.assertEqual(self.review_request.status,
+                         ReviewRequest.PENDING_REVIEW)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.total_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.pending_outgoing_request_count, 1)
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.total_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.pending_outgoing_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
+
+    def test_double_publish(self):
+        """Testing counters with publishing a review request twice"""
+        self.assertFalse(self.review_request.public)
+        self.assertEqual(self.review_request.status,
+                         ReviewRequest.PENDING_REVIEW)
+
+        # Publish the first time.
+        self.review_request.publish(self.user)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             starred_public=1)
+
+        # Publish the second time.
+        self.review_request.publish(self.user)
+
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             starred_public=1)
 
     def test_add_group(self):
         """Testing counters when adding a group reviewer"""
         draft = ReviewRequestDraft.create(self.review_request)
         draft.target_groups.add(self.group)
 
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             total_incoming=1,
+                             group_incoming=1,
+                             starred_public=1)
 
     def test_remove_group(self):
         """Testing counters when removing a group reviewer"""
@@ -1936,34 +1873,33 @@ class ReviewRequestCounterTests(TestCase):
         draft = ReviewRequestDraft.create(self.review_request)
         draft.target_groups.remove(self.group)
 
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             total_incoming=1,
+                             group_incoming=1,
+                             starred_public=1)
 
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             starred_public=1)
 
     def test_add_person(self):
         """Testing counters when adding a person reviewer"""
         draft = ReviewRequestDraft.create(self.review_request)
         draft.target_people.add(self.user)
 
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
 
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1)
 
     def test_remove_person(self):
         """Testing counters when removing a person reviewer"""
@@ -1972,18 +1908,17 @@ class ReviewRequestCounterTests(TestCase):
         draft = ReviewRequestDraft.create(self.review_request)
         draft.target_people.remove(self.user)
 
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1)
 
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             starred_public=1)
 
     def test_populate_counters(self):
         """Testing counters when populated from a fresh upgrade or clear"""
@@ -1993,14 +1928,12 @@ class ReviewRequestCounterTests(TestCase):
         draft.target_people.add(self.user)
         self.review_request.publish(self.user)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             total_incoming=1,
+                             direct_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
         LocalSiteProfile.objects.update(
             direct_incoming_request_count=None,
@@ -2010,14 +1943,12 @@ class ReviewRequestCounterTests(TestCase):
             starred_public_request_count=None)
         Group.objects.update(incoming_request_count=None)
 
-        self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             total_incoming=1,
+                             direct_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
 
     def test_populate_counters_after_change(self):
         """Testing counter inc/dec on uninitialized counter fields"""
@@ -2026,6 +1957,9 @@ class ReviewRequestCounterTests(TestCase):
         draft.target_groups.add(self.group)
         draft.target_people.add(self.user)
 
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1)
+
         LocalSiteProfile.objects.update(
             direct_incoming_request_count=None,
             total_incoming_request_count=None,
@@ -2063,14 +1997,45 @@ class ReviewRequestCounterTests(TestCase):
 
         Group.incoming_request_count._locks = {}
 
+        self._check_counters(total_outgoing=1,
+                             pending_outgoing=1,
+                             direct_incoming=1,
+                             total_incoming=1,
+                             starred_public=1,
+                             group_incoming=1)
+
+    def _check_counters(self, total_outgoing=0, pending_outgoing=0,
+                        direct_incoming=0, total_incoming=0,
+                        starred_public=0, group_incoming=0,
+                        with_local_site=False):
         self._reload_objects()
-        self.assertEqual(self.site_profile.direct_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.total_incoming_request_count, 1)
-        self.assertEqual(self.site_profile.starred_public_request_count, 1)
-        self.assertEqual(self.site_profile2.direct_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.total_incoming_request_count, 0)
-        self.assertEqual(self.site_profile2.starred_public_request_count, 0)
-        self.assertEqual(self.group.incoming_request_count, 1)
+
+        if with_local_site:
+            main_site_profile = self.site_profile2
+            unused_site_profile = self.site_profile
+        else:
+            main_site_profile = self.site_profile
+            unused_site_profile = self.site_profile2
+
+        self.assertEqual(main_site_profile.total_outgoing_request_count,
+                         total_outgoing)
+        self.assertEqual(main_site_profile.pending_outgoing_request_count,
+                         pending_outgoing)
+        self.assertEqual(main_site_profile.direct_incoming_request_count,
+                         direct_incoming)
+        self.assertEqual(main_site_profile.total_incoming_request_count,
+                         total_incoming)
+        self.assertEqual(main_site_profile.starred_public_request_count,
+                         starred_public)
+        self.assertEqual(self.group.incoming_request_count, group_incoming)
+
+        # These should never be affected by the updates on the main
+        # LocalSite we're working with, so they should always be 0.
+        self.assertEqual(unused_site_profile.total_outgoing_request_count, 0)
+        self.assertEqual(unused_site_profile.pending_outgoing_request_count, 0)
+        self.assertEqual(unused_site_profile.direct_incoming_request_count, 0)
+        self.assertEqual(unused_site_profile.total_incoming_request_count, 0)
+        self.assertEqual(unused_site_profile.starred_public_request_count, 0)
 
     def _reload_objects(self):
         self.test_site = LocalSite.objects.get(pk=self.test_site.pk)
