diff --git a/ironic/tests/base.py b/ironic/tests/base.py index 5da683c509..aa408c3fa1 100644 --- a/ironic/tests/base.py +++ b/ironic/tests/base.py @@ -129,11 +129,27 @@ class TestCase(oslo_test_base.BaseTestCase): group='neutron') self.config(rescuing_network=uuidutils.generate_uuid(), group='neutron') - self.config(enabled_drivers=['fake']) - self.config(enabled_hardware_types=['fake-hardware']) - self.config(enabled_network_interfaces=['flat', 'noop', 'neutron']) + self.config(enabled_drivers=[]) + self.config(enabled_hardware_types=['fake-hardware', + 'manual-management']) for iface in drivers_base.ALL_INTERFACES: - self.config(**{'default_%s_interface' % iface: None}) + # Restore some reasonable defaults + if iface == 'network': + values = ['flat', 'noop', 'neutron'] + else: + values = ['fake'] + + if iface == 'deploy': + values.extend(['iscsi', 'direct']) + elif iface == 'boot': + values.append('pxe') + elif iface == 'storage': + values.append('noop') + elif iface not in {'network', 'power', 'management'}: + values.append('no-%s' % iface) + + self.config(**{'enabled_%s_interfaces' % iface: values, + 'default_%s_interface' % iface: None}) self.set_defaults(host='fake-mini', debug=True) self.set_defaults(connection="sqlite://", diff --git a/ironic/tests/unit/api/controllers/v1/test_driver.py b/ironic/tests/unit/api/controllers/v1/test_driver.py index ddd74ec84a..ad6dcbf67a 100644 --- a/ironic/tests/unit/api/controllers/v1/test_driver.py +++ b/ironic/tests/unit/api/controllers/v1/test_driver.py @@ -449,7 +449,7 @@ class TestListDrivers(base.BaseApiTest): driver._RAID_PROPERTIES = {} self.register_fake_conductors() disk_prop_mock.side_effect = exception.UnsupportedDriverExtension( - extension='raid', driver='fake') + extension='raid', driver='fake-hardware') path = '/drivers/%s/raid/logical_disk_properties' % self.d1 ret = self.get_json(path, headers={api_base.Version.string: "1.12"}, @@ -467,7 +467,7 @@ class TestDriverProperties(base.BaseApiTest): def test_driver_properties_fake(self, mock_topic, mock_properties): # Can get driver properties for fake driver. driver._DRIVER_PROPERTIES = {} - driver_name = 'fake' + driver_name = 'test' mock_topic.return_value = 'fake_topic' mock_properties.return_value = {'prop1': 'Property 1. Required.'} data = self.get_json('/drivers/%s/properties' % driver_name) @@ -501,12 +501,17 @@ class TestDriverProperties(base.BaseApiTest): # only one RPC-conductor call will be made and the info cached # for subsequent requests driver._DRIVER_PROPERTIES = {} - driver_name = 'fake' + driver_name = 'manual-management' mock_topic.return_value = 'fake_topic' mock_properties.return_value = {'prop1': 'Property 1. Required.'} - data = self.get_json('/drivers/%s/properties' % driver_name) - data = self.get_json('/drivers/%s/properties' % driver_name) - data = self.get_json('/drivers/%s/properties' % driver_name) + + with mock.patch.object(self.dbapi, 'get_active_hardware_type_dict', + autospec=True) as mock_hw_type: + mock_hw_type.return_value = {driver_name: 'fake_topic'} + data = self.get_json('/drivers/%s/properties' % driver_name) + data = self.get_json('/drivers/%s/properties' % driver_name) + data = self.get_json('/drivers/%s/properties' % driver_name) + self.assertEqual(mock_properties.return_value, data) mock_topic.assert_called_once_with(driver_name) mock_properties.assert_called_once_with(mock.ANY, driver_name, diff --git a/ironic/tests/unit/api/controllers/v1/test_node.py b/ironic/tests/unit/api/controllers/v1/test_node.py index cbc89c9009..2de2a603fa 100644 --- a/ironic/tests/unit/api/controllers/v1/test_node.py +++ b/ironic/tests/unit/api/controllers/v1/test_node.py @@ -1178,17 +1178,17 @@ class TestListNodes(test_api_base.BaseApiTest): def test_get_nodes_by_driver(self): node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='pxe_ipmitool') + driver='ipmi') node1 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake') + driver='fake-hardware') - data = self.get_json('/nodes?driver=pxe_ipmitool', + data = self.get_json('/nodes?driver=ipmi', headers={api_base.Version.string: "1.16"}) uuids = [n['uuid'] for n in data['nodes']] self.assertIn(node.uuid, uuids) self.assertNotIn(node1.uuid, uuids) - data = self.get_json('/nodes?driver=fake', + data = self.get_json('/nodes?driver=fake-hardware', headers={api_base.Version.string: "1.16"}) uuids = [n['uuid'] for n in data['nodes']] self.assertIn(node1.uuid, uuids) @@ -1215,11 +1215,9 @@ class TestListNodes(test_api_base.BaseApiTest): node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', resource_class='foo') node1 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', resource_class='bar') data = self.get_json(base_url % 'foo', @@ -2346,7 +2344,6 @@ class TestPost(test_api_base.BaseApiTest): def setUp(self): super(TestPost, self).setUp() - self.config(enabled_drivers=['fake']) self.chassis = obj_utils.create_test_chassis(self.context) p = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for') self.mock_gtf = p.start() @@ -2450,22 +2447,8 @@ class TestPost(test_api_base.BaseApiTest): expect_errors=True) self.assertEqual(http_client.NOT_ACCEPTABLE, response.status_int) - def test_create_node_classic_driver_specify_interface(self): - headers = {api_base.Version.string: '1.31'} - for field in api_utils.V31_FIELDS: - node = { - 'uuid': uuidutils.generate_uuid(), - field: 'fake', - } - ndict = test_api_utils.post_get_test_node(**node) - response = self.post_json('/nodes', ndict, - headers=headers, - expect_errors=True) - self.assertEqual(http_client.BAD_REQUEST, response.status_int) - self.assertEqual('application/json', response.content_type) - self.assertTrue(response.json['error_message']) - def test_create_node_explicit_storage_interface(self): + self.config(enabled_storage_interfaces=['cinder', 'noop', 'fake']) headers = {api_base.Version.string: '1.33'} result = self._test_create_node(headers=headers, storage_interface='cinder') @@ -3990,7 +3973,7 @@ class TestPut(test_api_base.BaseApiTest): raid_config = {'logical_disks': [{'size_gb': 100, 'raid_level': 1}]} set_raid_config_mock.side_effect = ( exception.UnsupportedDriverExtension(extension='raid', - driver='fake')) + driver='fake-hardware')) ret = self.put_json( '/nodes/%s/states/raid' % self.node.uuid, raid_config, headers={api_base.Version.string: "1.12"}, diff --git a/ironic/tests/unit/common/test_driver_factory.py b/ironic/tests/unit/common/test_driver_factory.py index 92a26f0009..889c15b0dd 100644 --- a/ironic/tests/unit/common/test_driver_factory.py +++ b/ironic/tests/unit/common/test_driver_factory.py @@ -35,7 +35,6 @@ class FakeEp(object): class DriverLoadTestCase(db_base.DbTestCase): - def _fake_init_name_err(self, *args, **kwargs): kwargs['on_load_failure_callback'](None, FakeEp, NameError('aaa')) @@ -97,43 +96,6 @@ class DriverLoadTestCase(db_base.DbTestCase): driver_factory.HardwareTypesFactory._extension_manager.names()) self.assertTrue(mock_warn.called) - @mock.patch.object(driver_factory.LOG, 'warning', autospec=True) - def test_classic_drivers_unsupported(self, mock_warn): - self.config(enabled_drivers=['fake']) - driver_factory.DriverFactory._init_extension_manager() - self.assertTrue(mock_warn.called) - - def test_build_driver_for_task(self): - node = obj_utils.create_test_node(self.context, driver='fake') - with task_manager.acquire(self.context, node.id) as task: - for iface in drivers_base.ALL_INTERFACES: - impl = getattr(task.driver, iface) - if iface in ['bios', 'rescue']: - self.assertIsNone(impl) - else: - self.assertIsNotNone(impl) - - @mock.patch.object(drivers_base.BaseDriver, 'supported', True) - @mock.patch.object(driver_factory, '_attach_interfaces_to_driver', - autospec=True) - @mock.patch.object(driver_factory.LOG, 'warning', autospec=True) - def test_build_driver_for_task_incorrect(self, mock_warn, mock_attach): - # Cannot set these node interfaces for classic driver - no_set_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - for iface in no_set_interfaces: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid(), - iface_name: 'fake'} - node = obj_utils.create_test_node(self.context, driver='fake', - **node_kwargs) - with task_manager.acquire(self.context, node.id) as task: - mock_warn.assert_called_once_with(mock.ANY, mock.ANY) - mock_warn.reset_mock() - mock_attach.assert_called_once_with(mock.ANY, task.node, - mock.ANY) - mock_attach.reset_mock() - class WarnUnsupportedDriversTestCase(base.TestCase): @mock.patch.object(driver_factory.LOG, 'warning', autospec=True) @@ -154,23 +116,13 @@ class WarnUnsupportedDriversTestCase(base.TestCase): self._test__warn_if_unsupported(False) -class GetDriverTestCase(base.TestCase): - def test_get_driver_known(self): - driver = driver_factory.get_driver('fake') - self.assertIsInstance(driver, drivers_base.BaseDriver) - - def test_get_driver_unknown(self): - self.assertRaises(exception.DriverNotFound, - driver_factory.get_driver, 'unknown_driver') - - class NetworkInterfaceFactoryTestCase(db_base.DbTestCase): @mock.patch.object(driver_factory, '_warn_if_unsupported', autospec=True) def test_build_driver_for_task(self, mock_warn): # flat, neutron, and noop network interfaces are enabled in base test # case factory = driver_factory.NetworkInterfaceFactory - node = obj_utils.create_test_node(self.context, driver='fake', + node = obj_utils.create_test_node(self.context, network_interface='flat') with task_manager.acquire(self.context, node.id) as task: extension_mgr = factory._extension_manager @@ -188,38 +140,11 @@ class NetworkInterfaceFactoryTestCase(db_base.DbTestCase): # each activated interface or driver causes the number to increment. self.assertTrue(mock_warn.called) - def test_build_driver_for_task_default_is_none(self): - # flat, neutron, and noop network interfaces are enabled in base test - # case - factory = driver_factory.NetworkInterfaceFactory - self.config(dhcp_provider='none', group='dhcp') - node = obj_utils.create_test_node(self.context, driver='fake') - with task_manager.acquire(self.context, node.id) as task: - extension_mgr = factory._extension_manager - self.assertIn('flat', extension_mgr) - self.assertIn('neutron', extension_mgr) - self.assertIn('noop', extension_mgr) - self.assertEqual(extension_mgr['noop'].obj, task.driver.network) - - def test_build_driver_for_task_default_network_interface_is_set(self): - # flat, neutron, and noop network interfaces are enabled in base test - # case - factory = driver_factory.NetworkInterfaceFactory - self.config(dhcp_provider='none', group='dhcp') - self.config(default_network_interface='flat') - node = obj_utils.create_test_node(self.context, driver='fake') - with task_manager.acquire(self.context, node.id) as task: - extension_mgr = factory._extension_manager - self.assertIn('flat', extension_mgr) - self.assertIn('neutron', extension_mgr) - self.assertIn('noop', extension_mgr) - self.assertEqual(extension_mgr['flat'].obj, task.driver.network) - def test_build_driver_for_task_default_is_flat(self): # flat, neutron, and noop network interfaces are enabled in base test # case factory = driver_factory.NetworkInterfaceFactory - node = obj_utils.create_test_node(self.context, driver='fake') + node = obj_utils.create_test_node(self.context) with task_manager.acquire(self.context, node.id) as task: extension_mgr = factory._extension_manager self.assertIn('flat', extension_mgr) @@ -228,7 +153,7 @@ class NetworkInterfaceFactoryTestCase(db_base.DbTestCase): self.assertEqual(extension_mgr['flat'].obj, task.driver.network) def test_build_driver_for_task_unknown_network_interface(self): - node = obj_utils.create_test_node(self.context, driver='fake', + node = obj_utils.create_test_node(self.context, network_interface='meow') self.assertRaises(exception.InterfaceNotFoundInEntrypoint, task_manager.acquire, self.context, node.id) @@ -236,16 +161,10 @@ class NetworkInterfaceFactoryTestCase(db_base.DbTestCase): class StorageInterfaceFactoryTestCase(db_base.DbTestCase): - def setUp(self): - super(StorageInterfaceFactoryTestCase, self).setUp() - driver_factory.DriverFactory._extension_manager = None - driver_factory.StorageInterfaceFactory._extension_manager = None - self.config(enabled_drivers=['fake']) - def test_build_interface_for_task(self): """Validate a node has no default storage interface.""" factory = driver_factory.StorageInterfaceFactory - node = obj_utils.create_test_node(self.context, driver='fake') + node = obj_utils.create_test_node(self.context, driver='fake-hardware') with task_manager.acquire(self.context, node.id) as task: manager = factory._extension_manager self.assertIn('noop', manager) @@ -265,71 +184,36 @@ class NewFactoryTestCase(db_base.DbTestCase): class CheckAndUpdateNodeInterfacesTestCase(db_base.DbTestCase): def test_no_network_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake') + node = obj_utils.get_test_node(self.context) self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('flat', node.network_interface) def test_none_network_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake', - network_interface=None) + node = obj_utils.get_test_node(self.context, network_interface=None) self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('flat', node.network_interface) def test_no_network_interface_default_from_conf(self): self.config(default_network_interface='noop') - node = obj_utils.get_test_node(self.context, driver='fake') + node = obj_utils.get_test_node(self.context) self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('noop', node.network_interface) - def test_no_network_interface_default_from_dhcp(self): - self.config(dhcp_provider='none', group='dhcp') - node = obj_utils.get_test_node(self.context, driver='fake') - self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) - # "none" dhcp provider corresponds to "noop" network_interface - self.assertEqual('noop', node.network_interface) - - def test_create_node_classic_driver_valid_interfaces(self): - node = obj_utils.get_test_node(self.context, driver='fake', + def test_create_node_valid_interfaces(self): + node = obj_utils.get_test_node(self.context, network_interface='noop', storage_interface='noop') - self.assertFalse(driver_factory.check_and_update_node_interfaces(node)) + self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('noop', node.network_interface) self.assertEqual('noop', node.storage_interface) - def test_create_node_classic_driver_invalid_network_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake', + def test_create_node_invalid_network_interface(self): + node = obj_utils.get_test_node(self.context, network_interface='banana') self.assertRaises(exception.InterfaceNotFoundInEntrypoint, driver_factory.check_and_update_node_interfaces, node) - def test_create_node_classic_driver_not_allowed_interfaces_set(self): - # Cannot set these node interfaces for classic driver - no_set_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - for iface in no_set_interfaces: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid(), - iface_name: 'fake'} - node = obj_utils.get_test_node(self.context, driver='fake', - **node_kwargs) - self.assertRaisesRegex( - exception.InvalidParameterValue, - 'driver fake.*%s' % iface_name, - driver_factory.check_and_update_node_interfaces, node) - - def test_create_node_classic_driver_no_interfaces_set(self): - no_set_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node = obj_utils.get_test_node(self.context, driver='fake', - **node_kwargs) - driver_factory.check_and_update_node_interfaces(node) - - for iface in no_set_interfaces: - iface_name = '%s_interface' % iface - self.assertIsNone(getattr(node, iface_name)) - def _get_valid_default_interface_name(self, iface): i_name = 'fake' # there is no 'fake' network interface @@ -344,15 +228,6 @@ class CheckAndUpdateNodeInterfacesTestCase(db_base.DbTestCase): 'default_%s_interface' % iface: i_name} self.config(**config_kwarg) - 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_create_node_dynamic_driver_interfaces_set(self): self._set_config_interface_options_hardware_type() @@ -366,101 +241,6 @@ class CheckAndUpdateNodeInterfacesTestCase(db_base.DbTestCase): driver_factory.check_and_update_node_interfaces(node) self.assertEqual(i_name, getattr(node, iface_name)) - def test_update_node_set_classic_driver_and_not_allowed_interfaces(self): - """Update driver to classic and interfaces specified""" - not_allowed_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - self.config(enabled_drivers=['fake', 'fake_agent']) - for iface in not_allowed_interfaces: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node = obj_utils.create_test_node(self.context, driver='fake', - **node_kwargs) - setattr(node, iface_name, 'fake') - node.driver = 'fake_agent' - self.assertRaisesRegex( - exception.InvalidParameterValue, - 'driver fake.*%s' % iface_name, - driver_factory.check_and_update_node_interfaces, node) - - def test_update_node_set_classic_driver_and_allowed_interfaces(self): - """Update driver to classic and interfaces specified""" - self._set_config_interface_options_hardware_type() - self.config(enabled_drivers=['fake', 'fake_agent']) - for iface in ['network', 'storage']: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node = obj_utils.create_test_node(self.context, driver='fake', - **node_kwargs) - i_name = self._get_valid_default_interface_name(iface) - setattr(node, iface_name, i_name) - node.driver = 'fake_agent' - driver_factory.check_and_update_node_interfaces(node) - self.assertEqual(i_name, getattr(node, iface_name)) - - def test_update_node_set_classic_driver_unset_interfaces(self): - """Update driver to classic and set interfaces to None""" - no_set_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - self.config(enabled_drivers=['fake', 'fake_agent']) - for iface in no_set_interfaces: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node = obj_utils.create_test_node(self.context, driver='fake', - **node_kwargs) - setattr(node, iface_name, None) - node.driver = 'fake_agent' - driver_factory.check_and_update_node_interfaces(node) - self.assertEqual('fake_agent', node.driver) - self.assertIsNone(getattr(node, iface_name)) - - def test_update_node_classic_driver_unset_interfaces(self): - """Update interfaces to None for node with classic driver""" - no_set_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - self.config(enabled_drivers=['fake', 'fake_agent']) - for iface in no_set_interfaces: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node = obj_utils.create_test_node(self.context, driver='fake', - **node_kwargs) - setattr(node, iface_name, None) - driver_factory.check_and_update_node_interfaces(node) - self.assertIsNone(getattr(node, iface_name)) - - def test_update_node_set_classic_driver_no_interfaces(self): - """Update driver to classic no interfaces specified""" - self._set_config_interface_options_hardware_type() - no_set_interfaces = (drivers_base.ALL_INTERFACES - - set(['network', 'storage'])) - for iface in no_set_interfaces: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node_kwargs[iface_name] = 'fake' - node = obj_utils.create_test_node(self.context, - driver='fake-hardware', - **node_kwargs) - node.driver = 'fake' - driver_factory.check_and_update_node_interfaces(node) - self.assertEqual('fake', node.driver) - self.assertIsNone(getattr(node, iface_name)) - self.assertEqual('noop', node.network_interface) - - def test_update_node_set_dynamic_driver_and_interfaces(self): - """Update driver to dynamic and interfaces specified""" - self._set_config_interface_options_hardware_type() - - for iface in drivers_base.ALL_INTERFACES: - iface_name = '%s_interface' % iface - node_kwargs = {'uuid': uuidutils.generate_uuid()} - node = obj_utils.create_test_node(self.context, driver='fake', - **node_kwargs) - i_name = self._get_valid_default_interface_name(iface) - setattr(node, iface_name, i_name) - node.driver = 'fake-hardware' - driver_factory.check_and_update_node_interfaces(node) - self.assertEqual(i_name, getattr(node, iface_name)) - def test_node_update_dynamic_driver_set_interfaces(self): """Update interfaces for node with dynamic driver""" self._set_config_interface_options_hardware_type() @@ -480,8 +260,7 @@ class CheckAndUpdateNodeInterfacesTestCase(db_base.DbTestCase): class DefaultInterfaceTestCase(db_base.DbTestCase): def setUp(self): super(DefaultInterfaceTestCase, self).setUp() - self.config(enabled_hardware_types=['manual-management'], - enabled_drivers=['fake']) + self.config(enabled_hardware_types=['manual-management']) self.driver = driver_factory.get_hardware_type('manual-management') def test_from_config(self): @@ -501,22 +280,6 @@ class DefaultInterfaceTestCase(db_base.DbTestCase): iface = driver_factory.default_interface(self.driver, 'network') self.assertEqual('neutron', iface) - def test_network_from_additional_defaults(self): - self.config(default_network_interface=None) - self.config(dhcp_provider='none', group='dhcp') - iface = driver_factory.default_interface( - driver_factory.get_driver_or_hardware_type('fake'), - 'network') - self.assertEqual('noop', iface) - - def test_network_from_additional_defaults_neutron_dhcp(self): - self.config(default_network_interface=None) - self.config(dhcp_provider='neutron', group='dhcp') - iface = driver_factory.default_interface( - driver_factory.get_driver_or_hardware_type('fake'), - 'network') - self.assertEqual('flat', iface) - def test_calculated_with_one(self): self.config(default_deploy_interface=None) self.config(enabled_deploy_interfaces=['direct']) @@ -655,14 +418,16 @@ class HardwareTypeLoadTestCase(db_base.DbTestCase): self.assertIsInstance(hw_type, fake_hardware.FakeHardware) def test_get_hardware_type_missing(self): + self.config(enabled_drivers=['fake_agent']) self.assertRaises(exception.DriverNotFound, - # "fake" is a classic driver - driver_factory.get_hardware_type, 'fake') + # "fake_agent" is a classic driver + driver_factory.get_hardware_type, 'fake_agent') def test_get_driver_or_hardware_type(self): + self.config(enabled_drivers=['fake_agent']) hw_type = driver_factory.get_driver_or_hardware_type('fake-hardware') self.assertIsInstance(hw_type, fake_hardware.FakeHardware) - driver = driver_factory.get_driver_or_hardware_type('fake') + driver = driver_factory.get_driver_or_hardware_type('fake_agent') self.assertNotIsInstance(driver, fake_hardware.FakeHardware) def test_get_driver_or_hardware_type_missing(self): @@ -745,12 +510,12 @@ class HardwareTypeLoadTestCase(db_base.DbTestCase): task_manager.acquire, self.context, node.id) def test_no_storage_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake') + node = obj_utils.get_test_node(self.context) self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('noop', node.storage_interface) def test_none_storage_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake', + node = obj_utils.get_test_node(self.context, storage_interface=None) self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('noop', node.storage_interface) @@ -758,22 +523,17 @@ class HardwareTypeLoadTestCase(db_base.DbTestCase): def test_no_storage_interface_default_from_conf(self): self.config(enabled_storage_interfaces=['noop', 'fake']) self.config(default_storage_interface='fake') - node = obj_utils.get_test_node(self.context, driver='fake') + node = obj_utils.get_test_node(self.context) self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) self.assertEqual('fake', node.storage_interface) def test_invalid_storage_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake', + node = obj_utils.get_test_node(self.context, storage_interface='scoop') self.assertRaises(exception.InterfaceNotFoundInEntrypoint, driver_factory.check_and_update_node_interfaces, node) - def test_none_rescue_interface(self): - node = obj_utils.get_test_node(self.context, driver='fake') - self.assertTrue(driver_factory.check_and_update_node_interfaces(node)) - self.assertIsNone(node.rescue_interface) - def test_no_rescue_interface_default_from_conf(self): self.config(enabled_rescue_interfaces=['fake']) self.config(default_rescue_interface='fake') diff --git a/ironic/tests/unit/common/test_network.py b/ironic/tests/unit/common/test_network.py index 67c4f51138..e6ffcd08c8 100644 --- a/ironic/tests/unit/common/test_network.py +++ b/ironic/tests/unit/common/test_network.py @@ -48,7 +48,7 @@ class TestNetwork(db_base.DbTestCase): port1 = db_utils.create_test_port(node_id=self.node.id, address='aa:bb:cc:dd:ee:ff', uuid=uuidutils.generate_uuid(), - driver='fake', **kwargs1) + **kwargs1) expected = {'portgroups': {}, 'ports': {port1.uuid: 'test-vif-A'}} with task_manager.acquire(self.context, self.node.uuid) as task: @@ -91,11 +91,11 @@ class TestNetwork(db_base.DbTestCase): port1 = db_utils.create_test_port(node_id=self.node.id, address='aa:bb:cc:dd:ee:ff', uuid=uuidutils.generate_uuid(), - driver='fake', **kwargs1) + **kwargs1) port2 = db_utils.create_test_port(node_id=self.node.id, address='dd:ee:ff:aa:bb:cc', uuid=uuidutils.generate_uuid(), - driver='fake', **kwargs2) + **kwargs2) expected = {'portgroups': {}, 'ports': {port1.uuid: 'test-vif-A', port2.uuid: 'test-vif-B'}} @@ -201,9 +201,8 @@ class TestRemoveVifsTestCase(db_base.DbTestCase): class GetPortgroupByIdTestCase(db_base.DbTestCase): - def test_portgroup_by_id(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) portgroup = object_utils.create_test_portgroup(self.context, node_id=node.id) object_utils.create_test_portgroup(self.context, @@ -216,7 +215,7 @@ class GetPortgroupByIdTestCase(db_base.DbTestCase): self.assertEqual(portgroup.id, res.id) def test_portgroup_by_id_no_such_portgroup(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) object_utils.create_test_portgroup(self.context, node_id=node.id) with task_manager.acquire(self.context, node.uuid) as task: portgroup_id = 'invalid-portgroup-id' @@ -227,7 +226,7 @@ class GetPortgroupByIdTestCase(db_base.DbTestCase): class GetPortsByPortgroupIdTestCase(db_base.DbTestCase): def test_ports_by_portgroup_id(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) portgroup = object_utils.create_test_portgroup(self.context, node_id=node.id) port = object_utils.create_test_port(self.context, node_id=node.id, @@ -240,7 +239,7 @@ class GetPortsByPortgroupIdTestCase(db_base.DbTestCase): self.assertEqual([port.id], [p.id for p in res]) def test_ports_by_portgroup_id_empty(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) portgroup = object_utils.create_test_portgroup(self.context, node_id=node.id) with task_manager.acquire(self.context, node.uuid) as task: @@ -251,20 +250,20 @@ class GetPortsByPortgroupIdTestCase(db_base.DbTestCase): class GetPhysnetsForNodeTestCase(db_base.DbTestCase): def test_get_physnets_for_node_no_ports(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) with task_manager.acquire(self.context, node.uuid) as task: res = network.get_physnets_for_node(task) self.assertEqual(set(), res) def test_get_physnets_for_node_excludes_None(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) object_utils.create_test_port(self.context, node_id=node.id) with task_manager.acquire(self.context, node.uuid) as task: res = network.get_physnets_for_node(task) self.assertEqual(set(), res) def test_get_physnets_for_node_multiple_ports(self): - node = object_utils.create_test_node(self.context, driver='fake') + node = object_utils.create_test_node(self.context) object_utils.create_test_port(self.context, node_id=node.id, physical_network='physnet1') object_utils.create_test_port(self.context, node_id=node.id, @@ -280,7 +279,7 @@ class GetPhysnetsByPortgroupID(db_base.DbTestCase): def setUp(self): super(GetPhysnetsByPortgroupID, self).setUp() - self.node = object_utils.create_test_node(self.context, driver='fake') + self.node = object_utils.create_test_node(self.context) self.portgroup = object_utils.create_test_portgroup( self.context, node_id=self.node.id) diff --git a/ironic/tests/unit/common/test_pxe_utils.py b/ironic/tests/unit/common/test_pxe_utils.py index fce88e37fc..a2677d7c37 100644 --- a/ironic/tests/unit/common/test_pxe_utils.py +++ b/ironic/tests/unit/common/test_pxe_utils.py @@ -30,6 +30,8 @@ from ironic.tests.unit.objects import utils as object_utils CONF = cfg.CONF +# Prevent /httpboot validation on creating the node +@mock.patch('ironic.drivers.modules.pxe.PXEBoot.__init__', lambda self: None) class TestPXEUtils(db_base.DbTestCase): def setUp(self): diff --git a/ironic/tests/unit/common/test_raid.py b/ironic/tests/unit/common/test_raid.py index 0b47470a6a..6e2ed519fb 100644 --- a/ironic/tests/unit/common/test_raid.py +++ b/ironic/tests/unit/common/test_raid.py @@ -180,8 +180,7 @@ class RaidPublicMethodsTestCase(db_base.DbTestCase): def _test_update_raid_info(self, current_config, capabilities=None): - node = obj_utils.create_test_node(self.context, - driver='fake') + node = obj_utils.create_test_node(self.context) if capabilities: properties = node.properties properties['capabilities'] = capabilities diff --git a/ironic/tests/unit/conductor/mgr_utils.py b/ironic/tests/unit/conductor/mgr_utils.py index 02f387a071..44e492462e 100644 --- a/ironic/tests/unit/conductor/mgr_utils.py +++ b/ironic/tests/unit/conductor/mgr_utils.py @@ -22,7 +22,6 @@ import mock from oslo_utils import strutils from oslo_utils import uuidutils -from ironic.common import driver_factory from ironic.common import exception from ironic.common import states from ironic.conductor import manager @@ -126,25 +125,10 @@ class ServiceSetUpMixin(object): def setUp(self): super(ServiceSetUpMixin, self).setUp() self.hostname = 'test-host' - self.config(enabled_drivers=['fake']) self.config(node_locked_retry_attempts=1, group='conductor') self.config(node_locked_retry_interval=0, group='conductor') - self.config(enabled_hardware_types=['fake-hardware', - 'manual-management']) - self.config(enabled_boot_interfaces=['fake', 'pxe']) - self.config(enabled_console_interfaces=['fake', 'no-console']) - self.config(enabled_deploy_interfaces=['fake', 'iscsi']) - self.config(enabled_inspect_interfaces=['fake', 'no-inspect']) - self.config(enabled_management_interfaces=['fake']) - self.config(enabled_power_interfaces=['fake']) - self.config(enabled_raid_interfaces=['fake', 'no-raid']) - self.config(enabled_rescue_interfaces=['fake', 'no-rescue']) - self.config(enabled_vendor_interfaces=['fake', 'no-vendor']) - self.config(enabled_bios_interfaces=['fake', 'no-bios']) - self.service = manager.ConductorManager(self.hostname, 'test-topic') - self.driver = driver_factory.get_driver('fake') def _stop_service(self): try: diff --git a/ironic/tests/unit/conductor/test_base_manager.py b/ironic/tests/unit/conductor/test_base_manager.py index 52cb9ef31e..6c75007f7d 100644 --- a/ironic/tests/unit/conductor/test_base_manager.py +++ b/ironic/tests/unit/conductor/test_base_manager.py @@ -175,11 +175,6 @@ class StartStopTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): 'options enabled_boot_interfaces', self.service.init_host) - def test_starts_without_enabled_hardware_types(self): - self.config(enabled_hardware_types=[]) - self.config(enabled_boot_interfaces=[]) - self._start_service() - @mock.patch.object(base_manager, 'LOG') @mock.patch.object(driver_factory, 'HardwareTypesFactory') @mock.patch.object(driver_factory, 'DriverFactory') @@ -208,20 +203,6 @@ class StartStopTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): df_mock.assert_called_with() self.assertFalse(del_mock.called) - @mock.patch.object(base_manager, 'LOG') - @mock.patch.object(base_manager.BaseConductorManager, 'del_host', - autospec=True) - @mock.patch.object(driver_factory, 'HardwareTypesFactory') - def test_starts_with_only_classic_drivers(self, ht_mock, del_mock, - log_mock): - # don't load any dynamic drivers - driver_factory_mock = mock.MagicMock(names=[]) - ht_mock.return_value = driver_factory_mock - self.service.init_host() - self.assertFalse(log_mock.error.called) - ht_mock.assert_called_with() - self.assertFalse(del_mock.called) - @mock.patch.object(base_manager, 'LOG') @mock.patch.object(base_manager.BaseConductorManager, '_register_and_validate_hardware_interfaces') diff --git a/ironic/tests/unit/conductor/test_manager.py b/ironic/tests/unit/conductor/test_manager.py index 2ea75f90bb..b0e4ff0607 100644 --- a/ironic/tests/unit/conductor/test_manager.py +++ b/ironic/tests/unit/conductor/test_manager.py @@ -548,7 +548,7 @@ class UpdateNodeTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self._test_associate_node(states.POWER_ON) def test_update_node_invalid_driver(self): - existing_driver = 'fake' + existing_driver = 'fake-hardware' wrong_driver = 'wrong-driver' node = obj_utils.create_test_node(self.context, driver=existing_driver, @@ -577,7 +577,7 @@ class UpdateNodeTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): 'power_interface': UpdateInterfaces(None, 'fake'), 'raid_interface': UpdateInterfaces(None, 'fake'), 'rescue_interface': UpdateInterfaces(None, 'no-rescue'), - 'storage_interface': UpdateInterfaces('noop', 'cinder'), + 'storage_interface': UpdateInterfaces('noop', 'fake'), } def _create_node_with_interfaces(self, prov_state, maintenance=False): @@ -721,10 +721,10 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): @mock.patch.object(task_manager.TaskManager, 'upgrade_lock') @mock.patch.object(task_manager.TaskManager, 'spawn_after') - def _test_vendor_passthru_async(self, driver, vendor_iface, mock_spawn, - mock_upgrade): - node = obj_utils.create_test_node(self.context, driver=driver, - vendor_interface=vendor_iface) + def test_vendor_passthru_async(self, mock_spawn, + mock_upgrade): + node = obj_utils.create_test_node(self.context, + vendor_interface='fake') info = {'bar': 'baz'} self._start_service() @@ -747,12 +747,6 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): # Verify reservation has been cleared. self.assertIsNone(node.reservation) - def test_vendor_passthru_async(self): - self._test_vendor_passthru_async('fake', None) - - def test_vendor_passthru_async_hw_type(self): - self._test_vendor_passthru_async('fake-hardware', 'fake') - @mock.patch.object(task_manager.TaskManager, 'upgrade_lock') @mock.patch.object(task_manager.TaskManager, 'spawn_after') def test_vendor_passthru_sync(self, mock_spawn, mock_upgrade): @@ -876,26 +870,6 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): # Verify reservation has been cleared. self.assertIsNone(node.reservation) - def test_vendor_passthru_vendor_interface_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake') - info = {'bar': 'baz'} - self.driver.vendor = None - self._start_service() - - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.vendor_passthru, - self.context, node.uuid, - 'whatever_method', 'POST', info) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - - node.refresh() - # Verify reservation has been cleared. - self.assertIsNone(node.reservation) - def test_vendor_passthru_worker_pool_full(self): node = obj_utils.create_test_node(self.context, driver='fake-hardware') info = {'bar': 'baz'} @@ -936,30 +910,13 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): del fake_routes['test_method']['func'] self.assertEqual(fake_routes, data) - def test_get_node_vendor_passthru_methods_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake') - self.driver.vendor = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.get_node_vendor_passthru_methods, - self.context, node.uuid) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - @mock.patch.object(driver_factory, 'get_interface') @mock.patch.object(manager.ConductorManager, '_spawn_worker') - def _test_driver_vendor_passthru_sync(self, is_hw_type, mock_spawn, - mock_get_if): + def test_driver_vendor_passthru_sync(self, mock_spawn, mock_get_if): expected = {'foo': 'bar'} vendor_mock = mock.Mock(spec=drivers_base.VendorInterface) - if is_hw_type: - mock_get_if.return_value = vendor_mock - driver_name = 'fake-hardware' - else: - self.driver.vendor = vendor_mock - driver_name = 'fake' + mock_get_if.return_value = vendor_mock + driver_name = 'fake-hardware' test_method = mock.MagicMock(return_value=expected) vendor_mock.driver_routes = { 'test_method': {'func': test_method, @@ -984,14 +941,7 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): test_method.assert_called_once_with(self.context, **vendor_args) # No worker was spawned self.assertFalse(mock_spawn.called) - if is_hw_type: - mock_get_if.assert_called_once_with(mock.ANY, 'vendor', 'fake') - - def test_driver_vendor_passthru_sync(self): - self._test_driver_vendor_passthru_sync(False) - - def test_driver_vendor_passthru_sync_hw_type(self): - self._test_driver_vendor_passthru_sync(True) + mock_get_if.assert_called_once_with(mock.ANY, 'vendor', 'fake') @mock.patch.object(driver_factory, 'get_interface', autospec=True) @mock.patch.object(manager.ConductorManager, '_spawn_worker') @@ -1033,20 +983,6 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self.assertEqual(exception.InvalidParameterValue, exc.exc_info[0]) - def test_driver_vendor_passthru_vendor_interface_not_supported(self): - # Test for when no vendor interface is set at all - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - self.driver.vendor = None - self.service.init_host() - exc = self.assertRaises(messaging.ExpectedException, - self.service.driver_vendor_passthru, - self.context, 'fake', 'test_method', - 'POST', {}) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - def test_driver_vendor_passthru_method_not_supported(self): # Test for when the vendor interface is set, but hasn't passed a # driver_passthru_mapping to MixinVendorInterface @@ -1085,16 +1021,11 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self.assertEqual(exception.NoValidDefaultForInterface, exc.exc_info[0]) - @mock.patch.object(driver_factory, 'get_interface') - def _test_get_driver_vendor_passthru_methods(self, is_hw_type, - mock_get_if): + @mock.patch.object(driver_factory, 'get_interface', autospec=True) + def test_get_driver_vendor_passthru_methods(self, mock_get_if): vendor_mock = mock.Mock(spec=drivers_base.VendorInterface) - if is_hw_type: - mock_get_if.return_value = vendor_mock - driver_name = 'fake-hardware' - else: - self.driver.vendor = vendor_mock - driver_name = 'fake' + mock_get_if.return_value = vendor_mock + driver_name = 'fake-hardware' fake_routes = {'test_method': {'async': True, 'description': 'foo', 'http_methods': ['POST'], @@ -1111,29 +1042,7 @@ class VendorPassthruTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): del fake_routes['test_method']['func'] self.assertEqual(fake_routes, data) - if is_hw_type: - mock_get_if.assert_called_once_with(mock.ANY, 'vendor', 'fake') - else: - mock_get_if.assert_not_called() - - def test_get_driver_vendor_passthru_methods(self): - self._test_get_driver_vendor_passthru_methods(False) - - def test_get_driver_vendor_passthru_methods_hw_type(self): - self._test_get_driver_vendor_passthru_methods(True) - - def test_get_driver_vendor_passthru_methods_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - self.service.init_host() - self.driver.vendor = None - exc = self.assertRaises( - messaging.rpc.ExpectedException, - self.service.get_driver_vendor_passthru_methods, - self.context, 'fake') - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) + mock_get_if.assert_called_once_with(mock.ANY, 'vendor', 'fake') @mock.patch.object(driver_factory, 'default_interface', autospec=True) def test_get_driver_vendor_passthru_methods_no_default_interface( @@ -3089,21 +2998,6 @@ class DoNodeRescueTestCase(mgr_utils.CommonMixIn, mgr_utils.ServiceSetUpMixin, def test_do_node_rescue_when_network_validate_fail(self, mock_validate): self._test_do_node_rescue_when_validate_fail(mock_validate) - def test_do_node_rescue_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node( - self.context, driver='fake', - provision_state=states.ACTIVE, - network_interface='noop', - target_provision_state=states.NOSTATE, - instance_info={}) - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.do_node_rescue, - self.context, node.uuid, "password") - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0], str(exc.exc_info)) - def test_do_node_rescue_maintenance(self): node = obj_utils.create_test_node( self.context, driver='fake-hardware', @@ -3225,19 +3119,6 @@ class DoNodeRescueTestCase(mgr_utils.CommonMixIn, mgr_utils.ServiceSetUpMixin, # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.InstanceUnrescueFailure, exc.exc_info[0]) - def test_do_node_unrescue_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node( - self.context, driver='fake', - provision_state=states.RESCUE, - instance_info={}) - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.do_node_unrescue, - self.context, node.uuid) - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - def test_do_node_unrescue_maintenance(self): node = obj_utils.create_test_node( self.context, driver='fake-hardware', @@ -3497,32 +3378,6 @@ class MiscTestCase(mgr_utils.ServiceSetUpMixin, mgr_utils.CommonMixIn, self.assertEqual(expected, ret) mock_iwdi.assert_called_once_with(self.context, node.instance_info) - @mock.patch.object(images, 'is_whole_disk_image') - def test_validate_driver_interfaces_classic_driver(self, mock_iwdi): - mock_iwdi.return_value = False - target_raid_config = {'logical_disks': [{'size_gb': 1, - 'raid_level': '1'}]} - node = obj_utils.create_test_node( - self.context, driver='fake', - target_raid_config=target_raid_config, - network_interface='noop') - ret = self.service.validate_driver_interfaces(self.context, - node.uuid) - reason = ('not supported') - expected = {'console': {'result': True}, - 'power': {'result': True}, - 'inspect': {'result': True}, - 'management': {'result': True}, - 'boot': {'result': True}, - 'raid': {'result': True}, - 'deploy': {'result': True}, - 'network': {'result': True}, - 'storage': {'result': True}, - 'rescue': {'reason': reason, 'result': None}} - - self.assertEqual(expected, ret) - mock_iwdi.assert_called_once_with(self.context, node.instance_info) - @mock.patch.object(fake.FakeDeploy, 'validate', autospec=True) @mock.patch.object(images, 'is_whole_disk_image') def test_validate_driver_interfaces_validation_fail(self, mock_iwdi, @@ -3664,23 +3519,6 @@ class ConsoleTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): mock.call(mock.ANY, 'console_set', obj_fields.NotificationStatus.END)]) - def test_set_console_mode_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake', - last_error=None) - self._start_service() - # null the console interface - self.driver.console = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.set_console_mode, self.context, - node.uuid, True) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - self._stop_service() - node.refresh() - @mock.patch.object(fake.FakeConsole, 'validate', autospec=True) def test_set_console_mode_validation_fail(self, mock_val): node = obj_utils.create_test_node(self.context, driver='fake-hardware', @@ -3742,17 +3580,16 @@ class ConsoleTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self.assertFalse(mock_sc.called) self.assertFalse(mock_notify.called) + @mock.patch.object(fake.FakeConsole, 'stop_console', autospec=True) @mock.patch.object(notification_utils, 'emit_console_notification') - def test_disable_console_already_disabled(self, mock_notify): + def test_disable_console_already_disabled(self, mock_notify, mock_sc): node = obj_utils.create_test_node(self.context, driver='fake-hardware', console_enabled=False) self._start_service() - with mock.patch.object(self.driver.console, - 'stop_console') as mock_sc: - self.service.set_console_mode(self.context, node.uuid, False) - self._stop_service() - self.assertFalse(mock_sc.called) - self.assertFalse(mock_notify.called) + self.service.set_console_mode(self.context, node.uuid, False) + self._stop_service() + self.assertFalse(mock_sc.called) + self.assertFalse(mock_notify.called) @mock.patch.object(fake.FakeConsole, 'get_console', autospec=True) def test_get_console(self, mock_gc): @@ -3764,20 +3601,6 @@ class ConsoleTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): node.uuid) self.assertEqual(console_info, data) - def test_get_console_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake', - console_enabled=True) - # null the console interface - self.driver.console = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.get_console_information, - self.context, node.uuid) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - def test_get_console_disabled(self): node = obj_utils.create_test_node(self.context, driver='fake-hardware', console_enabled=False) @@ -4288,17 +4111,14 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): CONF.set_override('send_sensor_data', True, group='conductor') task = acquire_mock.return_value.__enter__.return_value - task.driver = self.driver task.node.maintenance = False - with mock.patch.object(self.driver.management, - 'get_sensors_data') as get_sensors_data_mock: - with mock.patch.object(self.driver.management, - 'validate') as validate_mock: - get_sensors_data_mock.return_value = 'fake-sensor-data' - self.service._sensors_nodes_task(self.context, nodes) - self.assertEqual(5, acquire_mock.call_count) - self.assertEqual(5, validate_mock.call_count) - self.assertEqual(5, get_sensors_data_mock.call_count) + get_sensors_data_mock = task.driver.management.get_sensors_data + validate_mock = task.driver.management.validate + get_sensors_data_mock.return_value = 'fake-sensor-data' + self.service._sensors_nodes_task(self.context, nodes) + self.assertEqual(5, acquire_mock.call_count) + self.assertEqual(5, validate_mock.call_count) + self.assertEqual(5, get_sensors_data_mock.call_count) @mock.patch.object(task_manager, 'acquire') def test_send_sensor_task_shutdown(self, acquire_mock): @@ -4319,20 +4139,13 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self._start_service() - self.driver.management = None task = acquire_mock.return_value.__enter__.return_value - task.driver = self.driver task.node.maintenance = False + task.driver.management = None - with mock.patch.object(fake.FakeManagement, 'get_sensors_data', - autospec=True) as get_sensors_data_mock: - with mock.patch.object(fake.FakeManagement, 'validate', - autospec=True) as validate_mock: - self.service._sensors_nodes_task(self.context, nodes) + self.service._sensors_nodes_task(self.context, nodes) self.assertTrue(acquire_mock.called) - self.assertFalse(get_sensors_data_mock.called) - self.assertFalse(validate_mock.called) @mock.patch.object(manager.LOG, 'debug', autospec=True) @mock.patch.object(task_manager, 'acquire', autospec=True) @@ -4343,17 +4156,15 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): CONF.set_override('send_sensor_data', True, group='conductor') task = acquire_mock.return_value.__enter__.return_value - task.driver = self.driver task.node.maintenance = True - with mock.patch.object(self.driver.management, - 'get_sensors_data') as get_sensors_data_mock: - with mock.patch.object(self.driver.management, - 'validate') as validate_mock: - self.service._sensors_nodes_task(self.context, nodes) - self.assertTrue(acquire_mock.called) - self.assertFalse(validate_mock.called) - self.assertFalse(get_sensors_data_mock.called) - self.assertTrue(debug_log.called) + get_sensors_data_mock = task.driver.management.get_sensors_data + validate_mock = task.driver.management.validate + + self.service._sensors_nodes_task(self.context, nodes) + self.assertTrue(acquire_mock.called) + self.assertFalse(validate_mock.called) + self.assertFalse(get_sensors_data_mock.called) + self.assertTrue(debug_log.called) @mock.patch.object(manager.ConductorManager, '_spawn_worker') @mock.patch.object(manager.ConductorManager, '_mapped_to_this_conductor') @@ -4434,19 +4245,6 @@ class BootDeviceTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeLocked, exc.exc_info[0]) - def test_set_boot_device_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake') - # null the console interface - self.driver.management = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.set_boot_device, - self.context, node.uuid, boot_devices.DISK) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - @mock.patch.object(fake.FakeManagement, 'validate', autospec=True) def test_set_boot_device_validate_fail(self, mock_val): node = obj_utils.create_test_node(self.context, driver='fake-hardware') @@ -4472,19 +4270,6 @@ class BootDeviceTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeLocked, exc.exc_info[0]) - def test_get_boot_device_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake') - # null the management interface - self.driver.management = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.get_boot_device, - self.context, node.uuid) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - @mock.patch.object(fake.FakeManagement, 'validate', autospec=True) def test_get_boot_device_validate_fail(self, mock_val): node = obj_utils.create_test_node(self.context, driver='fake-hardware') @@ -4501,19 +4286,6 @@ class BootDeviceTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): node.uuid) self.assertEqual([boot_devices.PXE], bootdevs) - def test_get_supported_boot_devices_iface_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake') - # null the management interface - self.driver.management = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.get_supported_boot_devices, - self.context, node.uuid) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - @mgr_utils.mock_record_keepalive class NmiTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): @@ -4535,19 +4307,6 @@ class NmiTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeLocked, exc.exc_info[0]) - def test_inject_nmi_not_supported(self): - # TODO(dtantsur): remove this test when classic drivers are removed - # (interfaces in dynamic drivers cannot be None). - node = obj_utils.create_test_node(self.context, driver='fake') - # null the management interface - self.driver.management = None - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.inject_nmi, - self.context, node.uuid) - # Compare true exception hidden by @messaging.expected_exceptions - self.assertEqual(exception.UnsupportedDriverExtension, - exc.exc_info[0]) - @mock.patch.object(fake.FakeManagement, 'validate', autospec=True) def test_inject_nmi_validate_invalid_param(self, mock_val): node = obj_utils.create_test_node(self.context, driver='fake-hardware') @@ -4897,7 +4656,7 @@ class UpdatePortgroupTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): @mgr_utils.mock_record_keepalive class RaidTestCases(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): - driver_name = 'fake' + driver_name = 'fake-hardware' raid_interface = None def setUp(self): @@ -4914,14 +4673,6 @@ class RaidTestCases(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self.assertIn('raid_level', properties) self.assertIn('size_gb', properties) - def test_get_raid_logical_disk_properties_iface_not_supported(self): - self.driver.raid = None - self._start_service() - exc = self.assertRaises(messaging.rpc.ExpectedException, - self.service.get_raid_logical_disk_properties, - self.context, self.driver_name) - self.assertEqual(exception.UnsupportedDriverExtension, exc.exc_info[0]) - def test_set_target_raid_config(self): raid_config = {'logical_disks': [{'size_gb': 100, 'raid_level': '1'}]} self.service.set_target_raid_config( @@ -4938,18 +4689,6 @@ class RaidTestCases(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self.node.refresh() self.assertEqual({}, self.node.target_raid_config) - def test_set_target_raid_config_iface_not_supported(self): - raid_config = {'logical_disks': [{'size_gb': 100, 'raid_level': '1'}]} - self.driver.raid = None - exc = self.assertRaises( - messaging.rpc.ExpectedException, - self.service.set_target_raid_config, - self.context, self.node.uuid, raid_config) - self.node.refresh() - self.assertEqual({}, self.node.target_raid_config) - self.assertEqual(exception.UnsupportedDriverExtension, exc.exc_info[0]) - self.assertIn(self.driver_name, six.text_type(exc.exc_info[1])) - def test_set_target_raid_config_invalid_parameter_value(self): # Missing raid_level in the below raid config. raid_config = {'logical_disks': [{'size_gb': 100}]} @@ -7597,7 +7336,7 @@ class DoNodeInspectAbortTestCase(mgr_utils.CommonMixIn, task = task_manager.TaskManager(self.context, node.uuid) mock_acquire.side_effect = self._get_acquire_side_effect(task) mock_abort.side_effect = exception.UnsupportedDriverExtension( - driver='fake', extension='inspect') + driver='fake-hardware', extension='inspect') self._start_service() exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.do_provisioning_action, diff --git a/ironic/tests/unit/conductor/test_task_manager.py b/ironic/tests/unit/conductor/test_task_manager.py index ced54195bd..37255af50f 100644 --- a/ironic/tests/unit/conductor/test_task_manager.py +++ b/ironic/tests/unit/conductor/test_task_manager.py @@ -85,7 +85,7 @@ class TaskManagerTestCase(db_base.DbTestCase): reserve_mock, release_mock, node_get_mock): node2 = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake') + driver='fake-hardware') reserve_mock.return_value = self.node get_ports_mock.return_value = mock.sentinel.ports1 diff --git a/ironic/tests/unit/conductor/test_utils.py b/ironic/tests/unit/conductor/test_utils.py index 13ca1f6df8..02ed17d1bf 100644 --- a/ironic/tests/unit/conductor/test_utils.py +++ b/ironic/tests/unit/conductor/test_utils.py @@ -21,6 +21,7 @@ from ironic.common import states from ironic.conductor import task_manager from ironic.conductor import utils as conductor_utils from ironic.drivers import base as drivers_base +from ironic.drivers.modules import fake from ironic import objects from ironic.objects import fields as obj_fields from ironic.tests import base as tests_base @@ -102,32 +103,29 @@ class NodeSetBootDeviceTestCase(db_base.DbTestCase): class NodePowerActionTestCase(db_base.DbTestCase): - def setUp(self): - super(NodePowerActionTestCase, self).setUp() - self.driver = driver_factory.get_driver("fake") - - def test_node_power_action_power_on(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_on(self, get_power_mock): """Test node_power_action to turn node power on.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_OFF + get_power_mock.return_value = states.POWER_OFF - conductor_utils.node_power_action(task, states.POWER_ON) + conductor_utils.node_power_action(task, states.POWER_ON) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) @mock.patch('ironic.objects.node.NodeSetPowerStateNotification') - def test_node_power_action_power_on_notify(self, mock_notif): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_on_notify(self, get_power_mock, + mock_notif): """Test node_power_action to power on node and send notification.""" self.config(notification_level='info') self.config(host='my-host') @@ -135,110 +133,107 @@ class NodePowerActionTestCase(db_base.DbTestCase): mock_notif.__name__ = 'NodeSetPowerStateNotification' node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_OFF + get_power_mock.return_value = states.POWER_OFF - conductor_utils.node_power_action(task, states.POWER_ON) + conductor_utils.node_power_action(task, states.POWER_ON) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_ON, node.power_state) - self.assertIsNone(node.target_power_state) - self.assertIsNone(node.last_error) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_ON, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNone(node.last_error) - # 2 notifications should be sent: 1 .start and 1 .end - self.assertEqual(2, mock_notif.call_count) - self.assertEqual(2, mock_notif.return_value.emit.call_count) + # 2 notifications should be sent: 1 .start and 1 .end + self.assertEqual(2, mock_notif.call_count) + self.assertEqual(2, mock_notif.return_value.emit.call_count) - first_notif_args = mock_notif.call_args_list[0][1] - second_notif_args = mock_notif.call_args_list[1][1] + first_notif_args = mock_notif.call_args_list[0][1] + second_notif_args = mock_notif.call_args_list[1][1] - self.assertNotificationEqual(first_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.start', - obj_fields.NotificationLevel.INFO) - self.assertNotificationEqual(second_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.end', - obj_fields.NotificationLevel.INFO) + self.assertNotificationEqual(first_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.start', + obj_fields.NotificationLevel.INFO) + self.assertNotificationEqual(second_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.end', + obj_fields.NotificationLevel.INFO) - def test_node_power_action_power_off(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_off(self, get_power_mock): """Test node_power_action to turn node power off.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - conductor_utils.node_power_action(task, states.POWER_OFF) + conductor_utils.node_power_action(task, states.POWER_OFF) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_power_reboot(self): + @mock.patch.object(fake.FakePower, 'reboot', autospec=True) + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_reboot(self, get_power_mock, reboot_mock): """Test for reboot a node.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, 'reboot') as reboot_mock: - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - conductor_utils.node_power_action(task, states.REBOOT) - self.assertFalse(get_power_mock.called) + conductor_utils.node_power_action(task, states.REBOOT) + self.assertFalse(get_power_mock.called) - node.refresh() - reboot_mock.assert_called_once_with(mock.ANY, timeout=None) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + reboot_mock.assert_called_once_with(mock.ANY, mock.ANY, timeout=None) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_invalid_state(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_invalid_state(self, get_power_mock): """Test for exception when changing to an invalid power state.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - self.assertRaises(exception.InvalidParameterValue, - conductor_utils.node_power_action, - task, - "INVALID_POWER_STATE") + self.assertRaises(exception.InvalidParameterValue, + conductor_utils.node_power_action, + task, + "INVALID_POWER_STATE") - node.refresh() - self.assertFalse(get_power_mock.called) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNotNone(node['last_error']) + node.refresh() + self.assertFalse(get_power_mock.called) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNotNone(node['last_error']) - # last_error is cleared when a new transaction happens - conductor_utils.node_power_action(task, states.POWER_OFF) - node.refresh() - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + # last_error is cleared when a new transaction happens + conductor_utils.node_power_action(task, states.POWER_OFF) + node.refresh() + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) @mock.patch('ironic.objects.node.NodeSetPowerStateNotification') - def test_node_power_action_invalid_state_notify(self, mock_notif): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_invalid_state_notify(self, get_power_mock, + mock_notif): """Test for notification when changing to an invalid power state.""" self.config(notification_level='info') self.config(host='my-host') @@ -246,40 +241,38 @@ class NodePowerActionTestCase(db_base.DbTestCase): mock_notif.__name__ = 'NodeSetPowerStateNotification' node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - self.assertRaises(exception.InvalidParameterValue, - conductor_utils.node_power_action, - task, - "INVALID_POWER_STATE") + self.assertRaises(exception.InvalidParameterValue, + conductor_utils.node_power_action, + task, + "INVALID_POWER_STATE") - node.refresh() - self.assertFalse(get_power_mock.called) - self.assertEqual(states.POWER_ON, node.power_state) - self.assertIsNone(node.target_power_state) - self.assertIsNotNone(node.last_error) + node.refresh() + self.assertFalse(get_power_mock.called) + self.assertEqual(states.POWER_ON, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNotNone(node.last_error) - # 2 notifications should be sent: 1 .start and 1 .error - self.assertEqual(2, mock_notif.call_count) - self.assertEqual(2, mock_notif.return_value.emit.call_count) + # 2 notifications should be sent: 1 .start and 1 .error + self.assertEqual(2, mock_notif.call_count) + self.assertEqual(2, mock_notif.return_value.emit.call_count) - first_notif_args = mock_notif.call_args_list[0][1] - second_notif_args = mock_notif.call_args_list[1][1] + first_notif_args = mock_notif.call_args_list[0][1] + second_notif_args = mock_notif.call_args_list[1][1] - self.assertNotificationEqual(first_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.start', - obj_fields.NotificationLevel.INFO) - self.assertNotificationEqual(second_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.error', - obj_fields.NotificationLevel.ERROR) + self.assertNotificationEqual(first_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.start', + obj_fields.NotificationLevel.INFO) + self.assertNotificationEqual(second_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.error', + obj_fields.NotificationLevel.ERROR) def test_node_power_action_already_being_processed(self): """Test node power action after aborted power action. @@ -292,7 +285,7 @@ class NodePowerActionTestCase(db_base.DbTestCase): """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON, target_power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) @@ -305,7 +298,10 @@ class NodePowerActionTestCase(db_base.DbTestCase): self.assertIsNone(node['last_error']) @mock.patch.object(conductor_utils, 'LOG', autospec=True) - def test_node_power_action_in_same_state(self, log_mock): + @mock.patch.object(fake.FakePower, 'set_power_state', autospec=True) + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_in_same_state(self, get_power_mock, + set_power_mock, log_mock): """Test setting node state to its present state. Test that we don't try to set the power state if the requested @@ -313,32 +309,32 @@ class NodePowerActionTestCase(db_base.DbTestCase): """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - with mock.patch.object(self.driver.power, - 'set_power_state') as set_power_mock: - conductor_utils.node_power_action(task, states.POWER_ON) + conductor_utils.node_power_action(task, states.POWER_ON) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertFalse(set_power_mock.called, - "set_power_state unexpectedly called") - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) - log_mock.warning.assert_called_once_with( - u"Not going to change node %(node)s power state because " - u"current state = requested state = '%(state)s'.", - {'state': states.POWER_ON, 'node': node.uuid}) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertFalse(set_power_mock.called, + "set_power_state unexpectedly called") + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) + log_mock.warning.assert_called_once_with( + u"Not going to change node %(node)s power state because " + u"current state = requested state = '%(state)s'.", + {'state': states.POWER_ON, 'node': node.uuid}) - def test_node_power_action_in_same_state_db_not_in_sync(self): + @mock.patch.object(fake.FakePower, 'set_power_state', autospec=True) + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_in_same_state_db_not_in_sync(self, + get_power_mock, + set_power_mock): """Test setting node state to its present state if DB is out of sync. Under rare conditions (see bug #1403106) database might contain stale @@ -346,53 +342,51 @@ class NodePowerActionTestCase(db_base.DbTestCase): """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_OFF + get_power_mock.return_value = states.POWER_OFF - with mock.patch.object(self.driver.power, - 'set_power_state') as set_power_mock: - conductor_utils.node_power_action(task, states.POWER_OFF) + conductor_utils.node_power_action(task, states.POWER_OFF) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertFalse(set_power_mock.called, - "set_power_state unexpectedly called") - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertFalse(set_power_mock.called, + "set_power_state unexpectedly called") + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_failed_getting_state(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_failed_getting_state(self, get_power_mock): """Test for exception when we can't get the current power state.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_state_mock: - get_power_state_mock.side_effect = ( - exception.InvalidParameterValue('failed getting power state')) + get_power_mock.side_effect = ( + exception.InvalidParameterValue('failed getting power state')) - self.assertRaises(exception.InvalidParameterValue, - conductor_utils.node_power_action, - task, - states.POWER_ON) + self.assertRaises(exception.InvalidParameterValue, + conductor_utils.node_power_action, + task, + states.POWER_ON) - node.refresh() - get_power_state_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNotNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNotNone(node['last_error']) @mock.patch('ironic.objects.node.NodeSetPowerStateNotification') - def test_node_power_action_failed_getting_state_notify(self, mock_notif): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_failed_getting_state_notify(self, + get_power_mock, + mock_notif): """Test for notification when we can't get the current power state.""" self.config(notification_level='info') self.config(host='my-host') @@ -400,73 +394,74 @@ class NodePowerActionTestCase(db_base.DbTestCase): mock_notif.__name__ = 'NodeSetPowerStateNotification' node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_state_mock: - get_power_state_mock.side_effect = ( - exception.InvalidParameterValue('failed getting power state')) + get_power_mock.side_effect = ( + exception.InvalidParameterValue('failed getting power state')) - self.assertRaises(exception.InvalidParameterValue, - conductor_utils.node_power_action, - task, - states.POWER_ON) + self.assertRaises(exception.InvalidParameterValue, + conductor_utils.node_power_action, + task, + states.POWER_ON) - node.refresh() - get_power_state_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_ON, node.power_state) - self.assertIsNone(node.target_power_state) - self.assertIsNotNone(node.last_error) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_ON, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNotNone(node.last_error) - # 2 notifications should be sent: 1 .start and 1 .error - self.assertEqual(2, mock_notif.call_count) - self.assertEqual(2, mock_notif.return_value.emit.call_count) + # 2 notifications should be sent: 1 .start and 1 .error + self.assertEqual(2, mock_notif.call_count) + self.assertEqual(2, mock_notif.return_value.emit.call_count) - first_notif_args = mock_notif.call_args_list[0][1] - second_notif_args = mock_notif.call_args_list[1][1] + first_notif_args = mock_notif.call_args_list[0][1] + second_notif_args = mock_notif.call_args_list[1][1] - self.assertNotificationEqual(first_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.start', - obj_fields.NotificationLevel.INFO) - self.assertNotificationEqual(second_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.error', - obj_fields.NotificationLevel.ERROR) + self.assertNotificationEqual(first_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.start', + obj_fields.NotificationLevel.INFO) + self.assertNotificationEqual(second_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.error', + obj_fields.NotificationLevel.ERROR) - def test_node_power_action_set_power_failure(self): + @mock.patch.object(fake.FakePower, 'set_power_state', autospec=True) + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_set_power_failure(self, get_power_mock, + set_power_mock): """Test if an exception is thrown when the set_power call fails.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - with mock.patch.object(self.driver.power, - 'set_power_state') as set_power_mock: - get_power_mock.return_value = states.POWER_OFF - set_power_mock.side_effect = exception.IronicException() + get_power_mock.return_value = states.POWER_OFF + set_power_mock.side_effect = exception.IronicException() - self.assertRaises( - exception.IronicException, - conductor_utils.node_power_action, - task, - states.POWER_ON) + self.assertRaises( + exception.IronicException, + conductor_utils.node_power_action, + task, + states.POWER_ON) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - set_power_mock.assert_called_once_with( - mock.ANY, states.POWER_ON, timeout=None) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNotNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + set_power_mock.assert_called_once_with( + mock.ANY, mock.ANY, states.POWER_ON, timeout=None) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNotNone(node['last_error']) @mock.patch('ironic.objects.node.NodeSetPowerStateNotification') - def test_node_power_action_set_power_failure_notify(self, mock_notif): + @mock.patch.object(fake.FakePower, 'set_power_state', autospec=True) + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_set_power_failure_notify(self, get_power_mock, + set_power_mock, + mock_notif): """Test if a notification is sent when the set_power call fails.""" self.config(notification_level='info') self.config(host='my-host') @@ -474,109 +469,99 @@ class NodePowerActionTestCase(db_base.DbTestCase): mock_notif.__name__ = 'NodeSetPowerStateNotification' node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - with mock.patch.object(self.driver.power, - 'set_power_state') as set_power_mock: - get_power_mock.return_value = states.POWER_OFF - set_power_mock.side_effect = exception.IronicException() + get_power_mock.return_value = states.POWER_OFF + set_power_mock.side_effect = exception.IronicException() - self.assertRaises( - exception.IronicException, - conductor_utils.node_power_action, - task, - states.POWER_ON) + self.assertRaises( + exception.IronicException, + conductor_utils.node_power_action, + task, + states.POWER_ON) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - set_power_mock.assert_called_once_with( - mock.ANY, states.POWER_ON, timeout=None) - self.assertEqual(states.POWER_OFF, node.power_state) - self.assertIsNone(node.target_power_state) - self.assertIsNotNone(node.last_error) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + set_power_mock.assert_called_once_with( + mock.ANY, mock.ANY, states.POWER_ON, timeout=None) + self.assertEqual(states.POWER_OFF, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNotNone(node.last_error) - # 2 notifications should be sent: 1 .start and 1 .error - self.assertEqual(2, mock_notif.call_count) - self.assertEqual(2, mock_notif.return_value.emit.call_count) + # 2 notifications should be sent: 1 .start and 1 .error + self.assertEqual(2, mock_notif.call_count) + self.assertEqual(2, mock_notif.return_value.emit.call_count) - first_notif_args = mock_notif.call_args_list[0][1] - second_notif_args = mock_notif.call_args_list[1][1] + first_notif_args = mock_notif.call_args_list[0][1] + second_notif_args = mock_notif.call_args_list[1][1] - self.assertNotificationEqual(first_notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.start', - obj_fields.NotificationLevel.INFO) - self.assertNotificationEqual( - second_notif_args, 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.error', - obj_fields.NotificationLevel.ERROR) + self.assertNotificationEqual(first_notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.start', + obj_fields.NotificationLevel.INFO) + self.assertNotificationEqual( + second_notif_args, 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.error', + obj_fields.NotificationLevel.ERROR) - def test_node_power_action_power_on_storage_attach(self): + @mock.patch.object(fake.FakeStorage, 'attach_volumes', autospec=True) + def test_node_power_action_power_on_storage_attach(self, attach_mock): """Test node_power_action to turn node power on and attach storage.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_OFF, - storage_interface="cinder", + storage_interface="fake", provision_state=states.ACTIVE) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(task.driver.storage, - 'attach_volumes', - autospec=True) as attach_mock: - conductor_utils.node_power_action(task, states.POWER_ON) + conductor_utils.node_power_action(task, states.POWER_ON) - node.refresh() - attach_mock.assert_called_once_with(task) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + attach_mock.assert_called_once_with(mock.ANY, task) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_reboot_storage_attach(self): + @mock.patch.object(fake.FakeStorage, 'attach_volumes', autospec=True) + def test_node_power_action_reboot_storage_attach(self, attach_mock): """Test node_power_action to reboot the node and attach storage.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON, - storage_interface="cinder", + storage_interface="fake", provision_state=states.ACTIVE) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(task.driver.storage, - 'attach_volumes', - autospec=True) as attach_mock: - conductor_utils.node_power_action(task, states.REBOOT) + conductor_utils.node_power_action(task, states.REBOOT) - node.refresh() - attach_mock.assert_called_once_with(task) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + attach_mock.assert_called_once_with(mock.ANY, task) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_power_off_storage_detach(self): + @mock.patch.object(fake.FakeStorage, 'detach_volumes', autospec=True) + def test_node_power_action_power_off_storage_detach(self, detach_mock): """Test node_power_action to turn node power off and detach storage.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON, - storage_interface="cinder", + storage_interface="fake", provision_state=states.ACTIVE) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(task.driver.storage, - 'detach_volumes', - autospec=True) as detach_mock: - conductor_utils.node_power_action(task, states.POWER_OFF) + conductor_utils.node_power_action(task, states.POWER_OFF) - node.refresh() - detach_mock.assert_called_once_with(task) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + detach_mock.assert_called_once_with(mock.ANY, task) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) def test__calculate_target_state(self): for new_state in (states.POWER_ON, states.REBOOT, states.SOFT_REBOOT): @@ -589,7 +574,8 @@ class NodePowerActionTestCase(db_base.DbTestCase): conductor_utils._calculate_target_state(new_state)) self.assertIsNone(conductor_utils._calculate_target_state('bad_state')) - def test__can_skip_state_change_different_state(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test__can_skip_state_change_different_state(self, get_power_mock): """Test setting node state to different state. Test that we should change state if requested state is different from @@ -597,23 +583,22 @@ class NodePowerActionTestCase(db_base.DbTestCase): """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - result = conductor_utils._can_skip_state_change( - task, states.POWER_OFF) + result = conductor_utils._can_skip_state_change( + task, states.POWER_OFF) - self.assertFalse(result) - get_power_mock.assert_called_once_with(mock.ANY) + self.assertFalse(result) + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) @mock.patch.object(conductor_utils, 'LOG', autospec=True) - def test__can_skip_state_change_same_state(self, mock_log): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test__can_skip_state_change_same_state(self, get_power_mock, mock_log): """Test setting node state to its present state. Test that we don't try to set the power state if the requested @@ -621,30 +606,29 @@ class NodePowerActionTestCase(db_base.DbTestCase): """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - result = conductor_utils._can_skip_state_change( - task, states.POWER_ON) + result = conductor_utils._can_skip_state_change( + task, states.POWER_ON) - self.assertTrue(result) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertEqual(states.NOSTATE, node['target_power_state']) - self.assertIsNone(node['last_error']) - mock_log.warning.assert_called_once_with( - u"Not going to change node %(node)s power state because " - u"current state = requested state = '%(state)s'.", - {'state': states.POWER_ON, 'node': node.uuid}) + self.assertTrue(result) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertEqual(states.NOSTATE, node['target_power_state']) + self.assertIsNone(node['last_error']) + mock_log.warning.assert_called_once_with( + u"Not going to change node %(node)s power state because " + u"current state = requested state = '%(state)s'.", + {'state': states.POWER_ON, 'node': node.uuid}) - def test__can_skip_state_change_db_not_in_sync(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test__can_skip_state_change_db_not_in_sync(self, get_power_mock): """Test setting node state to its present state if DB is out of sync. Under rare conditions (see bug #1403106) database might contain stale @@ -652,29 +636,27 @@ class NodePowerActionTestCase(db_base.DbTestCase): """ node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', last_error='anything but None', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_OFF + get_power_mock.return_value = states.POWER_OFF - result = conductor_utils._can_skip_state_change( - task, states.POWER_OFF) + result = conductor_utils._can_skip_state_change(task, states.POWER_OFF) - self.assertTrue(result) + self.assertTrue(result) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertEqual(states.NOSTATE, node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertEqual(states.NOSTATE, node['target_power_state']) + self.assertIsNone(node['last_error']) @mock.patch('ironic.objects.node.NodeSetPowerStateNotification') + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) def test__can_skip_state_change_failed_getting_state_notify( - self, mock_notif): + self, get_power_mock, mock_notif): """Test for notification & exception when can't get power state. Test to make sure we generate a notification and also that an exception @@ -686,36 +668,34 @@ class NodePowerActionTestCase(db_base.DbTestCase): mock_notif.__name__ = 'NodeSetPowerStateNotification' node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_state_mock: - get_power_state_mock.side_effect = ( - exception.InvalidParameterValue('failed getting power state')) + get_power_mock.side_effect = ( + exception.InvalidParameterValue('failed getting power state')) - self.assertRaises(exception.InvalidParameterValue, - conductor_utils._can_skip_state_change, - task, - states.POWER_ON) + self.assertRaises(exception.InvalidParameterValue, + conductor_utils._can_skip_state_change, + task, + states.POWER_ON) - node.refresh() - get_power_state_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_ON, node.power_state) - self.assertEqual(states.NOSTATE, node['target_power_state']) - self.assertIsNotNone(node.last_error) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_ON, node.power_state) + self.assertEqual(states.NOSTATE, node['target_power_state']) + self.assertIsNotNone(node.last_error) - # 1 notification should be sent for the error - self.assertEqual(1, mock_notif.call_count) - self.assertEqual(1, mock_notif.return_value.emit.call_count) + # 1 notification should be sent for the error + self.assertEqual(1, mock_notif.call_count) + self.assertEqual(1, mock_notif.return_value.emit.call_count) - notif_args = mock_notif.call_args_list[0][1] + notif_args = mock_notif.call_args_list[0][1] - self.assertNotificationEqual(notif_args, - 'ironic-conductor', CONF.host, - 'baremetal.node.power_set.error', - obj_fields.NotificationLevel.ERROR) + self.assertNotificationEqual(notif_args, + 'ironic-conductor', CONF.host, + 'baremetal.node.power_set.error', + obj_fields.NotificationLevel.ERROR) def test_node_power_action_reboot_no_timeout(self): """Test node reboot using Power Interface with no timeout arg.""" @@ -748,113 +728,103 @@ class NodePowerActionTestCase(db_base.DbTestCase): class NodeSoftPowerActionTestCase(db_base.DbTestCase): - def setUp(self): - super(NodeSoftPowerActionTestCase, self).setUp() - self.config(enabled_drivers=['fake_soft_power']) - self.driver = driver_factory.get_driver("fake_soft_power") - - def test_node_power_action_power_soft_reboot(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_soft_reboot(self, get_power_mock): """Test for soft reboot a node.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake_soft_power', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - conductor_utils.node_power_action(task, states.SOFT_REBOOT) + conductor_utils.node_power_action(task, states.SOFT_REBOOT) - node.refresh() - self.assertFalse(get_power_mock.called) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + self.assertFalse(get_power_mock.called) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_power_soft_reboot_timeout(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_soft_reboot_timeout(self, get_power_mock): """Test for soft reboot a node.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake_soft_power', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - conductor_utils.node_power_action(task, states.SOFT_REBOOT, - timeout=2) + conductor_utils.node_power_action(task, states.SOFT_REBOOT, + timeout=2) - node.refresh() - self.assertFalse(get_power_mock.called) - self.assertEqual(states.POWER_ON, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + self.assertFalse(get_power_mock.called) + self.assertEqual(states.POWER_ON, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_soft_power_off(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_soft_power_off(self, get_power_mock): """Test node_power_action to turn node soft power off.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake_soft_power', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - conductor_utils.node_power_action(task, states.SOFT_POWER_OFF) + conductor_utils.node_power_action(task, states.SOFT_POWER_OFF) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_soft_power_off_timeout(self): + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_soft_power_off_timeout(self, get_power_mock): """Test node_power_action to turn node soft power off.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake_soft_power', + driver='fake-hardware', power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(self.driver.power, - 'get_power_state') as get_power_mock: - get_power_mock.return_value = states.POWER_ON + get_power_mock.return_value = states.POWER_ON - conductor_utils.node_power_action(task, states.SOFT_POWER_OFF, - timeout=2) + conductor_utils.node_power_action(task, states.SOFT_POWER_OFF, + timeout=2) - node.refresh() - get_power_mock.assert_called_once_with(mock.ANY) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) - def test_node_power_action_soft_power_off_storage_detach(self): + @mock.patch.object(fake.FakeStorage, 'detach_volumes', autospec=True) + def test_node_power_action_soft_power_off_storage_detach(self, + detach_mock): """Test node_power_action to soft power off node and detach storage.""" node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), - driver='fake_soft_power', + driver='fake-hardware', power_state=states.POWER_ON, - storage_interface="cinder", + storage_interface="fake", provision_state=states.ACTIVE) task = task_manager.TaskManager(self.context, node.uuid) - with mock.patch.object(task.driver.storage, - 'detach_volumes', - autospec=True) as detach_mock: - conductor_utils.node_power_action(task, states.SOFT_POWER_OFF) + conductor_utils.node_power_action(task, states.SOFT_POWER_OFF) - node.refresh() - detach_mock.assert_called_once_with(task) - self.assertEqual(states.POWER_OFF, node['power_state']) - self.assertIsNone(node['target_power_state']) - self.assertIsNone(node['last_error']) + node.refresh() + detach_mock.assert_called_once_with(mock.ANY, task) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertIsNone(node['target_power_state']) + self.assertIsNone(node['last_error']) class CleanupAfterTimeoutTestCase(tests_base.TestCase): @@ -922,13 +892,15 @@ class NodeCleaningStepsTestCase(db_base.DbTestCase): 'argsinfo': {'arg1': {'description': 'desc1', 'required': True}, 'arg2': {'description': 'desc2'}}} + @mock.patch('ironic.drivers.modules.fake.FakeBIOS.get_clean_steps', + lambda self, task: []) @mock.patch('ironic.drivers.modules.fake.FakeDeploy.get_clean_steps') @mock.patch('ironic.drivers.modules.fake.FakePower.get_clean_steps') def test__get_cleaning_steps(self, mock_power_steps, mock_deploy_steps): # Test getting cleaning steps, with one driver returning None, two # conflicting priorities, and asserting they are ordered properly. node = obj_utils.create_test_node( - self.context, driver='fake', + self.context, driver='fake-hardware', provision_state=states.CLEANING, target_provision_state=states.AVAILABLE) @@ -942,12 +914,14 @@ class NodeCleaningStepsTestCase(db_base.DbTestCase): self.assertEqual(self.clean_steps, steps) + @mock.patch('ironic.drivers.modules.fake.FakeBIOS.get_clean_steps', + lambda self, task: []) @mock.patch('ironic.drivers.modules.fake.FakeDeploy.get_clean_steps') @mock.patch('ironic.drivers.modules.fake.FakePower.get_clean_steps') def test__get_cleaning_steps_unsorted(self, mock_power_steps, mock_deploy_steps): node = obj_utils.create_test_node( - self.context, driver='fake', + self.context, driver='fake-hardware', provision_state=states.CLEANING, target_provision_state=states.MANAGEABLE) @@ -968,7 +942,7 @@ class NodeCleaningStepsTestCase(db_base.DbTestCase): # conflicting priorities, and asserting they are ordered properly. # Should discard zero-priority (manual) clean step node = obj_utils.create_test_node( - self.context, driver='fake', + self.context, driver='fake-hardware', provision_state=states.CLEANING, target_provision_state=states.AVAILABLE) @@ -990,7 +964,7 @@ class NodeCleaningStepsTestCase(db_base.DbTestCase): mock_steps.return_value = self.clean_steps node = obj_utils.create_test_node( - self.context, driver='fake', + self.context, driver='fake-hardware', provision_state=states.CLEANING, target_provision_state=states.AVAILABLE, last_error=None, @@ -1015,7 +989,7 @@ class NodeCleaningStepsTestCase(db_base.DbTestCase): mock_validate_user_steps.return_value = clean_steps node = obj_utils.create_test_node( - self.context, driver='fake', + self.context, driver='fake-hardware', provision_state=states.CLEANING, target_provision_state=states.MANAGEABLE, last_error=None, @@ -1439,7 +1413,8 @@ class ValidatePortPhysnetTestCase(db_base.DbTestCase): def setUp(self): super(ValidatePortPhysnetTestCase, self).setUp() - self.node = obj_utils.create_test_node(self.context, driver='fake') + self.node = obj_utils.create_test_node(self.context, + driver='fake-hardware') @mock.patch.object(objects.Port, 'obj_what_changed') def test_validate_port_physnet_no_portgroup_create(self, mock_owc): @@ -1758,7 +1733,7 @@ class MiscTestCase(db_base.DbTestCase): super(MiscTestCase, self).setUp() self.node = obj_utils.create_test_node( self.context, - driver='fake', + driver='fake-hardware', instance_info={'rescue_password': 'pass'}) def _test_remove_node_rescue_password(self, save=True): @@ -1781,7 +1756,8 @@ class ValidateInstanceInfoTraitsTestCase(tests_base.TestCase): def setUp(self): super(ValidateInstanceInfoTraitsTestCase, self).setUp() - self.node = obj_utils.get_test_node(self.context, driver='fake', + self.node = obj_utils.get_test_node(self.context, + driver='fake-hardware', traits=['trait1', 'trait2']) def test_validate_instance_info_traits_no_instance_traits(self): diff --git a/ironic/tests/unit/db/utils.py b/ironic/tests/unit/db/utils.py index e6427dc872..1d690b14b2 100644 --- a/ironic/tests/unit/db/utils.py +++ b/ironic/tests/unit/db/utils.py @@ -179,7 +179,7 @@ def get_test_node(**kw): 'last_error': kw.get('last_error'), 'instance_uuid': kw.get('instance_uuid'), 'instance_info': kw.get('instance_info', fake_instance_info), - 'driver': kw.get('driver', 'fake'), + 'driver': kw.get('driver', 'fake-hardware'), 'driver_info': kw.get('driver_info', fake_driver_info), 'driver_internal_info': kw.get('driver_internal_info', fake_internal_info), diff --git a/ironic/tests/unit/dhcp/test_factory.py b/ironic/tests/unit/dhcp/test_factory.py index 13c434b506..b72a565b18 100644 --- a/ironic/tests/unit/dhcp/test_factory.py +++ b/ironic/tests/unit/dhcp/test_factory.py @@ -31,7 +31,6 @@ class TestDHCPFactory(base.TestCase): def setUp(self): super(TestDHCPFactory, self).setUp() - self.config(enabled_drivers=['fake']) self.config(url='test-url', url_timeout=30, group='neutron') diff --git a/ironic/tests/unit/drivers/modules/ansible/test_deploy.py b/ironic/tests/unit/drivers/modules/ansible/test_deploy.py index 6c21dc76ea..e2eacb71b5 100644 --- a/ironic/tests/unit/drivers/modules/ansible/test_deploy.py +++ b/ironic/tests/unit/drivers/modules/ansible/test_deploy.py @@ -55,10 +55,10 @@ class AnsibleDeployTestCaseBase(db_base.DbTestCase): def setUp(self): super(AnsibleDeployTestCaseBase, self).setUp() - self.config(enabled_hardware_types='manual-management', - enabled_deploy_interfaces='ansible', - enabled_power_interfaces='fake', - enabled_management_interfaces='fake') + self.config(enabled_hardware_types=['manual-management'], + enabled_deploy_interfaces=['ansible'], + enabled_power_interfaces=['fake'], + enabled_management_interfaces=['fake']) node = { 'driver': 'manual-management', 'instance_info': INSTANCE_INFO, diff --git a/ironic/tests/unit/drivers/modules/network/test_common.py b/ironic/tests/unit/drivers/modules/network/test_common.py index a68867244b..ac9d4e4a4c 100644 --- a/ironic/tests/unit/drivers/modules/network/test_common.py +++ b/ironic/tests/unit/drivers/modules/network/test_common.py @@ -29,7 +29,6 @@ class TestCommonFunctions(db_base.DbTestCase): def setUp(self): super(TestCommonFunctions, self).setUp() - self.config(enabled_drivers=['fake']) self.node = obj_utils.create_test_node(self.context, network_interface='neutron') self.port = obj_utils.create_test_port( @@ -436,7 +435,6 @@ class TestVifPortIDMixin(db_base.DbTestCase): def setUp(self): super(TestVifPortIDMixin, self).setUp() - self.config(enabled_drivers=['fake']) self.interface = common.VIFPortIDMixin() self.node = obj_utils.create_test_node(self.context, network_interface='neutron') @@ -660,7 +658,6 @@ class TestNeutronVifPortIDMixin(db_base.DbTestCase): def setUp(self): super(TestNeutronVifPortIDMixin, self).setUp() - self.config(enabled_drivers=['fake']) self.interface = common.NeutronVIFPortIDMixin() self.node = obj_utils.create_test_node(self.context, network_interface='neutron') diff --git a/ironic/tests/unit/drivers/modules/network/test_flat.py b/ironic/tests/unit/drivers/modules/network/test_flat.py index 5cb9075ac9..31462c3fb9 100644 --- a/ironic/tests/unit/drivers/modules/network/test_flat.py +++ b/ironic/tests/unit/drivers/modules/network/test_flat.py @@ -30,7 +30,6 @@ class TestFlatInterface(db_base.DbTestCase): def setUp(self): super(TestFlatInterface, self).setUp() - self.config(enabled_drivers=['fake']) self.interface = flat_interface.FlatNetwork() self.node = utils.create_test_node(self.context) self.port = utils.create_test_port( diff --git a/ironic/tests/unit/drivers/modules/network/test_noop.py b/ironic/tests/unit/drivers/modules/network/test_noop.py index 0d969131e4..156af25df4 100644 --- a/ironic/tests/unit/drivers/modules/network/test_noop.py +++ b/ironic/tests/unit/drivers/modules/network/test_noop.py @@ -20,7 +20,6 @@ class NoopInterfaceTestCase(db_base.DbTestCase): def setUp(self): super(NoopInterfaceTestCase, self).setUp() - self.config(enabled_drivers=['fake']) self.interface = noop.NoopNetwork() self.node = utils.create_test_node(self.context, network_interface='noop') diff --git a/ironic/tests/unit/drivers/modules/storage/test_cinder.py b/ironic/tests/unit/drivers/modules/storage/test_cinder.py index afcfada426..b2f6a45536 100644 --- a/ironic/tests/unit/drivers/modules/storage/test_cinder.py +++ b/ironic/tests/unit/drivers/modules/storage/test_cinder.py @@ -35,13 +35,15 @@ class CinderInterfaceTestCase(db_base.DbTestCase): self.config(action_retries=3, action_retry_interval=0, group='cinder') - self.config(enabled_storage_interfaces=['noop', 'cinder']) + self.config(enabled_boot_interfaces=['fake'], + enabled_storage_interfaces=['noop', 'cinder']) self.interface = cinder.CinderStorage() + self.node = object_utils.create_test_node(self.context, + boot_interface='fake', + storage_interface='cinder') @mock.patch.object(cinder, 'LOG', autospec=True) def test__fail_validation(self, mock_log): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') """Ensure the validate helper logs and raises exceptions.""" fake_error = 'a error!' expected = ("Failed to validate cinder storage interface for node " @@ -55,8 +57,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test__generate_connector_raises_with_insufficent_data(self, mock_log): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') with task_manager.acquire(self.context, self.node.id) as task: self.assertRaises(exception.StorageError, self.interface._generate_connector, @@ -64,8 +64,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): self.assertTrue(mock_log.error.called) def test__generate_connector_iscsi(self): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') expected = { 'initiator': 'iqn.address', 'ip': 'ip.address', @@ -84,8 +82,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test__generate_connector_iscsi_and_unknown(self, mock_log): """Validate we return and log with valid and invalid connectors.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') expected = { 'initiator': 'iqn.address', 'host': self.node.uuid, @@ -104,8 +100,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test__generate_connector_unknown_raises_excption(self, mock_log): """Validate an exception is raised with only an invalid connector.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='foo', connector_id='bar') @@ -119,8 +113,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): def test__generate_connector_single_path(self): """Validate an exception is raised with only an invalid connector.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') expected = { 'initiator': 'iqn.address', 'host': self.node.uuid} @@ -132,8 +124,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): self.assertDictEqual(expected, return_value) def test__generate_connector_multiple_fc_wwns(self): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') """Validate handling of WWPNs and WWNNs.""" expected = { 'wwpns': ['wwpn1', 'wwpn2'], @@ -171,8 +161,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder.CinderStorage, '_fail_validation', autospec=True) @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_success_no_settings(self, mock_log, mock_fail): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') with task_manager.acquire(self.context, self.node.id) as task: self.interface.validate(task) self.assertFalse(mock_fail.called) @@ -180,9 +168,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_failure_if_iscsi_boot_no_connectors(self, mock_log): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') - valid_types = ', '.join(cinder.VALID_ISCSI_TYPES) expected_msg = ("Failed to validate cinder storage interface for node " "%(id)s. In order to enable the 'iscsi_boot' " @@ -200,8 +185,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_failure_if_fc_boot_no_connectors(self, mock_log): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') valid_types = ', '.join(cinder.VALID_FC_TYPES) expected_msg = ("Failed to validate cinder storage interface for node " "%(id)s. In order to enable the 'fibre_channel_boot' " @@ -222,8 +205,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_success_iscsi_connector(self, mock_log, mock_fail): """Perform validate with only an iSCSI connector in place.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='iqn', connector_id='iqn.address') @@ -236,8 +217,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_success_fc_connectors(self, mock_log, mock_fail): """Perform validate with only FC connectors in place""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='wwpn', connector_id='wwpn.address', uuid=uuidutils.generate_uuid()) @@ -253,8 +232,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_success_connectors_and_boot(self, mock_log, mock_fail): """Perform validate with volume connectors and boot capabilities.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='iqn', connector_id='iqn.address', uuid=uuidutils.generate_uuid()) @@ -277,8 +254,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_success_iscsi_targets(self, mock_log, mock_fail): """Validate success with full iscsi scenario.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='iqn', connector_id='iqn.address', uuid=uuidutils.generate_uuid()) @@ -295,8 +270,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_success_fc_targets(self, mock_log, mock_fail): """Validate success with full fc scenario.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='wwpn', connector_id='fc.address', uuid=uuidutils.generate_uuid()) @@ -318,8 +291,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): def test_validate_fails_with_ipxe_not_enabled(self, mock_log): """Ensure a validation failure is raised when iPXE not enabled.""" self.config(ipxe_enabled=False, group='pxe') - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='iqn', connector_id='foo.address') @@ -336,8 +307,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_fails_when_fc_connectors_unequal(self, mock_log): """Validate should fail with only wwnn FC connector in place""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='wwnn', connector_id='wwnn.address') @@ -350,8 +319,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_fail_on_unknown_volume_types(self, mock_log): """Ensure exception is raised when connector/target do not match.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='iqn', connector_id='foo.address') @@ -368,8 +335,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_fails_iscsi_conn_fc_target(self, mock_log): """Validate failure of iSCSI connectors with FC target.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='iqn', connector_id='foo.address') @@ -386,8 +351,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_validate_fails_fc_conn_iscsi_target(self, mock_log): """Validate failure of FC connectors with iSCSI target.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_connector( self.context, node_id=self.node.id, type='fibre_channel', connector_id='foo.address') @@ -408,8 +371,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG') def test_attach_detach_volumes_no_volumes(self, mock_log, mock_attach, mock_detach): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') with task_manager.acquire(self.context, self.node.id) as task: self.interface.attach_volumes(task) self.interface.detach_volumes(task) @@ -424,8 +385,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): mock_attach, mock_detach): """Without connectors, attach and detach should fail.""" - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') @@ -447,8 +406,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): mock_log, mock_attach, mock_detach): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') target_uuid = uuidutils.generate_uuid() test_volume_target = object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', @@ -481,9 +438,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder, 'LOG', autospec=True) def test_attach_volumes_failure(self, mock_log, mock_attach, mock_detach): """Verify detach is called upon attachment failing.""" - - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') @@ -516,8 +470,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): Volume attachment fails if the number of attachments completed does not match the number of configured targets. """ - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') @@ -538,8 +490,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): @mock.patch.object(cinder_common, 'detach_volumes', autospec=True) @mock.patch.object(cinder, 'LOG', autospec=True) def test_detach_volumes_failure(self, mock_log, mock_detach): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') @@ -568,8 +518,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): def test_detach_volumes_failure_raises_exception(self, mock_log, mock_detach): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') @@ -589,8 +537,6 @@ class CinderInterfaceTestCase(db_base.DbTestCase): self.assertEqual(4, mock_detach.call_count) def test_should_write_image(self): - self.node = object_utils.create_test_node(self.context, - storage_interface='cinder') object_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') diff --git a/ironic/tests/unit/drivers/modules/test_deploy_utils.py b/ironic/tests/unit/drivers/modules/test_deploy_utils.py index 331645b4e4..28f93be8ed 100644 --- a/ironic/tests/unit/drivers/modules/test_deploy_utils.py +++ b/ironic/tests/unit/drivers/modules/test_deploy_utils.py @@ -975,7 +975,8 @@ class GetPxeBootConfigTestCase(db_base.DbTestCase): def setUp(self): super(GetPxeBootConfigTestCase, self).setUp() - self.node = obj_utils.get_test_node(self.context, driver='fake') + self.node = obj_utils.get_test_node(self.context, + driver='fake-hardware') self.config(pxe_bootfile_name='bios-bootfile', group='pxe') self.config(uefi_pxe_bootfile_name='uefi-bootfile', group='pxe') self.config(pxe_config_template='bios-template', group='pxe') @@ -1308,7 +1309,8 @@ class ParseInstanceInfoCapabilitiesTestCase(tests_base.TestCase): def setUp(self): super(ParseInstanceInfoCapabilitiesTestCase, self).setUp() - self.node = obj_utils.get_test_node(self.context, driver='fake') + self.node = obj_utils.get_test_node(self.context, + driver='fake-hardware') def test_parse_instance_info_capabilities_string(self): self.node.instance_info = {'capabilities': '{"cat": "meow"}'} @@ -1440,7 +1442,8 @@ class TrySetBootDeviceTestCase(db_base.DbTestCase): def setUp(self): super(TrySetBootDeviceTestCase, self).setUp() - self.node = obj_utils.create_test_node(self.context, driver="fake") + self.node = obj_utils.create_test_node(self.context, + driver="fake-hardware") @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) def test_try_set_boot_device_okay(self, node_set_boot_device_mock): @@ -2380,7 +2383,8 @@ class TestStorageInterfaceUtils(db_base.DbTestCase): def setUp(self): super(TestStorageInterfaceUtils, self).setUp() self.node = obj_utils.create_test_node(self.context, - driver='fake') + driver='fake-hardware') + self.config(enabled_storage_interfaces=['noop', 'fake', 'cinder']) def test_check_interface_capability(self): class fake_driver(object): @@ -2415,18 +2419,14 @@ class TestStorageInterfaceUtils(db_base.DbTestCase): self.context, self.node.uuid, shared=False) as task: self.assertIsNone(utils.get_remote_boot_volume(task)) - @mock.patch.object(fake, 'FakeBoot', autospec=True) - @mock.patch.object(fake, 'FakeDeploy', autospec=True) + @mock.patch.object(fake.FakeBoot, 'capabilities', + ['iscsi_volume_boot'], create=True) + @mock.patch.object(fake.FakeDeploy, 'capabilities', + ['iscsi_volume_deploy'], create=True) @mock.patch.object(cinder.CinderStorage, 'should_write_image', autospec=True) def test_populate_storage_driver_internal_info_iscsi(self, - mock_should_write, - mock_deploy, - mock_boot): - mock_deploy.return_value = mock.Mock( - capabilities=['iscsi_volume_deploy']) - mock_boot.return_value = mock.Mock( - capabilities=['iscsi_volume_boot']) + mock_should_write): mock_should_write.return_value = True vol_uuid = uuidutils.generate_uuid() obj_utils.create_test_volume_target( @@ -2453,18 +2453,14 @@ class TestStorageInterfaceUtils(db_base.DbTestCase): task.node.driver_internal_info.get('boot_from_volume_deploy', None)) - @mock.patch.object(fake, 'FakeBoot', autospec=True) - @mock.patch.object(fake, 'FakeDeploy', autospec=True) + @mock.patch.object(fake.FakeBoot, 'capabilities', + ['fibre_channel_volume_boot'], create=True) + @mock.patch.object(fake.FakeDeploy, 'capabilities', + ['fibre_channel_volume_deploy'], create=True) @mock.patch.object(cinder.CinderStorage, 'should_write_image', autospec=True) def test_populate_storage_driver_internal_info_fc(self, - mock_should_write, - mock_deploy, - mock_boot): - mock_deploy.return_value = mock.Mock( - capabilities=['fibre_channel_volume_deploy']) - mock_boot.return_value = mock.Mock( - capabilities=['fibre_channel_volume_boot']) + mock_should_write): mock_should_write.return_value = True self.node.storage_interface = "cinder" self.node.save() @@ -2487,15 +2483,11 @@ class TestStorageInterfaceUtils(db_base.DbTestCase): task.node.driver_internal_info.get('boot_from_volume_deploy', None)) - @mock.patch.object(fake, 'FakeBoot', autospec=True) - @mock.patch.object(fake, 'FakeDeploy', autospec=True) - def test_populate_storage_driver_internal_info_error( - self, mock_deploy, mock_boot): - mock_deploy.return_value = mock.Mock( - capabilities=['fibre_channel_volume_deploy']) - mock_boot.return_value = mock.Mock( - capabilities=['fibre_channel_volume_boot']) - + @mock.patch.object(fake.FakeBoot, 'capabilities', + ['fibre_channel_volume_boot'], create=True) + @mock.patch.object(fake.FakeDeploy, 'capabilities', + ['fibre_channel_volume_deploy'], create=True) + def test_populate_storage_driver_internal_info_error(self): obj_utils.create_test_volume_target( self.context, node_id=self.node.id, volume_type='iscsi', boot_index=0, volume_id='1234') diff --git a/ironic/tests/unit/drivers/test_fake.py b/ironic/tests/unit/drivers/test_fake_hardware.py similarity index 89% rename from ironic/tests/unit/drivers/test_fake.py rename to ironic/tests/unit/drivers/test_fake_hardware.py index 0d6df7a3a2..7091db4a50 100644 --- a/ironic/tests/unit/drivers/test_fake.py +++ b/ironic/tests/unit/drivers/test_fake_hardware.py @@ -17,28 +17,24 @@ """Test class for Fake driver.""" -import mock from ironic.common import boot_devices -from ironic.common import driver_factory from ironic.common import exception from ironic.common import states from ironic.conductor import task_manager from ironic.drivers import base as driver_base from ironic.tests.unit.db import base as db_base -from ironic.tests.unit.objects import utils as obj_utils +from ironic.tests.unit.db import utils as db_utils -class FakeDriverTestCase(db_base.DbTestCase): +class FakeHardwareTestCase(db_base.DbTestCase): def setUp(self): - super(FakeDriverTestCase, self).setUp() - 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 + super(FakeHardwareTestCase, self).setUp() + self.node = db_utils.create_test_node() + self.task = task_manager.acquire(self.context, self.node.id) + self.addCleanup(self.task.release_resources) + self.driver = self.task.driver def test_driver_interfaces(self): self.assertIsInstance(self.driver.power, driver_base.PowerInterface) @@ -49,7 +45,7 @@ class FakeDriverTestCase(db_base.DbTestCase): driver_base.ConsoleInterface) def test_get_properties(self): - expected = ['A1', 'A2', 'B1', 'B2'] + expected = ['B1', 'B2'] properties = self.driver.get_properties() self.assertEqual(sorted(expected), sorted(properties)) diff --git a/ironic/tests/unit/drivers/test_generic.py b/ironic/tests/unit/drivers/test_generic.py index fd70b44050..e1f4a90936 100644 --- a/ironic/tests/unit/drivers/test_generic.py +++ b/ironic/tests/unit/drivers/test_generic.py @@ -34,8 +34,7 @@ class ManualManagementHardwareTestCase(db_base.DbTestCase): super(ManualManagementHardwareTestCase, self).setUp() self.config(enabled_hardware_types=['manual-management'], enabled_power_interfaces=['fake'], - enabled_management_interfaces=['fake'], - enabled_inspect_interfaces=['no-inspect']) + enabled_management_interfaces=['fake']) self.config(enabled=True, group='inspector') def test_default_interfaces(self): @@ -50,7 +49,8 @@ class ManualManagementHardwareTestCase(db_base.DbTestCase): self.assertIsInstance(task.driver.raid, noop.NoRAID) def test_supported_interfaces(self): - self.config(enabled_inspect_interfaces=['inspector', 'no-inspect']) + self.config(enabled_inspect_interfaces=['inspector', 'no-inspect'], + enabled_raid_interfaces=['agent']) node = obj_utils.create_test_node(self.context, driver='manual-management', deploy_interface='direct', diff --git a/ironic/tests/unit/drivers/test_utils.py b/ironic/tests/unit/drivers/test_utils.py index 115550b7c6..b09915704f 100644 --- a/ironic/tests/unit/drivers/test_utils.py +++ b/ironic/tests/unit/drivers/test_utils.py @@ -20,7 +20,6 @@ import mock from oslo_config import cfg from oslo_utils import timeutils -from ironic.common import driver_factory from ironic.common import exception from ironic.common import swift from ironic.conductor import task_manager @@ -37,32 +36,8 @@ class UtilsTestCase(db_base.DbTestCase): def setUp(self): super(UtilsTestCase, self).setUp() - self.driver = driver_factory.get_driver("fake") self.node = obj_utils.create_test_node(self.context) - def test_vendor_interface_get_properties(self): - expected = {'A1': 'A1 description. Required.', - 'A2': 'A2 description. Optional.', - 'B1': 'B1 description. Required.', - 'B2': 'B2 description. Required.'} - props = self.driver.vendor.get_properties() - self.assertEqual(expected, props) - - @mock.patch.object(fake.FakeVendorA, 'validate', autospec=True) - def test_vendor_interface_validate_valid_methods(self, - mock_fakea_validate): - with task_manager.acquire(self.context, self.node.uuid) as task: - self.driver.vendor.validate(task, method='first_method') - mock_fakea_validate.assert_called_once_with( - self.driver.vendor.mapping['first_method'], - task, method='first_method') - - def test_vendor_interface_validate_bad_method(self): - with task_manager.acquire(self.context, self.node.uuid) as task: - self.assertRaises(exception.InvalidParameterValue, - self.driver.vendor.validate, - task, method='fake_method') - def test_get_node_mac_addresses(self): ports = [] ports.append( @@ -378,3 +353,41 @@ class UtilsRamdiskLogsTestCase(tests_base.TestCase): mock_makedirs.assert_called_once_with(log_path) mock_logs_name.assert_called_once_with(self.node, label=None) + + +class MixinVendorInterfaceTestCase(db_base.DbTestCase): + + def setUp(self): + super(MixinVendorInterfaceTestCase, self).setUp() + self.a = fake.FakeVendorA() + self.b = fake.FakeVendorB() + self.mapping = {'first_method': self.a, + 'second_method': self.b, + 'third_method_sync': self.b, + 'fourth_method_shared_lock': self.b} + self.vendor = driver_utils.MixinVendorInterface(self.mapping) + self.node = obj_utils.create_test_node(self.context, + driver='fake-hardware') + + def test_vendor_interface_get_properties(self): + expected = {'A1': 'A1 description. Required.', + 'A2': 'A2 description. Optional.', + 'B1': 'B1 description. Required.', + 'B2': 'B2 description. Required.'} + props = self.vendor.get_properties() + self.assertEqual(expected, props) + + @mock.patch.object(fake.FakeVendorA, 'validate', autospec=True) + def test_vendor_interface_validate_valid_methods(self, + mock_fakea_validate): + with task_manager.acquire(self.context, self.node.uuid) as task: + self.vendor.validate(task, method='first_method') + mock_fakea_validate.assert_called_once_with( + self.vendor.mapping['first_method'], + task, method='first_method') + + def test_vendor_interface_validate_bad_method(self): + with task_manager.acquire(self.context, self.node.uuid) as task: + self.assertRaises(exception.InvalidParameterValue, + self.vendor.validate, + task, method='fake_method')