Move misago caches tests to pytest

misago/cache/tests/conftest.py

@@ -1,5 +1,8 @@
+import pytest
+
 from misago.cache.models import CacheVersion
 
 
-def cache_version():
+@pytest.fixture
+def cache_version(db):
     return CacheVersion.objects.create(cache="test_cache")

misago/cache/tests/test_assert_invalidates_cache.py

@@ -1,25 +1,23 @@
-from django.test import TestCase
+import pytest
 
 from misago.cache.models import CacheVersion
 from misago.cache.test import assert_invalidates_cache
 from misago.cache.versions import invalidate_cache
 
 
-class AssertCacheVersionChangedTests(TestCase):
-    def test_assertion_fails_if_specified_cache_is_not_invaldiated(self):
-        CacheVersion.objects.create(cache="test")
-        with self.assertRaises(AssertionError):
-            with assert_invalidates_cache("test"):
-                pass
+def test_assertion_fails_if_specified_cache_is_not_invaldiated(cache_version):
+    with pytest.raises(AssertionError):
+        with assert_invalidates_cache(cache_version.cache):
+            pass
 
-    def test_assertion_passess_if_specified_cache_is_invalidated(self):
-        CacheVersion.objects.create(cache="test")
-        with assert_invalidates_cache("test"):
-            invalidate_cache("test")
 
-    def test_assertion_fails_if_other_cache_is_invalidated(self):
-        CacheVersion.objects.create(cache="test")
-        CacheVersion.objects.create(cache="changed_test")
-        with self.assertRaises(AssertionError):
-            with assert_invalidates_cache("test"):
-                invalidate_cache("changed_test")
+def test_assertion_passess_if_specified_cache_is_invalidated(cache_version):
+    with assert_invalidates_cache(cache_version.cache):
+        invalidate_cache(cache_version.cache)
+
+
+def test_assertion_fails_if_other_cache_is_invalidated(cache_version):
+    CacheVersion.objects.create(cache="changed_test")
+    with pytest.raises(AssertionError):
+        with assert_invalidates_cache(cache_version.cache):
+            invalidate_cache("changed_test")

misago/cache/tests/test_cache_versions_middleware.py

@@ -1,22 +1,27 @@
 from unittest.mock import Mock
 
-from django.test import TestCase
+import pytest
 
-from misago.cache.versions import CACHE_NAME
 from misago.cache.middleware import cache_versions_middleware
 
 
-class MiddlewareTests(TestCase):
-    def test_middleware_sets_attr_on_request(self):
-        get_response = Mock()
-        request = Mock()
-        middleware = cache_versions_middleware(get_response)
-        middleware(request)
-        assert request.cache_versions
-
-    def test_middleware_calls_get_response(self):
-        get_response = Mock()
-        request = Mock()
-        middleware = cache_versions_middleware(get_response)
-        middleware(request)
-        get_response.assert_called_once()
+@pytest.fixture
+def get_response():
+    return Mock()
+
+
+@pytest.fixture
+def request_mock():
+    return Mock()
+
+
+def test_middleware_sets_attr_on_request(db, get_response, request_mock):
+    middleware = cache_versions_middleware(get_response)
+    middleware(request_mock)
+    assert request_mock.cache_versions
+
+
+def test_middleware_calls_get_response(db, get_response, request_mock):
+    middleware = cache_versions_middleware(get_response)
+    middleware(request_mock)
+    get_response.assert_called_once()

misago/cache/tests/test_getting_cache_versions.py

@@ -1,45 +1,50 @@
-from unittest.mock import patch
-
-from django.test import TestCase
-
 from misago.cache.versions import (
-    CACHE_NAME, get_cache_versions, get_cache_versions_from_cache, get_cache_versions_from_db
+    CACHE_NAME, get_cache_versions, get_cache_versions_from_cache,
+    get_cache_versions_from_db
 )
 
 
