Merge pull request #1152 from rafalp/move-some-tests-to-pytest

Move recently written tests to pytest

misago/acl/test.py

@@ -2,6 +2,7 @@ from contextlib import ContextDecorator, ExitStack, contextmanager
 from functools import wraps
 from unittest.mock import patch
 
+from .forms import get_permissions_forms
 from .useracl import get_user_acl
 
 __all__ = ["patch_user_acl"]
@@ -54,3 +55,20 @@ class patch_user_acl(ContextDecorator, ExitStack):
             "misago.acl.useracl.get_user_acl",
             side_effect=self.patched_get_user_acl,
         )
+
+
+def mock_role_form_data(model, data):
+    """
+    In order for form to don't fail submission, all permission fields need
+    to receive values. This function populates data dict with default values
+    for permissions, making form validation pass
+    """
+    for form in get_permissions_forms(model):
+        for field in form:
+            if field.value() is True:
+                data[field.html_name] = 1
+            elif field.value() is False:
+                data[field.html_name] = 0
+            else:
+                data[field.html_name] = field.value()
+    return data

misago/acl/tests/test_acl_algebra.py

@@ -1,88 +1,82 @@
-from django.test import TestCase
-
 from misago.acl import algebra
 
 
-class ComparisionsTests(TestCase):
-    def test_greater(self):
-        """greater permission wins test"""
-        self.assertEqual(algebra.greater(1, 3), 3)
-        self.assertEqual(algebra.greater(4, 2), 4)
-        self.assertEqual(algebra.greater(2, 2), 2)
-        self.assertEqual(algebra.greater(True, False), True)
+def test_greatest_value_is_returned():
+    assert algebra.greater(1, 3) == 3
+    assert algebra.greater(4, 2) == 4
+    assert algebra.greater(2, 2) == 2
+    assert algebra.greater(True, False) == True
+
+
+def test_greatest_or_zero_value_is_returned():
+    assert algebra.greater_or_zero(1, 3) == 3
+    assert algebra.greater_or_zero(4, 2) == 4
+    assert algebra.greater_or_zero(2, 2) == 2
+    assert algebra.greater_or_zero(True, False) == False
+    assert algebra.greater_or_zero(2, 0) == 0
+    assert algebra.greater_or_zero(0, 0) == 0
+    assert algebra.greater_or_zero(0, 120) == 0
 
-    def test_greater_or_zero(self):
-        """greater or zero permission wins test"""
-        self.assertEqual(algebra.greater_or_zero(1, 3), 3)
-        self.assertEqual(algebra.greater_or_zero(4, 2), 4)
-        self.assertEqual(algebra.greater_or_zero(2, 2), 2)
-        self.assertEqual(algebra.greater_or_zero(True, False), False)
-        self.assertEqual(algebra.greater_or_zero(2, 0), 0)
-        self.assertEqual(algebra.greater_or_zero(0, 0), 0)
-        self.assertEqual(algebra.greater_or_zero(0, 120), 0)
 
-    def test_lower(self):
-        """lower permission wins test"""
-        self.assertEqual(algebra.lower(1, 3), 1)
-        self.assertEqual(algebra.lower(4, 2), 2)
-        self.assertEqual(algebra.lower(2, 2), 2)
-        self.assertEqual(algebra.lower(True, False), False)
+def test_lower_value_is_returned():
+    assert algebra.lower(1, 3) == 1
+    assert algebra.lower(4, 2) == 2
+    assert algebra.lower(2, 2) == 2
+    assert algebra.lower(True, False) == False
 
-    def test_lower_non_zero(self):
-        """lower non-zero wins test"""
-        self.assertEqual(algebra.lower_non_zero(1, 3), 1)
-        self.assertEqual(algebra.lower_non_zero(0, 2), 2)
-        self.assertEqual(algebra.lower_non_zero(1, 2), 1)
-        self.assertEqual(algebra.lower_non_zero(0, 0), 0)
 
+def test_lowest_non_zero_value_is_returned():
+    assert algebra.lower_non_zero(1, 3) == 1
+    assert algebra.lower_non_zero(0, 2) == 2
+    assert algebra.lower_non_zero(1, 2) == 1
+    assert algebra.lower_non_zero(0, 0) == 0
 
-class SumACLTests(TestCase):
-    def test_sum_acls(self):
-        """acls are summed"""
-        test_acls = [
-            {
-                'can_see': 0,
-                'can_hear': 0,
-                'max_speed': 10,
-                'min_age': 16,
-                'speed_limit': 50,
-            },
-            {
-                'can_see': 1,
-                'can_hear': 0,
-                'max_speed': 40,
-                'min_age': 20,
-                'speed_limit': 0,
-            },
-            {
-                'can_see': 0,
-                'can_hear': 1,
-                'max_speed': 80,
-                'min_age': 18,
-                'speed_limit': 40,
-            },
-        ]
 
-        defaults = {
+def test_acls_are_be_added_together():
+    test_acls = [
+        {
             'can_see': 0,
             'can_hear': 0,
-            'max_speed': 30,
+            'max_speed': 10,
+            'min_age': 16,
+            'speed_limit': 50,
+        },
+        {
+            'can_see': 1,
+            'can_hear': 0,
+            'max_speed': 40,
+            'min_age': 20,
+            'speed_limit': 0,
+        },
+        {
+            'can_see': 0,
+            'can_hear': 1,
+            'max_speed': 80,
             'min_age': 18,
-            'speed_limit': 60,
-        }
+            'speed_limit': 40,
+        },
+    ]
+
+    defaults = {
+        'can_see': 0,
+        'can_hear': 0,
+        'max_speed': 30,
+        'min_age': 18,
+        'speed_limit': 60,
+    }
 
-        acl = algebra.sum_acls(
-            defaults,
-            acls=test_acls,
-            can_see=algebra.greater,
-            can_hear=algebra.greater,
-            max_speed=algebra.greater,
-            min_age=algebra.lower,
-            speed_limit=algebra.greater_or_zero,
-        )
+    acl = algebra.sum_acls(
+        defaults,
+        acls=test_acls,
+        can_see=algebra.greater,
+        can_hear=algebra.greater,
+        max_speed=algebra.greater,
+        min_age=algebra.lower,
+        speed_limit=algebra.greater_or_zero,
+    )
 
-        self.assertEqual(acl['can_see'], 1)
-        self.assertEqual(acl['can_hear'], 1)
-        self.assertEqual(acl['max_speed'], 80)
-        self.assertEqual(acl['min_age'], 16)
-        self.assertEqual(acl['speed_limit'], 0)
+    assert acl['can_see'] == 1
+    assert acl['can_hear'] == 1
+    assert acl['max_speed'] == 80
+    assert acl['min_age'] == 16
+    assert acl['speed_limit'] == 0

misago/acl/tests/test_getting_user_acl.py

@@ -1,94 +1,102 @@
-from unittest.mock import patch
+from misago.acl.useracl import get_user_acl
 
-from django.contrib.auth import get_user_model
-from django.test import TestCase
 
