From 7fcca34de6347b1f5c5eb76a292e7f50086a135a Mon Sep 17 00:00:00 2001 From: Dmitry Tantsur Date: Fri, 25 May 2018 16:09:35 +0200 Subject: [PATCH] Completely stop using the "fake" classic driver in unit tests This change makes "fake-hardware" the default driver for test nodes and makes enabled_drivers empty in the base test class. Note that some unit test coverage for classic drivers is lost because of this change. It is fine, because the classic drivers themselves are deprecated and will be removed soon. Change-Id: I06acb5aed24ef952db3f9e6987e5a90c81e96401 --- ironic/tests/base.py | 24 +- .../unit/api/controllers/v1/test_driver.py | 17 +- .../unit/api/controllers/v1/test_node.py | 29 +- .../tests/unit/common/test_driver_factory.py | 284 +------ ironic/tests/unit/common/test_network.py | 23 +- ironic/tests/unit/common/test_pxe_utils.py | 2 + ironic/tests/unit/common/test_raid.py | 3 +- ironic/tests/unit/conductor/mgr_utils.py | 16 - .../tests/unit/conductor/test_base_manager.py | 19 - ironic/tests/unit/conductor/test_manager.py | 341 +------- .../tests/unit/conductor/test_task_manager.py | 2 +- ironic/tests/unit/conductor/test_utils.py | 794 +++++++++--------- ironic/tests/unit/db/utils.py | 2 +- ironic/tests/unit/dhcp/test_factory.py | 1 - .../drivers/modules/ansible/test_deploy.py | 8 +- .../drivers/modules/network/test_common.py | 3 - .../unit/drivers/modules/network/test_flat.py | 1 - .../unit/drivers/modules/network/test_noop.py | 1 - .../drivers/modules/storage/test_cinder.py | 64 +- .../unit/drivers/modules/test_deploy_utils.py | 54 +- .../{test_fake.py => test_fake_hardware.py} | 20 +- ironic/tests/unit/drivers/test_generic.py | 6 +- ironic/tests/unit/drivers/test_utils.py | 63 +- 23 files changed, 581 insertions(+), 1196 deletions(-) rename ironic/tests/unit/drivers/{test_fake.py => test_fake_hardware.py} (89%) 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 e04eb2da4f..c95daea58d 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', @@ -2317,7 +2315,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() @@ -2421,22 +2418,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') @@ -3961,7 +3944,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')