def test_as_float_with_existent_key(self):
config = MemoryConfig()
config.set('key', '2')
container = PropertyContainer('key', config, version=Version())
self.assertIsInstance(container.as_float(1.0).get(), float)
self.assertEqual(2, container.as_float(1.0).get())
def test_get_value_with_overridden_key(self):
config = ChainConfig(
MemoryConfig(data={'key': 1}),
MemoryConfig(data={'key': 2})
)
self.assertEqual(2, config.get_value('key', int))
def test_as_type_for_same_existent_key(self):
config = MemoryConfig()
config.set('key', '2')
container = PropertyContainer('key', config, version=Version())
self.assertEqual(container.as_type(int, 1), container.as_type(int, 1))
def test_as_list_with_existent_key(self):
config = MemoryConfig()
config.set('key', ['value'])
container = PropertyContainer('key', config, version=Version())
self.assertIsInstance(container.as_list([]).get(), list)
self.assertEqual(['value'], container.as_list([]).get())
def test_as_dict_with_existent_key(self):
config = MemoryConfig()
config.set('key', {'key': 'value'})
container = PropertyContainer('key', config, version=Version())
self.assertIsInstance(container.as_dict({}).get(), MutableMapping)
self.assertEqual({'key': 'value'}, container.as_dict({}).get())
def test_as_bool_with_existent_key(self):
config = MemoryConfig()
config.set('key', '0')
container = PropertyContainer('key', config, version=Version())
self.assertIsInstance(container.as_bool(True).get(), bool)
self.assertEqual(False, container.as_bool(True).get())
def test_as_str_with_existent_key(self):
config = MemoryConfig()
config.set('key', 'value')
container = PropertyContainer('key', config, version=Version())
self.assertIsInstance(
container.as_str('default value').get(), string_types)
self.assertEqual('value', container.as_str('default value').get())
def test_resolve_with_variable_in_a_composite_config(self):
config = MemoryConfig()
root = ChainConfig(MemoryConfig(data={'key': 'value'}),
ChainConfig(config))
self.assertEqual('value',
self._interpolator.resolve('${key}', config.lookup))
def test_invalidate_properties(self):
config = MemoryConfig()
properties = PropertyManager(config)
self.assertEqual(0, properties._version.number)
config.set('key', 'value')
self.assertEqual(1, properties._version.number)
def test_str(self):
config = MemoryConfig()
config.set('key', '2')
prop = Property(name='key',
default=1,
type=int,
config=config,
version=Version())
self.assertEqual('2', str(prop))
def test_updated_trigger(self):
child = MemoryConfig()
config = MergeConfig(child)
passed = []
config.updated.add(lambda: passed.append(True))
child.set('key', 'value')
self.assertEqual(1, len(passed))
def test_trigger_updated_event_on_set_key(self):
ev = Event()
config = MemoryConfig()
@config.on_updated
def on_updated():
ev.set()
config.set('key1', 'value1')
self.assertTrue(ev.is_set)
def test_init_data_with_dict_value(self):
data = {'key1': 'value'}
config = MemoryConfig(data)
self.assertEqual('value', config['key1'])
config.set('key1', 'value1')
self.assertEqual('value1', config['key1'])
# the initial dict should be cloned by MemoryConfig
self.assertEqual(data['key1'], 'value')
def test_reload_with_updated_error(self):
config = MemoryConfig().reload_every(0.005)
ev = Event()
@config.on_updated
def updated():
ev.set()
raise MemoryError()
config.load()
time.sleep(0.02)
self.assertTrue(ev.is_set())
def test_init_version_with_int_value(self):
with self.assertRaises(TypeError):
Property(name='key',
default=1,
type=int,
config=MemoryConfig(),
version=123)
def test_init_name_with_none_value(self):
with self.assertRaises(TypeError):
Property(name=None,
default=1,
type=int,
config=MemoryConfig(),
version=Version())
def test_init_name_with_str_value(self):
prop = Property(name='name',
default=1,
type=int,
config=MemoryConfig(),
version=Version())
self.assertEqual('name', prop.name)
def test_init_cast_with_none_value(self):
with self.assertRaises(ValueError):
Property(name='key',
default=1,
type=None,
config=MemoryConfig(),
version=Version())
def test_get_updated_with_default_value(self):
prop = Property(name='key',
default=1,
type=int,
config=MemoryConfig(),
version=Version())
self.assertEqual(EventHandler, type(prop.updated))
def test_init_cast_with_int_value(self):
prop = Property(name='key',
default=1,
type=int,
config=MemoryConfig(),
version=Version())
self.assertEqual(int, prop.type)
def test_resolve_with_variable(self):
self.assertEqual(
'value',
self._interpolator.resolve(
'${key}',
MemoryConfig(data={
'key': 'value'
}).lookup))
def test_set_with_ignore_case_dict_as_value(self):
data = IgnoreCaseDict(item='value')
config = MemoryConfig()
config.set('key', data)
self.assertIsInstance(config.get('key'), IgnoreCaseDict)
self.assertEqual(id(config.get('key')), id(data))
def test_on_updated_with_func_value(self):
prop = Property(name='key',
default=1,
type=int,
config=MemoryConfig(),
version=Version())
def dummy():
pass
prop.on_updated(dummy)
self.assertEqual(1, len(prop.updated))
def _create_base_config(self, load_data=False):
if load_data:
config = ChainConfig(
MemoryConfig(data={
'key_str': 'value',
'key_int': 1,
'key_int_as_str': '1',
'key_dict': {'key_str': 'value'},
'key_dict_as_str': 'item_key=value',
'key_list_as_str': 'item1,item2'}),
MemoryConfig(data={
'key_interpolated': '${key_str}',
'key_ignore_case': 'value',
'key_IGNORE_case': 'value1',
'key_delimited': {'key_str': 'value'}})
)
config.load()
else:
config = ChainConfig()
return config
def test_add_updated_with_func_value(self):
config = MemoryConfig()
version = Version()
ev = Event()
prop = Property(name='key',
default=1,
type=int,
config=config,
version=version)
def dummy(v):
ev.set()
prop.updated.add(dummy)
version.number += 1
self.assertTrue(ev.is_set())
def test_get_for_invalidated_key(self):
config = MemoryConfig()
config.set('key', '2')
version = Version()
prop = Property('key', 1, int, config, version)
self.assertEqual(2, prop.get())
config.set('key', '3')
version.number += 1
self.assertEqual(3, prop.get())
def _create_base_config(self, load_data=False):
config = MemoryConfig()
if load_data:
config.set('prefix', {
'key_str': 'value',
'key_int': 1,
'key_int_as_str': '1',
'key_dict': {'key_str': 'value'},
'key_dict_as_str': 'item_key=value',
'key_list_as_str': 'item1,item2',
'key_interpolated': '${key_str}',
'key_ignore_case': 'value',
'key_IGNORE_case': 'value1',
'key_delimited': {'key_str': 'value'}
})
config.set('prefix.nested_delimited', 'value')
prefixed = config.prefixed('prefix')
if load_data:
prefixed.load()
return prefixed
def test_lookup_with_nonexistent_key(self):
config = MemoryConfig()
lookup = ConfigLookup(config)
self.assertEqual(None, lookup.lookup('key'))
def test_lookup_with_existent_key(self):
config = MemoryConfig(data={'key': 1})
lookup = ConfigLookup(config)
self.assertEqual('1', lookup.lookup('key'))
def test_init_config_with_config_value(self):
config = MemoryConfig()
lookup = ConfigLookup(config)
self.assertEqual(config, lookup.config)
