def test_add_aggregation_returns_aggregation(self):
def foo(all, local, args):
return 17
n = config_manager.Namespace()
aggregation = n.add_aggregation('myaggregation', foo)
self.assertEqual(n['myaggregation'], aggregation)
def test_setting_nested_namespaces(self):
n = config_manager.Namespace()
n.namespace('sub')
sub_n = n.sub
sub_n.add_option('name')
self.assertTrue(n.sub)
self.assertTrue(isinstance(n.sub.name, config_manager.Option))
def test_comparing_namespace_instances(self):
n = config_manager.Namespace()
n2 = config_manager.Namespace()
self.assertEqual(n, n2)
n3 = config_manager.Namespace()
n3.add_option('name', 'Peter')
self.assertNotEqual(n, n3)
n2.add_option('name', 'Peter', 'Name of a person')
self.assertNotEqual(n, n2)
self.assertNotEqual(n2, n3)
n4 = config_manager.Namespace()
n4.add_option('name', 'Peter')
self.assertEqual(n4, n3)
def test_write_json(self):
n = config_manager.Namespace(doc='top')
n.add_option('aaa',
'2011-05-04T15:10:00',
'the a',
short_form='a',
from_string_converter=dtu.datetime_from_ISO_string)
def value_iter():
yield 'aaa', 'aaa', n.aaa
s = StringIO()
ValueSource.write(value_iter, output_stream=s)
received = s.getvalue()
s.close()
jrec = json.loads(received)
expect_to_find = {
"short_form": "a",
"default": "2011-05-04T15:10:00",
"doc": "the a",
"value": "2011-05-04T15:10:00",
"from_string_converter":
"configman.datetime_util.datetime_from_ISO_string",
"name": "aaa"
}
for key, value in expect_to_find.items():
self.assertEqual(jrec['aaa'][key], value)
def test_write_json(self):
n = config_manager.Namespace(doc='top')
n.add_option('aaa', '2011-05-04T15:10:00', 'the a',
short_form='a',
from_string_converter=dtu.datetime_from_ISO_string
)
c = config_manager.ConfigurationManager(
[n],
use_admin_controls=True,
use_auto_help=False,
argv_source=[]
)
out = StringIO()
c.write_conf(for_json, opener=stringIO_context_wrapper(out))
received = out.getvalue()
out.close()
jrec = json.loads(received)
expect_to_find = {
"short_form": "a",
"default": "2011-05-04T15:10:00",
"doc": "the a",
"value": "2011-05-04T15:10:00",
"from_string_converter":
"configman.datetime_util.datetime_from_ISO_string",
"name": "aaa"
}
for key, value in expect_to_find.items():
self.assertEqual(jrec['aaa'][key], value)
def _some_namespaces(self):
"""set up some namespaces"""
n = config_manager.Namespace(doc='top')
n.add_option('aaa',
'2011-05-04T15:10:00',
'the a',
short_form='a',
from_string_converter=dtu.datetime_from_ISO_string)
n.c = config_manager.Namespace(doc='c space')
n.c.add_option('fred', 'stupid', 'husband from Flintstones')
n.c.add_option('wilma', 'waspish', 'wife from Flintstones')
n.d = config_manager.Namespace(doc='d space')
n.d.add_option('fred', 'crabby', 'male neighbor from I Love Lucy')
n.d.add_option('ethel', 'silly', 'female neighbor from I Love Lucy')
n.x = config_manager.Namespace(doc='x space')
n.x.add_option('size', 100, 'how big in tons', short_form='s')
n.x.add_option('password', 'secret', 'the password')
return n
def test_deep_copy(self):
from copy import deepcopy
n = config_manager.Namespace()
n2 = deepcopy(n)
self.assertTrue(n is not n2)
n = config_manager.Namespace()
n.add_option('name', 'Peter')
n3 = deepcopy(n)
self.assertEqual(n, n3)
self.assertTrue(n.name is not n3.name)
def foo(all, local, args):
return 17
n = config_manager.Namespace()
n.add_aggregation('a', foo)
n4 = deepcopy(n)
self.assertTrue(n.a is not n4.a)
def test_add_option_returns_option(self):
n = config_manager.Namespace()
option = n.add_option('name', 'Peter')
self.assertEqual(option.name, 'name')
self.assertEqual(option.value, 'Peter')
self.assertEqual(option, n['name'])
# should work the same if you add an option straight
o = Option('dwight')
option = n.add_option(o)
self.assertEqual(option, o)
def test_overlay_config_6(self):
"""test namespace definition w/getopt"""
n = config_manager.Namespace()
n.add_option('a', doc='the a', default=1)
n.b = 17
n.c = config_manager.Namespace()
n.c.add_option('extra', doc='the x', default=3.14159, short_form='e')
c = config_manager.ConfigurationManager(
[n], [['--a', '2', '--c.extra', '11.0']],
use_admin_controls=True,
use_auto_help=False)
self.assertEqual(type(c.option_definitions.b), config_manager.Option)
self.assertEqual(c.option_definitions.a.value, 2)
self.assertEqual(c.option_definitions.b.value, 17)
self.assertEqual(c.option_definitions.b.default, 17)
self.assertEqual(c.option_definitions.b.name, 'b')
self.assertEqual(c.option_definitions.c.extra.name, 'extra')
self.assertEqual(c.option_definitions.c.extra.doc, 'the x')
self.assertEqual(c.option_definitions.c.extra.default, '11.0')
self.assertEqual(c.option_definitions.c.extra.value, 11.0)
def test_walk_expanding_class_options(self):
class A(config_manager.RequiredConfig):
required_config = {
'a': config_manager.Option('a', 1, 'the a'),
'b': 17,
}
n = config_manager.Namespace()
n.source = config_manager.Namespace()
n.source.add_option('c', A, 'the A class')
assert n.source.c.doc == 'the A class'
n.dest = config_manager.Namespace()
n.dest.add_option('c', A, doc='the A class')
assert n.dest.c.doc == 'the A class'
c = config_manager.ConfigurationManager(
[n],
use_admin_controls=True,
#use_config_files=False,
use_auto_help=False,
argv_source=[])
e = config_manager.Namespace()
e.s = config_manager.Namespace()
e.s.add_option('c', A, doc='the A class')
e.s.add_option('a', 1, 'the a')
e.s.add_option('b', default=17)
e.d = config_manager.Namespace()
e.d.add_option('c', A, doc='the A class')
e.d.add_option('a', 1, 'the a')
e.d.add_option('b', default=17)
def namespace_test(val):
self.assertEqual(type(val), config_manager.Namespace)
def option_test(val, expected=None):
self.assertEqual(val.name, expected.name)
self.assertEqual(val.default, expected.default)
self.assertEqual(val.doc, expected.doc)
e = [
('dest', 'dest', namespace_test),
('dest.a', 'a', functools.partial(option_test, expected=e.d.a)),
('dest.b', 'b', functools.partial(option_test, expected=e.d.b)),
('dest.c', 'c', functools.partial(option_test, expected=e.d.c)),
('source', 'source', namespace_test),
('source.a', 'a', functools.partial(option_test, expected=e.s.a)),
('source.b', 'b', functools.partial(option_test, expected=e.s.b)),
('source.c', 'c', functools.partial(option_test, expected=e.s.c)),
]
c_contents = [(qkey, key, val) for qkey, key, val in c._walk_config()]
c_contents.sort()
e.sort()
for c_tuple, e_tuple in zip(c_contents, e):
qkey, key, val = c_tuple
e_qkey, e_key, e_fn = e_tuple
self.assertEqual(qkey, e_qkey)
self.assertEqual(key, e_key)
e_fn(val)
def test_overlay_config_6a(self):
"""test namespace w/getopt w/short form"""
n = config_manager.Namespace()
n.add_option('a', 1, doc='the a')
n.b = 17
n.c = config_manager.Namespace()
n.c.add_option('extra', 3.14159, 'the x', short_form='e')
c = config_manager.ConfigurationManager(
[n], [getopt],
use_admin_controls=True,
argv_source=['--a', '2', '-e', '11.0'],
use_auto_help=False)
self.assertEqual(c.option_definitions.a, n.a)
self.assertEqual(type(c.option_definitions.b), config_manager.Option)
self.assertEqual(c.option_definitions.a.value, 2)
self.assertEqual(c.option_definitions.b.value, 17)
self.assertEqual(c.option_definitions.b.default, 17)
self.assertEqual(c.option_definitions.b.name, 'b')
self.assertEqual(c.option_definitions.c.extra.name, 'extra')
self.assertEqual(c.option_definitions.c.extra.doc, 'the x')
self.assertEqual(c.option_definitions.c.extra.default, 3.14159)
self.assertEqual(c.option_definitions.c.extra.value, 11.0)
def test_configuration_with_namespace(self):
namespace = config_manager.Namespace()
namespace.add_option('a')
namespace.a.default = 1
namespace.a.doc = 'the a'
namespace.b = 17
config = config_manager.ConfigurationManager([namespace],
argv_source=[])
self.assertTrue(
isinstance(config.option_definitions.b, config_manager.Option))
self.assertEqual(config.option_definitions.b.value, 17)
self.assertEqual(config.option_definitions.b.default, 17)
self.assertEqual(config.option_definitions.b.name, 'b')
def test_verify_key_order(self):
d = config_manager.Namespace()
d.add_option('a.b.c')
d.a.b.add_option('d')
d.a.add_option('x')
d.add_aggregation('b', lambda x, y, z: None)
self.assertTrue(isinstance(d._key_order, OrderedSet))
# the keys should be in order of insertion within each level of the
# nested dicts
keys_in_breadth_first_order = [
'a', 'b', 'a.b', 'a.x', 'a.b.c', 'a.b.d'
]
self.assertEqual(keys_in_breadth_first_order,
[k for k in d.keys_breadth_first(include_dicts=True)])
def test_Namespace_basics(self):
namespace = config_manager.Namespace('doc string')
namespace.alpha = 1
my_birthday = datetime.datetime(1960, 5, 4, 15, 10)
namespace.beta = my_birthday
self.assertEqual(namespace.alpha.name, 'alpha')
self.assertEqual(namespace.alpha.doc, None)
self.assertEqual(namespace.alpha.default, 1)
self.assertEqual(namespace.alpha.from_string_converter, int)
self.assertEqual(namespace.alpha.value, 1)
self.assertEqual(namespace.beta.name, 'beta')
self.assertEqual(namespace.beta.doc, None)
self.assertEqual(namespace.beta.default, my_birthday)
self.assertEqual(namespace.beta.from_string_converter,
dtu.datetime_from_ISO_string)
self.assertEqual(namespace.beta.value, my_birthday)
def test_editing_values_on_namespace(self):
n = config_manager.Namespace()
self.assertRaises(KeyError, n.set_value, 'name', 'Peter')
n.add_option('name', 'Lars')
n.set_value('name', 'Peter')
self.assertTrue(n.name)
self.assertEqual(n.name.value, 'Peter')
n.namespace('user')
n.user.add_option('age', 100)
n.set_value('user.age', 200)
self.assertTrue(n.user.age)
self.assertEqual(n.user.age.value, 200)
# let's not be strict once
n.set_value('user.gender', u'male', strict=False)
self.assertEqual(n.user.gender.value, u'male')
def test_setup_definitions_1(self):
d = dd.DotDict()
def fake_mapping_func(source, destination):
self.assertTrue(isinstance(source, collections.Mapping))
self.assertEqual(d, destination)
saved_original = defsrc.definition_dispatch.copy()
try:
defsrc.definition_dispatch[collections.Mapping] = fake_mapping_func
s = {}
defsrc.setup_definitions(s, d)
s = dd.DotDict()
defsrc.setup_definitions(s, d)
s = config_manager.Namespace()
defsrc.setup_definitions(s, d)
finally:
defsrc.definition_dispatch = saved_original
def test_overlay_config_5(self):
"""test namespace definition w/getopt"""
n = config_manager.Namespace()
n.add_option('a', 1, doc='the a')
n.b = 17
n.add_option('c', False, doc='the c')
c = config_manager.ConfigurationManager([n], [['--a', '2', '--c']],
use_admin_controls=True,
use_auto_help=False,
argv_source=[])
self.assertTrue(
isinstance(c.option_definitions.b, config_manager.Option))
self.assertEqual(c.option_definitions.a.value, 2)
self.assertEqual(c.option_definitions.b.value, 17)
self.assertEqual(c.option_definitions.b.default, 17)
self.assertEqual(c.option_definitions.b.name, 'b')
self.assertEqual(c.option_definitions.c.name, 'c')
self.assertEqual(c.option_definitions.c.value, True)
def test_json_round_trip(self):
n = config_manager.Namespace(doc='top')
n.add_option('aaa',
'2011-05-04T15:10:00',
'the a',
short_form='a',
from_string_converter=dtu.datetime_from_ISO_string)
expected_date = dtu.datetime_from_ISO_string('2011-05-04T15:10:00')
n.add_option('bbb',
'37',
'the a',
short_form='a',
from_string_converter=int)
n.add_option('write', 'json')
n.add_aggregation('bbb_minus_one', bbb_minus_one)
#t = tempfile.NamedTemporaryFile('w', suffix='.json', delete=False)
name = '/tmp/test.json'
import functools
opener = functools.partial(open, name, 'w')
c1 = config_manager.ConfigurationManager([n], [],
use_admin_controls=True,
use_auto_help=False,
app_name='/tmp/test',
app_version='0',
app_description='',
argv_source=[])
c1.write_conf('json', opener)
d1 = {'bbb': 88}
d2 = {'bbb': '-99'}
try:
with open(name) as jfp:
j = json.load(jfp)
c2 = config_manager.ConfigurationManager((j, ), (d1, d2),
use_admin_controls=True,
use_auto_help=False,
argv_source=[])
config = c2.get_config()
self.assertEqual(config.aaa, expected_date)
self.assertEqual(config.bbb, -99)
self.assertEqual(config.bbb_minus_one, -100)
finally:
os.unlink(name)
def test_add_option_with_option(self):
o = Option('dwight')
n = config_manager.Namespace()
n.add_option(o)
self.assertTrue(o is n.dwight)
def test_add_namespace_returns_namespace(self):
n = config_manager.Namespace()
namespace = n.namespace('deeper', 'My doc')
self.assertEqual(namespace, n.deeper)
self.assertEqual(namespace._doc, 'My doc')
