django-dav-events/dav_base/tests/test_config.py

# -*- coding: utf-8 -*-
from django.apps import apps
from django.core.exceptions import ImproperlyConfigured
from django.test import SimpleTestCase

from ..config.apps import DefaultSetting, AppSettings, AppConfig
from ..apps import AppConfig as RealAppConfig

TEST_SETTING_VALUE = 'do not change this value'


class DefaultSettingTestCase(SimpleTestCase):
    def test_key_name(self):
        name = 'somename'
        key_name = 'SoMeKeY'

        setting = DefaultSetting(name, None)
        self.assertEqual(setting.key_name, name.upper())

        setting = DefaultSetting(name, None, key_name=key_name)
        self.assertEqual(setting.key_name, key_name)

    def test_validate(self):
        name = 'somename'

        setting = DefaultSetting(name, None, validator=None)
        try:
            setting.validate(False)
        except ImproperlyConfigured:  # pragma: no cover
            self.fail('Disabled validation validated invalid :(')

        def callable_validator(value):
            return (value % 2) == 0

        valid_values = (2, 4)
        invalid_values = (3, 5)

        setting = DefaultSetting(name, None, validator=callable_validator)
        for val in valid_values:
            try:
                setting.validate(val)
            except ImproperlyConfigured:  # pragma: no cover
                self.fail('Callable validated valid value invalid :(')

        for val in invalid_values:
            with self.assertRaises(ImproperlyConfigured):
                setting.validate(val)

        re_validator = r'[a-z]'

        valid_values = 'aocd'
        invalid_values = 'Aö1.'

        setting = DefaultSetting(name, None, validator=re_validator)
        for val in valid_values:
            try:
                setting.validate(val)
            except ImproperlyConfigured:  # pragma: no cover
                self.fail('Regular Expression validated valid value invalid :(')

        for val in invalid_values:
            with self.assertRaises(ImproperlyConfigured):
                setting.validate(val)


class AppSettingsTestCase(SimpleTestCase):
    def setUp(self):
        self.app_name = 'dav_base'
        self.test_setting_value = TEST_SETTING_VALUE

    def test_no_settings_file(self):
        """Test that nothing bad happens if no settings file can be read"""
        app_settings = AppSettings('', ())
        self.assertIsInstance(app_settings, AppSettings)

    def test_defaults(self):
        """Test the default value for optional and unset settings"""
        default_settings = (
            DefaultSetting('no_test_setting', 1),
            DefaultSetting('no_test_setting_2', 2),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.no_test_setting, 1)
        self.assertEqual(app_settings.no_test_setting_2, 2)

    def test_improperlyconfigured_by_class(self):
        """Test if mandatory but unset setting raise correct exception"""
        default_settings = (
            DefaultSetting('no_test_setting', ImproperlyConfigured),
        )
        with self.assertRaisesRegex(ImproperlyConfigured, 'NO_TEST_SETTING must be defined in main.settings-dav_base'):
            _ = AppSettings(self.app_name, default_settings)

    def test_improperlyconfigured_by_instance(self):
        """Test if mandatory but unset setting raise correct exception"""
        default_settings = (
            DefaultSetting('no_test_setting', ImproperlyConfigured('Some Error Message')),
        )
        with self.assertRaisesRegex(ImproperlyConfigured, 'Some Error Message'):
            _ = AppSettings(self.app_name, default_settings)

    def test_improperlyconfigured_by_func(self):
        """Test if invalid setting raise correct exception"""
        def validator(value):  # pylint: disable=unused-argument
            return False
        default_settings = (
            DefaultSetting('test_setting', 1, validator=validator),
        )
        with self.assertRaises(ImproperlyConfigured):
            _ = AppSettings(self.app_name, default_settings)

    def test_improperlyconfigured_by_regex(self):
        """Test if invalid setting raise correct exception"""
        default_settings = (
            DefaultSetting('test_setting', 1, validator=r'^[01]$'),
        )
        with self.assertRaises(ImproperlyConfigured):
            _ = AppSettings(self.app_name, default_settings)

    def test_settings_from_file(self):
        """Test if value from settings file eliminate exception"""
        default_settings = (
            DefaultSetting('test_setting', ImproperlyConfigured),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.test_setting, self.test_setting_value)

        # Test if value from settings file overwrites default value
        default_settings = (
            DefaultSetting('test_setting', 1),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.test_setting, self.test_setting_value)

    def test_key_name(self):
        default_settings = (
            DefaultSetting('test_setting', 1, key_name='NO_TEST_SETTING'),
            DefaultSetting('no_test_setting', ImproperlyConfigured, key_name='TEST_SETTING'),
        )
        app_settings = AppSettings(self.app_name, default_settings)
        self.assertEqual(app_settings.test_setting, 1)
        self.assertEqual(app_settings.no_test_setting, self.test_setting_value)


class AppConfigTestCase(SimpleTestCase):
    def test_init(self):
        app_name = 'dav_base'
        import dav_base as app_module  # pylint: disable=import-outside-toplevel

        test_default_settings = (
            DefaultSetting('test_setting', ImproperlyConfigured),
            DefaultSetting('no_test_setting', 1),
        )

        class TestAppConfig(AppConfig):
            name = 'not_dav_base'
            verbose_name = 'DAV Base App'
            default_settings = test_default_settings

        app_config = TestAppConfig(app_name, app_module)
        app_settings = app_config.settings

        self.assertEqual(app_config.name, app_name)
        self.assertEqual(app_settings.test_setting, TEST_SETTING_VALUE)
        self.assertEqual(app_settings.no_test_setting, 1)

    def test_integrated(self):
        app_config = apps.get_containing_app_config(__package__)
        self.assertEqual(app_config.__class__, RealAppConfig)
        self.assertIsInstance(app_config, AppConfig)
        self.assertEqual(app_config.settings.__class__, AppSettings)


class ModuleMetaTestCase(SimpleTestCase):
    def test_some(self):
        # TODO
        pass


class ModuleConfigTestCase(SimpleTestCase):
    def test_some(self):
        # TODO
        pass