middleware: Convert tests to pytest style

Signed-off-by: Sunil Mohan Adapa <sunil@medhas.org>
Reviewed-by: Joseph Nuthalapati <njoseph@thoughtworks.com>

plinth/tests/test_middleware.py

@@ -14,66 +14,63 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
-
 """
 Test module for custom middleware.
 """
 
-from unittest.mock import Mock, MagicMock, patch
+from unittest.mock import MagicMock, Mock, patch
 
+import pytest
 from django.contrib.auth.models import AnonymousUser, User
 from django.core.exceptions import PermissionDenied
 from django.http import HttpResponse
-from django.test import TestCase
 from django.test.client import RequestFactory
 from stronghold.decorators import public
 
-from plinth import cfg
-from plinth.middleware import SetupMiddleware, AdminRequiredMiddleware
+from plinth.middleware import AdminRequiredMiddleware, SetupMiddleware
 
 
-class TestSetupMiddleware(TestCase):
+@pytest.fixture(name='kwargs')
+def fixture_kwargs():
+    """Fixture for returning kwargs for creating middleware."""
+    return {
+        'view_func': HttpResponse,
+        'view_args': [],
+        'view_kwargs': {},
+    }
+
+
+class TestSetupMiddleware:
     """Test cases for setup middleware."""
-    @classmethod
-    def setUpClass(cls):
-        """Setup all the test cases."""
-        super(TestSetupMiddleware, cls).setUpClass()
-        cfg.read()
 
-    def setUp(self):
-        """Setup each test case before execution."""
-        super(TestSetupMiddleware, self).setUp()
-
-        self.middleware = SetupMiddleware()
-
-        self.kwargs = {
-            'view_func': HttpResponse,
-            'view_args': [],
-            'view_kwargs': {},
-        }
+    @staticmethod
+    @pytest.fixture(name='middleware')
+    def fixture_middleware(load_cfg):
+        """Fixture for returning middleware."""
+        return SetupMiddleware()
 
+    @staticmethod
     @patch('django.urls.reverse', return_value='users:login')
-    def test_404_urls(self, reverse):
+    def test_404_urls(reverse, middleware, kwargs):
         """Test how middleware deals with 404 URLs."""
         request = RequestFactory().get('/plinth/non-existing-url')
+        response = middleware.process_view(request, **kwargs)
+        assert response is None
 
-        response = self.middleware.process_view(request, **self.kwargs)
-
-        self.assertEqual(response, None)
-
+    @staticmethod
     @patch('django.urls.reverse', return_value='users:login')
-    def test_url_not_an_application(self, reverse):
+    def test_url_not_an_application(reverse, middleware, kwargs):
         """Test that none is returned for URLs that are not applications."""
         request = RequestFactory().get('/plinth/')
+        response = middleware.process_view(request, **kwargs)
+        assert response is None
 
-        response = self.middleware.process_view(request, **self.kwargs)
-
-        self.assertEqual(response, None)
-
+    @staticmethod
     @patch('plinth.module_loader.loaded_modules')
     @patch('django.urls.resolve')
     @patch('django.urls.reverse', return_value='users:login')
-    def test_module_is_up_to_date(self, reverse, resolve, loaded_modules):
+    def test_module_is_up_to_date(reverse, resolve, loaded_modules, middleware,
+                                  kwargs):
         """Test that none is returned when module is up-to-date."""
         resolve.return_value.namespaces = ['mockapp']
         module = Mock()
@@ -82,16 +79,16 @@ class TestSetupMiddleware(TestCase):
         loaded_modules.__getitem__.return_value = module
 
         request = RequestFactory().get('/plinth/mockapp')
+        response = middleware.process_view(request, **kwargs)
+        assert response is None
 
-        response = self.middleware.process_view(request, **self.kwargs)
-
-        self.assertEqual(response, None)
-
+    @staticmethod
     @patch('plinth.views.SetupView')
     @patch('plinth.module_loader.loaded_modules')
     @patch('django.urls.resolve')
     @patch('django.urls.reverse', return_value='users:login')
-    def test_module_view(self, reverse, resolve, loaded_modules, setup_view):
+    def test_module_view(reverse, resolve, loaded_modules, setup_view,
+                         middleware, kwargs):
         """Test that only registered users can access the setup view."""
         resolve.return_value.namespaces = ['mockapp']
         module = Mock()
@@ -103,21 +100,22 @@ class TestSetupMiddleware(TestCase):
 
         # Verify that anonymous users cannot access the setup page
         request.user = AnonymousUser()
