Move bunch of misago.acl tests to pytest

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_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_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 +1,8 @@
-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)
+def test_fake_post_data_for_role():
+    """fake data was created for Role"""
+    test_data = fake_post_data(Role(), {'can_fly': 1})
+    assert "can_fly" in 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/conftest.py

@@ -1,10 +1,48 @@
+import pytest
+
 from misago.acl import ACL_CACHE
 from misago.conf import SETTINGS_CACHE
 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 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