diff --git a/reviewboard/reviews/tests/test_actions.py b/reviewboard/reviews/tests/test_actions.py
index 19dd13b936d308d2a81fcaab9965d8b5886e96c7..19120825ccda6aba366f284d0a698bd71ef95a85 100644
--- a/reviewboard/reviews/tests/test_actions.py
+++ b/reviewboard/reviews/tests/test_actions.py
@@ -4,8 +4,8 @@ from django.contrib.auth.models import AnonymousUser, User
 from django.template import Context
 from django.test.client import RequestFactory
 from django.utils import six
+from djblets.siteconfig.models import SiteConfiguration
 from djblets.testing.decorators import add_fixtures
-from mock import Mock
 
 from reviewboard.reviews.actions import (BaseReviewRequestAction,
                                          BaseReviewRequestMenuAction,
@@ -28,6 +28,18 @@ from reviewboard.reviews.models import ReviewRequest
 from reviewboard.testing import TestCase
 
 
+class FakeResolverMatch(object):
+    """Mock URL pattern match used for testing."""
+
+    def __init__(self, url_name):
+        """Initialize the mock resolver match.
+
+        Args:
+            url_name (unicode):
+                The URL pattern match.
+        """
+        self.url_name = url_name
+
 class FooAction(BaseReviewRequestAction):
     action_id = 'foo-action'
     label = 'Foo Action'
@@ -50,6 +62,106 @@ class PoorlyCodedAction(BaseReviewRequestAction):
         raise Exception
 
 
+class ReadOnlyActionTestsMixin(object):
+    """Mixin for Review Board actions-related unit tests.
+
+    This mixin is used to add read-only mode tests into action tests. Using
+    this mixin is especially important for actions that change visibility
+    based on whether read-only mode is active. Actions that should always be
+    visible can also be tested by setting ``read_only_always_show``.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the mock resolver match.
+
+        Args:
+            *args (tuple):
+                Positional arguments for the superclass constructor.
+
+            **kwargs (dict):
+                Keyword arguments for the superclass constructor.
+        """
+        super(ReadOnlyActionTestsMixin, self).__init__(*args, **kwargs)
+
+        if hasattr(self, 'read_only_test_fixtures'):
+            _add_fixtures = add_fixtures(self.read_only_test_fixtures)
+
+            _add_fixtures(self.test_should_render_with_user_in_read_only
+                          .__func__)
+            _add_fixtures(self.test_should_render_with_superuser_in_read_only
+                          .__func__)
+
+    def setUp(self):
+        super(ReadOnlyActionTestsMixin, self).setUp()
+
+        self.request = RequestFactory().request()
+        self.siteconfig = SiteConfiguration.objects.get_current()
+
+    def shortDescription(self):
+        """Return an updated description for a particular test.
+
+        If the test has an ``action`` attribute set and contains ``<ACTION>``
+        in the docstring, then ACTION will be replaced by the ``action_id``
+        attribute of the
+        :py:class:`~reviewboard.reviews.actions.BaseReviewRequestAction`.
+
+        Returns:
+            unicode: The description of the test.
+        """
+        desc = super(ReadOnlyActionTestsMixin, self).shortDescription()
+
+        if self.action:
+
+            if getattr(self, self._testMethodName, False):
+                desc = desc.replace('<ACTION>', type(self.action).__name__)
+
+        return desc
+
+    def test_should_render_with_user_in_read_only(self):
+        """Testing <ACTION>.should_render with authenticated user in read-only
+        mode
+        """
+        self.request.user = User.objects.get(username='doc')
+
+        # Turning on read-only mode prevents creation of some objects so call
+        # request_context first.
+        request_context = self._get_request_context()
+
+        try:
+            self.siteconfig.set('site_read_only', True)
+            self.siteconfig.save()
+
+            if getattr(self, 'read_only_always_show', False):
+                self.assertTrue(self.action.should_render(request_context))
+            else:
+                self.assertFalse(self.action.should_render(request_context))
+        finally:
+            defaults = self.siteconfig.get_defaults()
+
+            self.siteconfig.set('site_read_only', defaults.get('site_read_only'))
+            self.siteconfig.save()
+
+
+    def test_should_render_with_superuser_in_read_only(self):
+        """Testing <ACTION>.should_render with superuser in read-only mode"""
+        self.request.user = User.objects.get(username='admin')
+
+        # Turning on read-only mode prevents creation of some objects so call
+        # request_context first.
+        request_context = self._get_request_context()
+
+        try:
+            self.siteconfig.set('site_read_only', True)
+            self.siteconfig.save()
+
+            self.assertTrue(self.action.should_render(request_context))
+        finally:
+            defaults = self.siteconfig.get_defaults()
+
+            self.siteconfig.set('site_read_only', defaults.get('site_read_only'))
+            self.siteconfig.save()
+
+
 class ActionsTestCase(TestCase):
     """Test case for unit tests dealing with actions."""
 
@@ -298,55 +410,60 @@ class BaseReviewRequestActionTests(ActionsTestCase):
         self.assertEquals(old_dict_count, new_dict_count)
 
 
-class AddGeneralCommentActionTests(ActionsTestCase):
+class AddGeneralCommentActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for AddGeneralCommentAction."""
 
+    action = AddGeneralCommentAction()
     fixtures = ['test_users']
 
-    def setUp(self):
-        super(AddGeneralCommentActionTests, self).setUp()
-
-        self.action = AddGeneralCommentAction()
+    def _get_request_context(self):
+        return {'request': self.request}
 
     def test_should_render_with_authenticated(self):
         """Testing AddGeneralCommentAction.should_render with authenticated
         user
         """
-        request = RequestFactory().request()
-        request.user = User.objects.get(username='doc')
+        self.request.user = User.objects.get(username='doc')
 
-        self.assertTrue(self.action.should_render({'request': request}))
+        self.assertTrue(self.action.should_render({'request': self.request}))
 
     def test_should_render_with_anonymous(self):
-        """Testing AddGeneralCommentAction.should_render with authenticated
+        """Testing AddGeneralCommentAction.should_render with anonymous
         user
         """
-        request = RequestFactory().request()
-        request.user = AnonymousUser()
+        self.request.user = AnonymousUser()
 
-        self.assertFalse(self.action.should_render({'request': request}))
+        self.assertFalse(self.action.should_render({'request': self.request}))
 
 
-class CloseMenuActionTests(ActionsTestCase):
+class CloseMenuActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for CloseMenuAction."""
 
+    action = CloseMenuAction()
     fixtures = ['test_users']
 
-    def setUp(self):
-        super(CloseMenuActionTests, self).setUp()
+    def _get_request_context(self):
+        review_request = self.create_review_request(publish=True)
 
-        self.action = CloseMenuAction()
+        return {
+            'review_request': review_request,
+            'request': self.request,
+            'perms': {
+                'reviews': {
+                    'can_change_status': True,
+                },
+            },
+        }
 
     def test_should_render_for_owner(self):
         """Testing CloseMenuAction.should_render for owner of review request"""
         review_request = self.create_review_request(publish=True)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertTrue(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': False,
@@ -360,12 +477,11 @@ class CloseMenuActionTests(ActionsTestCase):
         """
         review_request = self.create_review_request(public=False)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertTrue(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': False,
@@ -377,12 +493,11 @@ class CloseMenuActionTests(ActionsTestCase):
         """Testing CloseMenuAction.should_render for normal user"""
         review_request = self.create_review_request(publish=True)
 
-        request = RequestFactory().request()
-        request.user = User.objects.create(username='test-user')
+        self.request.user = User.objects.create(username='test-user')
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': False,
@@ -396,12 +511,11 @@ class CloseMenuActionTests(ActionsTestCase):
         """
         review_request = self.create_review_request(publish=True)
 
-        request = RequestFactory().request()
-        request.user = User.objects.create(username='test-user')
+        self.request.user = User.objects.create(username='test-user')
 
         self.assertTrue(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': True,
@@ -415,12 +529,11 @@ class CloseMenuActionTests(ActionsTestCase):
         """
         review_request = self.create_review_request(public=False)
 
-        request = RequestFactory().request()
-        request.user = User.objects.create(username='test-user')
+        self.request.user = User.objects.create(username='test-user')
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': True,
@@ -434,12 +547,11 @@ class CloseMenuActionTests(ActionsTestCase):
         review_request = \
             self.create_review_request(status=ReviewRequest.DISCARDED)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': False,
@@ -453,12 +565,11 @@ class CloseMenuActionTests(ActionsTestCase):
         review_request = \
             self.create_review_request(status=ReviewRequest.SUBMITTED)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_change_status': False,
@@ -467,13 +578,26 @@ class CloseMenuActionTests(ActionsTestCase):
         }))
 
 
