def test_default_gateway(self, mock_routes):
default_gateway = mock.Mock()
default_gateway.destination = '0.0.0.0'
mock_routes.return_value = iter((mock.Mock(), default_gateway))
gateway = self._network.default_gateway()
self.assertEqual(default_gateway, gateway)
def test_is_datasource_available(self):
class CustomStrategy(strategy.BaseSearchStrategy):
def search_data_sources(self, _):
pass
instance = CustomStrategy()
good_source = mock.Mock()
good_source.load.return_value = True
bad_source = mock.Mock()
bad_source.load.return_value = False
self.assertTrue(instance.is_datasource_available(good_source))
self.assertFalse(instance.is_datasource_available(bad_source))
def test_routes(self, mock_forward_table):
def _same(arg):
return arg._mock_name.encode()
route = mock.MagicMock()
mock_cast_result = mock.Mock()
mock_cast_result.contents = [route]
self._ctypes_mock.cast.return_value = mock_cast_result
self._network_module.ws2_32.Ws2_32.inet_ntoa.side_effect = _same
route.dwForwardIfIndex = 'dwForwardIfIndex'
route.dwForwardProto = 'dwForwardProto'
route.dwForwardMetric1 = 'dwForwardMetric1'
routes = self._network.routes()
mock_forward_table.assert_called_once_with()
enter = mock_forward_table.return_value.__enter__
enter.assert_called_once_with()
exit_ = mock_forward_table.return_value.__exit__
exit_.assert_called_once_with(None, None, None)
self.assertEqual(1, len(routes))
given_route = routes[0]
self.assertEqual('dwForwardDest', given_route.destination)
self.assertEqual('dwForwardNextHop', given_route.gateway)
self.assertEqual('dwForwardMask', given_route.netmask)
self.assertEqual('dwForwardIfIndex', given_route.interface)
self.assertEqual('dwForwardMetric1', given_route.metric)
self.assertEqual('dwForwardProto', given_route.flags)
def test_handler_config_not_modified(self, available_handlers):
handler_type_name = 'test_handler'
handler_cls = mock.Mock()
available_handlers.registered_items = {handler_type_name: handler_cls}
handler_config = {'type': handler_type_name, 'foo': 'bar'}
expected_handler_config = handler_config.copy()
reporting.add_configuration({'my_test_handler': handler_config})
self.assertEqual(expected_handler_config, handler_config)
def test_looks_up_handler_by_type_and_adds_it(self, available_handlers):
handler_type_name = 'test_handler'
handler_cls = mock.Mock()
available_handlers.registered_items = {handler_type_name: handler_cls}
handler_name = 'my_test_handler'
reporting.add_configuration(
{handler_name: {'type': handler_type_name}})
self.assertEqual(
{handler_name: handler_cls.return_value},
reporting.instantiated_handler_registry.registered_items)
def _test__heap_alloc(self, fail):
mock_heap = mock.Mock()
mock_size = mock.Mock()
if fail:
self._kernel32.HeapAlloc.return_value = None
e = self.assertRaises(exceptions.CloudInitError,
self._network_module._heap_alloc, mock_heap,
mock_size)
self.assertEqual(
'Unable to allocate memory for the IP '
'forward table', str(e))
else:
result = self._network_module._heap_alloc(mock_heap, mock_size)
self.assertEqual(self._kernel32.HeapAlloc.return_value, result)
self._kernel32.HeapAlloc.assert_called_once_with(
mock_heap, 0, self._ctypes_mock.c_size_t(mock_size.value))
def test_set_metadata_ip_route_route_already_exists(
self, mock_default_gateway, mock_routes, mock_osutils):
mock_route = mock.Mock()
mock_route.destination = "169.254.169.254"
mock_routes.return_value = (mock_route, )
self._network.set_metadata_ip_route("http://169.254.169.254")
self.assertTrue(mock_routes.called)
self.assertFalse(mock_default_gateway.called)
def setUp(self):
super(TestNetworkWindows, self).setUp()
self._ctypes_mock = mock.MagicMock()
self._winreg_mock = mock.Mock()
self._win32com_mock = mock.Mock()
self._wmi_mock = mock.Mock()
self._module_patcher = mock.patch.dict(
'sys.modules', {
'ctypes': self._ctypes_mock,
'win32com': self._win32com_mock,
'wmi': self._wmi_mock,
'six.moves.winreg': self._winreg_mock
})
self._module_patcher.start()
self._iphlpapi = mock.Mock()
self._kernel32 = mock.Mock()
self._ws2_32 = mock.Mock()
self._network_module = importlib.import_module(
'cloudinit.osys.windows.network')
self._network_module.iphlpapi = self._iphlpapi
self._network_module.kernel32 = self._kernel32
self._network_module.ws2_32 = self._ws2_32
self._network = self._network_module.Network()
def test__get_forward_table_no_memory(self):
self._network_module._heap_alloc = mock.Mock()
error_msg = 'Unable to allocate memory for the IP forward table'
exc = exceptions.CloudInitError(error_msg)
self._network_module._heap_alloc.side_effect = exc
e = self.assertRaises(exceptions.CloudInitError,
self._check_raises_forward)
self.assertEqual(error_msg, str(e))
self._network_module._heap_alloc.assert_called_once_with(
self._kernel32.GetProcessHeap.return_value,
self._ctypes_mock.wintypes.ULONG.return_value)
def test_handlers_removed_if_falseish_specified(self, available_handlers):
handler_type_name = 'test_handler'
handler_cls = mock.Mock()
available_handlers.registered_items = {handler_type_name: handler_cls}
handler_name = 'my_test_handler'
reporting.update_configuration(
{handler_name: {
'type': handler_type_name
}})
self.assertEqual(
1, len(reporting.instantiated_handler_registry.registered_items))
reporting.update_configuration({handler_name: None})
self.assertEqual(
0, len(reporting.instantiated_handler_registry.registered_items))
def setUp(self):
super(TestWindowsGeneral, self).setUp()
self._ctypes_mock = mock.Mock()
self._util_mock = mock.MagicMock()
self._module_patcher = mock.patch.dict(
'sys.modules',
{'ctypes': self._ctypes_mock,
'cloudinit.osys.windows.util': self._util_mock})
self._module_patcher.start()
self._general_module = importlib.import_module(
"cloudinit.osys.windows.general")
self._kernel32 = self._general_module.kernel32
self._general = self._general_module.General()
def test_uses_non_type_parts_of_config_dict_as_kwargs(
self, available_handlers):
handler_type_name = 'test_handler'
handler_cls = mock.Mock()
available_handlers.registered_items = {handler_type_name: handler_cls}
extra_kwargs = {'foo': 'bar', 'bar': 'baz'}
handler_config = extra_kwargs.copy()
handler_config.update({'type': handler_type_name})
handler_name = 'my_test_handler'
reporting.update_configuration({handler_name: handler_config})
self.assertEqual(
handler_cls.return_value, reporting.instantiated_handler_registry.
registered_items[handler_name])
self.assertEqual([mock.call(**extra_kwargs)],
handler_cls.call_args_list)
def test__get_data(self, mock_wait_any_url, mock_path_join):
mock_response = mock.Mock()
response = b"test"
mock_response.contents = response
mock_response.encoding = 'utf-8'
mock_wait_any_url.return_value = (None, mock_response)
mock_path_join.return_value = mock.sentinel.path_join
expected_logging = [
'Getting metadata from: %s' % mock.sentinel.path_join
]
with LogSnatcher('cloudinit.sources.openstack.'
'httpopenstack') as snatcher:
result = self._source._get_data('test')
self.assertEqual(expected_logging, snatcher.output)
self.assertIsInstance(result, base.APIResponse)
self.assertEqual('test', str(result))
self.assertEqual(b'test', result.buffer)
class UrlHelperWaitForUrlsTest(TestCase):
@httpretty.activate
def test_url_wait_for(self):
urls_actions = [
("http://www.yahoo.com", (False, False, True)),
("http://www.google.com", (False, False, False)),
]
urls = []
for (url, actions) in urls_actions:
urls.append(url)
for worked in actions:
if worked:
httpretty.register_uri(httpretty.GET,
url,
body=b'it worked!')
else:
httpretty.register_uri(httpretty.GET,
url,
body=b'no worky',
status=400)
url, response = url_helper.wait_any_url(urls)
self.assertEqual("http://www.yahoo.com", url)
self.assertIsInstance(response, url_helper.RequestsResponse)
self.assertEqual(response.contents, b'it worked!')
@httpretty.activate
@mock.patch.object(url_helper, 'now',
mock.Mock(side_effect=TimeJumpSideEffect(0, 100)))
def test_url_wait_for_no_work(self):
def request_callback(request, uri, headers):
return (400, headers, b"no worky")
urls = [
"http://www.yahoo.com",
"http://www.google.com",
]
for url in urls:
httpretty.register_uri(httpretty.GET, url, body=request_callback)
self.assertIsNone(url_helper.wait_any_url(urls, max_wait=1))
def _test_route_add(self, mock_popen, err):
mock_route = mock.Mock()
mock_route.destination = mock.sentinel.destination
mock_route.netmask = mock.sentinel.netmask
mock_route.gateway = mock.sentinel.gateway
args = [
'ROUTE', 'ADD', mock.sentinel.destination, 'MASK',
mock.sentinel.netmask, mock.sentinel.gateway
]
mock_popen.return_value.returncode = err
mock_popen.return_value.communicate.return_value = (None, err)
if err:
e = self.assertRaises(exceptions.CloudInitError,
self._network_module.Route.add, mock_route)
msg = "Unable to add route: %s" % err
self.assertEqual(msg, str(e))
else:
self._network_module.Route.add(mock_route)
mock_popen.assert_called_once_with(args,
shell=False,
stderr=subprocess.PIPE)
def test_modifying_registered_items_isnt_exposed_to_other_callers(self):
registry = DictRegistry()
registry.registered_items['test_item'] = mock.Mock()
self.assertEqual({}, registry.registered_items)
def test_added_item_included_in_output(self):
registry = DictRegistry()
item_key, item_to_register = 'test_key', mock.Mock()
registry.register_item(item_key, item_to_register)
self.assertEqual({item_key: item_to_register},
registry.registered_items)
def test_default_gateway_no_gateway(self, mock_routes):
mock_routes.return_value = iter((mock.Mock(), mock.Mock()))
self.assertIsNone(self._network.default_gateway())
mock_routes.assert_called_once_with()
def test_keys_cannot_be_replaced(self):
registry = DictRegistry()
item_key = 'test_key'
registry.register_item(item_key, mock.Mock())
self.assertRaises(ValueError, registry.register_item, item_key,
mock.Mock())
def _fake_registry():
return mock.Mock(registered_items={'a': mock.MagicMock(),
'b': mock.MagicMock()})