-from misago.acl.useracl import get_user_acl
-from misago.conftest import get_cache_versions
-from misago.users.models import AnonymousUser
-
-User = get_user_model()
-
-cache_versions = get_cache_versions()
-
-
-class GettingUserACLTests(TestCase):
-    def test_getter_returns_authenticated_user_acl(self):
-        user = User.objects.create_user('Bob', 'bob@bob.com')
-        acl = get_user_acl(user, cache_versions)
-
-        assert acl
-        assert acl["user_id"] == user.id
-        assert acl["is_authenticated"] is True
-        assert acl["is_anonymous"] is False
-
-    def test_user_acl_includes_staff_and_superuser_false_status(self):
-        user = User.objects.create_user('Bob', 'bob@bob.com')
-        acl = get_user_acl(user, cache_versions)
-
-        assert acl
-        assert acl["is_staff"] is False
-        assert acl["is_superuser"] is False
-
-    def test_user_acl_includes_cache_versions(self):
-        user = User.objects.create_user('Bob', 'bob@bob.com')
-        acl = get_user_acl(user, cache_versions)
-
-        assert acl
-        assert acl["cache_versions"] == cache_versions
-
-    def test_getter_returns_anonymous_user_acl(self):
-        user = AnonymousUser()
-        acl = get_user_acl(user, cache_versions)
-
-        assert acl
-        assert acl["user_id"] == user.id
-        assert acl["is_authenticated"] is False
-        assert acl["is_anonymous"] is True
-
-    def test_superuser_acl_includes_staff_and_superuser_true_status(self):
-        user = User.objects.create_superuser('Bob', 'bob@bob.com', 'Pass.123')
-        acl = get_user_acl(user, cache_versions)
-
-        assert acl
-        assert acl["is_staff"] is True
-        assert acl["is_superuser"] is True
-
-    @patch('django.core.cache.cache.get', return_value=dict())
-    def test_getter_returns_acl_from_cache(self, cache_get):
-        user = AnonymousUser()
-        get_user_acl(user, cache_versions)
-        cache_get.assert_called_once()
-
-    @patch('django.core.cache.cache.set')
-    @patch('misago.acl.buildacl.build_acl', return_value=dict())
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_getter_builds_new_acl_when_cache_is_not_available(self, cache_get, *_):
-        user = AnonymousUser()
-        get_user_acl(user, cache_versions)
-        cache_get.assert_called_once()
-
-    @patch('django.core.cache.cache.set')
-    @patch('misago.acl.buildacl.build_acl', return_value=dict())
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_getter_sets_new_cache_if_no_cache_is_set(self, cache_set, *_):
-        user = AnonymousUser()
-        get_user_acl(user, cache_versions)
-        cache_set.assert_called_once()
-
-
-    @patch('django.core.cache.cache.set')
-    @patch('misago.acl.buildacl.build_acl', return_value=dict())
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_acl_cache_name_includes_cache_verssion(self, cache_set, *_):
-        user = AnonymousUser()
-        get_user_acl(user, cache_versions)
-        cache_key = cache_set.call_args[0][0]
-        assert cache_versions["acl"] in cache_key
-
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=dict())
-    def test_getter_is_not_setting_new_cache_if_cache_is_set(self, _, cache_set):
-        user = AnonymousUser()
-        get_user_acl(user, cache_versions)
-        cache_set.assert_not_called()
+def test_getter_returns_authenticated_user_acl(cache_versions, user):
+    acl = get_user_acl(user, cache_versions)
+
+    assert acl
+    assert acl["user_id"] == user.id
+    assert acl["is_authenticated"] is True
+    assert acl["is_anonymous"] is False
+
+
+def test_user_acl_includes_staff_and_superuser_false_status(cache_versions, user):
+    acl = get_user_acl(user, cache_versions)
+
+    assert acl
+    assert acl["is_staff"] is False
+    assert acl["is_superuser"] is False
+
+
+def test_user_acl_includes_cache_versions(cache_versions, user):
+    acl = get_user_acl(user, cache_versions)
+
+    assert acl
+    assert acl["cache_versions"] == cache_versions
+
+
+def test_getter_returns_anonymous_user_acl(db, cache_versions, anonymous_user):
+    acl = get_user_acl(anonymous_user, cache_versions)
+
+    assert acl
+    assert acl["user_id"] == anonymous_user.id
+    assert acl["is_authenticated"] is False
+    assert acl["is_anonymous"] is True
+
+
+def test_superuser_acl_includes_staff_and_superuser_true_status(
+    cache_versions, superuser
+):
+    acl = get_user_acl(superuser, cache_versions)
+
+    assert acl
+    assert acl["is_staff"] is True
+    assert acl["is_superuser"] is True
+
+
+def test_staffuser_acl_includes_staff_and_superuser_true_status(
+    cache_versions, staffuser
+):
+    acl = get_user_acl(staffuser, cache_versions)
+
+    assert acl
+    assert acl["is_staff"] is True
+    assert acl["is_superuser"] is False
+
+
+def test_getter_returns_acl_from_cache(mocker, db, cache_versions, anonymous_user):
+    cache_get = mocker.patch('django.core.cache.cache.get', return_value=dict())
+    get_user_acl(anonymous_user, cache_versions)
+    cache_get.assert_called_once()
+
+
+def test_getter_builds_new_acl_when_cache_is_not_available(mocker, cache_versions, user):
+    mocker.patch('django.core.cache.cache.set')
+    mocker.patch('misago.acl.buildacl.build_acl', return_value=dict())
+    cache_get = mocker.patch('django.core.cache.cache.get', return_value=None)
+
+    get_user_acl(user, cache_versions)
+    cache_get.assert_called_once()
+
+
+def test_getter_sets_new_cache_if_no_cache_is_set(
+    mocker, db, cache_versions, anonymous_user
+):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('misago.acl.buildacl.build_acl', return_value=dict())
+    mocker.patch('django.core.cache.cache.get', return_value=None)
+
+    get_user_acl(anonymous_user, cache_versions)
+    cache_set.assert_called_once()
+
+
+def test_acl_cache_name_includes_cache_version(
+    mocker, db, cache_versions, anonymous_user
+):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('misago.acl.buildacl.build_acl', return_value=dict())
+    mocker.patch('django.core.cache.cache.get', return_value=None)
+
+    get_user_acl(anonymous_user, cache_versions)
+    cache_key = cache_set.call_args[0][0]
+    assert cache_versions["acl"] in cache_key
+
+
+def test_getter_is_not_setting_new_cache_if_cache_is_set(
+    mocker, cache_versions, anonymous_user
+):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value=dict())
+
+    get_user_acl(anonymous_user, cache_versions)
+    cache_set.assert_not_called()

misago/acl/tests/test_mock_role_admin_form_data.py

@@ -0,0 +1,7 @@
+from misago.acl.models import Role
+from misago.acl.test import mock_role_form_data
+
+
+def test_factory_for_change_role_permissions_form_data():
+    test_data = mock_role_form_data(Role(), {'can_fly': 1})
+    assert "can_fly" in test_data

misago/acl/tests/test_patching_user_acl.py

@@ -1,79 +1,67 @@
-from django.contrib.auth import get_user_model
-from django.test import TestCase
-
 from misago.acl import useracl
 from misago.acl.test import patch_user_acl
-from misago.conftest import get_cache_versions
-
-User = get_user_model()
-
-cache_versions = get_cache_versions()
 
 
 def callable_acl_patch(user, user_acl):
     user_acl["patched_for_user_id"] = user.id
 
 
-class PatchingUserACLTests(TestCase):
+@patch_user_acl({"is_patched": True})
+def test_decorator_patches_all_users_acls_in_test(cache_versions, user):
+    user_acl = useracl.get_user_acl(user, cache_versions)
+    assert user_acl["is_patched"]
+
+
+def test_decorator_removes_patches_after_test(cache_versions, user):
     @patch_user_acl({"is_patched": True})
