826 lines
31 KiB
Python
826 lines
31 KiB
Python
# -*- coding: utf-8; -*-
|
|
|
|
import configparser
|
|
import os
|
|
from unittest import TestCase
|
|
from unittest.mock import patch, MagicMock
|
|
|
|
import pytest
|
|
|
|
from wuttjamaican import conf as mod
|
|
# TODO: get rid of this eventually
|
|
from wuttjamaican import conf
|
|
from wuttjamaican.exc import ConfigurationError
|
|
from wuttjamaican.app import AppHandler
|
|
from wuttjamaican.testing import FileTestCase
|
|
|
|
|
|
class TestWuttaConfig(FileTestCase):
|
|
|
|
def make_config(self, **kwargs):
|
|
return mod.WuttaConfig(**kwargs)
|
|
|
|
def test_contstructor_basic(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertEqual(config.appname, 'wutta')
|
|
self.assertEqual(config.files_read, [])
|
|
|
|
def test_constructor_valid_files(self):
|
|
myfile = self.write_file('my.conf', '')
|
|
config = conf.WuttaConfig(files=[myfile])
|
|
self.assertEqual(len(config.files_read), 1)
|
|
self.assertEqual(config.files_read[0], myfile)
|
|
|
|
def test_constructor_missing_files(self):
|
|
invalid = os.path.join(self.tempdir, 'invalid.conf')
|
|
self.assertRaises(FileNotFoundError, conf.WuttaConfig, files=[invalid])
|
|
|
|
def test_constructor_required_files_are_present(self):
|
|
first = self.write_file('first.conf', """\
|
|
[foo]
|
|
bar = 1
|
|
baz = A
|
|
""")
|
|
|
|
second = self.write_file('second.conf', """\
|
|
[wutta.config]
|
|
require = %(here)s/first.conf
|
|
|
|
[foo]
|
|
baz = B
|
|
""")
|
|
|
|
config = conf.WuttaConfig(files=[second])
|
|
self.assertEqual(len(config.files_read), 2)
|
|
# nb. files_read listing is in order of "priority" which is
|
|
# same the as order in which files were initially read
|
|
self.assertEqual(config.files_read[0], second)
|
|
self.assertEqual(config.files_read[1], first)
|
|
self.assertEqual(config.get('foo.bar'), '1')
|
|
self.assertEqual(config.get('foo.baz'), 'B')
|
|
|
|
def test_constructor_required_files_are_missing(self):
|
|
second = self.write_file('second.conf', """\
|
|
[wutta.config]
|
|
require = %(here)s/first.conf
|
|
|
|
[foo]
|
|
baz = B
|
|
""")
|
|
|
|
self.assertRaises(FileNotFoundError, conf.WuttaConfig, files=[second])
|
|
|
|
def test_constructor_included_files_are_present(self):
|
|
first = self.write_file('first.conf', """\
|
|
[foo]
|
|
bar = 1
|
|
baz = A
|
|
""")
|
|
|
|
second = self.write_file('second.conf', """\
|
|
[wutta.config]
|
|
include = %(here)s/first.conf
|
|
|
|
[foo]
|
|
baz = B
|
|
""")
|
|
|
|
config = conf.WuttaConfig(files=[second])
|
|
self.assertEqual(len(config.files_read), 2)
|
|
# nb. files_read listing is in order of "priority" which is
|
|
# same the as order in which files were initially read
|
|
self.assertEqual(config.files_read[0], second)
|
|
self.assertEqual(config.files_read[1], first)
|
|
self.assertEqual(config.get('foo.bar'), '1')
|
|
self.assertEqual(config.get('foo.baz'), 'B')
|
|
|
|
def test_constructor_included_files_are_missing(self):
|
|
second = self.write_file('second.conf', """\
|
|
[wutta.config]
|
|
include = %(here)s/first.conf
|
|
|
|
[foo]
|
|
baz = B
|
|
""")
|
|
|
|
config = conf.WuttaConfig(files=[second])
|
|
self.assertEqual(len(config.files_read), 1)
|
|
self.assertEqual(config.files_read[0], second)
|
|
self.assertIsNone(config.get('foo.bar'))
|
|
self.assertEqual(config.get('foo.baz'), 'B')
|
|
|
|
def test_prioritized_files(self):
|
|
first = self.write_file('first.conf', """\
|
|
[foo]
|
|
bar = 1
|
|
""")
|
|
|
|
second = self.write_file('second.conf', """\
|
|
[wutta.config]
|
|
require = %(here)s/first.conf
|
|
""")
|
|
|
|
config = conf.WuttaConfig(files=[second])
|
|
files = config.get_prioritized_files()
|
|
self.assertEqual(len(files), 2)
|
|
self.assertEqual(files[0], second)
|
|
self.assertEqual(files[1], first)
|
|
|
|
def test_constructor_defaults(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertEqual(config.defaults, {})
|
|
self.assertIsNone(config.get('foo'))
|
|
|
|
config = conf.WuttaConfig(defaults={'foo': 'bar'})
|
|
self.assertEqual(config.defaults, {'foo': 'bar'})
|
|
self.assertEqual(config.get('foo'), 'bar')
|
|
|
|
def test_constructor_db_flags(self):
|
|
try:
|
|
# nb. we don't need this import but the test will not
|
|
# behave correctly unless the lib is installed
|
|
import sqlalchemy
|
|
except ImportError:
|
|
pytest.skip("test is not relevant without sqlalchemy")
|
|
|
|
myfile = self.write_file('my.conf', """\
|
|
[wutta.config]
|
|
usedb = true
|
|
preferdb = true
|
|
""")
|
|
|
|
# flags are off by default
|
|
config = conf.WuttaConfig()
|
|
self.assertFalse(config.usedb)
|
|
self.assertFalse(config.preferdb)
|
|
|
|
# but may override via constructor
|
|
config = conf.WuttaConfig(usedb=True, preferdb=True)
|
|
self.assertTrue(config.usedb)
|
|
self.assertTrue(config.preferdb)
|
|
|
|
# and also may override via config file
|
|
config = conf.WuttaConfig(files=[myfile])
|
|
self.assertTrue(config.usedb)
|
|
self.assertTrue(config.preferdb)
|
|
|
|
def test_constructor_db_not_supported(self):
|
|
try:
|
|
# nb. we don't need this import but the test will not
|
|
# behave correctly unless the lib is installed
|
|
import sqlalchemy
|
|
except ImportError:
|
|
pytest.skip("test is not relevant without sqlalchemy")
|
|
|
|
# flags are off by default
|
|
config = conf.WuttaConfig()
|
|
self.assertFalse(config.usedb)
|
|
self.assertFalse(config.preferdb)
|
|
|
|
# but caller may enable the flags (if sqlalchemy available)
|
|
config = conf.WuttaConfig(usedb=True, preferdb=True)
|
|
self.assertTrue(config.usedb)
|
|
self.assertTrue(config.preferdb)
|
|
|
|
# but db flags are force-disabled if sqlalchemy not available,
|
|
# regardless of flag values caller provides...
|
|
|
|
orig_import = __import__
|
|
|
|
def mock_import(name, *args, **kwargs):
|
|
if name == 'wuttjamaican.db':
|
|
raise ImportError
|
|
return orig_import(name, *args, **kwargs)
|
|
|
|
with patch('builtins.__import__', side_effect=mock_import):
|
|
config = conf.WuttaConfig(usedb=True, preferdb=True)
|
|
self.assertFalse(config.usedb)
|
|
self.assertFalse(config.preferdb)
|
|
|
|
def test_constructor_may_configure_logging(self):
|
|
myfile = self.write_file('my.conf', """\
|
|
[wutta.config]
|
|
configure_logging = true
|
|
""")
|
|
|
|
with patch.object(conf.WuttaConfig, '_configure_logging') as method:
|
|
|
|
# no logging config by default
|
|
config = conf.WuttaConfig()
|
|
method.assert_not_called()
|
|
|
|
# but may override via constructor
|
|
method.reset_mock()
|
|
config = conf.WuttaConfig(configure_logging=True)
|
|
method.assert_called_once()
|
|
|
|
# and also may override via config file
|
|
method.reset_mock()
|
|
config = conf.WuttaConfig(files=[myfile])
|
|
method.assert_called_once()
|
|
|
|
def test_constructor_configures_logging(self):
|
|
myfile = self.write_file('my.conf', """\
|
|
[wutta]
|
|
timezone.default = America/Chicago
|
|
|
|
[wutta.config]
|
|
configure_logging = true
|
|
""")
|
|
|
|
with patch('wuttjamaican.conf.logging') as logging:
|
|
|
|
# basic constructor attempts logging config
|
|
config = conf.WuttaConfig(configure_logging=True)
|
|
logging.config.fileConfig.assert_called_once()
|
|
|
|
# if logging config fails, error is *not* raised
|
|
logging.config.fileConfig.reset_mock()
|
|
logging.config.fileConfig.side_effect = configparser.NoSectionError('logging')
|
|
config = conf.WuttaConfig(configure_logging=True)
|
|
logging.config.fileConfig.assert_called_once()
|
|
|
|
# and it works if we specify config file
|
|
logging.config.fileConfig.reset_mock()
|
|
config = conf.WuttaConfig(files=[myfile])
|
|
logging.config.fileConfig.assert_called_once()
|
|
|
|
def test_config_has_no_app_after_init(self):
|
|
|
|
# initial config should *not* have an app yet, otherwise
|
|
# extensions cannot specify a default app handler
|
|
config = conf.WuttaConfig()
|
|
self.assertFalse(hasattr(config, '_app'))
|
|
|
|
# but after that we can get an app okay
|
|
app = config.get_app()
|
|
self.assertIs(app, config._app)
|
|
|
|
def test_setdefault(self):
|
|
config = conf.WuttaConfig()
|
|
|
|
# value is empty by default
|
|
self.assertIsNone(config.get('foo'))
|
|
|
|
# but we can change that by setting default
|
|
config.setdefault('foo', 'bar')
|
|
self.assertEqual(config.get('foo'), 'bar')
|
|
|
|
# also, value is returned when we set default
|
|
self.assertIsNone(config.get('baz'))
|
|
self.assertEqual(config.setdefault('baz', 'blarg'), 'blarg')
|
|
|
|
def test_get_require_with_default(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertRaises(ValueError, config.get, 'foo', require=True, default='bar')
|
|
|
|
def test_get_require_missing(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertRaises(ConfigurationError, config.get, 'foo', require=True)
|
|
|
|
def test_get_with_default(self):
|
|
config = conf.WuttaConfig()
|
|
# nb. returns None if no default specified
|
|
self.assertIsNone(config.get('foo'))
|
|
self.assertEqual(config.get('foo', default='bar'), 'bar')
|
|
|
|
def test_get_from_db(self):
|
|
try:
|
|
import sqlalchemy as sa
|
|
from wuttjamaican.db import Session
|
|
except ImportError:
|
|
pytest.skip("test is not relevant without sqlalchemy")
|
|
|
|
# minimal config, but at least it needs db cxn info
|
|
config = conf.WuttaConfig(defaults={'wutta.db.default.url': 'sqlite://'})
|
|
|
|
session = Session()
|
|
|
|
# setup table for testing
|
|
session.execute(sa.text("""
|
|
create table setting (
|
|
name varchar(255) primary key,
|
|
value text
|
|
);
|
|
"""))
|
|
session.commit()
|
|
|
|
# setting not yet defined
|
|
self.assertIsNone(config.get_from_db('foo'))
|
|
|
|
# insert setting value to db
|
|
session.execute(sa.text("insert into setting values ('foo', 'bar')"))
|
|
session.commit()
|
|
|
|
# now setting returns a value
|
|
self.assertEqual(config.get_from_db('foo'), 'bar')
|
|
|
|
# also works if we provide the session
|
|
self.assertEqual(config.get_from_db('foo', session=session), 'bar')
|
|
|
|
session.close()
|
|
|
|
def test_get_default(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertIsNone(config.get('foo'))
|
|
self.assertEqual(config.get('foo', default='bar'), 'bar')
|
|
|
|
def test_get_require(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertIsNone(config.get('foo'))
|
|
self.assertRaises(ConfigurationError, config.get, 'foo', require=True)
|
|
|
|
def test_get_require_message(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertIsNone(config.get('foo'))
|
|
try:
|
|
config.get('foo', require=True, message="makin stuff up")
|
|
except ConfigurationError as error:
|
|
self.assertIn("makin stuff up", str(error))
|
|
|
|
def test_get_preferdb(self):
|
|
try:
|
|
import sqlalchemy as sa
|
|
from wuttjamaican.db import Session
|
|
except ImportError:
|
|
pytest.skip("test is not relevant without sqlalchemy")
|
|
|
|
# start out with a default value
|
|
config = conf.WuttaConfig(defaults={'wutta.db.default.url': 'sqlite://',
|
|
'foo': 'bar'})
|
|
self.assertEqual(config.get('foo'), 'bar')
|
|
|
|
session = Session()
|
|
|
|
# setup table for testing
|
|
session.execute(sa.text("""
|
|
create table setting (
|
|
name varchar(255) primary key,
|
|
value text
|
|
);
|
|
"""))
|
|
session.execute(sa.text("insert into setting values ('foo', 'baz')"))
|
|
session.commit()
|
|
|
|
# we did not specify usedb=True, so original default is still returned
|
|
self.assertFalse(config.usedb)
|
|
self.assertEqual(config.get('foo'), 'bar')
|
|
|
|
# usedb but no preferdb means original default is still returned
|
|
self.assertEqual(config.get('foo', usedb=True), 'bar')
|
|
|
|
# but preferdb should mean newer db value is returned
|
|
self.assertEqual(config.get('foo', usedb=True, preferdb=True), 'baz')
|
|
|
|
# try a different key to ensure db fallback works if no default present
|
|
session.execute(sa.text("insert into setting values ('blarg', 'blitz')"))
|
|
session.commit()
|
|
self.assertIsNone(config.get('blarg'))
|
|
self.assertEqual(config.get('blarg', usedb=True), 'blitz')
|
|
|
|
session.close()
|
|
|
|
def test_get_ambiguous(self):
|
|
config = conf.WuttaConfig()
|
|
|
|
# value is returned if key is not ambiguous
|
|
config.setdefault('foo', 'bar')
|
|
self.assertEqual(config.get('foo'), 'bar')
|
|
|
|
# but None is returned if key is ambiguous
|
|
config.setdefault('foo.bar', 'baz')
|
|
self.assertIsNone(config.get('foo'))
|
|
|
|
def test_require(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertRaises(ConfigurationError, config.require, 'foo')
|
|
|
|
def test_get_bool(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertFalse(config.get_bool('foo.bar'))
|
|
config.setdefault('foo.bar', 'true')
|
|
self.assertTrue(config.get_bool('foo.bar'))
|
|
|
|
def test_get_int(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertIsNone(config.get_int('foo.bar'))
|
|
config.setdefault('foo.bar', '42')
|
|
self.assertEqual(config.get_int('foo.bar'), 42)
|
|
|
|
def test_get_list(self):
|
|
config = conf.WuttaConfig()
|
|
self.assertIsNone(config.get_list('foo.bar'))
|
|
config.setdefault('foo.bar', 'hello world')
|
|
self.assertEqual(config.get_list('foo.bar'), ['hello', 'world'])
|
|
|
|
def test_parse_bool_null(self):
|
|
config = self.make_config()
|
|
self.assertIsNone(config.parse_bool(None))
|
|
|
|
def test_parse_bool_bool(self):
|
|
config = self.make_config()
|
|
self.assertTrue(config.parse_bool(True))
|
|
self.assertFalse(config.parse_bool(False))
|
|
|
|
def test_parse_bool_string_true(self):
|
|
config = self.make_config()
|
|
self.assertTrue(config.parse_bool('true'))
|
|
self.assertTrue(config.parse_bool('yes'))
|
|
self.assertTrue(config.parse_bool('y'))
|
|
self.assertTrue(config.parse_bool('on'))
|
|
self.assertTrue(config.parse_bool('1'))
|
|
|
|
def test_parse_bool_string_false(self):
|
|
config = self.make_config()
|
|
self.assertFalse(config.parse_bool('false'))
|
|
self.assertFalse(config.parse_bool('no'))
|
|
self.assertFalse(config.parse_bool('n'))
|
|
self.assertFalse(config.parse_bool('off'))
|
|
self.assertFalse(config.parse_bool('0'))
|
|
# nb. assume false for unrecognized input
|
|
self.assertFalse(config.parse_bool('whatever-else'))
|
|
|
|
def test_parse_list_null(self):
|
|
config = self.make_config()
|
|
value = config.parse_list(None)
|
|
self.assertIsInstance(value, list)
|
|
self.assertEqual(len(value), 0)
|
|
|
|
def test_parse_list_list_instance(self):
|
|
config = self.make_config()
|
|
mylist = []
|
|
value = config.parse_list(mylist)
|
|
self.assertIs(value, mylist)
|
|
|
|
def test_parse_list_single_value(self):
|
|
config = self.make_config()
|
|
value = config.parse_list('foo')
|
|
self.assertEqual(len(value), 1)
|
|
self.assertEqual(value[0], 'foo')
|
|
|
|
def test_parse_list_single_value_padded_by_spaces(self):
|
|
config = self.make_config()
|
|
value = config.parse_list(' foo ')
|
|
self.assertEqual(len(value), 1)
|
|
self.assertEqual(value[0], 'foo')
|
|
|
|
def test_parse_list_slash_is_not_a_separator(self):
|
|
config = self.make_config()
|
|
value = config.parse_list('/dev/null')
|
|
self.assertEqual(len(value), 1)
|
|
self.assertEqual(value[0], '/dev/null')
|
|
|
|
def test_parse_list_multiple_values_separated_by_whitespace(self):
|
|
config = self.make_config()
|
|
value = config.parse_list('foo bar baz')
|
|
self.assertEqual(len(value), 3)
|
|
self.assertEqual(value[0], 'foo')
|
|
self.assertEqual(value[1], 'bar')
|
|
self.assertEqual(value[2], 'baz')
|
|
|
|
def test_parse_list_multiple_values_separated_by_commas(self):
|
|
config = self.make_config()
|
|
value = config.parse_list('foo,bar,baz')
|
|
self.assertEqual(len(value), 3)
|
|
self.assertEqual(value[0], 'foo')
|
|
self.assertEqual(value[1], 'bar')
|
|
self.assertEqual(value[2], 'baz')
|
|
|
|
def test_parse_list_multiple_values_separated_by_whitespace_and_commas(self):
|
|
config = self.make_config()
|
|
value = config.parse_list(' foo, bar baz')
|
|
self.assertEqual(len(value), 3)
|
|
self.assertEqual(value[0], 'foo')
|
|
self.assertEqual(value[1], 'bar')
|
|
self.assertEqual(value[2], 'baz')
|
|
|
|
def test_parse_list_multiple_values_separated_by_whitespace_and_commas_with_some_quoting(self):
|
|
config = self.make_config()
|
|
value = config.parse_list("""
|
|
foo
|
|
"C:\\some path\\with spaces\\and, a comma",
|
|
baz
|
|
""")
|
|
self.assertEqual(len(value), 3)
|
|
self.assertEqual(value[0], 'foo')
|
|
self.assertEqual(value[1], 'C:\\some path\\with spaces\\and, a comma')
|
|
self.assertEqual(value[2], 'baz')
|
|
|
|
def test_parse_list_multiple_values_separated_by_whitespace_and_commas_with_single_quotes(self):
|
|
config = self.make_config()
|
|
value = config.parse_list("""
|
|
foo
|
|
'C:\\some path\\with spaces\\and, a comma',
|
|
baz
|
|
""")
|
|
self.assertEqual(len(value), 3)
|
|
self.assertEqual(value[0], 'foo')
|
|
self.assertEqual(value[1], 'C:\\some path\\with spaces\\and, a comma')
|
|
self.assertEqual(value[2], 'baz')
|
|
|
|
def test_get_app(self):
|
|
|
|
# default handler
|
|
config = conf.WuttaConfig()
|
|
self.assertEqual(config.default_app_handler_spec, 'wuttjamaican.app:AppHandler')
|
|
app = config.get_app()
|
|
self.assertIsInstance(app, AppHandler)
|
|
# nb. make extra sure we didn't get a subclass
|
|
self.assertIs(type(app), AppHandler)
|
|
|
|
# custom default handler
|
|
config = conf.WuttaConfig()
|
|
config.default_app_handler_spec = 'tests.test_conf:CustomAppHandler'
|
|
app = config.get_app()
|
|
self.assertIsInstance(app, CustomAppHandler)
|
|
|
|
def test_get_engine_maker(self):
|
|
try:
|
|
from wuttjamaican.db.conf import make_engine_from_config
|
|
except ImportError:
|
|
pytest.skip("test is not relevant without sqlalchemy")
|
|
|
|
# default func
|
|
config = conf.WuttaConfig()
|
|
self.assertEqual(config.default_engine_maker_spec, 'wuttjamaican.db.conf:make_engine_from_config')
|
|
make_engine = config.get_engine_maker()
|
|
self.assertIs(make_engine, make_engine_from_config)
|
|
|
|
# custom default func
|
|
config = conf.WuttaConfig()
|
|
config.default_engine_maker_spec = 'tests.test_conf:custom_make_engine_from_config'
|
|
make_engine = config.get_engine_maker()
|
|
self.assertIs(make_engine, custom_make_engine_from_config)
|
|
|
|
def test_production(self):
|
|
config = conf.WuttaConfig()
|
|
|
|
# false if not defined
|
|
self.assertFalse(config.production())
|
|
|
|
# but config may specify
|
|
config.setdefault('wutta.production', 'true')
|
|
self.assertTrue(config.production())
|
|
|
|
|
|
class CustomAppHandler(AppHandler):
|
|
pass
|
|
|
|
|
|
def custom_make_engine_from_config():
|
|
pass
|
|
|
|
|
|
class TestWuttaConfigExtension(TestCase):
|
|
|
|
def test_basic(self):
|
|
config = conf.WuttaConfig()
|
|
ext = conf.WuttaConfigExtension()
|
|
self.assertIsNone(ext.key)
|
|
self.assertEqual(repr(ext), 'WuttaConfigExtension(key=None)')
|
|
|
|
|
|
class TestGenericDefaultFiles(TestCase):
|
|
|
|
def test_linux(self):
|
|
files = conf.generic_default_files('wuttatest')
|
|
self.assertIsInstance(files, list)
|
|
self.assertTrue(len(files) > 1)
|
|
self.assertIn('/etc/wuttatest.conf', files)
|
|
|
|
def test_win32(self):
|
|
win32com = MagicMock()
|
|
win32com.shell.SHGetSpecialFolderPath.return_value = r'C:' + os.sep
|
|
with patch.dict('sys.modules', **{'win32com.shell': win32com}):
|
|
with patch('wuttjamaican.conf.sys', platform='win32'):
|
|
|
|
files = conf.generic_default_files('wuttatest')
|
|
self.assertIsInstance(files, list)
|
|
self.assertTrue(len(files) > 1)
|
|
self.assertIn(os.path.join('C:', 'wuttatest.conf'), files)
|
|
|
|
def test_win32_broken(self):
|
|
orig_import = __import__
|
|
|
|
def mock_import(name, *args, **kwargs):
|
|
if name == 'win32com.shell':
|
|
raise ImportError
|
|
return orig_import(name, *args, **kwargs)
|
|
|
|
with patch('builtins.__import__', side_effect=mock_import):
|
|
with patch('wuttjamaican.conf.sys', platform='win32'):
|
|
|
|
files = conf.generic_default_files('wuttatest')
|
|
self.assertIsInstance(files, list)
|
|
self.assertEqual(len(files), 0)
|
|
|
|
|
|
class TestGetConfigPaths(FileTestCase):
|
|
|
|
def test_winsvc(self):
|
|
myconf = self.write_file('my.conf', """
|
|
[wutta.config]
|
|
winsvc.RattailFileMonitor = /path/to/other/file
|
|
""")
|
|
|
|
files = conf.get_config_paths(files=[myconf], winsvc='RattailFileMonitor')
|
|
self.assertEqual(files, ['/path/to/other/file'])
|
|
|
|
def test_nonexistent_default_files(self):
|
|
files = conf.get_config_paths(files=None,
|
|
env_files_name='IGNORE_THIS',
|
|
default_files=['/this/does/not/exist'])
|
|
self.assertEqual(files, [])
|
|
|
|
|
|
class TestMakeConfig(FileTestCase):
|
|
|
|
# nb. we use appname='wuttatest' in this suite to avoid any
|
|
# "valid" default config files, env vars etc. which may be present
|
|
# on the dev machine
|
|
|
|
def test_generic_default_files(self):
|
|
generic = self.write_file('generic.conf', '')
|
|
|
|
with patch('wuttjamaican.conf.generic_default_files') as generic_default_files:
|
|
with patch('wuttjamaican.conf.WuttaConfig') as WuttaConfig:
|
|
|
|
# generic files are used if nothing is specified
|
|
generic_default_files.return_value = [generic]
|
|
config = conf.make_config(appname='wuttatest')
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# make sure empty defaults works too
|
|
generic_default_files.reset_mock()
|
|
generic_default_files.return_value = []
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest')
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
def test_specify_default_files(self):
|
|
generic = self.write_file('generic.conf', '')
|
|
myfile = self.write_file('my.conf', '')
|
|
|
|
with patch('wuttjamaican.conf.generic_default_files') as generic_default_files:
|
|
with patch('wuttjamaican.conf.WuttaConfig') as WuttaConfig:
|
|
|
|
# generic defaults are used if nothing specified
|
|
generic_default_files.return_value = [generic]
|
|
config = conf.make_config(appname='wuttatest')
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify single default file
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest', default_files=myfile)
|
|
generic_default_files.assert_not_called()
|
|
WuttaConfig.assert_called_once_with([myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify default files as list
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest', default_files=[myfile])
|
|
generic_default_files.assert_not_called()
|
|
WuttaConfig.assert_called_once_with([myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify default files as callable
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest', default_files=lambda appname: [myfile])
|
|
generic_default_files.assert_not_called()
|
|
WuttaConfig.assert_called_once_with([myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
def test_specify_plus_files(self):
|
|
generic = self.write_file('generic.conf', '')
|
|
myfile = self.write_file('my.conf', '')
|
|
|
|
with patch('wuttjamaican.conf.generic_default_files') as generic_default_files:
|
|
with patch('wuttjamaican.conf.WuttaConfig') as WuttaConfig:
|
|
|
|
generic_default_files.return_value = [generic]
|
|
|
|
# no plus files by default
|
|
config = conf.make_config(appname='wuttatest')
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify single plus file
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest', plus_files=myfile)
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic, myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify plus files as list
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest', plus_files=[myfile])
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic, myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify plus files via env
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest',
|
|
env={'WUTTATEST_CONFIG_PLUS_FILES': myfile})
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic, myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
def test_specify_primary_files(self):
|
|
generic = self.write_file('generic.conf', '')
|
|
myfile = self.write_file('my.conf', '')
|
|
|
|
with patch('wuttjamaican.conf.generic_default_files') as generic_default_files:
|
|
with patch('wuttjamaican.conf.WuttaConfig') as WuttaConfig:
|
|
|
|
generic_default_files.return_value = [generic]
|
|
|
|
# generic files by default
|
|
config = conf.make_config(appname='wuttatest')
|
|
generic_default_files.assert_called_once_with('wuttatest')
|
|
WuttaConfig.assert_called_once_with([generic], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify single primary file (nb. no default files)
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(myfile, appname='wuttatest')
|
|
generic_default_files.assert_not_called()
|
|
WuttaConfig.assert_called_once_with([myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify primary files as list
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config([myfile], appname='wuttatest')
|
|
generic_default_files.assert_not_called()
|
|
WuttaConfig.assert_called_once_with([myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
# can specify primary files via env
|
|
generic_default_files.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = conf.make_config(appname='wuttatest',
|
|
env={'WUTTATEST_CONFIG_FILES': myfile})
|
|
generic_default_files.assert_not_called()
|
|
WuttaConfig.assert_called_once_with([myfile], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
|
|
def test_extensions(self):
|
|
generic = self.write_file('generic.conf', '')
|
|
myfile = self.write_file('my.conf', '')
|
|
|
|
with patch.object(mod, 'WuttaConfig') as WuttaConfig:
|
|
with patch.object(mod, 'load_entry_points') as load_entry_points:
|
|
|
|
# no entry points loaded if extend=False
|
|
config = mod.make_config(appname='wuttatest', extend=False)
|
|
WuttaConfig.assert_called_once_with([], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
load_entry_points.assert_not_called()
|
|
|
|
# confirm entry points for default appname
|
|
load_entry_points.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = mod.make_config([], appname='wutta')
|
|
WuttaConfig.assert_called_once_with([], appname='wutta',
|
|
usedb=None, preferdb=None)
|
|
load_entry_points.assert_called_once_with('wutta.config.extensions')
|
|
|
|
# confirm entry points for custom appname
|
|
load_entry_points.reset_mock()
|
|
WuttaConfig.reset_mock()
|
|
config = mod.make_config(appname='wuttatest')
|
|
WuttaConfig.assert_called_once_with([], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
load_entry_points.assert_called_once_with('wuttatest.config.extensions')
|
|
|
|
# confirm extensions are invoked
|
|
load_entry_points.reset_mock()
|
|
foo_obj = MagicMock()
|
|
foo_cls = MagicMock(return_value=foo_obj)
|
|
load_entry_points.return_value = {'foo': foo_cls}
|
|
WuttaConfig.reset_mock()
|
|
testconfig = MagicMock()
|
|
WuttaConfig.return_value = testconfig
|
|
config = mod.make_config(appname='wuttatest')
|
|
WuttaConfig.assert_called_once_with([], appname='wuttatest',
|
|
usedb=None, preferdb=None)
|
|
load_entry_points.assert_called_once_with('wuttatest.config.extensions')
|
|
foo_cls.assert_called_once_with()
|
|
foo_obj.configure.assert_called_once_with(testconfig)
|
|
foo_obj.startup.assert_called_once_with(testconfig)
|