Move misago.conf tests to pytest

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

@@ -2,6 +2,8 @@ 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
@@ -21,6 +23,16 @@ def 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"