def test_build_loader_callable(self): load_func, filename = mock.Mock(), mock.Mock() loader_callable = config.build_loader_callable(load_func, filename, self.namespace) result = loader_callable() self.mock_get_namespace.assert_called_with(self.namespace) mock_namespace = self.mock_get_namespace.return_value mock_namespace.clear.assert_called_with() load_func.assert_called_with(filename, namespace=self.namespace) assert_equal(result, load_func.return_value)
def test_reload_end_to_end(self): loader = mock.Mock() callback = mock.Mock() facade = staticconf.ConfigFacade.load(self.file.name, self.namespace, loader) assert_equal(loader.call_count, 1) time.sleep(1) facade.reload_if_changed() assert_equal(loader.call_count, 1) os.utime(self.file.name, None) facade.reload_if_changed() assert_equal(loader.call_count, 2)
def setup_configuration_values(self): validator = mock.Mock(return_value=2) self.name = 'test_namespace' self.namespace = config.get_namespace(self.name) self.config_key = 'something' self.value_proxy = proxy.ValueProxy(validator, self.namespace, self.config_key)
def test_reload_custom(self): reloader = mock.Mock() watcher = config.ConfigurationWatcher(self.loader, self.filename, reloader=reloader) watcher.reload() reloader.assert_called_with()
def test_get_value_fails_validation(self): expected = [self.name, self.config_key] validator = mock.Mock(side_effect=validation.ValidationError) _ = proxy.ValueProxy( # flake8: noqa validator, self.namespace, 'something.broken') assert_raises_and_contains(errors.ConfigurationError, expected, lambda: self.value_proxy.value)
def test_load(self): loaders = [(mock.Mock(return_value={i: 0}), 1, 2) for i in range(3)] composite = loader.CompositeConfiguration(loaders) assert_equal(composite.load(), {0: 0, 1: 0, 2: 0}) for loader_call, arg_one, arg_two in loaders: loader_call.assert_called_with(arg_one, arg_two)
def test_build_loader_without_flatten(self): source = {'base': {'one': 'thing', 'two': 'foo'}} loader_func = mock.Mock(return_value=source) config_loader = loader.build_loader(loader_func) config = config_loader(source, flatten=False) assert_equal(config, source)
def test_load_passes_comparators_to_configuration_watcher(self): filename, namespace = "filename", "namespace" loader = mock.Mock() comparator = mock.Mock(name='MockComparator') with mock.patch('staticconf.config.ConfigurationWatcher', autospec=True) as mock_watcher_class: config.ConfigFacade.load(filename, namespace, loader, comparators=[comparator]) mock_watcher_class.assert_called_with(mock.ANY, filename, min_interval=mock.ANY, reloader=mock.ANY, comparators=[comparator])
def test_get_value_cached(self): expected = "the other stars" validator = mock.Mock() value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something.string') value_proxy._value = expected assert_equal(value_proxy.value, expected) validator.assert_not_called()
def test_proxy_list(self): the_list = range(3) validator = mock.Mock(return_value=the_list) value_proxy = proxy.ValueProxy(validator, self.value_cache, 'the_list') assert_equal(value_proxy, the_list) assert_in(2, value_proxy) assert_equal(value_proxy[:1], range(0, 1)) assert_equal(len(value_proxy), 3)
def test_validate_keys_no_unknown_keys(self): proxies = [mock.Mock(config_key=i) for i in self.config_data] for mock_proxy in proxies: self.namespace.register_proxy(mock_proxy) with mock.patch('staticconf.config.log') as mock_log: self.namespace.validate_keys(self.config_data, True) self.namespace.validate_keys(self.config_data, False) assert not mock_log.warn.mock_calls
def test_build_loader_optional(self): err_msg = "Failed to do" loader_func = mock.Mock() loader_func.side_effect = ValueError(err_msg) config_loader = loader.build_loader(loader_func) config_loader(optional=True) assert_raises(ValueError, config_loader)
def test_build_reader(self, mock_get_namespace): config_key, validator, self.namespace = 'the_key', mock.Mock( ), 'the_name' reader = readers.build_reader(validator, self.namespace) value = reader(config_key) mock_get_namespace.assert_called_with(self.namespace) validator.assert_called_with( mock_get_namespace.return_value.get.return_value) assert_equal(value, validator.return_value)
def test_proxy_zero(self): validator = mock.Mock(return_value=0) self.value_proxy = proxy.ValueProxy(validator, self.value_cache, 'zero') assert_equal(self.value_proxy, 0) assert not self.value_proxy assert not self.value_proxy and True assert not self.value_proxy or False assert not self.value_proxy ^ 0 assert ~ self.value_proxy
def setup_factory(self): self.factory = getters.ProxyFactory() self.validator = mock.Mock() self.namespace = mock.create_autospec(config.ConfigNamespace) self.config_key = 'some_key' self.default = 'bad_default' self.help = 'some help message no one reads' self.args = (self.validator, self.namespace, self.config_key, self.default, self.help)
def test_build_getter(self): validator = mock.Mock() getter = getters.build_getter(validator) assert callable(getter), "Getter is not callable" value_proxy = getter('the_name') namespace = config.get_namespace(config.DEFAULT) assert_in(id(value_proxy), namespace.value_proxies) assert_equal(value_proxy.config_key, "the_name") assert_equal(value_proxy.namespace, namespace)
def test_build_getter_with_getter_namespace(self): validator = mock.Mock() name = 'the stars' getter = getters.build_getter(validator, getter_namespace=name) assert callable(getter), "Getter is not callable" value_proxy = getter('the_name') namespace = config.get_namespace(name) assert_in(id(value_proxy), namespace.value_proxies) assert_equal(value_proxy.config_key, "the_name") assert_equal(value_proxy.namespace, namespace)
def test_load_end_to_end(self): loader = staticconf.YamlConfiguration callback = mock.Mock() facade = staticconf.ConfigFacade.load(self.file.name, self.namespace, loader) facade.add_callback('one', callback) assert_equal(staticconf.get('one', namespace=self.namespace), "A") self.write(b"one: B", 10) facade.reload_if_changed() assert_equal(staticconf.get('one', namespace=self.namespace), "B") callback.assert_called_with()
def test_load(self): filename, namespace = "filename", "namespace" loader = mock.Mock() with mock.patch('staticconf.config.ConfigurationWatcher', autospec=True) as mock_watcher_class: facade = config.ConfigFacade.load(filename, namespace, loader) facade.watcher.load_config.assert_called_with() assert_equal(facade.watcher, mock_watcher_class.return_value) reloader = facade.callback_chain assert_equal(reloader, facade.watcher.get_reloader())
def setup_mocks_and_config_watcher(self): self.loader = mock.Mock() with mock.patch('staticconf.config.time') as self.mock_time: with mock.patch('staticconf.config.os.stat') as self.mock_stat: with tempfile.NamedTemporaryFile() as file: with mock.patch('staticconf.config.os.path') as self.mock_path: file.flush() self.mock_stat.return_value.st_ino = 1 self.mock_stat.return_value.st_dev = 2 self.filename = file.name self.watcher = config.ConfigurationWatcher( self.loader, self.filename) yield
def test_proxy_with_string(self): validator = mock.Mock(return_value='one%s') value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something') assert_equal(value_proxy, 'one%s') assert value_proxy < 'two' assert value_proxy > 'ab' assert_equal(value_proxy + '!', 'one%s!') assert_equal(value_proxy % '!', 'one!') assert_equal(repr(value_proxy), "'one%s'") assert_equal(str(value_proxy), "one%s") assert_equal(hash(value_proxy), hash("one%s")) assert bool(value_proxy)
def test_proxy_with_datetime(self): the_date = datetime.datetime(2012, 12, 1, 5, 5, 5) validator = mock.Mock(return_value=the_date) value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something') assert_equal(value_proxy, the_date) assert value_proxy < datetime.datetime(2012, 12, 3) assert value_proxy > datetime.datetime(2012, 1, 4) four_days_ahead = datetime.datetime(2012, 12, 4, 5, 5, 5) assert_equal(value_proxy + datetime.timedelta(days=3), four_days_ahead) assert_equal(repr(value_proxy), repr(the_date)) assert_equal(str(value_proxy), str(the_date)) assert_equal(hash(value_proxy), hash(the_date)) assert bool(value_proxy)
def test_proxy(self): validator = mock.Mock(return_value=2) value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something') assert_equal(value_proxy, 2) assert value_proxy < 4 assert value_proxy > 1 assert_equal(value_proxy + 5, 7) assert_equal(repr(value_proxy), "2") assert_equal(str(value_proxy), "2") assert_equal(3 % value_proxy, 1) assert_equal(3 ** value_proxy, 9) assert_equal(value_proxy ** 3, 8) assert_equal(hash(value_proxy), 2) assert_equal(abs(value_proxy), 2) assert_equal(hex(value_proxy), "0x2") assert bool(value_proxy) assert_equal(range(5)[value_proxy], 2) assert_equal(range(5)[:value_proxy], range(2))
def test_register_get_value_proxies(self): proxies = [mock.Mock(), mock.Mock()] for mock_proxy in proxies: self.namespace.register_proxy(mock_proxy) assert_equal(self.namespace.get_value_proxies(), proxies)
def test_build_loader(self): loader_func = mock.Mock() assert callable(loader.build_loader(loader_func))
def setup_callback_chain(self): self.callbacks = list(enumerate([mock.Mock(), mock.Mock()])) self.callback_chain = config.ReloadCallbackChain( callbacks=self.callbacks)
def test_add_remove(self): callback = mock.Mock() self.callback_chain.add('one', callback) assert_equal(self.callback_chain.callbacks['one'], callback) self.callback_chain.remove('one') assert 'one' not in self.callback_chain.callbacks
def test_proxied_attributes(self): validator = mock.Mock(return_value=self.value_cache['the_date']) value_proxy = proxy.ValueProxy(validator, self.value_cache, 'the_date') assert_equal(value_proxy.date(), datetime.date(2012, 3, 14)) assert_equal(value_proxy.hour, 4)
def test_get_value(self): expected = "the stars" validator = mock.Mock(return_value=expected) value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something.string') assert_equal(value_proxy, expected)
def test_add_callback(self): name, func = 'name', mock.Mock() self.facade.add_callback(name, func) self.facade.callback_chain.add.assert_called_with(name, func)