-        self.middleware.process_view(request, **self.kwargs)
+        middleware.process_view(request, **kwargs)
         setup_view.as_view.assert_called_once_with()
         view.assert_not_called()
 
         # Verify that logged-in users can access the setup page
         request.user = User(username='johndoe')
-        self.middleware.process_view(request, **self.kwargs)
+        middleware.process_view(request, **kwargs)
         view.assert_called_once_with(request, setup_helper=module.setup_helper)
 
+    @staticmethod
     @patch('django.contrib.messages.success')
     @patch('plinth.module_loader.loaded_modules')
     @patch('django.urls.resolve')
     @patch('django.urls.reverse', return_value='users:login')
-    def test_install_result_collection(self, reverse, resolve, loaded_modules,
-                                       messages_success):
+    def test_install_result_collection(reverse, resolve, loaded_modules,
+                                       messages_success, middleware, kwargs):
         """Test that module installation result is collected properly."""
         resolve.return_value.namespaces = ['mockapp']
         module = Mock()
@@ -128,55 +126,54 @@ class TestSetupMiddleware(TestCase):
         loaded_modules.__getitem__.return_value = module
 
         request = RequestFactory().get('/plinth/mockapp')
-        response = self.middleware.process_view(request, **self.kwargs)
+        response = middleware.process_view(request, **kwargs)
 
-        self.assertIsNone(response)
+        assert response is None
         assert messages_success.called
         module.setup_helper.collect_result.assert_called_once_with()
 
 
-class TestAdminMiddleware(TestCase):
+class TestAdminMiddleware:
     """Test cases for admin middleware."""
-    @classmethod
-    def setUpClass(cls):
-        """Setup all the test cases."""
-        super(TestAdminMiddleware, cls).setUpClass()
 
-        cfg.read()
+    @staticmethod
+    @pytest.fixture(name='middleware')
+    def fixture_middleware(load_cfg):
+        """Fixture for returning middleware."""
+        return AdminRequiredMiddleware()
 
-    def setUp(self):
-        """Setup each test case before execution."""
-        super(TestAdminMiddleware, self).setUp()
+    @staticmethod
+    @pytest.fixture(name='web_request')
+    def fixture_web_request():
+        """Fixture for returning kwargs."""
+        web_request = RequestFactory().get('/plinth/mockapp')
+        web_request.user = Mock()
+        return web_request
 
-        self.middleware = AdminRequiredMiddleware()
-        self.kwargs = {
-            'view_func': HttpResponse,
-            'view_args': [],
-            'view_kwargs': {},
-        }
-
-        request = RequestFactory().get('/plinth/mockapp')
-        request.user = Mock()
-        self.request = request
-
-    def test_that_admin_view_is_denied_for_usual_user(self):
+    @staticmethod
+    def test_that_admin_view_is_denied_for_usual_user(web_request, middleware,
+                                                      kwargs):
         """Test that normal user is denied for an admin view"""
-        self.request.user.groups.filter().exists = Mock(return_value=False)
-        self.request.session = MagicMock()
-        self.assertRaises(PermissionDenied, self.middleware.process_view,
-                          self.request, **self.kwargs)
+        web_request.user.groups.filter().exists = Mock(return_value=False)
+        web_request.session = MagicMock()
+        with pytest.raises(PermissionDenied):
+            middleware.process_view(web_request, **kwargs)
 
-    def test_that_admin_view_is_allowed_for_admin_user(self):
+    @staticmethod
+    def test_that_admin_view_is_allowed_for_admin_user(web_request, middleware,
+                                                       kwargs):
         """Test that admin user is allowed for an admin view"""
-        self.request.user.groups.filter().exists = Mock(return_value=True)
-        self.request.session = MagicMock()
-        response = self.middleware.process_view(self.request, **self.kwargs)
-        self.assertIsNone(response)
+        web_request.user.groups.filter().exists = Mock(return_value=True)
+        web_request.session = MagicMock()
+        response = middleware.process_view(web_request, **kwargs)
+        assert response is None
 
-    def test_that_public_view_is_allowed_for_normal_user(self):
+    @staticmethod
+    def test_that_public_view_is_allowed_for_normal_user(
+            web_request, middleware, kwargs):
         """Test that normal user is allowed for an public view"""
-        kwargs = dict(self.kwargs)
+        kwargs = dict(kwargs)
         kwargs['view_func'] = public(HttpResponse)
 
-        response = self.middleware.process_view(self.request, **kwargs)
-        self.assertIsNone(response)
+        response = middleware.process_view(web_request, **kwargs)
+        assert response is None