def test_fecth_again_after_clear(self): value1 = 'value1' value2 = 'value2' given_fetch_method = mock.Mock( side_effect=[iter([( 'key', value1)]), iter([('key', value2)])]) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched result1 = given_cache.fetch('key', 60.0) # When cache is cleared given_cache.clear() # When value with same key is fetched again result2 = given_cache.fetch('key', 0.0) # Then first result is returned self.assertIs(value1, result1) # Then fetch method is called twice self.assertEqual([mock.call( ('key', )), mock.call(('key', ))], given_fetch_method.mock_calls) # Then second result is returned self.assertIs(value2, result2)
def test_fecth_with_no_result(self): given_fetch_method = mock.Mock(return_value=iter([])) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched try: given_cache.fetch('key', 60.0) except cache.CacheFetchError as error: given_fetch_method.assert_called_once_with(('key', )) self.assertRaises(KeyError, error.reraise_cause) else: self.fail('Expecting CacheFetchError to be raised.')
def __init__(self, vif_details=None, client=None): # Details for binding port self._vif_details = vif_details or {portbindings.CAP_PORT_FILTER: True} # Rest client used for getting network topology from ODL self._client = client or NetworkTopologyClient.create_client() # Table of NetworkTopologyElement self._elements_by_ip = cache.Cache( self._fetch_and_parse_network_topology) # Parsers used for processing network topology self._parsers = list(self._create_parsers())
def test_fecth_all_with_multiple_entries(self): given_fetch_method = mock.Mock( return_value=iter([('key', 'value1'), ('key', 'value2')])) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched results = list(given_cache.fetch_all(['key'], 0.0)) # Then fetch method is once given_fetch_method.assert_called_once_with(('key', )) # Then both results are yield in the right order self.assertEqual([('key', 'value1'), ('key', 'value2')], results)
def test_fecth_once(self): value = 'value' given_fetch_method = mock.Mock(return_value=iter([('key', value)])) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched result = given_cache.fetch('key', 60.0) # Result is returned self.assertIs(value, result) # Then fetch method is called once given_fetch_method.assert_called_once_with(('key', ))
def test_fecth_all_with_repeated_entries(self): entry = ('key', 'value') given_fetch_method = mock.Mock( return_value=iter([entry, entry, entry])) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched results = list(given_cache.fetch_all(['key'], 0.0)) # Then fetch method is once given_fetch_method.assert_called_once_with(('key', )) # Then results are yield in the right order self.assertEqual([entry, entry, entry], results)
def __init__(self, vif_details=None, client=None): # Details for binding port self._vif_details = vif_details or {portbindings.CAP_PORT_FILTER: True} # Rest client used for getting network topology from ODL self._client = client or NetworkTopologyClient.create_client() # Table of NetworkTopologyElement self._elements_by_ip = cache.Cache( self._fetch_and_parse_network_topology) # Parsers used for processing network topology self._parsers = list(self._create_parsers()) LOG.warning( "networking-topology port binding controller is deprecated " "and will be removed. switch to pseudo-agentdb-binding.")
def test_fecth_two_values_yielding_both_before_timeout(self): value1 = 'value1' value2 = 'value2' given_fetch_method = mock.Mock( return_value=iter([('key1', value1), ('key2', value2)])) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched result1 = given_cache.fetch('key1', 60.0) # When value with another key is fetched and cached entry is not # expired result2 = given_cache.fetch('key2', 60.0) # Then first result is returned self.assertIs(value1, result1) # Then fetch method is called once given_fetch_method.assert_called_once_with(('key1', )) # Then second result is returned self.assertIs(value2, result2)
def test_fecth_with_failure(self, logger): # pylint: disable=unused-argument given_error = RuntimeError("It doesn't work like this!") def failing_function(keys): raise given_error given_fetch_method = mock.Mock(side_effect=failing_function) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched try: given_cache.fetch('key', 60.0) except cache.CacheFetchError as error: given_fetch_method.assert_called_once_with(('key', )) self.assertRaises(RuntimeError, error.reraise_cause) else: self.fail('Expecting CacheFetchError to be raised.') logger.warning.assert_called_once_with( 'Error fetching values for keys: %r', "'key'", exc_info=(type(given_error), given_error, mock.ANY))
def test_fecth_two_values_yielding_both_after_timeout(self): value1 = 'value1' value2 = 'value2' given_fetch_method = mock.Mock(return_value=[('key1', value1), ('key2', value2)]) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched result1 = given_cache.fetch('key1', 0.0) # When value with another key is fetched and cached entry is # expired result2 = given_cache.fetch('key2', 0.0) # Then first result is returned self.assertIs(value1, result1) # Then fetch method is called twice self.assertEqual([mock.call( ('key1', )), mock.call(('key2', ))], given_fetch_method.mock_calls) # Then second result is returned self.assertIs(value2, result2)
def test_fecth_again_before_timeout(self): value1 = 'value1' value2 = 'value2' given_fetch_method = mock.Mock( side_effect=[iter([( 'key', value1)]), iter([('key', value2)])]) given_cache = cache.Cache(given_fetch_method) # When value with key is fetched result1 = given_cache.fetch('key', 1.0) # When value with same key is fetched again and cached entry is not # expired result2 = given_cache.fetch('key', 0.0) # First result is returned self.assertIs(value1, result1) # Then fetch method is called once given_fetch_method.assert_called_once_with(('key', )) # Then first result is returned twice self.assertIs(value1, result2)
try: del d[key] except KeyError: pass def _fetch_all_addresses_by_hostnames(hostnames): for name in hostnames: # it uses an ordered dict to avoid duplicates and keep order entries = collections.OrderedDict( (info[4][0], None) for info in socket.getaddrinfo(name, None)) for entry in entries: yield name, entry _addresses_by_name_cache = cache.Cache(_fetch_all_addresses_by_hostnames) def get_addresses_by_name(name, time_to_live=60.0): """Gets and caches addresses for given name. This is a cached wrapper for function 'socket.getaddrinfo'. :returns: a sequence of unique addresses bound to given hostname. """ try: results = _addresses_by_name_cache.fetch_all([name], timeout=time_to_live) return tuple(address for name, address in results) except cache.CacheFetchError as error:
def test_init_without_callable(self): self.assertRaises(TypeError, lambda: cache.Cache(object()))
def test_init_with_callable(self): def given_fetch_method(): pass cache.Cache(given_fetch_method)