-    def test_decorator_patches_all_users_acls_in_test(self):
-        user = User.objects.create_user("User", "user@example.com")
+    def test_function(patch_user_acl):
         user_acl = useracl.get_user_acl(user, cache_versions)
         assert user_acl["is_patched"]
 
-    def test_decorator_removes_patches_after_test(self):
-        user = User.objects.create_user("User", "user@example.com")
+    user_acl = useracl.get_user_acl(user, cache_versions)
+    assert "is_patched" not in user_acl
 
-        @patch_user_acl({"is_patched": True})
-        def test_function(patch_user_acl):
-            user_acl = useracl.get_user_acl(user, cache_versions)
-            assert user_acl["is_patched"]
 
+def test_context_manager_patches_all_users_acls_in_test(cache_versions, user):
+    with patch_user_acl({"can_rename_users": "patched"}):
         user_acl = useracl.get_user_acl(user, cache_versions)
-        assert "is_patched" not in user_acl
+        assert user_acl["can_rename_users"] == "patched"
 
-    def test_context_manager_patches_all_users_acls_in_test(self):
-        user = User.objects.create_user("User", "user@example.com")
-        with patch_user_acl({"can_rename_users": "patched"}):
-            user_acl = useracl.get_user_acl(user, cache_versions)
-            assert user_acl["can_rename_users"] == "patched"
 
-    def test_context_manager_removes_patches_after_exit(self):
-        user = User.objects.create_user("User", "user@example.com")
+def test_context_manager_removes_patches_after_exit(cache_versions, user):
+    with patch_user_acl({"is_patched": True}):
+        user_acl = useracl.get_user_acl(user, cache_versions)
+        assert user_acl["is_patched"]
 
-        with patch_user_acl({"is_patched": True}):
-            user_acl = useracl.get_user_acl(user, cache_versions)
-            assert user_acl["is_patched"]
+    user_acl = useracl.get_user_acl(user, cache_versions)
+    assert "is_patched" not in user_acl
+
+
+@patch_user_acl(callable_acl_patch)
+def test_callable_patch_is_called_with_user_and_acl_by_decorator(cache_versions, user):
+    user_acl = useracl.get_user_acl(user, cache_versions)
+    assert user_acl["patched_for_user_id"] == user.id
 
-        user_acl = useracl.get_user_acl(user, cache_versions)
-        assert "is_patched" not in user_acl
 
-    @patch_user_acl(callable_acl_patch)
-    def test_callable_patch_is_called_with_user_and_acl_by_decorator(self):
-        user = User.objects.create_user("User", "user@example.com")
+def test_callable_patch_is_called_with_user_and_acl_by_context_manager(cache_versions, user):
+    with patch_user_acl(callable_acl_patch):
         user_acl = useracl.get_user_acl(user, cache_versions)
         assert user_acl["patched_for_user_id"] == user.id
 
-    def test_callable_patch_is_called_with_user_and_acl_by_context_manager(self):
-        user = User.objects.create_user("User", "user@example.com")
-        with patch_user_acl(callable_acl_patch):
-            user_acl = useracl.get_user_acl(user, cache_versions)
-            assert user_acl["patched_for_user_id"] == user.id
 
-    @patch_user_acl({"acl_patch": 1})
-    @patch_user_acl({"acl_patch": 2})
-    def test_multiple_acl_patches_applied_by_decorator_stack(self):
-        user = User.objects.create_user("User", "user@example.com")
-        user_acl = useracl.get_user_acl(user, cache_versions)
-        assert user_acl["acl_patch"] == 2
-
-    def test_multiple_acl_patches_applied_by_context_manager_stack(self):
-        user = User.objects.create_user("User", "user@example.com")
-        with patch_user_acl({"acl_patch": 1}):
-            with patch_user_acl({"acl_patch": 2}):
-                user_acl = useracl.get_user_acl(user, cache_versions)
-                assert user_acl["acl_patch"] == 2
+@patch_user_acl({"acl_patch": 1})
+@patch_user_acl({"acl_patch": 2})
+def test_multiple_acl_patches_applied_by_decorator_stack(cache_versions, user):
+    user_acl = useracl.get_user_acl(user, cache_versions)
+    assert user_acl["acl_patch"] == 2
+
+
+def test_multiple_acl_patches_applied_by_context_manager_stack(cache_versions, user):
+    with patch_user_acl({"acl_patch": 1}):
+        with patch_user_acl({"acl_patch": 2}):
             user_acl = useracl.get_user_acl(user, cache_versions)
-            assert user_acl["acl_patch"] == 1
+            assert user_acl["acl_patch"] == 2
         user_acl = useracl.get_user_acl(user, cache_versions)
-        assert "acl_patch" not in user_acl
+        assert user_acl["acl_patch"] == 1
+    user_acl = useracl.get_user_acl(user, cache_versions)
+    assert "acl_patch" not in user_acl

misago/acl/tests/test_providers.py

@@ -1,85 +1,93 @@
-from django.test import TestCase
+import pytest
 
 from misago.acl.providers import PermissionProviders
 from misago.conf import settings
 
 
-class PermissionProvidersTests(TestCase):
-    def test_providers_are_not_loaded_on_container_init(self):
-        providers = PermissionProviders()
+def test_providers_are_not_loaded_on_container_init():
+    providers = PermissionProviders()
 
-        assert not providers._initialized
-        assert not providers._providers
-        assert not providers._annotators
-        assert not providers._user_acl_serializers
+    assert not providers._initialized
+    assert not providers._providers
+    assert not providers._annotators
+    assert not providers._user_acl_serializers
 
-    def test_container_loads_providers(self):
-        providers = PermissionProviders()
-        providers.load()
 
-        assert providers._providers
-        assert providers._annotators
-        assert providers._user_acl_serializers
+def test_container_loads_providers():
+    providers = PermissionProviders()
+    providers.load()
 
-    def test_loading_providers_second_time_raises_runtime_error(self):
-        providers = PermissionProviders()
-        providers.load()
+    assert providers._providers
+    assert providers._annotators
+    assert providers._user_acl_serializers
 
-        with self.assertRaises(RuntimeError):
-            providers.load()
 
-    def test_container_returns_list_of_providers(self):
-        providers = PermissionProviders()
-        providers.load()
-        
-        providers_setting = settings.MISAGO_ACL_EXTENSIONS
-        self.assertEqual(len(providers.list()), len(providers_setting))
+def test_loading_providers_second_time_raises_runtime_error():
+    providers = PermissionProviders()
+    providers.load()
 
-    def test_container_returns_dict_of_providers(self):
-        providers = PermissionProviders()
+    with pytest.raises(RuntimeError):
         providers.load()
-        
-        providers_setting = settings.MISAGO_ACL_EXTENSIONS
-        self.assertEqual(len(providers.dict()), len(providers_setting))
-
-    def test_accessing_providers_list_before_load_raises_assertion_error(self):
-        providers = PermissionProviders()
-        with self.assertRaises(AssertionError):
-            providers.list()
+
+
+def test_container_returns_list_of_providers():
+    providers = PermissionProviders()
+    providers.load()
     
-    def test_accessing_providers_dict_before_load_raises_assertion_error(self):
-        providers = PermissionProviders()
-        with self.assertRaises(AssertionError):
-            providers.dict()
+    providers_setting = settings.MISAGO_ACL_EXTENSIONS
+    assert len(providers.list()) == len(providers_setting)
 
-    def test_getter_returns_registered_type_annotator(self):
-        class TestType(object):
-            pass
 