-class DeleteActionTests(ActionsTestCase):
+class DeleteActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for DeleteAction."""
 
+    action = DeleteAction()
+    fixtures = ['test_users']
+
+    def _get_request_context(self):
+        return {
+            'perms': {
+                'reviews': {
+                    'delete_reviewrequest': True,
+                },
+            },
+            'request': self.request,
+        }
+
     def setUp(self):
         super(DeleteActionTests, self).setUp()
 
-        self.action = DeleteAction()
+        self.request.user = User.objects.get(username='doc')
 
     def test_should_render_with_published(self):
         """Testing DeleteAction.should_render with standard user"""
@@ -483,6 +607,7 @@ class DeleteActionTests(ActionsTestCase):
                     'delete_reviewrequest': False,
                 },
             },
+            'request': self.request,
         }))
 
     def test_should_render_with_permission(self):
@@ -495,57 +620,59 @@ class DeleteActionTests(ActionsTestCase):
                     'delete_reviewrequest': True,
                 },
             },
+            'request': self.request,
         }))
 
 
-class DownloadDiffActionTests(ActionsTestCase):
+class DownloadDiffActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for DownloadDiffAction."""
 
+    action = DownloadDiffAction()
     fixtures = ['test_users']
+    # Download Diff should be visible even in read-only mode.
+    read_only_always_show = True
 
