241 lines
8.9 KiB
Python
241 lines
8.9 KiB
Python
# -*- coding: utf-8 -*-
|
|
import datetime
|
|
import json
|
|
import os
|
|
import shutil
|
|
from unittest.mock import patch
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.test import SimpleTestCase
|
|
from django.urls import URLResolver
|
|
|
|
from ..config.modules import ModuleMeta, ModuleConfig
|
|
|
|
from .utils import mkdtemp
|
|
|
|
TMP_BASE_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'tmp')
|
|
|
|
|
|
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')
|
|
self.assertEqual(mm.root_url_name, 'dav_base_tests_fake_app1:root')
|
|
pattern = mm.url_conf_pattern
|
|
self.assertIsInstance(pattern, URLResolver)
|
|
self.assertEqual('^test/', str(pattern.pattern))
|
|
|
|
def test_module_not_exists(self):
|
|
with self.assertRaises(ModuleNotFoundError):
|
|
_ = ModuleMeta('dav_base.tests.non_existent_app')
|
|
|
|
def test_init_without_load(self):
|
|
app_name = 'dav_base.tests.non_existent_app'
|
|
app_namespace = app_name.replace('.', '_')
|
|
mm = ModuleMeta(app_name, load=False)
|
|
self.assertEqual(mm.package, app_name)
|
|
self.assertEqual(mm.app, app_name)
|
|
self.assertEqual(mm.url_prefix, app_name)
|
|
self.assertEqual(mm.url_namespace, app_namespace)
|
|
self.assertEqual(mm.root_url_name, app_namespace + ':root')
|
|
|
|
def test_url_config_not_exists(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_str(self):
|
|
app_name = 'dav_base.tests.fake_app1'
|
|
mm = ModuleMeta(app_name)
|
|
self.assertEqual(str(mm), '- {}'.format(app_name))
|
|
|
|
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',
|
|
}
|
|
expected_namespace = dd['package'].replace('.', '_')
|
|
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, expected_namespace)
|
|
self.assertEqual(mm.root_url_name, expected_namespace + ':root')
|
|
|
|
dd = {'package': 'dav_base2.bar'}
|
|
expected_namespace = dd['package'].replace('.', '_')
|
|
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'])
|
|
self.assertEqual(mm.url_namespace, expected_namespace)
|
|
self.assertEqual(mm.root_url_name, expected_namespace + ':root')
|
|
|
|
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 setUp(self):
|
|
prefix = 'dav_base.tests.test_config_modules-{datetime}-'.format(
|
|
datetime=datetime.datetime.now().strftime('%Y%m%d-%H%M')
|
|
)
|
|
self.temp_dir = mkdtemp(prefix=prefix, base_dir=TMP_BASE_DIR)
|
|
|
|
self.config_dir = os.path.join(self.temp_dir, 'main')
|
|
os.makedirs(self.config_dir)
|
|
self.config_file = os.path.join(self.config_dir, 'module_config.json')
|
|
|
|
def tearDown(self):
|
|
shutil.rmtree(self.temp_dir)
|
|
|
|
def test_default_config_file_not_exists(self):
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc = ModuleConfig()
|
|
self.assertEqual(mc.modules, {})
|
|
|
|
def test_default_config_file_exists(self):
|
|
config_data = {
|
|
'modules': [
|
|
{'package': 'pkg1'},
|
|
{'package': 'pkg2'},
|
|
]
|
|
}
|
|
|
|
with open(self.config_file, 'w', encoding='ascii') as f:
|
|
json.dump(config_data, f)
|
|
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc = ModuleConfig()
|
|
self.assertEqual(list(mc.modules.keys()), ['pkg1', 'pkg2'])
|
|
|
|
def test_django_base_dir_parameter(self):
|
|
config_data = {
|
|
'modules': [
|
|
{'package': 'pkgA'},
|
|
{'package': 'pkgB'},
|
|
]
|
|
}
|
|
|
|
with open(self.config_file, 'w', encoding='ascii') as f:
|
|
json.dump(config_data, f)
|
|
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.config_dir # No config file there
|
|
|
|
mc = ModuleConfig()
|
|
self.assertEqual(mc.modules, {})
|
|
|
|
mc = ModuleConfig(django_base_dir=self.temp_dir)
|
|
self.assertEqual(list(mc.modules.keys()), ['pkgA', 'pkgB'])
|
|
|
|
def test_custom_config_file_path(self):
|
|
config_data = {
|
|
'modules': [
|
|
{'package': 'pkgX'},
|
|
{'package': 'pkgY'},
|
|
]
|
|
}
|
|
|
|
config_file = os.path.join(self.config_dir, 'test.json')
|
|
with open(config_file, 'w', encoding='ascii') as f:
|
|
json.dump(config_data, f)
|
|
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc = ModuleConfig(config_file_path=config_file)
|
|
self.assertEqual(list(mc.modules.keys()), ['pkgX', 'pkgY'])
|
|
|
|
def test_custom_config_file_path_and_django_base_dir(self):
|
|
config_data = {
|
|
'modules': [
|
|
{'package': 'pkg11'},
|
|
{'package': 'pkg22'},
|
|
]
|
|
}
|
|
|
|
config_file = os.path.join(self.config_dir, 'test.json')
|
|
with open(config_file, 'w', encoding='ascii') as f:
|
|
json.dump(config_data, f)
|
|
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc = ModuleConfig(config_file_path=config_file, django_base_dir=self.config_dir)
|
|
self.assertEqual(list(mc.modules.keys()), ['pkg11', 'pkg22'])
|
|
|
|
def test_save(self):
|
|
config_data = {
|
|
'modules': [
|
|
{'package': 'pkg_foo'},
|
|
{'package': 'pkg_bar'},
|
|
{'package': 'pkg_baz'},
|
|
{'package': 'pkg_quux', 'url_prefix': 'quux'},
|
|
]
|
|
}
|
|
copy_modules = ['pkg_bar', 'pkg_quux']
|
|
expected_config_data = {'modules': [d for d in config_data['modules'] if d['package'] in copy_modules]}
|
|
|
|
config_file = os.path.join(self.config_dir, 'test.json')
|
|
with open(config_file, 'w', encoding='ascii') as f:
|
|
json.dump(config_data, f)
|
|
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc1 = ModuleConfig()
|
|
mc2 = ModuleConfig(config_file_path=config_file)
|
|
for module_name in copy_modules:
|
|
mc1.modules[module_name] = mc2.modules[module_name]
|
|
mc1.save()
|
|
|
|
with open(self.config_file, 'r', encoding='ascii') as f:
|
|
config_data = json.load(f)
|
|
|
|
self.assertEqual(config_data, expected_config_data)
|
|
|
|
def test_save_empty(self):
|
|
self.assertFalse(os.path.exists(self.config_file))
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc = ModuleConfig()
|
|
mc.save()
|
|
self.assertTrue(os.path.isfile(self.config_file))
|
|
|
|
with open(self.config_file, 'r', encoding='ascii') as f:
|
|
config_data = json.load(f)
|
|
|
|
self.assertEqual(config_data, {'modules': []})
|
|
|
|
def test_save_overwrite(self):
|
|
with patch('dav_base.config.modules.settings') as mock_settings:
|
|
mock_settings.BASE_DIR = self.temp_dir
|
|
mc = ModuleConfig()
|
|
mc.save()
|
|
self.assertTrue(os.path.isfile(self.config_file))
|
|
mc.modules['mod1'] = ModuleMeta('mod1', load=False)
|
|
mc.save()
|
|
|
|
with open(self.config_file, 'r', encoding='ascii') as f:
|
|
config_data = json.load(f)
|
|
|
|
self.assertEqual(config_data, {'modules': [{'package': 'mod1'}]})
|
|
|