+def test_container_returns_dict_of_providers():
+    providers = PermissionProviders()
+    providers.load()
+    
+    providers_setting = settings.MISAGO_ACL_EXTENSIONS
+    assert len(providers.dict()) == len(providers_setting)
 
-        def test_annotator():
-            pass
-        
 
-        providers = PermissionProviders()
-        providers.acl_annotator(TestType, test_annotator)
-        providers.load()
+def test_accessing_providers_list_before_load_raises_assertion_error():
+    providers = PermissionProviders()
+    with pytest.raises(AssertionError):
+        providers.list()
 
-        assert test_annotator in providers.get_obj_type_annotators(TestType())
 
-    def test_container_returns_list_of_user_acl_serializers(self):
-        providers = PermissionProviders()
-        providers.load()
+def test_accessing_providers_dict_before_load_raises_assertion_error():
+    providers = PermissionProviders()
+    with pytest.raises(AssertionError):
+        providers.dict()
 
-        assert providers.get_user_acl_serializers()
 
-    def test_getter_returns_registered_user_acl_serializer(self):
-        def test_user_acl_serializer():
-            pass
+def test_getter_returns_registered_type_annotator():
+    class TestType(object):
+        pass
 
 
-        providers = PermissionProviders()
-        providers.user_acl_serializer(test_user_acl_serializer)
-        providers.load()
+    def test_annotator():
+        pass
+    
+
+    providers = PermissionProviders()
+    providers.acl_annotator(TestType, test_annotator)
+    providers.load()
+
+    assert test_annotator in providers.get_obj_type_annotators(TestType())
+
+
+def test_container_returns_list_of_user_acl_serializers():
+    providers = PermissionProviders()
+    providers.load()
+
+    assert providers.get_user_acl_serializers()
+
+
+def test_getter_returns_registered_user_acl_serializer():
+    def test_user_acl_serializer():
+        pass
+
+
+    providers = PermissionProviders()
+    providers.user_acl_serializer(test_user_acl_serializer)
+    providers.load()
 
-        assert test_user_acl_serializer in providers.get_user_acl_serializers()
+    assert test_user_acl_serializer in providers.get_user_acl_serializers()

misago/acl/tests/test_roleadmin_views.py

@@ -2,13 +2,13 @@ from django.urls import reverse
 
 from misago.acl import ACL_CACHE
 from misago.acl.models import Role
-from misago.acl.testutils import fake_post_data
+from misago.acl.test import mock_role_form_data
 from misago.cache.test import assert_invalidates_cache
 from misago.admin.testutils import AdminTestCase
 
 
-def fake_data(data_dict):
-    return fake_post_data(Role(), data_dict)
+def create_data(data_dict):
+    return mock_role_form_data(Role(), data_dict)
 
 
 class RoleAdminViewsTests(AdminTestCase):