-class CacheVersionsTests(TestCase):
-    def test_db_getter_returns_cache_versions_from_db(self):
-        with self.assertNumQueries(1):
-            assert get_cache_versions_from_db()
-
-    @patch('django.core.cache.cache.get', return_value=True)
-    def test_cache_getter_returns_cache_versions_from_cache(self, cache_get):
-        assert get_cache_versions_from_cache() is True
-        cache_get.assert_called_once_with(CACHE_NAME)
-
-    @patch('django.core.cache.cache.get', return_value=True)
-    def test_getter_reads_from_cache(self, cache_get):
-        with self.assertNumQueries(0):
-            assert get_cache_versions() is True
-        cache_get.assert_called_once_with(CACHE_NAME)
-
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_getter_reads_from_db_when_cache_is_not_available(self, cache_get, _):
-        db_caches = get_cache_versions_from_db()
-        with self.assertNumQueries(1):
-            assert get_cache_versions() == db_caches
-        cache_get.assert_called_once_with(CACHE_NAME)
-
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_getter_sets_new_cache_if_no_cache_is_set(self, _, cache_set):
-        get_cache_versions()
-        db_caches = get_cache_versions_from_db()
-        cache_set.assert_called_once_with(CACHE_NAME, db_caches)
-
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=True)
-    def test_getter_is_not_setting_new_cache_if_cache_is_set(self, _, cache_set):
-        get_cache_versions()
-        cache_set.assert_not_called()
+def test_db_getter_returns_cache_versions_from_db(db, django_assert_num_queries):
+    with django_assert_num_queries(1):
+        assert get_cache_versions_from_db()
+
+
+def test_cache_getter_returns_cache_versions_from_cache(mocker):
+    cache_get = mocker.patch('django.core.cache.cache.get', return_value=True)
+    assert get_cache_versions_from_cache() is True
+    cache_get.assert_called_once_with(CACHE_NAME)
+
+
+def test_getter_reads_from_cache(mocker, django_assert_num_queries):
+    cache_get = mocker.patch('django.core.cache.cache.get', return_value=True)
+    with django_assert_num_queries(0):
+        assert get_cache_versions() is True
+    cache_get.assert_called_once_with(CACHE_NAME)
+
+
+def test_getter_reads_from_db_if_no_cache_is_set(
+    db, mocker, django_assert_num_queries
+):
+    mocker.patch('django.core.cache.cache.set')
+    cache_get = mocker.patch('django.core.cache.cache.get', return_value=None)
+
+    db_caches = get_cache_versions_from_db()
+    with django_assert_num_queries(1):
+        assert get_cache_versions() == db_caches
+    cache_get.assert_called_once_with(CACHE_NAME)
+
+
+def test_getter_sets_new_cache_if_no_cache_is_set(db, mocker):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value=None)
+
+    get_cache_versions()
+    db_caches = get_cache_versions_from_db()
+    cache_set.assert_called_once_with(CACHE_NAME, db_caches)
+
+
+def test_getter_is_not_setting_new_cache_if_cache_is_set(mocker):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value=True)
+    get_cache_versions()
+    cache_set.assert_not_called()

misago/cache/tests/test_invalidate_caches_management_command.py

@@ -1,11 +1,9 @@
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
 
 from django.core.management import call_command
-from django.test import TestCase
 
 
-class InvalidateCachesManagementCommandTests(TestCase):
-    @patch("misago.cache.versions.invalidate_all_caches")
-    def test_management_command_invalidates_all_caches(self, invalidate_all_caches):
-        call_command('invalidateversionedcaches', stdout=Mock())
-        invalidate_all_caches.assert_called_once()
+def test_management_command_invalidates_all_caches(mocker):
+    invalidate_all_caches = mocker.patch("misago.cache.versions.invalidate_all_caches")
+    call_command('invalidateversionedcaches', stdout=Mock())
+    invalidate_all_caches.assert_called_once()

misago/cache/tests/test_invalidating_caches.py

@@ -1,38 +1,33 @@
-from unittest.mock import patch
-
-from django.test import TestCase
+import pytest
 
 from misago.cache.versions import (
-    CACHE_NAME, get_cache_versions_from_db, invalidate_cache, invalidate_all_caches
+    CACHE_NAME, invalidate_cache, invalidate_all_caches
 )
 from misago.cache.models import CacheVersion
 
