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_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_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_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_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_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_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_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_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 _create_base_config(self, load_data=False):
config = MemoryConfig()
if load_data:
config.set('key_str', 'value')
config.set('key_int', 1)
config.set('key_int_as_str', '1')
config.set('key_dict', {'key_str': 'value'})
config.set('key_dict_as_str', 'item_key=value')
config.set('key_list_as_str', 'item1,item2')
config.set('key_interpolated', '${key_str}')
config.set('key_ignore_case', 'value')
config.set('key_IGNORE_case', 'value1')
config.set('key_delimited', {'key_str': 'value'})
return config.reload_every(12345)
def test_get_for_existent_key(self):
config = MemoryConfig()
config.set('key', '2')
prop = Property('key', 1, int, config, Version())
self.assertEqual(2, prop.get())
def test_set_with_dict_as_value(self):
config = MemoryConfig()
config.set('key', {'item': {'subitem': 'value'}})
self.assertIsInstance(config.get('key'), IgnoreCaseDict)
self.assertIsInstance(config.get('key.item'), IgnoreCaseDict)
def test_set_with_key_as_str(self):
config = MemoryConfig()
config.set('key1', 'value1')
self.assertEqual('value1', config['key1'])
def test_set_with_key_as_int(self):
config = MemoryConfig()
with self.assertRaises(TypeError):
config.set(key=123, value='value')