-    def setUp(self):
-        super(DownloadDiffActionTests, self).setUp()
+    def _get_request_context(self):
+        self.request.resolver_match = FakeResolverMatch('view-diff')
 
-        self.action = DownloadDiffAction()
+        review_request = self.create_review_request()
+
+        return {
+            'request': self.request,
+            'review_request': review_request
+        }
 
     def test_get_url_on_diff_viewer(self):
         """Testing DownloadDiffAction.get_url on diff viewer page"""
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-diff'
+        self.request.resolver_match = FakeResolverMatch('view-diff')
 
-        self.assertEqual(self.action.get_url({'request': request}),
+        self.assertEqual(self.action.get_url({'request': self.request}),
                          'raw/')
 
     def test_get_url_on_interdiff(self):
         """Testing DownloadDiffAction.get_url on diff viewer interdiff page"""
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-interdiff'
+        self.request.resolver_match = FakeResolverMatch('view-interdiff')
 
-        self.assertEqual(self.action.get_url({'request': request}),
+        self.assertEqual(self.action.get_url({'request': self.request}),
                          'raw/')
 
     def test_get_url_on_diff_viewer_revision(self):
         """Testing DownloadDiffAction.get_url on diff viewer revision page"""
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-diff-revision'
+        self.request.resolver_match = FakeResolverMatch('view-diff-revision')
 
-        self.assertEqual(self.action.get_url({'request': request}),
+        self.assertEqual(self.action.get_url({'request': self.request}),
                          'raw/')
 
     def test_get_url_on_review_request(self):
         """Testing DownloadDiffAction.get_url on review request page"""
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'review-request-detail'
+        self.request.resolver_match = \
+            FakeResolverMatch('review-request-detail')
 
         review_request = self.create_review_request()
 
         self.assertEqual(
             self.action.get_url({
-                'request': request,
+                'request': self.request,
                 'review_request': review_request,
             }),
             '/r/%s/diff/raw/' % review_request.display_id)
@@ -555,17 +682,16 @@ class DownloadDiffActionTests(ActionsTestCase):
         """Testing DownloadDiffAction.get_url on review request page with
         LocalSite
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'review-request-detail'
-        request._local_site_name = self.local_site_name
+        self.request.resolver_match = \
+            FakeResolverMatch('review-request-detail')
+        self.request._local_site_name = self.local_site_name
 
         review_request = self.create_review_request(id=123,
                                                     with_local_site=True)
 
         self.assertEqual(
             self.action.get_url({
-                'request': request,
+                'request': self.request,
                 'review_request': review_request,
             }),
             '/s/%s/r/%s/diff/raw/' % (self.local_site_name,
@@ -573,54 +699,45 @@ class DownloadDiffActionTests(ActionsTestCase):
 
     def test_get_hidden_on_diff_viewer(self):
         """Testing DownloadDiffAction.get_hidden on diff viewer page"""
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-diff'
+        self.request.resolver_match = FakeResolverMatch('view-diff')
 
-        self.assertFalse(self.action.get_hidden({'request': request}))
+        self.assertFalse(self.action.get_hidden({'request': self.request}))
 
     def test_get_hidden_on_interdiff(self):
         """Testing DownloadDiffAction.get_hidden on diff viewer interdiff page
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-interdiff'
+        self.request.resolver_match = FakeResolverMatch('view-interdiff')
 
-        self.assertTrue(self.action.get_hidden({'request': request}))
+        self.assertTrue(self.action.get_hidden({'request': self.request}))
 
     def test_get_hidden_on_diff_viewer_revision(self):
         """Testing DownloadDiffAction.get_hdiden on diff viewer revision page
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-diff-revision'
+        self.request.resolver_match = FakeResolverMatch('view-diff-revision')
 
-        self.assertFalse(self.action.get_hidden({'request': request}))
+        self.assertFalse(self.action.get_hidden({'request': self.request}))
 
     def test_get_hidden_on_review_request(self):
         """Testing DownloadDiffAction.get_hdiden on diff viewer revision page
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'review-request-detail'
+        self.request.resolver_match = \
+            FakeResolverMatch('review-request-detail')
 
         review_request = self.create_review_request()
 
         self.assertFalse(self.action.get_hidden({
-            'request': request,
+            'request': self.request,
             'review_request': review_request,
         }))
 
     def test_should_render_on_diff_viewer(self):
         """Testing DownloadDiffAction.should_render on diff viewer page"""
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-diff'
+        self.request.resolver_match = FakeResolverMatch('view-diff')
 
         review_request = self.create_review_request()
 
         self.assertTrue(self.action.should_render({
-            'request': request,
+            'request': self.request,
             'review_request': review_request,
         }))
 
@@ -628,14 +745,12 @@ class DownloadDiffActionTests(ActionsTestCase):
         """Testing DownloadDiffAction.should_render on diff viewer interdiff
         page
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-interdiff'
+        self.request.resolver_match = FakeResolverMatch('view-interdiff')
 
         review_request = self.create_review_request()
 
         self.assertTrue(self.action.should_render({
-            'request': request,
+            'request': self.request,
             'review_request': review_request,
         }))
 
@@ -643,14 +758,12 @@ class DownloadDiffActionTests(ActionsTestCase):
         """Testing DownloadDiffAction.should_render on diff viewer revision
         page
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'view-diff-revision'
+        self.request.resolver_match = FakeResolverMatch('view-diff-revision')
 
         review_request = self.create_review_request()
 
         self.assertTrue(self.action.should_render({
-            'request': request,
+            'request': self.request,
             'review_request': review_request,
         }))
 
@@ -659,14 +772,13 @@ class DownloadDiffActionTests(ActionsTestCase):
         """Testing DownloadDiffAction.should_render on review request page
         with repository
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'review-request-detail'
+        self.request.resolver_match = \
+            FakeResolverMatch('review-request-detail')
 
         review_request = self.create_review_request(create_repository=True)
 
         self.assertTrue(self.action.should_render({
-            'request': request,
+            'request': self.request,
             'review_request': review_request,
         }))
 
@@ -675,82 +787,85 @@ class DownloadDiffActionTests(ActionsTestCase):
         """Testing DownloadDiffAction.should_render on review request page
         without repository
         """
-        request = RequestFactory().request()
-        request.resolver_match = Mock()
-        request.resolver_match.url_name = 'review-request-detail'
+        self.request.resolver_match = \
+            FakeResolverMatch('review-request-detail')
 
         review_request = self.create_review_request()
 
         self.assertFalse(self.action.should_render({
-            'request': request,
+            'request': self.request,
             'review_request': review_request,
         }))
 
 
-class EditReviewActionTests(ActionsTestCase):
+class EditReviewActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for EditReviewAction."""
 
+    action = EditReviewAction()
     fixtures = ['test_users']
 
-    def setUp(self):
-        super(EditReviewActionTests, self).setUp()
-
-        self.action = EditReviewAction()
+    def _get_request_context(self):
+        return {'request': self.request}
 
     def test_should_render_with_authenticated(self):
         """Testing EditReviewAction.should_render with authenticated user"""
-        request = RequestFactory().request()
-        request.user = User.objects.get(username='doc')
+        self.request.user = User.objects.get(username='doc')
 
-        self.assertTrue(self.action.should_render({'request': request}))
+        self.assertTrue(self.action.should_render({'request': self.request}))
 
     def test_should_render_with_anonymous(self):
         """Testing EditReviewAction.should_render with authenticated user"""
-        request = RequestFactory().request()
-        request.user = AnonymousUser()
+        self.request.user = AnonymousUser()
 
-        self.assertFalse(self.action.should_render({'request': request}))
+        self.assertFalse(self.action.should_render({'request': self.request}))
 
 
-class ShipItActionTests(ActionsTestCase):
+class ShipItActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for ShipItAction."""
 
+    action = ShipItAction()
     fixtures = ['test_users']
 
-    def setUp(self):
-        super(ShipItActionTests, self).setUp()
-
-        self.action = ShipItAction()
+    def _get_request_context(self):
+        return {'request': self.request}
 
     def test_should_render_with_authenticated(self):
         """Testing ShipItAction.should_render with authenticated user"""
-        request = RequestFactory().request()
-        request.user = User.objects.get(username='doc')
+        self.request.user = User.objects.get(username='doc')
 
-        self.assertTrue(self.action.should_render({'request': request}))
+        self.assertTrue(self.action.should_render({'request': self.request}))
 
     def test_should_render_with_anonymous(self):
         """Testing ShipItAction.should_render with authenticated user"""
-        request = RequestFactory().request()
-        request.user = AnonymousUser()
+        self.request.user = AnonymousUser()
 
-        self.assertFalse(self.action.should_render({'request': request}))
+        self.assertFalse(self.action.should_render({'request': self.request}))
 
 
-class SubmitActionTests(ActionsTestCase):
+class SubmitActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for SubmitAction."""
 
+    action = SubmitAction()
     fixtures = ['test_users']
 
+    def _get_request_context(self):
+        review_request = self.create_review_request(public=True)
+
+        return {
+            'review_request': review_request,
+            'request': self.request,
+        }
+
     def setUp(self):
         super(SubmitActionTests, self).setUp()
 
-        self.action = SubmitAction()
+        self.request.user = User.objects.get(username='doc')
 
     def test_should_render_with_published(self):
         """Testing SubmitAction.should_render with published review request"""
         self.assertTrue(self.action.should_render({
             'review_request': self.create_review_request(public=True),
+            'request': self.request,
         }))
 
     def test_should_render_with_unpublished(self):
@@ -758,30 +873,39 @@ class SubmitActionTests(ActionsTestCase):
         """
         self.assertFalse(self.action.should_render({
             'review_request': self.create_review_request(public=False),
+            'request': self.request,
         }))
 
 
-class UpdateMenuActionTests(ActionsTestCase):
+class UpdateMenuActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for UpdateMenuAction."""
 
+    action = UpdateMenuAction()
     fixtures = ['test_users']
 
-    def setUp(self):
-        super(UpdateMenuActionTests, self).setUp()
+    def _get_request_context(self):
+        review_request = self.create_review_request(publish=True)
 
-        self.action = UpdateMenuAction()
+        return {
+            'review_request': review_request,
+            'request': self.request,
+            'perms': {
+                'reviews': {
+                    'can_edit_reviewrequest': True,
+                },
+            },
+        }
 
     def test_should_render_for_owner(self):
         """Testing UpdateMenuAction.should_render for owner of review request
         """
         review_request = self.create_review_request(publish=True)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertTrue(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_edit_reviewrequest': False,
@@ -793,12 +917,11 @@ class UpdateMenuActionTests(ActionsTestCase):
         """Testing UpdateMenuAction.should_render for normal user"""
         review_request = self.create_review_request(publish=True)
 
-        request = RequestFactory().request()
-        request.user = User.objects.create(username='test-user')
+        self.request.user = User.objects.create(username='test-user')
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_edit_reviewrequest': False,
@@ -812,12 +935,11 @@ class UpdateMenuActionTests(ActionsTestCase):
         """
         review_request = self.create_review_request(publish=True)
 
-        request = RequestFactory().request()
-        request.user = User.objects.create(username='test-user')
+        self.request.user = User.objects.create(username='test-user')
 
         self.assertTrue(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_edit_reviewrequest': True,
@@ -831,12 +953,11 @@ class UpdateMenuActionTests(ActionsTestCase):
         review_request = \
             self.create_review_request(status=ReviewRequest.DISCARDED)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_edit_reviewrequest': False,
@@ -850,12 +971,11 @@ class UpdateMenuActionTests(ActionsTestCase):
         review_request = \
             self.create_review_request(status=ReviewRequest.SUBMITTED)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
-            'request': request,
+            'request': self.request,
             'perms': {
                 'reviews': {
                     'can_edit_reviewrequest': False,
@@ -864,27 +984,32 @@ class UpdateMenuActionTests(ActionsTestCase):
         }))
 
 
-class UploadDiffActionTests(ActionsTestCase):
+class UploadDiffActionTests(ReadOnlyActionTestsMixin, ActionsTestCase):
     """Unit tests for UploadDiffAction."""
 
+    action = UploadDiffAction()
     fixtures = ['test_users']
+    read_only_test_fixtures = ['test_scmtools']
 
-    def setUp(self):
-        super(UploadDiffActionTests, self).setUp()
+    def _get_request_context(self):
+        review_request = self.create_review_request(create_repository=True)
+        review_request.submitter = self.request.user
 
-        self.action = UploadDiffAction()
+        return {
+            'review_request': review_request,
+            'request': self.request,
+        }
 
     def test_get_label_with_no_diffs(self):
         """Testing UploadDiffAction.get_label with no diffs"""
         review_request = self.create_review_request()
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertEqual(
             self.action.get_label({
                 'review_request': review_request,
-                'request': request,
+                'request': self.request,
             }),
             'Upload Diff')
 
@@ -894,13 +1019,12 @@ class UploadDiffActionTests(ActionsTestCase):
         review_request = self.create_review_request(create_repository=True)
         self.create_diffset(review_request)
 
-        request = RequestFactory().request()
-        request.user = review_request.submitter
+        self.request.user = review_request.submitter
 
         self.assertEqual(
             self.action.get_label({
                 'review_request': review_request,
-                'request': request,
+                'request': self.request,
             }),
             'Update Diff')
 
@@ -909,14 +1033,20 @@ class UploadDiffActionTests(ActionsTestCase):
         """Testing UploadDiffAction.should_render with repository"""
         review_request = self.create_review_request(create_repository=True)
 
+        self.request.user = review_request.submitter
+
         self.assertTrue(self.action.should_render({
             'review_request': review_request,
+            'request': self.request,
         }))
 
     def test_should_render_without_repository(self):
         """Testing UploadDiffAction.should_render without repository"""
         review_request = self.create_review_request()
 
+        self.request.user = review_request.submitter
+
         self.assertFalse(self.action.should_render({
             'review_request': review_request,
+            'request': self.request,
         }))