-from .conftest import cache_version
-
-
-class InvalidatingCacheTests(TestCase):
-    @patch('django.core.cache.cache.delete')
-    def test_invalidating_cache_updates_cache_version_in_database(self, _):
-        test_cache = cache_version()
-        invalidate_cache(test_cache.cache)
-        updated_test_cache = CacheVersion.objects.get(cache=test_cache.cache)
-        assert test_cache.version != updated_test_cache.version
-
-    @patch('django.core.cache.cache.delete')
-    def test_invalidating_cache_deletes_versions_cache(self, cache_delete):
-        test_cache = cache_version()
-        invalidate_cache(test_cache.cache)
-        cache_delete.assert_called_once_with(CACHE_NAME)
-
-    @patch('django.core.cache.cache.delete')
-    def test_invalidating_all_caches_updates_cache_version_in_database(self, _):
-        test_cache = cache_version()
-        invalidate_all_caches()
-        updated_test_cache = CacheVersion.objects.get(cache=test_cache.cache)
-        assert test_cache.version != updated_test_cache.version
-
-    @patch('django.core.cache.cache.delete')
-    def test_invalidating_all_caches_deletes_versions_cache(self, cache_delete):
-        cache_version()
-        invalidate_all_caches()
-        cache_delete.assert_called_once_with(CACHE_NAME)
+
+@pytest.fixture
+def cache_delete(mocker):
+    return mocker.patch('django.core.cache.cache.delete')
+
+
+def test_invalidating_cache_updates_cache_version_in_database(cache_delete, cache_version):
+    invalidate_cache(cache_version.cache)
+    updated_cache_version = CacheVersion.objects.get(cache=cache_version.cache)
+    assert cache_version.version != updated_cache_version.version
+
+
+def test_invalidating_cache_deletes_versions_cache(cache_delete, cache_version):
+    invalidate_cache(cache_version.cache)
+    cache_delete.assert_called_once_with(CACHE_NAME)
+
+
+def test_invalidating_all_caches_updates_cache_version_in_database(cache_delete, cache_version):
+    invalidate_all_caches()
+    updated_cache_version = CacheVersion.objects.get(cache=cache_version.cache)
+    assert cache_version.version != updated_cache_version.version
+
+
+def test_invalidating_all_caches_deletes_versions_cache(cache_delete, cache_version):
+    invalidate_all_caches()
+    cache_delete.assert_called_once_with(CACHE_NAME)

misago/categories/tests/test_permissions_admin_views.py

@@ -2,14 +2,14 @@ from django.urls import reverse
 
 from misago.acl import ACL_CACHE
 from misago.acl.models import Role
-from misago.acl.test import mock_form_data
+from misago.acl.test import mock_role_form_data
 from misago.admin.testutils import AdminTestCase
 from misago.cache.test import assert_invalidates_cache
 from misago.categories.models import Category, CategoryRole
 
 
 def create_data(data_dict):
-    return mock_form_data(CategoryRole(), data_dict)
+    return mock_role_form_data(CategoryRole(), data_dict)
 
 
 class CategoryRoleAdminViewsTests(AdminTestCase):
@@ -163,11 +163,11 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         """
         self.client.post(
             reverse('misago:admin:permissions:users:new'),
-            data=mock_form_data(Role(), {'name': 'Test Role A'})
+            data=mock_role_form_data(Role(), {'name': 'Test Role A'})
         )
         self.client.post(
             reverse('misago:admin:permissions:users:new'),
-            data=mock_form_data(Role(), {'name': 'Test Role B'})
+            data=mock_role_form_data(Role(), {'name': 'Test Role B'})
         )
 
         test_role_a = Role.objects.get(name='Test Role A')
@@ -244,7 +244,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         """change role categories perms view works"""
         self.client.post(
             reverse('misago:admin:permissions:users:new'),
-            data=mock_form_data(Role(), {'name': 'Test CategoryRole'})
+            data=mock_role_form_data(Role(), {'name': 'Test CategoryRole'})
         )
 
         test_role = Role.objects.get(name='Test CategoryRole')