def setUp(self):
super(SSHPrivateMethodsTestCase, self).setUp()
self.node = obj_utils.get_test_node(
self.context,
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.sshclient = paramiko.SSHClient()
def test__parse_driver_info_ssh_port_wrong_type(self):
# make sure error is raised when ssh_port is not integer
info = db_utils.get_test_ssh_info()
info['ssh_port'] = 'wrong_port_value'
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def test_create_node_valid_interfaces(self):
node = obj_utils.get_test_node(self.context,
network_interface='noop',
storage_interface='noop')
self.assertTrue(driver_factory.check_and_update_node_interfaces(node))
self.assertEqual('noop', node.network_interface)
self.assertEqual('noop', node.storage_interface)
def test_emit_notification(self, provision_mock):
provision_mock.__name__ = 'NodeSetProvisionStateNotification'
self.config(host='fake-host')
node = obj_utils.get_test_node(self.context,
provision_state='fake state',
target_provision_state='fake target',
instance_info={'foo': 'baz'})
task = mock.Mock(spec=task_manager.TaskManager)
task.node = node
test_level = fields.NotificationLevel.INFO
test_status = fields.NotificationStatus.SUCCESS
notif_utils.emit_provision_set_notification(
task, test_level, test_status, 'fake_old',
'fake_old_target', 'event')
init_kwargs = provision_mock.call_args[1]
publisher = init_kwargs['publisher']
event_type = init_kwargs['event_type']
level = init_kwargs['level']
payload = init_kwargs['payload']
self.assertEqual('fake-host', publisher.host)
self.assertEqual('ironic-conductor', publisher.service)
self.assertEqual('node', event_type.object)
self.assertEqual('provision_set', event_type.action)
self.assertEqual(test_status, event_type.status)
self.assertEqual(test_level, level)
self.assertEqual(node.uuid, payload.uuid)
self.assertEqual('fake state', payload.provision_state)
self.assertEqual('fake target', payload.target_provision_state)
self.assertEqual('fake_old', payload.previous_provision_state)
self.assertEqual('fake_old_target',
payload.previous_target_provision_state)
self.assertEqual({'foo': 'baz'}, payload.instance_info)
def test__get_libvirt_connection_error_none_conn(self, libvirt_open_mock):
node = obj_utils.get_test_node(
self.context,
driver='fake_libvirt_fake',
driver_info=_get_test_libvirt_driver_info('socket'))
self.assertRaises(isd_exc.LibvirtError, power._get_libvirt_connection,
node['driver_info'])
def test__parse_driver_info_empty_terminal_port(self):
info = dict(INFO_DICT)
info['seamicro_terminal_port'] = ''
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
seamicro._parse_driver_info,
node)
def setUp(self):
super(ConsoleUtilsTestCase, self).setUp()
self.node = obj_utils.get_test_node(
self.context,
driver='fake_ipmitool',
driver_info=INFO_DICT)
self.info = ipmi._parse_driver_info(self.node)
def test__parse_driver_info_missing_api_endpoint(self):
# make sure error is raised when info is missing
info = dict(INFO_DICT)
del info['seamicro_api_endpoint']
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.MissingParameterValue,
seamicro._parse_driver_info, node)
def test_node_notification_mask_secrets(self):
test_info = {'password': '******', 'some_value': 'fake-value'}
node = obj_utils.get_test_node(self.context,
driver_info=test_info)
notification.mask_secrets(node)
self.assertEqual('******', node.driver_info['password'])
self.assertEqual('fake-value', node.driver_info['some_value'])
def test_create_node_classic_driver_invalid_network_interface(self):
node = obj_utils.get_test_node(self.context,
driver='fake',
network_interface='banana')
self.assertRaises(exception.InterfaceNotFoundInEntrypoint,
driver_factory.check_and_update_node_interfaces,
node)
def test_invalid_rescue_interface(self):
node = obj_utils.get_test_node(self.context,
driver='fake-hardware',
rescue_interface='scoop')
self.assertRaises(exception.InterfaceNotFoundInEntrypoint,
driver_factory.check_and_update_node_interfaces,
node)
def test__parse_driver_info_missing_virt_type(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info()
del info['ssh_virt_type']
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.MissingParameterValue,
ssh._parse_driver_info, node)
def test__parse_driver_info_too_many(self):
info = db_utils.get_test_ssh_info('too_many')
node = obj_utils.get_test_node(self.context,
driver='fake_ssh',
driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def setUp(self):
super(ConsoleUtilsTestCase, self).setUp()
self.node = obj_utils.get_test_node(
self.context,
driver='fake_ipmitool',
driver_info=INFO_DICT)
self.info = ipmi._parse_driver_info(self.node)
def test_create_node_classic_driver_valid_interfaces(self):
node = obj_utils.get_test_node(self.context, driver='fake',
network_interface='noop',
storage_interface='noop')
self.assertFalse(driver_factory.check_and_update_node_interfaces(node))
self.assertEqual('noop', node.network_interface)
self.assertEqual('noop', node.storage_interface)
def test_emit_notification(self, provision_mock):
provision_mock.__name__ = 'NodeSetProvisionStateNotification'
self.config(host='fake-host')
node = obj_utils.get_test_node(self.context,
provision_state='fake state',
target_provision_state='fake target',
instance_info={'foo': 'baz'})
task = mock.Mock(spec=task_manager.TaskManager)
task.node = node
test_level = fields.NotificationLevel.INFO
test_status = fields.NotificationStatus.SUCCESS
notif_utils.emit_provision_set_notification(
task, test_level, test_status, 'fake_old',
'fake_old_target', 'event')
init_kwargs = provision_mock.call_args[1]
publisher = init_kwargs['publisher']
event_type = init_kwargs['event_type']
level = init_kwargs['level']
payload = init_kwargs['payload']
self.assertEqual('fake-host', publisher.host)
self.assertEqual('ironic-conductor', publisher.service)
self.assertEqual('node', event_type.object)
self.assertEqual('provision_set', event_type.action)
self.assertEqual(test_status, event_type.status)
self.assertEqual(test_level, level)
self.assertEqual(node.uuid, payload.uuid)
self.assertEqual('fake state', payload.provision_state)
self.assertEqual('fake target', payload.target_provision_state)
self.assertEqual('fake_old', payload.previous_provision_state)
self.assertEqual('fake_old_target',
payload.previous_target_provision_state)
self.assertEqual({'foo': 'baz'}, payload.instance_info)
def setUp(self):
super(ConsoleUtilsTestCase, self).setUp()
self.node = obj_utils.get_test_node(self.context,
driver_info=INFO_DICT)
self.info = ipmi._parse_driver_info(self.node)
self.mock_stdout = tempfile.NamedTemporaryFile(delete=False)
self.mock_stderr = tempfile.NamedTemporaryFile(delete=False)
def test_node_notification_mask_secrets(self):
test_info = {'password': '******', 'some_value': 'fake-value'}
node = obj_utils.get_test_node(self.context,
driver_info=test_info)
notification.mask_secrets(node)
self.assertEqual('******', node.driver_info['password'])
self.assertEqual('fake-value', node.driver_info['some_value'])
def test_create_node_dynamic_driver_invalid_network_interface(self):
self._set_config_interface_options_hardware_type()
node = obj_utils.get_test_node(self.context, driver='fake-hardware',
network_interface='banana')
self.assertRaises(exception.InterfaceNotFoundInEntrypoint,
driver_factory.check_and_update_node_interfaces,
node)
def test_serialize_objects(self):
node = obj_utils.get_test_node(self.context)
node = self.serializer.serialize_entity(self.context, node)
body = self._request('with_node', {'context': self.ctx, 'node': node})
self.assertNotIn('error', body)
self.assertIsInstance(body['result'], dict)
node = self.serializer.deserialize_entity(self.context, body['result'])
self.assertEqual({'answer': 42}, node.extra)
def test_emit_maintenance_notification(self, emit_mock):
node = obj_utils.get_test_node(self.context)
test_level = fields.NotificationLevel.INFO
test_status = fields.NotificationStatus.START
notif_utils._emit_api_notification(self.context, node,
'maintenance_set',
test_level, test_status)
emit_mock.assert_called_once_with(mock.ANY, self.context)
def test_as_dict_with_traits(self):
self.fake_node['traits'] = ['CUSTOM_1']
self.node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
d = self.node.as_dict()
expected_traits = {'objects': [{'trait': 'CUSTOM_1'}]}
self.assertEqual(expected_traits, d['traits'])
# Ensure the node can be serialised.
jsonutils.dumps(d)
def test_owner_supported_missing(self):
# owner_interface not set, should be set to default.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'owner')
node.obj_reset_changes()
node._convert_to_version("1.30")
self.assertIsNone(node.owner)
self.assertEqual({'owner': None}, node.obj_get_changes())
def test_allocation_id_supported_missing(self):
# allocation_id_interface not set, should be set to default.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'allocation_id')
node.obj_reset_changes()
node._convert_to_version("1.31")
self.assertIsNone(node.allocation_id)
self.assertEqual({'allocation_id': None}, node.obj_get_changes())
def test__parse_driver_info_missing_api_endpoint(self):
# make sure error is raised when info is missing
info = dict(INFO_DICT)
del info['seamicro_api_endpoint']
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.MissingParameterValue,
seamicro._parse_driver_info,
node)
def test_description_supported_missing(self):
# description not set, should be set to default.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'description')
node.obj_reset_changes()
node._convert_to_version("1.32")
self.assertIsNone(node.description)
self.assertEqual({'description': None}, node.obj_get_changes())
def test_create_node_invalid_network_interface_instance_info_override(
self):
instance_info = {'network_interface': 'banana'}
node = obj_utils.get_test_node(self.context,
instance_info=instance_info)
self.assertRaises(exception.InterfaceNotFoundInEntrypoint,
driver_factory.check_and_update_node_interfaces,
node)
def test_as_dict_with_traits(self):
self.fake_node['traits'] = ['CUSTOM_1']
self.node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
d = self.node.as_dict()
expected_traits = {'objects': [{'trait': 'CUSTOM_1'}]}
self.assertEqual(expected_traits, d['traits'])
# Ensure the node can be serialised.
jsonutils.dumps(d)
def test_serialize_objects(self):
node = obj_utils.get_test_node(self.context)
node = self.serializer.serialize_entity(self.context, node)
body = self._request('with_node', {'context': self.ctx, 'node': node})
self.assertNotIn('error', body)
self.assertIsInstance(body['result'], dict)
node = self.serializer.deserialize_entity(self.context, body['result'])
self.assertEqual({'answer': 42}, node.extra)
def test__parse_driver_info_sasl_and_ssh_key(self):
node = obj_utils.get_test_node(
self.context,
driver='fake_libvirt_fake',
driver_info=_get_test_libvirt_driver_info('ssh_sasl'))
self.assertRaises(exception.InvalidParameterValue,
power._parse_driver_info, node)
def test__parse_driver_info_bad_file(self):
# A filename that doesn't exist errors.
info = db_utils.get_test_ssh_info('file')
node = obj_utils.get_test_node(self.context,
driver='fake_ssh',
driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def test_emit_maintenance_notification(self, emit_mock):
node = obj_utils.get_test_node(self.context)
test_level = fields.NotificationLevel.INFO
test_status = fields.NotificationStatus.START
notif_utils._emit_api_notification(self.context, node,
'maintenance_set',
test_level, test_status)
emit_mock.assert_called_once_with(self.context)
def test__get_libvirt_connection_error_none_conn(self, libvirt_open_mock):
node = obj_utils.get_test_node(
self.context,
driver='fake_libvirt_fake',
driver_info=_get_test_libvirt_driver_info('socket'))
self.assertRaises(isd_exc.LibvirtError,
power._get_libvirt_connection,
node['driver_info'])
def test_owner_unsupported_missing(self):
# owner not set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'owner')
node.obj_reset_changes()
node._convert_to_version("1.29")
self.assertNotIn('owner', node)
self.assertEqual({}, node.obj_get_changes())
def test_mask_secrets(self):
test_info = {'configdrive': 'fake_drive', 'image_url': 'fake-url',
'some_value': 'fake-value'}
node = obj_utils.get_test_node(self.context,
instance_info=test_info)
notif_utils.mask_secrets(node)
self.assertEqual('******', node.instance_info['configdrive'])
self.assertEqual('******', node.instance_info['image_url'])
self.assertEqual('fake-value', node.instance_info['some_value'])
def test_allocation_id_unsupported_missing(self):
# allocation_id not set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'allocation_id')
node.obj_reset_changes()
node._convert_to_version("1.30")
self.assertNotIn('allocation_id', node)
self.assertEqual({}, node.obj_get_changes())
def test_fault_unsupported_missing(self):
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'fault')
node.obj_reset_changes()
node._convert_to_version("1.24")
self.assertNotIn('fault', node)
self.assertEqual({}, node.obj_get_changes())
def test_bios_unsupported_missing(self):
# bios_interface not set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'bios_interface')
node.obj_reset_changes()
node._convert_to_version("1.23")
self.assertNotIn('bios_interface', node)
self.assertEqual({}, node.obj_get_changes())
def test_owner_supported_set(self):
# owner set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.owner = "Sure, there is an owner"
node.obj_reset_changes()
node._convert_to_version("1.30")
self.assertEqual("Sure, there is an owner", node.owner)
self.assertEqual({}, node.obj_get_changes())
def test_owner_unsupported_set_no_remove_default(self):
# owner set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.owner = None
node.obj_reset_changes()
node._convert_to_version("1.29", False)
self.assertIsNone(node.owner)
self.assertEqual({}, node.obj_get_changes())
def test__get_libvirt_connection_socket(self, libvirt_open_mock):
node = obj_utils.get_test_node(
self.context,
driver='fake_libvirt_fake',
driver_info=_get_test_libvirt_driver_info('socket'))
power._get_libvirt_connection(node['driver_info'])
libvirt_open_mock.assert_called_once_with(
'qemu+unix:///system?socket=/opt/libvirt/run/libvirt-sock')
def test_automated_clean_supported_set(self):
# automated_clean set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.automated_clean = True
node.obj_reset_changes()
node._convert_to_version("1.28")
self.assertEqual(True, node.automated_clean)
self.assertEqual({}, node.obj_get_changes())
def test__parse_driver_info_sasl_and_ssh_key(self):
node = obj_utils.get_test_node(
self.context,
driver='fake_libvirt_fake',
driver_info=_get_test_libvirt_driver_info('ssh_sasl'))
self.assertRaises(exception.InvalidParameterValue,
power._parse_driver_info,
node)
def test_allocation_id_supported_missing(self):
# allocation_id_interface not set, should be set to default.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'allocation_id')
node.obj_reset_changes()
node._convert_to_version("1.31")
self.assertIsNone(node.allocation_id)
self.assertEqual({'allocation_id': None},
node.obj_get_changes())
def test_owner_supported_missing(self):
# owner_interface not set, should be set to default.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'owner')
node.obj_reset_changes()
node._convert_to_version("1.30")
self.assertIsNone(node.owner)
self.assertEqual({'owner': None},
node.obj_get_changes())
def test_owner_unsupported_set_remove(self):
# owner set, should be removed.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.owner = "magic"
node.obj_reset_changes()
node._convert_to_version("1.29")
self.assertNotIn('owner', node)
self.assertEqual({}, node.obj_get_changes())
def test_automated_clean_unsupported_set_no_remove_default(self):
# automated_clean set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.automated_clean = None
node.obj_reset_changes()
node._convert_to_version("1.27", False)
self.assertIsNone(node.automated_clean)
self.assertEqual({}, node.obj_get_changes())
def test_bios_unsupported_set_no_remove_default(self):
# bios_interface set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.bios_interface = None
node.obj_reset_changes()
node._convert_to_version("1.23", False)
self.assertIsNone(node.bios_interface)
self.assertEqual({}, node.obj_get_changes())
def test_bios_unsupported_set_remove(self):
# bios_interface set, should be removed.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.bios_interface = 'fake'
node.obj_reset_changes()
node._convert_to_version("1.23")
self.assertNotIn('bios_interface', node)
self.assertEqual({}, node.obj_get_changes())
def test_allocation_id_supported_set(self):
# allocation_id set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.allocation_id = 42
node.obj_reset_changes()
node._convert_to_version("1.31")
self.assertEqual(42, node.allocation_id)
self.assertEqual({}, node.obj_get_changes())
def test_bios_unsupported_set_no_remove_non_default(self):
# bios_interface set, should be set to default.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.bios_interface = 'fake'
node.obj_reset_changes()
node._convert_to_version("1.23", False)
self.assertIsNone(node.bios_interface)
self.assertEqual({'bios_interface': None}, node.obj_get_changes())
def test_create_node_dynamic_driver_invalid_network_interface(self):
self._set_config_interface_options_hardware_type()
node = obj_utils.get_test_node(self.context,
driver='fake-hardware',
network_interface='banana')
self.assertRaises(exception.InterfaceNotFoundInEntrypoint,
driver_factory.check_and_update_node_interfaces,
node)
def test_fault_supported_missing(self):
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'fault')
node.obj_reset_changes()
node._convert_to_version("1.25")
self.assertIsNone(node.fault)
self.assertEqual({'fault': None}, node.obj_get_changes())
def test_no_raid_interface_no_default(self):
# NOTE(rloo): It doesn't seem possible to not have a default interface
# for storage, so we'll test this case with raid.
self.config(enabled_raid_interfaces=[])
node = obj_utils.get_test_node(self.context, driver='fake-hardware')
self.assertRaisesRegex(exception.NoValidDefaultForInterface,
"raid interface",
driver_factory.check_and_update_node_interfaces,
node)
def test_automated_clean_unsupported_set_remove(self):
# automated_clean set, should be removed.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.automated_clean = True
node.obj_reset_changes()
node._convert_to_version("1.27")
self.assertNotIn('automated_clean', node)
self.assertEqual({}, node.obj_get_changes())
def test_allocation_id_unsupported_set_remove(self):
# allocation_id set, should be removed.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
node.allocation_id = 42
node.obj_reset_changes()
node._convert_to_version("1.30")
self.assertNotIn('allocation_id', node)
self.assertEqual({}, node.obj_get_changes())
def test_automated_clean_unsupported_missing(self):
# automated_clean not set, no change required.
node = obj_utils.get_test_node(self.ctxt, **self.fake_node)
delattr(node, 'automated_clean')
node.obj_reset_changes()
node._convert_to_version("1.27")
self.assertNotIn('automated_clean', node)
self.assertEqual({}, node.obj_get_changes())
def setUp(self):
super(FakeDriverTestCase, self).setUp()
mgr_utils.mock_the_extension_manager()
self.driver = driver_factory.get_driver("fake")
self.node = obj_utils.get_test_node(self.context)
self.task = mock.MagicMock(spec=task_manager.TaskManager)
self.task.shared = False
self.task.node = self.node
self.task.driver = self.driver
def test__get_libvirt_connection_ssh(self, libvirt_open_mock):
node = obj_utils.get_test_node(
self.context,
driver='fake_libvirt_fake',
driver_info=_get_test_libvirt_driver_info('ssh_key'))
power._get_libvirt_connection(node['driver_info'])
libvirt_open_mock.assert_called_once_with(
'qemu+ssh://test@test/?keyfile=/test/key/file&no_verify=1')
def test_no_raid_interface_no_default(self):
# NOTE(rloo): It doesn't seem possible to not have a default interface
# for storage, so we'll test this case with raid.
self.config(enabled_raid_interfaces=[])
node = obj_utils.get_test_node(self.context, driver='fake-hardware')
self.assertRaisesRegex(
exception.NoValidDefaultForInterface,
"raid interface",
driver_factory.check_and_update_node_interfaces, node)
