232 lines
8.7 KiB
Python
232 lines
8.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
from django.apps import apps
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.test import SimpleTestCase
|
|
from django.urls import URLResolver
|
|
|
|
from ..config.apps import DefaultSetting, AppSettings, AppConfig
|
|
from ..config.modules import ModuleMeta
|
|
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_init(self):
|
|
mm = ModuleMeta('dav_base.tests.fake_app1')
|
|
self.assertEqual(mm.package, 'dav_base.tests.fake_app1')
|
|
self.assertEqual(mm.app, 'dav_base.tests.fake_app1.apps.AppConfig')
|
|
self.assertEqual(mm.additional_apps, [])
|
|
self.assertEqual(mm.url_prefix, 'test')
|
|
self.assertEqual(mm.url_namespace, 'dav_base_tests_fake_app1')
|
|
pattern = mm.url_conf_pattern
|
|
self.assertIsInstance(pattern, URLResolver)
|
|
self.assertEqual('^test/', str(pattern.pattern))
|
|
|
|
def test_cannot_include_urls(self):
|
|
mm = ModuleMeta('dav_base.tests.fake_app1')
|
|
dd = {'package': 'dav_base'}
|
|
mm.load_from_dict(dd)
|
|
with self.assertRaises(ImproperlyConfigured):
|
|
_ = mm.url_conf_pattern
|
|
|
|
def test_load_from_dict(self):
|
|
mm = ModuleMeta('dav_base.tests.fake_app1')
|
|
dd = {'package': 'dav_base2.foo',
|
|
'app_config': 'MyApp.MyAppConfig',
|
|
'additional_apps': ['test1', 'test2.subtest'],
|
|
'url_prefix': 'test_url_prefix',
|
|
}
|
|
mm.load_from_dict(dd)
|
|
self.assertEqual(mm.package, dd['package'])
|
|
self.assertEqual(mm.app, dd['app_config'])
|
|
self.assertEqual(mm.additional_apps, dd['additional_apps'])
|
|
self.assertEqual(mm.url_prefix, dd['url_prefix'])
|
|
self.assertEqual(mm.url_namespace, dd['package'].replace('.', '_'))
|
|
|
|
dd = {'package': 'dav_base2.bar'}
|
|
mm.load_from_dict(dd)
|
|
self.assertEqual(mm.url_prefix, dd['package'])
|
|
self.assertEqual(mm.app, dd['package'])
|
|
self.assertEqual(mm.additional_apps, [])
|
|
self.assertEqual(mm.url_prefix, dd['package'])
|
|
|
|
def test_dump_as_dict(self):
|
|
mm = ModuleMeta('dav_base.tests.fake_app1')
|
|
dd_in = {'package': 'dav_base2.foo',
|
|
'app_config': '.mymod.MyAppConfig',
|
|
'additional_apps': ['test1'],
|
|
'url_prefix': 'test_url_prefix',
|
|
}
|
|
mm.load_from_dict(dd_in)
|
|
dd_out = mm.dump_as_dict()
|
|
self.assertEqual(dd_in, dd_out)
|
|
|
|
|
|
class ModuleConfigTestCase(SimpleTestCase):
|
|
def test_some(self):
|
|
# TODO
|
|
pass
|