@@ -28,7 +28,7 @@ class RoleAdminViewsTests(AdminTestCase):
         self.assertEqual(response.status_code, 200)
 
         response = self.client.post(
-            reverse('misago:admin:permissions:users:new'), data=fake_data({
+            reverse('misago:admin:permissions:users:new'), data=create_data({
                 'name': 'Test Role',
             })
         )
@@ -42,7 +42,7 @@ class RoleAdminViewsTests(AdminTestCase):
     def test_edit_view(self):
         """edit role view has no showstoppers"""
         self.client.post(
-            reverse('misago:admin:permissions:users:new'), data=fake_data({
+            reverse('misago:admin:permissions:users:new'), data=create_data({
                 'name': 'Test Role',
             })
         )
@@ -61,7 +61,7 @@ class RoleAdminViewsTests(AdminTestCase):
             reverse('misago:admin:permissions:users:edit', kwargs={
                 'pk': test_role.pk,
             }),
-            data=fake_data({
+            data=create_data({
                 'name': 'Top Lel',
             })
         )
@@ -74,7 +74,7 @@ class RoleAdminViewsTests(AdminTestCase):
 
     def test_editing_role_invalidates_acl_cache(self):
         self.client.post(
-            reverse('misago:admin:permissions:users:new'), data=fake_data({
+            reverse('misago:admin:permissions:users:new'), data=create_data({
                 'name': 'Test Role',
             })
         )
@@ -86,7 +86,7 @@ class RoleAdminViewsTests(AdminTestCase):
                 reverse('misago:admin:permissions:users:edit', kwargs={
                     'pk': test_role.pk,
                 }),
-                data=fake_data({
+                data=create_data({
                     'name': 'Top Lel',
                 })
             )
@@ -94,7 +94,7 @@ class RoleAdminViewsTests(AdminTestCase):
     def test_users_view(self):
         """users with this role view has no showstoppers"""
         response = self.client.post(
-            reverse('misago:admin:permissions:users:new'), data=fake_data({
+            reverse('misago:admin:permissions:users:new'), data=create_data({
                 'name': 'Test Role',
             })
         )
@@ -110,7 +110,7 @@ class RoleAdminViewsTests(AdminTestCase):
     def test_delete_view(self):
         """delete role view has no showstoppers"""
         self.client.post(
-            reverse('misago:admin:permissions:users:new'), data=fake_data({
+            reverse('misago:admin:permissions:users:new'), data=create_data({
                 'name': 'Test Role',
             })
         )
@@ -130,7 +130,7 @@ class RoleAdminViewsTests(AdminTestCase):
 
     def test_deleting_role_invalidates_acl_cache(self):
         self.client.post(
-            reverse('misago:admin:permissions:users:new'), data=fake_data({
+            reverse('misago:admin:permissions:users:new'), data=create_data({
                 'name': 'Test Role',
             })
         )

misago/acl/tests/test_serializing_user_acl.py

@@ -1,24 +1,14 @@
 import json
 
-from django.contrib.auth import get_user_model
-from django.test import TestCase
-
 from misago.acl.useracl import get_user_acl, serialize_user_acl
-from misago.conftest import get_cache_versions
-
-User = get_user_model()
 
-cache_versions = get_cache_versions()
 
+def test_user_acl_is_serializeable(cache_versions, user):
+    acl = get_user_acl(user, cache_versions)
+    assert serialize_user_acl(acl)
 
-class SerializingUserACLTests(TestCase):
-    def test_user_acl_is_serializeable(self):
-        user = User.objects.create_user('Bob', 'bob@bob.com')
-        acl = get_user_acl(user, cache_versions)
-        assert serialize_user_acl(acl)
 
-    def test_user_acl_is_json_serializeable(self):
-        user = User.objects.create_user('Bob', 'bob@bob.com')
-        acl = get_user_acl(user, cache_versions)
-        serialized_acl = serialize_user_acl(acl)
-        assert json.dumps(serialized_acl)
+def test_user_acl_is_json_serializeable(cache_versions, user):
+    acl = get_user_acl(user, cache_versions)
+    serialized_acl = serialize_user_acl(acl)
+    assert json.dumps(serialized_acl)

misago/acl/tests/test_testutils.py

@@ -1,11 +0,0 @@
-from django.test import TestCase
-
-from misago.acl.models import Role
-from misago.acl.testutils import fake_post_data
-
-
-class FakeTestDataTests(TestCase):
-    def test_fake_post_data_for_role(self):
-        """fake data was created for Role"""
-        test_data = fake_post_data(Role(), {'can_fly': 1})
-        self.assertIn('can_fly', test_data)

misago/acl/tests/test_user_acl_context_processor.py

@@ -1,12 +1,9 @@
 from unittest.mock import Mock
 
-from django.test import TestCase
-
 from misago.acl.context_processors import user_acl
 
 
-class ContextProcessorsTests(TestCase):
-    def test_context_processor_adds_request_user_acl_to_context(self):
-        test_acl = {"test": True}
-        context = user_acl(Mock(user_acl=test_acl))
-        assert context == {"user_acl": test_acl}
+def test_context_processor_adds_request_user_acl_to_context():
+    test_acl = {"test": True}
+    context = user_acl(Mock(user_acl=test_acl))
+    assert context == {"user_acl": test_acl}

misago/acl/tests/test_user_acl_middleware.py

@@ -1,30 +1,19 @@
 from unittest.mock import Mock
 
-from django.contrib.auth import get_user_model
-from django.test import TestCase
-
 from misago.acl.middleware import user_acl_middleware
-from misago.conftest import get_cache_versions
-
-User = get_user_model()
-
-cache_versions = get_cache_versions()
 
 
-class MiddlewareTests(TestCase):
-    def test_middleware_sets_attr_on_request(self):
-        user = User.objects.create_user("User", "user@example.com")
+def test_middleware_sets_attr_on_request(cache_versions, user):
+    get_response = Mock()
+    request = Mock(user=user, cache_versions=cache_versions)
+    middleware = user_acl_middleware(get_response)
+    middleware(request)
+    assert request.user_acl
 
-        get_response = Mock()
-        request = Mock(user=user, cache_versions=cache_versions)
-        middleware = user_acl_middleware(get_response)
-        middleware(request)
-        assert request.user_acl
 
-    def test_middleware_calls_get_response(self):
-        user = User.objects.create_user("User", "user@example.com")
-        get_response = Mock()
-        request = Mock(user=user, cache_versions=cache_versions)
-        middleware = user_acl_middleware(get_response)
-        middleware(request)
-        get_response.assert_called_once()
+def test_middleware_calls_get_response(cache_versions, user):
+    get_response = Mock()
+    request = Mock(user=user, cache_versions=cache_versions)
+    middleware = user_acl_middleware(get_response)
+    middleware(request)
+    get_response.assert_called_once()

misago/acl/testutils.py

@@ -1,18 +0,0 @@
-from .forms import get_permissions_forms
-
-
-def fake_post_data(target, data_dict):
-    """
-    In order for form to don't fail submission, all permission fields need
-    to receive values. This function populates data dict with default values
-    for permissions, making form validation pass
-    """
-    for form in get_permissions_forms(target):
-        for field in form:
-            if field.value() is True:
-                data_dict[field.html_name] = 1
-            elif field.value() is False:
-                data_dict[field.html_name] = 0
-            else:
-                data_dict[field.html_name] = field.value()
-    return data_dict

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.testutils import fake_post_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 fake_data(data_dict):
-    return fake_post_data(CategoryRole(), data_dict)
+def create_data(data_dict):
+    return mock_role_form_data(CategoryRole(), data_dict)
 
 
 class CategoryRoleAdminViewsTests(AdminTestCase):
@@ -32,7 +32,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
 
         response = self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test CategoryRole',
             }),
         )
@@ -46,7 +46,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         """edit role view has no showstoppers"""
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test CategoryRole',
             }),
         )
@@ -64,7 +64,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
             reverse('misago:admin:permissions:categories:edit', kwargs={
                 'pk': test_role.pk,
             }),
-            data=fake_data({
+            data=create_data({
                 'name': 'Top Lel',
             }),
         )
@@ -77,7 +77,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
     def test_editing_role_invalidates_acl_cache(self):
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test CategoryRole',
             }),
         )
@@ -89,7 +89,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
                 reverse('misago:admin:permissions:categories:edit', kwargs={
                     'pk': test_role.pk,
                 }),
-                data=fake_data({
+                data=create_data({
                     'name': 'Top Lel',
                 }),
             )
@@ -98,7 +98,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         """delete role view has no showstoppers"""
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test CategoryRole',
             }),
         )
@@ -118,7 +118,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
     def test_deleting_role_invalidates_acl_cache(self):
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test CategoryRole',
             }),
         )
@@ -163,11 +163,11 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         """
         self.client.post(
             reverse('misago:admin:permissions:users:new'),
-            data=fake_post_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=fake_post_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')
@@ -175,13 +175,13 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
 
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test Comments',
             }),
         )
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test Full',
             }),
         )
@@ -244,7 +244,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         """change role categories perms view works"""
         self.client.post(
             reverse('misago:admin:permissions:users:new'),
-            data=fake_post_data(Role(), {'name': 'Test CategoryRole'})
+            data=mock_role_form_data(Role(), {'name': 'Test CategoryRole'})
         )
 
         test_role = Role.objects.get(name='Test CategoryRole')
@@ -329,7 +329,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
         # Set test roles
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test Comments',
             }),
         )
@@ -337,7 +337,7 @@ class CategoryRoleAdminViewsTests(AdminTestCase):
 
         self.client.post(
             reverse('misago:admin:permissions:categories:new'),
-            data=fake_data({
+            data=create_data({
                 'name': 'Test Full',
             }),
         )

misago/conf/dynamicsettings.py

@@ -34,7 +34,9 @@ class DynamicSettings:
     def __getattr__(self, setting):
         if setting in self._overrides:
             return self._overrides[setting]
-        return self._settings[setting]["value"]
+        if setting in self._settings:
+            return self._settings[setting]["value"]
+        raise AttributeError("Setting %s is not defined" % setting)
 
     @classmethod
     def override_settings(cls, overrides):

misago/conf/tests/conftest.py

@@ -0,0 +1,56 @@
+import pytest
+
+from misago.conf.models import Setting, SettingsGroup
+
+
+@pytest.fixture
+def settings_group(db):
+    return SettingsGroup.objects.create(key="test", name="Test")
+
+
+@pytest.fixture
+def lazy_setting(settings_group):
+    return Setting.objects.create(
+        group=settings_group,
+        setting="lazy_setting",
+        name="Lazy setting",
+        dry_value="Hello",
+        is_lazy=True,
+        field_extra={},
+    )
+
+
+@pytest.fixture
+def lazy_setting_without_value(settings_group):
+    return Setting.objects.create(
+        group=settings_group,
+        setting="lazy_setting",
+        name="Lazy setting",
+        dry_value="",
+        is_lazy=True,
+        field_extra={},
+    )
+
+
+@pytest.fixture
+def private_setting(settings_group):
+    return Setting.objects.create(
+        group=settings_group,
+        setting="private_setting",
+        name="Private setting",
+        dry_value="Hello",
+        is_public=False,
+        field_extra={},
+    )
+
+
+@pytest.fixture
+def public_setting(settings_group):
+    return Setting.objects.create(
+        group=settings_group,
+        setting="public_setting",
+        name="Public setting",
+        dry_value="Hello",
+        is_public=True,
+        field_extra={},
+    )

misago/conf/tests/test_context_processors.py

@@ -1,21 +1,17 @@
 from unittest.mock import Mock
 
-from django.test import TestCase
-
-from misago.conftest import get_cache_versions
+import pytest
 
 from misago.conf.context_processors import conf
-from misago.conf.dynamicsettings import DynamicSettings
 
 
-class ContextProcessorsTests(TestCase):
-    def test_request_settings_are_included_in_template_context(self):
-        cache_versions = get_cache_versions()
-        mock_request = Mock(settings=DynamicSettings(cache_versions))
-        context_settings = conf(mock_request)['settings']
-        assert context_settings == mock_request.settings
+def test_request_settings_are_included_in_template_context(db, dynamic_settings):
+    mock_request = Mock(settings=dynamic_settings)
+    context_settings = conf(mock_request)['settings']
+    assert context_settings == mock_request.settings
+
 
-    def test_settings_are_included_in_frontend_context(self):
-        response = self.client.get('/')
-        self.assertEqual(response.status_code, 200)
-        self.assertContains(response, '"SETTINGS": {"')
+def test_settings_are_included_in_frontend_context(db, client):
+    response = client.get('/')
+    assert response.status_code == 200
+    assert '"SETTINGS": {"' in response.content.decode("utf-8")

misago/conf/tests/test_dynamic_settings_middleware.py

@@ -1,50 +1,60 @@
-from unittest.mock import Mock, PropertyMock, patch
+from unittest.mock import Mock, PropertyMock
+
+import pytest
 
-from django.test import TestCase
 from django.utils.functional import SimpleLazyObject
 
-from misago.conf.dynamicsettings import DynamicSettings
 from misago.conf.middleware import dynamic_settings_middleware
 
 
-class MiddlewareTests(TestCase):
-    def test_middleware_sets_attr_on_request(self):
-        get_response = Mock()
-        request = Mock()
-        settings = PropertyMock()
-        type(request).settings = settings
-        middleware = dynamic_settings_middleware(get_response)
-        middleware(request)
-        settings.assert_called_once()
-
-    def test_attr_set_by_middleware_on_request_is_lazy_object(self):
-        get_response = Mock()
-        request = Mock()
-        settings = PropertyMock()
-        type(request).settings = settings
-        middleware = dynamic_settings_middleware(get_response)
-        middleware(request)
-        attr_value = settings.call_args[0][0]
-        assert isinstance(attr_value, SimpleLazyObject)
+@pytest.fixture
+def get_response():
+    return Mock()
 
-    def test_middleware_calls_get_response(self):
-        get_response = Mock()
-        request = Mock()
-        middleware = dynamic_settings_middleware(get_response)
-        middleware(request)
-        get_response.assert_called_once()
-
-    def test_middleware_is_not_reading_db(self):
-        get_response = Mock()
-        request = Mock()
-        with self.assertNumQueries(0):
-            middleware = dynamic_settings_middleware(get_response)
-            middleware(request)
-
-    @patch('django.core.cache.cache.get')
-    def test_middleware_is_not_reading_cache(self, cache_get):
-        get_response = Mock()
-        request = Mock()
+
+@pytest.fixture
+def settings():
+    return PropertyMock()
+
+
+@pytest.fixture
+def request_mock(settings):
+    request = Mock()
+    type(request).settings = settings
+    return request
+
+
+def test_middleware_sets_attr_on_request(db, get_response, request_mock, settings):
+    middleware = dynamic_settings_middleware(get_response)
+    middleware(request_mock)
+    settings.assert_called_once()
+
+
+def test_attr_set_by_middleware_on_request_is_lazy_object(
+    db, get_response, request_mock, settings
+):
+    middleware = dynamic_settings_middleware(get_response)
+    middleware(request_mock)
+    attr_value = settings.call_args[0][0]
+    assert isinstance(attr_value, SimpleLazyObject)
+
+
+def test_middleware_calls_get_response(db, get_response, request_mock):
+    middleware = dynamic_settings_middleware(get_response)
+    middleware(request_mock)
+    get_response.assert_called_once()
+
+
+def test_middleware_is_not_reading_db(
+    db, get_response, request_mock, django_assert_num_queries
+):
+    with django_assert_num_queries(0):
         middleware = dynamic_settings_middleware(get_response)
-        middleware(request)
-        cache_get.assert_not_called()
+        middleware(request_mock)
+
+
+def test_middleware_is_not_reading_cache(db, mocker, get_response, request_mock):
+    cache_get = mocker.patch('django.core.cache.cache.get')
+    middleware = dynamic_settings_middleware(get_response)
+    middleware(request_mock)
+    cache_get.assert_not_called()

misago/conf/tests/test_getting_dynamic_settings_values.py

@@ -1,167 +1,131 @@
-from unittest.mock import patch
-
-from django.test import TestCase
+import pytest
 
 from misago.conf import SETTINGS_CACHE
 from misago.conf.dynamicsettings import DynamicSettings
-from misago.conf.models import Setting, SettingsGroup
-from misago.conftest import get_cache_versions
-
-cache_versions = get_cache_versions()
 
 
-class GettingSettingValueTests(TestCase):
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_settings_are_loaded_from_database_if_cache_is_not_available(self, cache_get, _):
-        with self.assertNumQueries(1):
-            DynamicSettings(cache_versions)
+def test_settings_are_loaded_from_database_if_cache_is_not_available(
+    db, mocker, cache_versions, django_assert_num_queries
+):
+    mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value=None)
+    with django_assert_num_queries(1):
+        DynamicSettings(cache_versions)
 
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value={})
-    def test_settings_are_loaded_from_cache_if_it_is_not_none(self, cache_get, _):
-        with self.assertNumQueries(0):
-            DynamicSettings(cache_versions)
-        cache_get.assert_called_once()
 
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_settings_cache_is_set_if_none_exists(self, _, cache_set):
+def test_settings_are_loaded_from_cache_if_it_is_not_none(
+    db, mocker, cache_versions, django_assert_num_queries
+):
+    mocker.patch('django.core.cache.cache.set')
+    cache_get = mocker.patch('django.core.cache.cache.get', return_value={})
+    with django_assert_num_queries(0):
         DynamicSettings(cache_versions)
-        cache_set.assert_called_once()
-
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value={})
-    def test_settings_cache_is_not_set_if_it_already_exists(self, _, cache_set):
-        with self.assertNumQueries(0):
-            DynamicSettings(cache_versions)
-        cache_set.assert_not_called()
-
-    @patch('django.core.cache.cache.set')
-    @patch('django.core.cache.cache.get', return_value=None)
-    def test_settings_cache_key_includes_cache_name_and_version(self, _, cache_set):
+    cache_get.assert_called_once()
+
+
+def test_settings_cache_is_set_if_none_exists(db, mocker, cache_versions):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value=None)
+
+    DynamicSettings(cache_versions)
+    cache_set.assert_called_once()
+
+
+def test_settings_cache_is_not_set_if_it_already_exists(
+    db, mocker, cache_versions, django_assert_num_queries
+):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value={})
+    with django_assert_num_queries(0):
         DynamicSettings(cache_versions)
-        cache_key = cache_set.call_args[0][0]
-        assert SETTINGS_CACHE in cache_key
-        assert cache_versions[SETTINGS_CACHE] in cache_key
-
-    def test_accessing_attr_returns_setting_value(self):
-        settings = DynamicSettings(cache_versions)
-        assert settings.forum_name == "Misago"
-
-    def test_accessing_attr_for_undefined_setting_raises_error(self):
-        settings = DynamicSettings(cache_versions)
-        with self.assertRaises(KeyError):
-            settings.not_existing
-
-    def test_accessing_attr_for_lazy_setting_without_value_returns_none(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            is_lazy=True,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
-        assert settings.lazy_setting is None
-
-    def test_accessing_attr_for_lazy_setting_with_value_returns_true(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            dry_value="Hello",
-            is_lazy=True,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
-        assert settings.lazy_setting is True
-
-    def test_lazy_setting_getter_for_lazy_setting_with_value_returns_real_value(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            dry_value="Hello",
-            is_lazy=True,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
-        assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
-
-    def test_lazy_setting_getter_for_lazy_setting_makes_db_query(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            dry_value="Hello",
-            is_lazy=True,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
-        with self.assertNumQueries(1):
-            settings.get_lazy_setting_value("lazy_setting")
-
-    def test_lazy_setting_getter_for_lazy_setting_is_reusing_query_result(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            dry_value="Hello",
-            is_lazy=True,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
+    cache_set.assert_not_called()
+
+
+def test_settings_cache_key_includes_cache_name_and_version(db, mocker, cache_versions):
+    cache_set = mocker.patch('django.core.cache.cache.set')
+    mocker.patch('django.core.cache.cache.get', return_value=None)
+    DynamicSettings(cache_versions)
+    cache_key = cache_set.call_args[0][0]
+    assert SETTINGS_CACHE in cache_key
+    assert cache_versions[SETTINGS_CACHE] in cache_key
+
+
+def test_accessing_attr_returns_setting_value(db, cache_versions):
+    settings = DynamicSettings(cache_versions)
+    assert settings.forum_name == "Misago"
+
+
+def test_accessing_attr_for_undefined_setting_raises_attribute_error(db, cache_versions):
+    settings = DynamicSettings(cache_versions)
+    with pytest.raises(AttributeError):
+        settings.not_existing
+
+
+def test_accessing_attr_for_lazy_setting_with_value_returns_true(
+    cache_versions, lazy_setting
+):
+    settings = DynamicSettings(cache_versions)
+    assert settings.lazy_setting is True
+
+
+def test_lazy_setting_getter_for_lazy_setting_with_value_returns_real_value(
+    cache_versions, lazy_setting
+):
+    settings = DynamicSettings(cache_versions)
+    assert settings.get_lazy_setting_value("lazy_setting") == lazy_setting.value
+
+
+def test_lazy_setting_getter_for_lazy_setting_makes_db_query(
+    cache_versions, lazy_setting, django_assert_num_queries
+):
+    settings = DynamicSettings(cache_versions)
+    with django_assert_num_queries(1):
+        settings.get_lazy_setting_value("lazy_setting")
+
+
+def test_accessing_attr_for_lazy_setting_without_value_returns_none(
+    cache_versions, lazy_setting_without_value
+):
+    settings = DynamicSettings(cache_versions)
+    assert settings.lazy_setting is None
+
+
+def test_lazy_setting_getter_for_lazy_setting_is_reusing_query_result(
+    cache_versions, lazy_setting, django_assert_num_queries
+):
+    settings = DynamicSettings(cache_versions)
+    settings.get_lazy_setting_value("lazy_setting")
+    with django_assert_num_queries(0):
         settings.get_lazy_setting_value("lazy_setting")
-        with self.assertNumQueries(0):
-            settings.get_lazy_setting_value("lazy_setting")
-
-    def test_lazy_setting_getter_for_undefined_setting_raises_attribute_error(self):
-        settings = DynamicSettings(cache_versions)
-        with self.assertRaises(AttributeError):
-            settings.get_lazy_setting_value("undefined")
-
-    def test_lazy_setting_getter_for_not_lazy_setting_raises_value_error(self):
-        settings = DynamicSettings(cache_versions)
-        with self.assertRaises(ValueError):
-            settings.get_lazy_setting_value("forum_name")
-
-    def test_public_settings_getter_returns_dict_with_public_settings(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="public_setting",
-            name="Public setting",
-            dry_value="Hello",
-            is_public=True,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
-        public_settings = settings.get_public_settings()
-        assert public_settings["public_setting"] == "Hello"
-
-    def test_public_settings_getter_excludes_private_settings_from_dict(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        Setting.objects.create(
-            group=settings_group,
-            setting="private_setting",
-            name="Private setting",
-            dry_value="Hello",
-            is_public=False,
-            field_extra={},
-        )
-
-        settings = DynamicSettings(cache_versions)
-        public_settings = settings.get_public_settings()
-        assert "private_setting" not in public_settings
+
+
+def test_lazy_setting_getter_for_undefined_setting_raises_attribute_error(
+    db, cache_versions
+):
+    settings = DynamicSettings(cache_versions)
+    with pytest.raises(AttributeError):
+        settings.get_lazy_setting_value("undefined")
+
+
+def test_lazy_setting_getter_for_not_lazy_setting_raises_value_error(
+    db, cache_versions
+):
+    settings = DynamicSettings(cache_versions)
+    with pytest.raises(ValueError):
+        settings.get_lazy_setting_value("forum_name")
+
+
+def test_public_settings_getter_returns_dict_with_public_settings(
+    cache_versions, public_setting
+):
+    settings = DynamicSettings(cache_versions)
+    public_settings = settings.get_public_settings()
+    assert public_settings["public_setting"] == "Hello"
+
+
+def test_public_settings_getter_excludes_private_settings_from_dict(
+    cache_versions, private_setting
+):
+    settings = DynamicSettings(cache_versions)
+    public_settings = settings.get_public_settings()
+    assert "private_setting" not in public_settings

misago/conf/tests/test_getting_static_settings_values.py

@@ -1,33 +1,31 @@
-from django.test import TestCase, override_settings
+import pytest
 
-from misago.conf.staticsettings import StaticSettings
+from django.test import override_settings
 
 
-class GettingSettingValueTests(TestCase):
-    def test_accessing_attr_returns_setting_value_defined_in_settings_file(self):
-        settings = StaticSettings()
-        assert settings.STATIC_URL
+def test_accessing_attr_returns_setting_value_defined_in_settings_file(settings):
+    assert settings.STATIC_URL
 
-    def test_accessing_attr_returns_setting_value_defined_in_misago_defaults_file(self):
-        settings = StaticSettings()
-        assert settings.MISAGO_MOMENT_JS_LOCALES
 
-    def test_setting_value_can_be_overridden_using_django_util(self):
-        settings = StaticSettings()
-        with override_settings(STATIC_URL="/test/"):
-            assert settings.STATIC_URL == "/test/"
+def test_accessing_attr_returns_setting_value_defined_in_misago_defaults_file(settings):
+    assert settings.MISAGO_MOMENT_JS_LOCALES
 
-    def test_default_setting_value_can_be_overridden_using_django_util(self):
-        settings = StaticSettings()
-        with override_settings(MISAGO_MOMENT_JS_LOCALES="test"):
-            assert settings.MISAGO_MOMENT_JS_LOCALES == "test"
 
-    def test_undefined_setting_value_can_be_overridden_using_django_util(self):
-        settings = StaticSettings()
-        with override_settings(UNDEFINED_SETTING="test"):
-            assert settings.UNDEFINED_SETTING == "test"
+def test_setting_value_can_be_overridden_using_django_util(settings):
+    with override_settings(STATIC_URL="/test/"):
+        assert settings.STATIC_URL == "/test/"
 
-    def test_accessing_attr_for_undefined_setting_raises_attribute_error(self):
-        settings = StaticSettings()
-        with self.assertRaises(AttributeError):
-            assert settings.UNDEFINED_SETTING
+
+def test_default_setting_value_can_be_overridden_using_django_util(settings):
+    with override_settings(MISAGO_MOMENT_JS_LOCALES="test"):
+        assert settings.MISAGO_MOMENT_JS_LOCALES == "test"
+
+
+def test_undefined_setting_value_can_be_overridden_using_django_util(settings):
+    with override_settings(UNDEFINED_SETTING="test"):
+        assert settings.UNDEFINED_SETTING == "test"
+
+
+def test_accessing_attr_for_undefined_setting_raises_attribute_error(settings):
+    with pytest.raises(AttributeError):
+        assert settings.UNDEFINED_SETTING

misago/conf/tests/test_overridding_dynamic_settings.py

@@ -1,68 +1,44 @@
-from django.test import TestCase
+import pytest
 
-from misago.conf import SETTINGS_CACHE
 from misago.conf.dynamicsettings import DynamicSettings
-from misago.conf.models import Setting, SettingsGroup
-from misago.conftest import get_cache_versions
-
 from misago.conf.test import override_dynamic_settings
 
-cache_versions = get_cache_versions()
-
 
-class OverrideDynamicSettingsTests(TestCase):
-    def test_dynamic_setting_can_be_overridden_using_context_manager(self):
-        settings = DynamicSettings(cache_versions)
-        assert settings.forum_name == "Misago"
+def test_dynamic_setting_can_be_overridden_using_context_manager(dynamic_settings):
+    assert dynamic_settings.forum_name == "Misago"
+    with override_dynamic_settings(forum_name="Overrided"):
+        assert dynamic_settings.forum_name == "Overrided"
+    assert dynamic_settings.forum_name == "Misago"
 
-        with override_dynamic_settings(forum_name="Overrided"):
-            assert settings.forum_name == "Overrided"
 
-        assert settings.forum_name == "Misago"
+def test_dynamic_setting_can_be_overridden_using_decorator(dynamic_settings):
+    @override_dynamic_settings(forum_name="Overrided")
+    def decorated_function(settings):
+        return settings.forum_name
 
-    def test_dynamic_setting_can_be_overridden_using_decorator(self):
-        @override_dynamic_settings(forum_name="Overrided")
-        def decorated_function(settings):
-            return settings.forum_name
+    assert dynamic_settings.forum_name == "Misago"
+    assert decorated_function(dynamic_settings) == "Overrided"
+    assert dynamic_settings.forum_name == "Misago"
 
-        settings = DynamicSettings(cache_versions)
-        assert settings.forum_name == "Misago"
-        assert decorated_function(settings) == "Overrided"
-        assert settings.forum_name == "Misago"
 
-    def test_lazy_dynamic_setting_can_be_overridden_using_context_manager(self):
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        setting = Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            dry_value="Hello",
-            is_lazy=True,
-            field_extra={},
-        )
+def test_lazy_dynamic_setting_can_be_overridden_using_context_manager(
+    cache_versions, lazy_setting
+):
+    settings = DynamicSettings(cache_versions)
+    assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
+    with override_dynamic_settings(lazy_setting="Overrided"):
+        assert settings.get_lazy_setting_value("lazy_setting") == "Overrided"
+    assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
 
-        settings = DynamicSettings(cache_versions)
-        assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
-        with override_dynamic_settings(lazy_setting="Overrided"):
-            assert settings.get_lazy_setting_value("lazy_setting") == "Overrided"
-        assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
 
-    def test_lazy_dynamic_setting_can_be_overridden_using_decorator(self):
-        @override_dynamic_settings(lazy_setting="Overrided")
-        def decorated_function(settings):
-            return settings.get_lazy_setting_value("lazy_setting")
+def test_lazy_dynamic_setting_can_be_overridden_using_decorator(
+    cache_versions, lazy_setting
+):
+    @override_dynamic_settings(lazy_setting="Overrided")
+    def decorated_function(settings):
+        return settings.get_lazy_setting_value("lazy_setting")
 
-        settings_group = SettingsGroup.objects.create(key="test", name="Test")
-        setting = Setting.objects.create(
-            group=settings_group,
-            setting="lazy_setting",
-            name="Lazy setting",
-            dry_value="Hello",
-            is_lazy=True,
-            field_extra={},
-        )
-        
-        settings = DynamicSettings(cache_versions)
-        assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
-        assert decorated_function(settings) == "Overrided"
-        assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
+    settings = DynamicSettings(cache_versions)
+    assert settings.get_lazy_setting_value("lazy_setting") == "Hello"
+    assert decorated_function(settings) == "Overrided"
+    assert settings.get_lazy_setting_value("lazy_setting") == "Hello"

misago/conftest.py

@@ -1,10 +1,60 @@
+import pytest
+
 from misago.acl import ACL_CACHE
 from misago.conf import SETTINGS_CACHE
+from misago.conf.dynamicsettings import DynamicSettings
+from misago.conf.staticsettings import StaticSettings
 from misago.users.constants import BANS_CACHE
+from misago.users.models import AnonymousUser
+from misago.users.testutils import create_test_superuser, create_test_user
+
 
 def get_cache_versions():
     return {
         ACL_CACHE: "abcdefgh",
         BANS_CACHE: "abcdefgh",
         SETTINGS_CACHE: "abcdefgh",
-    }
+    }
+
+
+@pytest.fixture
+def cache_versions():
+    return get_cache_versions()
+
+
+@pytest.fixture
+def dynamic_settings(db, cache_versions):
+    return DynamicSettings(cache_versions)
+
+
+@pytest.fixture
+def settings():
+    return StaticSettings()
+
+
+@pytest.fixture
+def user_password():
+    return "password"
+
+
+@pytest.fixture
+def anonymous_user():
+    return AnonymousUser()
+
+
+@pytest.fixture
+def user(db, user_password):
+    return create_test_user("User", "user@example.com", user_password)
+
+
+@pytest.fixture
+def staffuser(db, user_password):
+    user = create_test_superuser("Staffuser", "staffuser@example.com", user_password)
+    user.is_superuser = False
+    user.save()
+    return user
+
+
+@pytest.fixture
+def superuser(db, user_password):
+    return create_test_superuser("Superuser", "superuser@example.com", user_password)

requirements.in

@@ -13,6 +13,7 @@ pillow<4.2
 psycopg2-binary<2.8
 pytest
 pytest-django
+pytest-mock
 pytz
 requests<3
 unidecode<1

requirements.txt

@@ -16,29 +16,32 @@ django-mptt==0.8.7
 django==1.11.16
 djangorestframework==3.6.4
 faker==0.8.18
-funcsigs==1.0.2           # via pytest
+funcsigs==1.0.2           # via mock, pytest
 html5lib==0.999999999
 idna==2.7                 # via requests
 ipaddress==1.0.22         # via faker
 markdown==2.6.11
 misago-social-auth-app-django==2.1.0
+mock==2.0.0               # via pytest-mock
 more-itertools==4.3.0     # via pytest
 oauthlib==2.1.0           # via requests-oauthlib, social-auth-core
 olefile==0.46             # via pillow
 pathlib2==2.3.3           # via pytest, pytest-django
+pbr==5.1.1                # via mock
 pillow==4.1.1
 pluggy==0.8.0             # via pytest
 psycopg2-binary==2.7.5
 py==1.7.0                 # via pytest
 pyjwt==1.6.4              # via social-auth-core
 pytest-django==3.4.4
+pytest-mock==1.10.0
 pytest==4.0.2
 python-dateutil==2.7.5    # via faker
 pytz==2018.7
 requests-oauthlib==1.0.0  # via social-auth-core
 requests==2.20.0
 scandir==1.9.0            # via pathlib2
-six==1.11.0               # via bleach, faker, html5lib, misago-social-auth-app-django, more-itertools, pathlib2, pytest, python-dateutil, social-auth-core
+six==1.11.0               # via bleach, faker, html5lib, misago-social-auth-app-django, mock, more-itertools, pathlib2, pytest, python-dateutil, social-auth-core
 social-auth-core==1.7.0   # via misago-social-auth-app-django
 sqlparse==0.2.4           # via django-debug-toolbar
 text-unidecode==1.2       # via faker