diff options
Diffstat (limited to 'ironic/tests')
19 files changed, 763 insertions, 344 deletions
diff --git a/ironic/tests/unit/api/controllers/v1/test_node.py b/ironic/tests/unit/api/controllers/v1/test_node.py index d56652b1e..87a029057 100644 --- a/ironic/tests/unit/api/controllers/v1/test_node.py +++ b/ironic/tests/unit/api/controllers/v1/test_node.py @@ -44,8 +44,8 @@ from ironic.common import indicator_states from ironic.common import policy from ironic.common import states from ironic.conductor import rpcapi +from ironic.conf import CONF from ironic.drivers.modules import inspect_utils -from ironic.drivers.modules import inspector from ironic import objects from ironic.objects import fields as obj_fields from ironic import tests as tests_root @@ -54,7 +54,6 @@ from ironic.tests.unit.api import base as test_api_base from ironic.tests.unit.api import utils as test_api_utils from ironic.tests.unit.objects import utils as obj_utils -CONF = inspector.CONF with open( os.path.join( @@ -844,6 +843,64 @@ class TestListNodes(test_api_base.BaseApiTest): self.assertIn('retired_reason', data['nodes'][0]) self.assertIn('network_data', data['nodes'][0]) + def test_detail_snmpv3(self): + driver_info = { + 'snmp_version': 3, + 'snmp_user': 'test-user', + 'snmp_auth_protocol': 'sha', + 'snmp_auth_key': 'test-auth-key', + 'snmp_priv_protocol': 'aes', + 'snmp_priv_key': 'test-priv-key' + } + sanitized_driver_info = driver_info.copy() + sanitized_driver_info['snmp_auth_key'] = '******' + sanitized_driver_info['snmp_priv_key'] = '******' + + node = obj_utils.create_test_node(self.context, + chassis_id=self.chassis.id, + driver_info=driver_info) + data = self.get_json( + '/nodes/detail', + headers={api_base.Version.string: str(api_v1.max_version())}) + self.assertEqual(node.uuid, data['nodes'][0]["uuid"]) + self.assertIn('name', data['nodes'][0]) + self.assertIn('driver', data['nodes'][0]) + self.assertIn('driver_info', data['nodes'][0]) + self.assertEqual(sanitized_driver_info, + data['nodes'][0]['driver_info']) + self.assertIn('extra', data['nodes'][0]) + self.assertIn('properties', data['nodes'][0]) + self.assertIn('chassis_uuid', data['nodes'][0]) + self.assertIn('reservation', data['nodes'][0]) + self.assertIn('maintenance', data['nodes'][0]) + self.assertIn('console_enabled', data['nodes'][0]) + self.assertIn('target_power_state', data['nodes'][0]) + self.assertIn('target_provision_state', data['nodes'][0]) + self.assertIn('provision_updated_at', data['nodes'][0]) + self.assertIn('inspection_finished_at', data['nodes'][0]) + self.assertIn('inspection_started_at', data['nodes'][0]) + self.assertIn('raid_config', data['nodes'][0]) + self.assertIn('target_raid_config', data['nodes'][0]) + self.assertIn('network_interface', data['nodes'][0]) + self.assertIn('resource_class', data['nodes'][0]) + for field in api_utils.V31_FIELDS: + self.assertIn(field, data['nodes'][0]) + self.assertIn('storage_interface', data['nodes'][0]) + self.assertIn('traits', data['nodes'][0]) + self.assertIn('conductor_group', data['nodes'][0]) + self.assertIn('automated_clean', data['nodes'][0]) + self.assertIn('protected', data['nodes'][0]) + self.assertIn('protected_reason', data['nodes'][0]) + self.assertIn('owner', data['nodes'][0]) + self.assertIn('lessee', data['nodes'][0]) + # never expose the chassis_id + self.assertNotIn('chassis_id', data['nodes'][0]) + self.assertNotIn('allocation_id', data['nodes'][0]) + self.assertIn('allocation_uuid', data['nodes'][0]) + self.assertIn('retired', data['nodes'][0]) + self.assertIn('retired_reason', data['nodes'][0]) + self.assertIn('network_data', data['nodes'][0]) + def test_detail_instance_uuid(self): instance_uuid = '6eccd391-961c-4da5-b3c5-e2fa5cfbbd9d' node = obj_utils.create_test_node( @@ -7928,20 +7985,15 @@ class TestNodeInventory(test_api_base.BaseApiTest): self.node = obj_utils.create_test_node( self.context, provision_state=states.AVAILABLE, name='node-81') - self.node.save() - self.node.obj_reset_changes() - - def _add_inventory(self): - self.inventory = objects.NodeInventory( - node_id=self.node.id, inventory_data=self.fake_inventory_data, - plugin_data=self.fake_plugin_data) - self.inventory.create() + CONF.set_override('data_backend', 'database', group='inventory') - def test_get_old_version(self): + @mock.patch.object(inspect_utils, 'get_inspection_data', autospec=True) + def test_get_old_version(self, mock_get): ret = self.get_json('/nodes/%s/inventory' % self.node.uuid, headers={api_base.Version.string: "1.80"}, expect_errors=True) self.assertEqual(http_client.NOT_FOUND, ret.status_code) + mock_get.assert_not_called() def test_get_inventory_no_inventory(self): ret = self.get_json('/nodes/%s/inventory' % self.node.uuid, @@ -7950,33 +8002,10 @@ class TestNodeInventory(test_api_base.BaseApiTest): self.assertEqual(http_client.NOT_FOUND, ret.status_code) def test_get_inventory(self): - self._add_inventory() - CONF.set_override('data_backend', 'database', - group='inventory') - ret = self.get_json('/nodes/%s/inventory' % self.node.uuid, - headers={api_base.Version.string: self.version}) - self.assertEqual({'inventory': self.fake_inventory_data, - 'plugin_data': self.fake_plugin_data}, ret) - - @mock.patch.object(inspect_utils, 'get_introspection_data', - autospec=True) - def test_get_inventory_exception(self, mock_get_data): - CONF.set_override('data_backend', 'database', - group='inventory') - mock_get_data.side_effect = [ - exception.NodeInventoryNotFound] - ret = self.get_json('/nodes/%s/inventory' % self.node.uuid, - headers={api_base.Version.string: self.version}, - expect_errors=True) - self.assertEqual(http_client.NOT_FOUND, ret.status_int) - - @mock.patch.object(inspect_utils, '_get_introspection_data_from_swift', - autospec=True) - def test_get_inventory_swift(self, mock_get_data): - CONF.set_override('data_backend', 'swift', - group='inventory') - mock_get_data.return_value = {"inventory": self.fake_inventory_data, - "plugin_data": self.fake_plugin_data} + obj_utils.create_test_inventory( + self.context, self.node, + inventory_data=self.fake_inventory_data, + plugin_data=self.fake_plugin_data) ret = self.get_json('/nodes/%s/inventory' % self.node.uuid, headers={api_base.Version.string: self.version}) self.assertEqual({'inventory': self.fake_inventory_data, diff --git a/ironic/tests/unit/common/test_kickstart_utils.py b/ironic/tests/unit/common/test_kickstart_utils.py index 0dd1ac572..db6123b9d 100644 --- a/ironic/tests/unit/common/test_kickstart_utils.py +++ b/ironic/tests/unit/common/test_kickstart_utils.py @@ -129,4 +129,5 @@ echo $CONTENT | /usr/bin/base64 --decode > {file_path}\n\ task.node.instance_info = i_info task.node.save() self.assertEqual(expected, ks_utils.prepare_config_drive(task)) - mock_get.assert_called_with('http://server/fake-configdrive-url') + mock_get.assert_called_with('http://server/fake-configdrive-url', + timeout=60) diff --git a/ironic/tests/unit/common/test_molds.py b/ironic/tests/unit/common/test_molds.py index 810dd61bc..2323c2fa8 100644 --- a/ironic/tests/unit/common/test_molds.py +++ b/ironic/tests/unit/common/test_molds.py @@ -46,7 +46,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): molds.save_configuration(task, url, data) mock_put.assert_called_once_with(url, '{\n "key": "value"\n}', - headers={'X-Auth-Token': 'token'}) + headers={'X-Auth-Token': 'token'}, + timeout=60) @mock.patch.object(swift, 'get_swift_session', autospec=True) @mock.patch.object(requests, 'put', autospec=True) @@ -77,7 +78,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): mock_put.assert_called_once_with( url, '{\n "key": "value"\n}', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) @mock.patch.object(requests, 'put', autospec=True) def test_save_configuration_http_noauth(self, mock_put): @@ -91,7 +93,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): molds.save_configuration(task, url, data) mock_put.assert_called_once_with( url, '{\n "key": "value"\n}', - headers=None) + headers=None, + timeout=60) @mock.patch.object(requests, 'put', autospec=True) def test_save_configuration_http_error(self, mock_put): @@ -112,7 +115,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): {'key': 'value'}) mock_put.assert_called_once_with( 'https://example.com/file2', '{\n "key": "value"\n}', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) @mock.patch.object(requests, 'put', autospec=True) def test_save_configuration_connection_error(self, mock_put): @@ -132,7 +136,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): task, 'https://example.com/file2', {'key': 'value'}) mock_put.assert_called_with( 'https://example.com/file2', '{\n "key": "value"\n}', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) self.assertEqual(mock_put.call_count, 3) @mock.patch.object(requests, 'put', autospec=True) @@ -155,7 +160,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): {'key': 'value'}) mock_put.assert_called_with( 'https://example.com/file2', '{\n "key": "value"\n}', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) self.assertEqual(mock_put.call_count, 2) @mock.patch.object(swift, 'get_swift_session', autospec=True) @@ -176,7 +182,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): result = molds.get_configuration(task, url) mock_get.assert_called_once_with( - url, headers={'X-Auth-Token': 'token'}) + url, headers={'X-Auth-Token': 'token'}, + timeout=60) self.assertJsonEqual({'key': 'value'}, result) @mock.patch.object(swift, 'get_swift_session', autospec=True) @@ -210,7 +217,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): result = molds.get_configuration(task, url) mock_get.assert_called_once_with( - url, headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + url, headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) self.assertJsonEqual({"key": "value"}, result) @mock.patch.object(requests, 'get', autospec=True) @@ -228,7 +236,7 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, self.node.uuid) as task: result = molds.get_configuration(task, url) - mock_get.assert_called_once_with(url, headers=None) + mock_get.assert_called_once_with(url, headers=None, timeout=60) self.assertJsonEqual({"key": "value"}, result) @mock.patch.object(requests, 'get', autospec=True) @@ -249,7 +257,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): 'https://example.com/file2') mock_get.assert_called_once_with( 'https://example.com/file2', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) @mock.patch.object(requests, 'get', autospec=True) def test_get_configuration_connection_error(self, mock_get): @@ -269,7 +278,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): task, 'https://example.com/file2') mock_get.assert_called_with( 'https://example.com/file2', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) self.assertEqual(mock_get.call_count, 3) @mock.patch.object(requests, 'get', autospec=True) @@ -291,7 +301,8 @@ class ConfigurationMoldTestCase(db_base.DbTestCase): 'https://example.com/file2') mock_get.assert_called_with( 'https://example.com/file2', - headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}) + headers={'Authorization': 'Basic dXNlcjpwYXNzd29yZA=='}, + timeout=60) self.assertEqual(mock_get.call_count, 2) @mock.patch.object(requests, 'get', autospec=True) diff --git a/ironic/tests/unit/common/test_release_mappings.py b/ironic/tests/unit/common/test_release_mappings.py index dad536257..e6f4479b9 100644 --- a/ironic/tests/unit/common/test_release_mappings.py +++ b/ironic/tests/unit/common/test_release_mappings.py @@ -44,7 +44,7 @@ NUMERIC_RELEASES = sorted( map(versionutils.convert_version_to_tuple, set(release_mappings.RELEASE_MAPPING) # Update the exceptions whenever needed - - {'master', 'zed', 'yoga'}), + - {'master', '2023.1', 'antelope', 'zed', 'yoga'}), reverse=True) diff --git a/ironic/tests/unit/conductor/test_cleaning.py b/ironic/tests/unit/conductor/test_cleaning.py index a4c3d57b6..34e805deb 100644 --- a/ironic/tests/unit/conductor/test_cleaning.py +++ b/ironic/tests/unit/conductor/test_cleaning.py @@ -1138,12 +1138,12 @@ class DoNodeCleanTestCase(db_base.DbTestCase): class DoNodeCleanAbortTestCase(db_base.DbTestCase): @mock.patch.object(fake.FakeDeploy, 'tear_down_cleaning', autospec=True) - def _test__do_node_clean_abort(self, step_name, tear_mock): + def _test_do_node_clean_abort(self, clean_step, tear_mock): node = obj_utils.create_test_node( self.context, driver='fake-hardware', - provision_state=states.CLEANFAIL, + provision_state=states.CLEANWAIT, target_provision_state=states.AVAILABLE, - clean_step={'step': 'foo', 'abortable': True}, + clean_step=clean_step, driver_internal_info={ 'agent_url': 'some url', 'agent_secret_token': 'token', @@ -1153,11 +1153,11 @@ class DoNodeCleanAbortTestCase(db_base.DbTestCase): 'skip_current_clean_step': True}) with task_manager.acquire(self.context, node.uuid) as task: - cleaning.do_node_clean_abort(task, step_name=step_name) + cleaning.do_node_clean_abort(task) self.assertIsNotNone(task.node.last_error) tear_mock.assert_called_once_with(task.driver.deploy, task) - if step_name: - self.assertIn(step_name, task.node.last_error) + if clean_step: + self.assertIn(clean_step['step'], task.node.last_error) # assert node's clean_step and metadata was cleaned up self.assertEqual({}, task.node.clean_step) self.assertNotIn('clean_step_index', @@ -1173,11 +1173,12 @@ class DoNodeCleanAbortTestCase(db_base.DbTestCase): self.assertNotIn('agent_secret_token', task.node.driver_internal_info) - def test__do_node_clean_abort(self): - self._test__do_node_clean_abort(None) + def test_do_node_clean_abort_early(self): + self._test_do_node_clean_abort(None) - def test__do_node_clean_abort_with_step_name(self): - self._test__do_node_clean_abort('foo') + def test_do_node_clean_abort_with_step(self): + self._test_do_node_clean_abort({'step': 'foo', 'interface': 'deploy', + 'abortable': True}) @mock.patch.object(fake.FakeDeploy, 'tear_down_cleaning', autospec=True) def test__do_node_clean_abort_tear_down_fail(self, tear_mock): diff --git a/ironic/tests/unit/conductor/test_inspection.py b/ironic/tests/unit/conductor/test_inspection.py new file mode 100644 index 000000000..c64b883e4 --- /dev/null +++ b/ironic/tests/unit/conductor/test_inspection.py @@ -0,0 +1,118 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from unittest import mock + +from ironic.common import exception +from ironic.common import states +from ironic.conductor import inspection +from ironic.conductor import task_manager +from ironic.tests.unit.db import base as db_base +from ironic.tests.unit.objects import utils as obj_utils + + +@mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', + autospec=True) +class TestInspectHardware(db_base.DbTestCase): + + def test_inspect_hardware_ok(self, mock_inspect): + node = obj_utils.create_test_node( + self.context, driver='fake-hardware', + provision_state=states.INSPECTING, + driver_internal_info={'agent_url': 'url', + 'agent_secret_token': 'token'}) + task = task_manager.TaskManager(self.context, node.uuid) + mock_inspect.return_value = states.MANAGEABLE + inspection.inspect_hardware(task) + node.refresh() + self.assertEqual(states.MANAGEABLE, node.provision_state) + self.assertEqual(states.NOSTATE, node.target_provision_state) + self.assertIsNone(node.last_error) + mock_inspect.assert_called_once_with(task.driver.inspect, task) + task.node.refresh() + self.assertNotIn('agent_url', task.node.driver_internal_info) + self.assertNotIn('agent_secret_token', task.node.driver_internal_info) + + def test_inspect_hardware_return_inspecting(self, mock_inspect): + node = obj_utils.create_test_node(self.context, driver='fake-hardware', + provision_state=states.INSPECTING) + task = task_manager.TaskManager(self.context, node.uuid) + mock_inspect.return_value = states.INSPECTING + self.assertRaises(exception.HardwareInspectionFailure, + inspection.inspect_hardware, task) + + node.refresh() + self.assertIn('driver returned unexpected state', node.last_error) + self.assertEqual(states.INSPECTFAIL, node.provision_state) + self.assertEqual(states.MANAGEABLE, node.target_provision_state) + mock_inspect.assert_called_once_with(task.driver.inspect, task) + + def test_inspect_hardware_return_inspect_wait(self, mock_inspect): + node = obj_utils.create_test_node(self.context, driver='fake-hardware', + provision_state=states.INSPECTING) + task = task_manager.TaskManager(self.context, node.uuid) + mock_inspect.return_value = states.INSPECTWAIT + inspection.inspect_hardware(task) + node.refresh() + self.assertEqual(states.INSPECTWAIT, node.provision_state) + self.assertEqual(states.MANAGEABLE, node.target_provision_state) + self.assertIsNone(node.last_error) + mock_inspect.assert_called_once_with(task.driver.inspect, task) + + @mock.patch.object(inspection, 'LOG', autospec=True) + def test_inspect_hardware_return_other_state(self, log_mock, mock_inspect): + node = obj_utils.create_test_node(self.context, driver='fake-hardware', + provision_state=states.INSPECTING) + task = task_manager.TaskManager(self.context, node.uuid) + mock_inspect.return_value = None + self.assertRaises(exception.HardwareInspectionFailure, + inspection.inspect_hardware, task) + node.refresh() + self.assertEqual(states.INSPECTFAIL, node.provision_state) + self.assertEqual(states.MANAGEABLE, node.target_provision_state) + self.assertIsNotNone(node.last_error) + mock_inspect.assert_called_once_with(task.driver.inspect, task) + self.assertTrue(log_mock.error.called) + + def test_inspect_hardware_raises_error(self, mock_inspect): + mock_inspect.side_effect = exception.HardwareInspectionFailure('test') + state = states.MANAGEABLE + node = obj_utils.create_test_node(self.context, driver='fake-hardware', + provision_state=states.INSPECTING, + target_provision_state=state) + task = task_manager.TaskManager(self.context, node.uuid) + + self.assertRaisesRegex(exception.HardwareInspectionFailure, '^test$', + inspection.inspect_hardware, task) + node.refresh() + self.assertEqual(states.INSPECTFAIL, node.provision_state) + self.assertEqual(states.MANAGEABLE, node.target_provision_state) + self.assertEqual('test', node.last_error) + self.assertTrue(mock_inspect.called) + + def test_inspect_hardware_unexpected_error(self, mock_inspect): + mock_inspect.side_effect = RuntimeError('x') + state = states.MANAGEABLE + node = obj_utils.create_test_node(self.context, driver='fake-hardware', + provision_state=states.INSPECTING, + target_provision_state=state) + task = task_manager.TaskManager(self.context, node.uuid) + + self.assertRaisesRegex(exception.HardwareInspectionFailure, + 'Unexpected exception of type RuntimeError: x', + inspection.inspect_hardware, task) + node.refresh() + self.assertEqual(states.INSPECTFAIL, node.provision_state) + self.assertEqual(states.MANAGEABLE, node.target_provision_state) + self.assertEqual('Unexpected exception of type RuntimeError: x', + node.last_error) + self.assertTrue(mock_inspect.called) diff --git a/ironic/tests/unit/conductor/test_manager.py b/ironic/tests/unit/conductor/test_manager.py index ded80718d..7278486a5 100644 --- a/ironic/tests/unit/conductor/test_manager.py +++ b/ironic/tests/unit/conductor/test_manager.py @@ -26,6 +26,7 @@ from unittest import mock import eventlet from futurist import waiters +from ironic_lib import metrics as ironic_metrics from oslo_config import cfg import oslo_messaging as messaging from oslo_utils import uuidutils @@ -45,6 +46,7 @@ from ironic.common import nova from ironic.common import states from ironic.conductor import cleaning from ironic.conductor import deployments +from ironic.conductor import inspection from ironic.conductor import manager from ironic.conductor import notification_utils from ironic.conductor import steps as conductor_steps @@ -2734,7 +2736,8 @@ class DoProvisioningActionTestCase(mgr_utils.ServiceSetUpMixin, # Node will be moved to tgt_prov_state after cleaning, not tested here self.assertEqual(states.CLEANFAIL, node.provision_state) self.assertEqual(tgt_prov_state, node.target_provision_state) - self.assertIsNone(node.last_error) + self.assertEqual('By request, the clean operation was aborted', + node.last_error) mock_spawn.assert_called_with( self.service, cleaning.do_node_clean_abort, mock.ANY) @@ -4273,7 +4276,8 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): def test__filter_out_unsupported_types_all(self): self._start_service() - CONF.set_override('send_sensor_data_types', ['All'], group='conductor') + CONF.set_override('data_types', ['All'], + group='sensor_data') fake_sensors_data = {"t1": {'f1': 'v1'}, "t2": {'f1': 'v1'}} actual_result = ( self.service._filter_out_unsupported_types(fake_sensors_data)) @@ -4282,7 +4286,8 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): def test__filter_out_unsupported_types_part(self): self._start_service() - CONF.set_override('send_sensor_data_types', ['t1'], group='conductor') + CONF.set_override('data_types', ['t1'], + group='sensor_data') fake_sensors_data = {"t1": {'f1': 'v1'}, "t2": {'f1': 'v1'}} actual_result = ( self.service._filter_out_unsupported_types(fake_sensors_data)) @@ -4291,7 +4296,8 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): def test__filter_out_unsupported_types_non(self): self._start_service() - CONF.set_override('send_sensor_data_types', ['t3'], group='conductor') + CONF.set_override('data_types', ['t3'], + group='sensor_data') fake_sensors_data = {"t1": {'f1': 'v1'}, "t2": {'f1': 'v1'}} actual_result = ( self.service._filter_out_unsupported_types(fake_sensors_data)) @@ -4305,7 +4311,8 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): for i in range(5): nodes.put_nowait(('fake_uuid-%d' % i, 'fake-hardware', '', None)) self._start_service() - CONF.set_override('send_sensor_data', True, group='conductor') + CONF.set_override('send_sensor_data', True, + group='sensor_data') task = acquire_mock.return_value.__enter__.return_value task.node.maintenance = False @@ -4334,7 +4341,8 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): nodes.put_nowait(('fake_uuid', 'fake-hardware', '', None)) self._start_service() self.service._shutdown = True - CONF.set_override('send_sensor_data', True, group='conductor') + CONF.set_override('send_sensor_data', True, + group='sensor_data') self.service._sensors_nodes_task(self.context, nodes) acquire_mock.return_value.__enter__.assert_not_called() @@ -4343,7 +4351,8 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): nodes = queue.Queue() nodes.put_nowait(('fake_uuid', 'fake-hardware', '', None)) - CONF.set_override('send_sensor_data', True, group='conductor') + CONF.set_override('send_sensor_data', True, + group='sensor_data') self._start_service() @@ -4361,7 +4370,7 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): nodes = queue.Queue() nodes.put_nowait(('fake_uuid', 'fake-hardware', '', None)) self._start_service() - CONF.set_override('send_sensor_data', True, group='conductor') + CONF.set_override('send_sensor_data', True, group='sensor_data') task = acquire_mock.return_value.__enter__.return_value task.node.maintenance = True @@ -4384,10 +4393,10 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): mock_spawn): self._start_service() - CONF.set_override('send_sensor_data', True, group='conductor') + CONF.set_override('send_sensor_data', True, group='sensor_data') # NOTE(galyna): do not wait for threads to be finished in unittests - CONF.set_override('send_sensor_data_wait_timeout', 0, - group='conductor') + CONF.set_override('wait_timeout', 0, + group='sensor_data') _mapped_to_this_conductor_mock.return_value = True get_nodeinfo_list_mock.return_value = [('fake_uuid', 'fake', None)] self.service._send_sensor_data(self.context) @@ -4395,6 +4404,37 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): self.service._sensors_nodes_task, self.context, mock.ANY) + @mock.patch.object(queue, 'Queue', autospec=True) + @mock.patch.object(manager.ConductorManager, '_sensors_conductor', + autospec=True) + @mock.patch.object(manager.ConductorManager, '_spawn_worker', + autospec=True) + @mock.patch.object(manager.ConductorManager, '_mapped_to_this_conductor', + autospec=True) + @mock.patch.object(dbapi.IMPL, 'get_nodeinfo_list', autospec=True) + def test___send_sensor_data_disabled( + self, get_nodeinfo_list_mock, + _mapped_to_this_conductor_mock, + mock_spawn, mock_sensors_conductor, + mock_queue): + self._start_service() + + CONF.set_override('send_sensor_data', True, group='sensor_data') + CONF.set_override('enable_for_nodes', False, + group='sensor_data') + CONF.set_override('enable_for_conductor', False, + group='sensor_data') + # NOTE(galyna): do not wait for threads to be finished in unittests + CONF.set_override('wait_timeout', 0, + group='sensor_data') + _mapped_to_this_conductor_mock.return_value = True + get_nodeinfo_list_mock.return_value = [('fake_uuid', 'fake', None)] + self.service._send_sensor_data(self.context) + mock_sensors_conductor.assert_not_called() + # NOTE(TheJulia): Can't use the spawn worker since it records other, + # unrelated calls. So, queue works well here. + mock_queue.assert_not_called() + @mock.patch('ironic.conductor.manager.ConductorManager._spawn_worker', autospec=True) @mock.patch.object(manager.ConductorManager, '_mapped_to_this_conductor', @@ -4407,24 +4447,66 @@ class SensorsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): mock_spawn.reset_mock() number_of_workers = 8 - CONF.set_override('send_sensor_data', True, group='conductor') - CONF.set_override('send_sensor_data_workers', number_of_workers, - group='conductor') + CONF.set_override('send_sensor_data', True, group='sensor_data') + CONF.set_override('workers', number_of_workers, + group='sensor_data') # NOTE(galyna): do not wait for threads to be finished in unittests - CONF.set_override('send_sensor_data_wait_timeout', 0, - group='conductor') + CONF.set_override('wait_timeout', 0, + group='sensor_data') _mapped_to_this_conductor_mock.return_value = True get_nodeinfo_list_mock.return_value = [('fake_uuid', 'fake', None)] * 20 self.service._send_sensor_data(self.context) - self.assertEqual(number_of_workers, + self.assertEqual(number_of_workers + 1, mock_spawn.call_count) # TODO(TheJulia): At some point, we should add a test to validate that # a modified filter to return all nodes actually works, although # the way the sensor tests are written, the list is all mocked. + @mock.patch('ironic.conductor.manager.ConductorManager._spawn_worker', + autospec=True) + @mock.patch.object(manager.ConductorManager, '_mapped_to_this_conductor', + autospec=True) + @mock.patch.object(dbapi.IMPL, 'get_nodeinfo_list', autospec=True) + def test___send_sensor_data_one_worker( + self, get_nodeinfo_list_mock, _mapped_to_this_conductor_mock, + mock_spawn): + self._start_service() + mock_spawn.reset_mock() + + number_of_workers = 1 + CONF.set_override('send_sensor_data', True, group='sensor_data') + CONF.set_override('workers', number_of_workers, + group='sensor_data') + # NOTE(galyna): do not wait for threads to be finished in unittests + CONF.set_override('wait_timeout', 0, + group='sensor_data') + + _mapped_to_this_conductor_mock.return_value = True + get_nodeinfo_list_mock.return_value = [('fake_uuid', 'fake', + None)] * 20 + self.service._send_sensor_data(self.context) + self.assertEqual(number_of_workers, + mock_spawn.call_count) + + @mock.patch.object(messaging.Notifier, 'info', autospec=True) + @mock.patch.object(ironic_metrics.MetricLogger, + 'get_metrics_data', autospec=True) + def test__sensors_conductor(self, mock_get_metrics, mock_notifier): + metric = {'metric': 'data'} + mock_get_metrics.return_value = metric + self._start_service() + self.service._sensors_conductor(self.context) + self.assertEqual(mock_notifier.call_count, 1) + self.assertEqual('ironic.metrics', mock_notifier.call_args.args[2]) + metrics_dict = mock_notifier.call_args.args[3] + self.assertEqual(metrics_dict.get('event_type'), + 'ironic.metrics.update') + self.assertDictEqual(metrics_dict.get('payload'), + metric) + @mgr_utils.mock_record_keepalive class BootDeviceTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): @@ -6380,77 +6462,6 @@ class ManagerSyncLocalStateTestCase(mgr_utils.CommonMixIn, db_base.DbTestCase): @mgr_utils.mock_record_keepalive class NodeInspectHardware(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): - @mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', - autospec=True) - def test_inspect_hardware_ok(self, mock_inspect): - self._start_service() - node = obj_utils.create_test_node( - self.context, driver='fake-hardware', - provision_state=states.INSPECTING, - driver_internal_info={'agent_url': 'url', - 'agent_secret_token': 'token'}) - task = task_manager.TaskManager(self.context, node.uuid) - mock_inspect.return_value = states.MANAGEABLE - manager._do_inspect_hardware(task) - node.refresh() - self.assertEqual(states.MANAGEABLE, node.provision_state) - self.assertEqual(states.NOSTATE, node.target_provision_state) - self.assertIsNone(node.last_error) - mock_inspect.assert_called_once_with(task.driver.inspect, task) - task.node.refresh() - self.assertNotIn('agent_url', task.node.driver_internal_info) - self.assertNotIn('agent_secret_token', task.node.driver_internal_info) - - @mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', - autospec=True) - def test_inspect_hardware_return_inspecting(self, mock_inspect): - self._start_service() - node = obj_utils.create_test_node(self.context, driver='fake-hardware', - provision_state=states.INSPECTING) - task = task_manager.TaskManager(self.context, node.uuid) - mock_inspect.return_value = states.INSPECTING - self.assertRaises(exception.HardwareInspectionFailure, - manager._do_inspect_hardware, task) - - node.refresh() - self.assertIn('driver returned unexpected state', node.last_error) - self.assertEqual(states.INSPECTFAIL, node.provision_state) - self.assertEqual(states.MANAGEABLE, node.target_provision_state) - mock_inspect.assert_called_once_with(task.driver.inspect, task) - - @mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', - autospec=True) - def test_inspect_hardware_return_inspect_wait(self, mock_inspect): - self._start_service() - node = obj_utils.create_test_node(self.context, driver='fake-hardware', - provision_state=states.INSPECTING) - task = task_manager.TaskManager(self.context, node.uuid) - mock_inspect.return_value = states.INSPECTWAIT - manager._do_inspect_hardware(task) - node.refresh() - self.assertEqual(states.INSPECTWAIT, node.provision_state) - self.assertEqual(states.MANAGEABLE, node.target_provision_state) - self.assertIsNone(node.last_error) - mock_inspect.assert_called_once_with(task.driver.inspect, task) - - @mock.patch.object(manager, 'LOG', autospec=True) - @mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', - autospec=True) - def test_inspect_hardware_return_other_state(self, mock_inspect, log_mock): - self._start_service() - node = obj_utils.create_test_node(self.context, driver='fake-hardware', - provision_state=states.INSPECTING) - task = task_manager.TaskManager(self.context, node.uuid) - mock_inspect.return_value = None - self.assertRaises(exception.HardwareInspectionFailure, - manager._do_inspect_hardware, task) - node.refresh() - self.assertEqual(states.INSPECTFAIL, node.provision_state) - self.assertEqual(states.MANAGEABLE, node.target_provision_state) - self.assertIsNotNone(node.last_error) - mock_inspect.assert_called_once_with(task.driver.inspect, task) - self.assertTrue(log_mock.error.called) - def test__check_inspect_wait_timeouts(self): self._start_service() CONF.set_override('inspect_wait_timeout', 1, group='conductor') @@ -6528,46 +6539,6 @@ class NodeInspectHardware(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): def test_inspect_hardware_power_validate_fail(self, mock_validate): self._test_inspect_hardware_validate_fail(mock_validate) - @mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', - autospec=True) - def test_inspect_hardware_raises_error(self, mock_inspect): - self._start_service() - mock_inspect.side_effect = exception.HardwareInspectionFailure('test') - state = states.MANAGEABLE - node = obj_utils.create_test_node(self.context, driver='fake-hardware', - provision_state=states.INSPECTING, - target_provision_state=state) - task = task_manager.TaskManager(self.context, node.uuid) - - self.assertRaisesRegex(exception.HardwareInspectionFailure, '^test$', - manager._do_inspect_hardware, task) - node.refresh() - self.assertEqual(states.INSPECTFAIL, node.provision_state) - self.assertEqual(states.MANAGEABLE, node.target_provision_state) - self.assertEqual('test', node.last_error) - self.assertTrue(mock_inspect.called) - - @mock.patch('ironic.drivers.modules.fake.FakeInspect.inspect_hardware', - autospec=True) - def test_inspect_hardware_unexpected_error(self, mock_inspect): - self._start_service() - mock_inspect.side_effect = RuntimeError('x') - state = states.MANAGEABLE - node = obj_utils.create_test_node(self.context, driver='fake-hardware', - provision_state=states.INSPECTING, - target_provision_state=state) - task = task_manager.TaskManager(self.context, node.uuid) - - self.assertRaisesRegex(exception.HardwareInspectionFailure, - 'Unexpected exception of type RuntimeError: x', - manager._do_inspect_hardware, task) - node.refresh() - self.assertEqual(states.INSPECTFAIL, node.provision_state) - self.assertEqual(states.MANAGEABLE, node.target_provision_state) - self.assertEqual('Unexpected exception of type RuntimeError: x', - node.last_error) - self.assertTrue(mock_inspect.called) - @mock.patch.object(conductor_utils, 'node_history_record', mock.Mock(spec=conductor_utils.node_history_record)) @@ -8166,7 +8137,7 @@ class NodeTraitsTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): class DoNodeInspectAbortTestCase(mgr_utils.CommonMixIn, mgr_utils.ServiceSetUpMixin, db_base.DbTestCase): - @mock.patch.object(manager, 'LOG', autospec=True) + @mock.patch.object(inspection, 'LOG', autospec=True) @mock.patch('ironic.drivers.modules.fake.FakeInspect.abort', autospec=True) @mock.patch('ironic.conductor.task_manager.acquire', autospec=True) def test_do_inspect_abort_interface_not_support(self, mock_acquire, @@ -8187,7 +8158,7 @@ class DoNodeInspectAbortTestCase(mgr_utils.CommonMixIn, exc.exc_info[0]) self.assertTrue(mock_log.error.called) - @mock.patch.object(manager, 'LOG', autospec=True) + @mock.patch.object(inspection, 'LOG', autospec=True) @mock.patch('ironic.drivers.modules.fake.FakeInspect.abort', autospec=True) @mock.patch('ironic.conductor.task_manager.acquire', autospec=True) def test_do_inspect_abort_interface_return_failed(self, mock_acquire, diff --git a/ironic/tests/unit/conductor/test_utils.py b/ironic/tests/unit/conductor/test_utils.py index a424e5132..52fc72436 100644 --- a/ironic/tests/unit/conductor/test_utils.py +++ b/ironic/tests/unit/conductor/test_utils.py @@ -196,7 +196,8 @@ class NodePowerActionTestCase(db_base.DbTestCase): node = obj_utils.create_test_node(self.context, uuid=uuidutils.generate_uuid(), driver='fake-hardware', - power_state=states.POWER_OFF) + power_state=states.POWER_OFF, + last_error='failed before') task = task_manager.TaskManager(self.context, node.uuid) get_power_mock.return_value = states.POWER_OFF @@ -209,6 +210,27 @@ class NodePowerActionTestCase(db_base.DbTestCase): self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_keep_last_error(self, get_power_mock): + """Test node_power_action to keep last_error for failed states.""" + node = obj_utils.create_test_node(self.context, + uuid=uuidutils.generate_uuid(), + driver='fake-hardware', + power_state=states.POWER_OFF, + provision_state=states.CLEANFAIL, + last_error='failed before') + task = task_manager.TaskManager(self.context, node.uuid) + + get_power_mock.return_value = states.POWER_OFF + + conductor_utils.node_power_action(task, states.POWER_ON) + + 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.assertEqual('failed before', node['last_error']) + @mock.patch('ironic.objects.node.NodeSetPowerStateNotification', autospec=True) @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) @@ -282,6 +304,31 @@ class NodePowerActionTestCase(db_base.DbTestCase): node['driver_internal_info']) @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) + def test_node_power_action_power_off_already(self, get_power_mock): + """Test node_power_action to turn node power off, but already off.""" + dii = {'agent_secret_token': 'token', + 'agent_cached_deploy_steps': ['steps']} + node = obj_utils.create_test_node(self.context, + uuid=uuidutils.generate_uuid(), + driver='fake-hardware', + power_state=states.POWER_ON, + driver_internal_info=dii) + task = task_manager.TaskManager(self.context, node.uuid) + + get_power_mock.return_value = states.POWER_OFF + + conductor_utils.node_power_action(task, states.POWER_OFF) + + 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']) + self.assertNotIn('agent_secret_token', node['driver_internal_info']) + self.assertNotIn('agent_cached_deploy_steps', + node['driver_internal_info']) + + @mock.patch.object(fake.FakePower, 'get_power_state', autospec=True) def test_node_power_action_power_off_pregenerated_token(self, get_power_mock): dii = {'agent_secret_token': 'token', @@ -1150,6 +1197,9 @@ class ErrorHandlersTestCase(db_base.DbTestCase): self.node.set_driver_internal_info('skip_current_clean_step', True) self.node.set_driver_internal_info('clean_step_index', 0) self.node.set_driver_internal_info('agent_url', 'url') + self.node.set_driver_internal_info('agent_secret_token', 'foo') + self.node.set_driver_internal_info('agent_secret_token_pregenerated', + False) msg = 'error bar' last_error = "last error" @@ -1162,6 +1212,9 @@ class ErrorHandlersTestCase(db_base.DbTestCase): self.assertNotIn('cleaning_polling', self.node.driver_internal_info) self.assertNotIn('skip_current_clean_step', self.node.driver_internal_info) + self.assertNotIn('agent_secret_token', self.node.driver_internal_info) + self.assertNotIn('agent_secret_token_pregenerated', + self.node.driver_internal_info) self.assertEqual(last_error, self.node.last_error) self.assertTrue(self.node.maintenance) self.assertEqual(last_error, self.node.maintenance_reason) diff --git a/ironic/tests/unit/db/test_api.py b/ironic/tests/unit/db/test_api.py index 6142fdfae..2396b1253 100644 --- a/ironic/tests/unit/db/test_api.py +++ b/ironic/tests/unit/db/test_api.py @@ -226,6 +226,11 @@ class UpdateToLatestVersionsTestCase(base.DbTestCase): for i in range(0, num_nodes): node = utils.create_test_node(version=version, uuid=uuidutils.generate_uuid()) + # Create entries on the tables so we force field upgrades + utils.create_test_node_trait(node_id=node.id, trait='foo', + version='0.0') + utils.create_test_bios_setting(node_id=node.id, version='1.0') + nodes.append(node.uuid) for uuid in nodes: node = self.dbapi.get_node_by_uuid(uuid) @@ -238,10 +243,15 @@ class UpdateToLatestVersionsTestCase(base.DbTestCase): return nodes = self._create_nodes(5) + # Check/migrate 2, 10 remain. + self.assertEqual( + (10, 2), self.dbapi.update_to_latest_versions(self.context, 2)) + # Check/migrate 10, 8 migrated, 8 remain. self.assertEqual( - (5, 2), self.dbapi.update_to_latest_versions(self.context, 2)) + (8, 8), self.dbapi.update_to_latest_versions(self.context, 10)) + # Just make sure it is still 0, 0 in case more things are added. self.assertEqual( - (3, 3), self.dbapi.update_to_latest_versions(self.context, 10)) + (0, 0), self.dbapi.update_to_latest_versions(self.context, 10)) for uuid in nodes: node = self.dbapi.get_node_by_uuid(uuid) self.assertEqual(self.node_ver, node.version) @@ -250,10 +260,19 @@ class UpdateToLatestVersionsTestCase(base.DbTestCase): if self.node_version_same: # can't test if we don't have diff versions of the node return - - nodes = self._create_nodes(5) + vm_count = 5 + nodes = self._create_nodes(vm_count) + # NOTE(TheJulia): Under current testing, 5 node will result in 10 + # records implicitly needing to be migrated. + migrate_count = vm_count * 2 + self.assertEqual( + (migrate_count, migrate_count), + self.dbapi.update_to_latest_versions(self.context, + migrate_count)) self.assertEqual( - (5, 5), self.dbapi.update_to_latest_versions(self.context, 5)) + (0, 0), self.dbapi.update_to_latest_versions(self.context, + migrate_count)) + for uuid in nodes: node = self.dbapi.get_node_by_uuid(uuid) self.assertEqual(self.node_ver, node.version) diff --git a/ironic/tests/unit/drivers/modules/ilo/test_boot.py b/ironic/tests/unit/drivers/modules/ilo/test_boot.py index 8aa6f78da..8ebaa14fa 100644 --- a/ironic/tests/unit/drivers/modules/ilo/test_boot.py +++ b/ironic/tests/unit/drivers/modules/ilo/test_boot.py @@ -1132,6 +1132,45 @@ class IloPXEBootTestCase(test_common.BaseIloTest): self.assertIsNone(task.node.driver_internal_info.get( 'ilo_uefi_iscsi_boot')) + @mock.patch.object(ilo_boot, 'prepare_node_for_deploy', spec_set=True, + autospec=True) + @mock.patch.object(deploy_utils, 'get_boot_option', autospec=True) + @mock.patch.object(deploy_utils, 'is_iscsi_boot', + spec_set=True, autospec=True) + @mock.patch.object(boot_mode_utils, 'get_boot_mode_for_deploy', + spec_set=True, autospec=True) + @mock.patch.object(ilo_common, 'update_boot_mode', spec_set=True, + autospec=True) + @mock.patch.object(pxe.PXEBoot, 'prepare_instance', spec_set=True, + autospec=True) + def _test_prepare_instance_anaconda(self, pxe_prepare_instance_mock, + update_boot_mode_mock, + get_boot_mode_mock, + is_iscsi_boot_mock, + mock_get_boot_opt, + mock_prep_node_fr_deploy, prov_state): + with task_manager.acquire(self.context, self.node.uuid, + shared=False) as task: + task.node.provision_state = prov_state + mock_get_boot_opt.return_value = 'kickstart' + is_iscsi_boot_mock.return_value = False + get_boot_mode_mock.return_value = 'uefi' + task.driver.boot.prepare_instance(task) + update_boot_mode_mock.assert_called_once_with(task) + pxe_prepare_instance_mock.assert_called_once_with(mock.ANY, task) + self.assertIsNone(task.node.driver_internal_info.get( + 'ilo_uefi_iscsi_boot')) + mock_prep_node_fr_deploy.assert_called_once_with(task) + + def test_prepare_instance_anaconda_deploying(self): + self._test_prepare_instance_anaconda(prov_state=states.DEPLOYING) + + def test_prepare_instance_anaconda_rescuing(self): + self._test_prepare_instance_anaconda(prov_state=states.RESCUING) + + def test_prepare_instance_anaconda_cleaning(self): + self._test_prepare_instance_anaconda(prov_state=states.CLEANING) + @mock.patch.object(deploy_utils, 'is_iscsi_boot', spec_set=True, autospec=True) @mock.patch.object(boot_mode_utils, 'get_boot_mode_for_deploy', @@ -1299,6 +1338,45 @@ class IloiPXEBootTestCase(test_common.BaseIloTest): self.assertIsNone(task.node.driver_internal_info.get( 'ilo_uefi_iscsi_boot')) + @mock.patch.object(ilo_boot, 'prepare_node_for_deploy', spec_set=True, + autospec=True) + @mock.patch.object(deploy_utils, 'get_boot_option', autospec=True) + @mock.patch.object(deploy_utils, 'is_iscsi_boot', + spec_set=True, autospec=True) + @mock.patch.object(boot_mode_utils, 'get_boot_mode_for_deploy', + spec_set=True, autospec=True) + @mock.patch.object(ilo_common, 'update_boot_mode', spec_set=True, + autospec=True) + @mock.patch.object(ipxe.iPXEBoot, 'prepare_instance', spec_set=True, + autospec=True) + def _test_prepare_instance_anaconda(self, pxe_prepare_instance_mock, + update_boot_mode_mock, + get_boot_mode_mock, + is_iscsi_boot_mock, + mock_get_boot_opt, + mock_prep_node_fr_deploy, prov_state): + with task_manager.acquire(self.context, self.node.uuid, + shared=False) as task: + task.node.provision_state = prov_state + mock_get_boot_opt.return_value = 'kickstart' + is_iscsi_boot_mock.return_value = False + get_boot_mode_mock.return_value = 'uefi' + task.driver.boot.prepare_instance(task) + update_boot_mode_mock.assert_called_once_with(task) + pxe_prepare_instance_mock.assert_called_once_with(mock.ANY, task) + self.assertIsNone(task.node.driver_internal_info.get( + 'ilo_uefi_iscsi_boot')) + mock_prep_node_fr_deploy.assert_called_once_with(task) + + def test_prepare_instance_anaconda_deploying(self): + self._test_prepare_instance_anaconda(prov_state=states.DEPLOYING) + + def test_prepare_instance_anaconda_rescuing(self): + self._test_prepare_instance_anaconda(prov_state=states.RESCUING) + + def test_prepare_instance_anaconda_cleaning(self): + self._test_prepare_instance_anaconda(prov_state=states.CLEANING) + @mock.patch.object(deploy_utils, 'is_iscsi_boot', spec_set=True, autospec=True) @mock.patch.object(boot_mode_utils, 'get_boot_mode_for_deploy', diff --git a/ironic/tests/unit/drivers/modules/inspector/__init__.py b/ironic/tests/unit/drivers/modules/inspector/__init__.py new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/ironic/tests/unit/drivers/modules/inspector/__init__.py diff --git a/ironic/tests/unit/drivers/modules/inspector/test_client.py b/ironic/tests/unit/drivers/modules/inspector/test_client.py new file mode 100644 index 000000000..08f0fcd93 --- /dev/null +++ b/ironic/tests/unit/drivers/modules/inspector/test_client.py @@ -0,0 +1,65 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +from unittest import mock + +from keystoneauth1 import exceptions as ks_exception +import openstack + +from ironic.common import context +from ironic.common import exception +from ironic.conf import CONF +from ironic.drivers.modules.inspector import client +from ironic.tests.unit.db import base as db_base + + +@mock.patch('ironic.common.keystone.get_auth', autospec=True, + return_value=mock.sentinel.auth) +@mock.patch('ironic.common.keystone.get_session', autospec=True, + return_value=mock.sentinel.session) +@mock.patch.object(openstack.connection, 'Connection', autospec=True) +class GetClientTestCase(db_base.DbTestCase): + + def setUp(self): + super(GetClientTestCase, self).setUp() + # NOTE(pas-ha) force-reset global inspector session object + client._INSPECTOR_SESSION = None + self.context = context.RequestContext(global_request_id='global') + + def test_get_client(self, mock_conn, mock_session, mock_auth): + client.get_client(self.context) + mock_conn.assert_called_once_with( + session=mock.sentinel.session, + oslo_conf=mock.ANY) + self.assertEqual(1, mock_auth.call_count) + self.assertEqual(1, mock_session.call_count) + + def test_get_client_standalone(self, mock_conn, mock_session, mock_auth): + self.config(auth_strategy='noauth') + client.get_client(self.context) + self.assertEqual('none', CONF.inspector.auth_type) + mock_conn.assert_called_once_with( + session=mock.sentinel.session, + oslo_conf=mock.ANY) + self.assertEqual(1, mock_auth.call_count) + self.assertEqual(1, mock_session.call_count) + + def test_get_client_connection_problem( + self, mock_conn, mock_session, mock_auth): + mock_conn.side_effect = ks_exception.DiscoveryFailure("") + self.assertRaises(exception.ConfigInvalid, + client.get_client, self.context) + mock_conn.assert_called_once_with( + session=mock.sentinel.session, + oslo_conf=mock.ANY) + self.assertEqual(1, mock_auth.call_count) + self.assertEqual(1, mock_session.call_count) diff --git a/ironic/tests/unit/drivers/modules/test_inspector.py b/ironic/tests/unit/drivers/modules/inspector/test_interface.py index 75ccc3ebf..42bb55f2b 100644 --- a/ironic/tests/unit/drivers/modules/test_inspector.py +++ b/ironic/tests/unit/drivers/modules/inspector/test_interface.py @@ -13,65 +13,19 @@ from unittest import mock import eventlet -from keystoneauth1 import exceptions as ks_exception -import openstack -from ironic.common import context from ironic.common import exception from ironic.common import states from ironic.common import utils from ironic.conductor import task_manager +from ironic.conf import CONF from ironic.drivers.modules import inspect_utils -from ironic.drivers.modules import inspector +from ironic.drivers.modules.inspector import client +from ironic.drivers.modules.inspector import interface as inspector from ironic.drivers.modules.redfish import utils as redfish_utils from ironic.tests.unit.db import base as db_base from ironic.tests.unit.objects import utils as obj_utils -CONF = inspector.CONF - - -@mock.patch('ironic.common.keystone.get_auth', autospec=True, - return_value=mock.sentinel.auth) -@mock.patch('ironic.common.keystone.get_session', autospec=True, - return_value=mock.sentinel.session) -@mock.patch.object(openstack.connection, 'Connection', autospec=True) -class GetClientTestCase(db_base.DbTestCase): - - def setUp(self): - super(GetClientTestCase, self).setUp() - # NOTE(pas-ha) force-reset global inspector session object - inspector._INSPECTOR_SESSION = None - self.context = context.RequestContext(global_request_id='global') - - def test__get_client(self, mock_conn, mock_session, mock_auth): - inspector._get_client(self.context) - mock_conn.assert_called_once_with( - session=mock.sentinel.session, - oslo_conf=mock.ANY) - self.assertEqual(1, mock_auth.call_count) - self.assertEqual(1, mock_session.call_count) - - def test__get_client_standalone(self, mock_conn, mock_session, mock_auth): - self.config(auth_strategy='noauth') - inspector._get_client(self.context) - self.assertEqual('none', inspector.CONF.inspector.auth_type) - mock_conn.assert_called_once_with( - session=mock.sentinel.session, - oslo_conf=mock.ANY) - self.assertEqual(1, mock_auth.call_count) - self.assertEqual(1, mock_session.call_count) - - def test__get_client_connection_problem( - self, mock_conn, mock_session, mock_auth): - mock_conn.side_effect = ks_exception.DiscoveryFailure("") - self.assertRaises(exception.ConfigInvalid, - inspector._get_client, self.context) - mock_conn.assert_called_once_with( - session=mock.sentinel.session, - oslo_conf=mock.ANY) - self.assertEqual(1, mock_auth.call_count) - self.assertEqual(1, mock_session.call_count) - class BaseTestCase(db_base.DbTestCase): def setUp(self): @@ -129,7 +83,7 @@ class CommonFunctionsTestCase(BaseTestCase): @mock.patch.object(eventlet, 'spawn_n', lambda f, *a, **kw: f(*a, **kw)) -@mock.patch('ironic.drivers.modules.inspector._get_client', autospec=True) +@mock.patch.object(client, 'get_client', autospec=True) class InspectHardwareTestCase(BaseTestCase): def test_validate_ok(self, mock_client): self.iface.validate(self.task) @@ -369,7 +323,7 @@ class InspectHardwareTestCase(BaseTestCase): self.task, 'power off', timeout=None) -@mock.patch('ironic.drivers.modules.inspector._get_client', autospec=True) +@mock.patch.object(client, 'get_client', autospec=True) class CheckStatusTestCase(BaseTestCase): def setUp(self): super(CheckStatusTestCase, self).setUp() @@ -551,22 +505,24 @@ class CheckStatusTestCase(BaseTestCase): self.task) self.driver.boot.clean_up_ramdisk.assert_called_once_with(self.task) - @mock.patch.object(inspect_utils, 'store_introspection_data', - autospec=True) + @mock.patch.object(inspect_utils, 'store_inspection_data', autospec=True) def test_status_ok_store_inventory(self, mock_store_data, mock_client): mock_get = mock_client.return_value.get_introspection mock_get.return_value = mock.Mock(is_finished=True, error=None, spec=['is_finished', 'error']) - fake_introspection_data = { - "inventory": {"cpu": "amd"}, "disks": [{"name": "/dev/vda"}]} + fake_inventory = {"cpu": "amd"} + fake_plugin_data = {"disks": [{"name": "/dev/vda"}]} + fake_introspection_data = dict(fake_plugin_data, + inventory=fake_inventory) mock_get_data = mock_client.return_value.get_introspection_data mock_get_data.return_value = fake_introspection_data inspector._check_status(self.task) mock_get.assert_called_once_with(self.node.uuid) mock_get_data.assert_called_once_with(self.node.uuid, processed=True) mock_store_data.assert_called_once_with(self.node, - fake_introspection_data, + fake_inventory, + fake_plugin_data, self.task.context) def test_status_ok_store_inventory_nostore(self, mock_client): @@ -593,7 +549,7 @@ class CheckStatusTestCase(BaseTestCase): mock_get_data.assert_not_called() -@mock.patch('ironic.drivers.modules.inspector._get_client', autospec=True) +@mock.patch.object(client, 'get_client', autospec=True) class InspectHardwareAbortTestCase(BaseTestCase): def test_abort_ok(self, mock_client): mock_abort = mock_client.return_value.abort_introspection diff --git a/ironic/tests/unit/drivers/modules/test_deploy_utils.py b/ironic/tests/unit/drivers/modules/test_deploy_utils.py index 1177e9743..7220697cb 100644 --- a/ironic/tests/unit/drivers/modules/test_deploy_utils.py +++ b/ironic/tests/unit/drivers/modules/test_deploy_utils.py @@ -1940,7 +1940,7 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): self.node.save() self.checksum_mock = self.useFixture(fixtures.MockPatchObject( - fileutils, 'compute_file_checksum')).mock + fileutils, 'compute_file_checksum', autospec=True)).mock self.checksum_mock.return_value = 'fake-checksum' self.cache_image_mock = self.useFixture(fixtures.MockPatchObject( utils, 'cache_instance_image', autospec=True)).mock @@ -2012,9 +2012,25 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): image_info=self.image_info, expect_raw=True) self.assertIsNone(instance_info['image_checksum']) + self.assertEqual(instance_info['image_os_hash_algo'], 'sha512') + self.assertEqual(instance_info['image_os_hash_value'], + 'fake-checksum') self.assertEqual(instance_info['image_disk_format'], 'raw') - calls = [mock.call(image_path, algorithm='sha512')] - self.checksum_mock.assert_has_calls(calls) + self.checksum_mock.assert_called_once_with(image_path, + algorithm='sha512') + + def test_build_instance_info_already_raw(self): + cfg.CONF.set_override('force_raw_images', True) + self.image_info['disk_format'] = 'raw' + image_path, instance_info = self._test_build_instance_info( + image_info=self.image_info, expect_raw=True) + + self.assertEqual(instance_info['image_checksum'], 'aa') + self.assertEqual(instance_info['image_os_hash_algo'], 'sha512') + self.assertEqual(instance_info['image_os_hash_value'], + 'fake-sha512') + self.assertEqual(instance_info['image_disk_format'], 'raw') + self.checksum_mock.assert_not_called() def test_build_instance_info_force_raw_drops_md5(self): cfg.CONF.set_override('force_raw_images', True) @@ -2027,6 +2043,17 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): calls = [mock.call(image_path, algorithm='sha256')] self.checksum_mock.assert_has_calls(calls) + def test_build_instance_info_already_raw_keeps_md5(self): + cfg.CONF.set_override('force_raw_images', True) + self.image_info['os_hash_algo'] = 'md5' + self.image_info['disk_format'] = 'raw' + image_path, instance_info = self._test_build_instance_info( + image_info=self.image_info, expect_raw=True) + + self.assertEqual(instance_info['image_checksum'], 'aa') + self.assertEqual(instance_info['image_disk_format'], 'raw') + self.checksum_mock.assert_not_called() + @mock.patch.object(image_service.HttpImageService, 'validate_href', autospec=True) def test_build_instance_info_file_image(self, validate_href_mock): @@ -2035,7 +2062,6 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): i_info['image_source'] = 'file://image-ref' i_info['image_checksum'] = 'aa' i_info['root_gb'] = 10 - i_info['image_checksum'] = 'aa' driver_internal_info['is_whole_disk_image'] = True self.node.instance_info = i_info self.node.driver_internal_info = driver_internal_info @@ -2052,6 +2078,7 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): self.assertEqual(expected_url, info['image_url']) self.assertEqual('sha256', info['image_os_hash_algo']) self.assertEqual('fake-checksum', info['image_os_hash_value']) + self.assertEqual('raw', info['image_disk_format']) self.cache_image_mock.assert_called_once_with( task.context, task.node, force_raw=True) self.checksum_mock.assert_called_once_with( @@ -2068,7 +2095,6 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): i_info['image_source'] = 'http://image-ref' i_info['image_checksum'] = 'aa' i_info['root_gb'] = 10 - i_info['image_checksum'] = 'aa' driver_internal_info['is_whole_disk_image'] = True self.node.instance_info = i_info self.node.driver_internal_info = driver_internal_info @@ -2102,7 +2128,6 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): i_info['image_source'] = 'http://image-ref' i_info['image_checksum'] = 'aa' i_info['root_gb'] = 10 - i_info['image_checksum'] = 'aa' i_info['image_download_source'] = 'local' driver_internal_info['is_whole_disk_image'] = True self.node.instance_info = i_info @@ -2138,7 +2163,6 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): i_info['image_source'] = 'http://image-ref' i_info['image_checksum'] = 'aa' i_info['root_gb'] = 10 - i_info['image_checksum'] = 'aa' d_info['image_download_source'] = 'local' driver_internal_info['is_whole_disk_image'] = True self.node.instance_info = i_info @@ -2164,6 +2188,41 @@ class TestBuildInstanceInfoForHttpProvisioning(db_base.DbTestCase): validate_href_mock.assert_called_once_with( mock.ANY, expected_url, False) + @mock.patch.object(image_service.HttpImageService, 'validate_href', + autospec=True) + def test_build_instance_info_local_image_already_raw(self, + validate_href_mock): + cfg.CONF.set_override('image_download_source', 'local', group='agent') + i_info = self.node.instance_info + driver_internal_info = self.node.driver_internal_info + i_info['image_source'] = 'http://image-ref' + i_info['image_checksum'] = 'aa' + i_info['root_gb'] = 10 + i_info['image_disk_format'] = 'raw' + driver_internal_info['is_whole_disk_image'] = True + self.node.instance_info = i_info + self.node.driver_internal_info = driver_internal_info + self.node.save() + + expected_url = ( + 'http://172.172.24.10:8080/agent_images/%s' % self.node.uuid) + + with task_manager.acquire( + self.context, self.node.uuid, shared=False) as task: + + info = utils.build_instance_info_for_deploy(task) + + self.assertEqual(expected_url, info['image_url']) + self.assertEqual('aa', info['image_checksum']) + self.assertEqual('raw', info['image_disk_format']) + self.assertIsNone(info['image_os_hash_algo']) + self.assertIsNone(info['image_os_hash_value']) + self.cache_image_mock.assert_called_once_with( + task.context, task.node, force_raw=True) + self.checksum_mock.assert_not_called() + validate_href_mock.assert_called_once_with( + mock.ANY, expected_url, False) + class TestStorageInterfaceUtils(db_base.DbTestCase): def setUp(self): diff --git a/ironic/tests/unit/drivers/modules/test_inspect_utils.py b/ironic/tests/unit/drivers/modules/test_inspect_utils.py index 7cb451473..57980d5a2 100644 --- a/ironic/tests/unit/drivers/modules/test_inspect_utils.py +++ b/ironic/tests/unit/drivers/modules/test_inspect_utils.py @@ -23,14 +23,13 @@ from ironic.common import context as ironic_context from ironic.common import exception from ironic.common import swift from ironic.conductor import task_manager +from ironic.conf import CONF from ironic.drivers.modules import inspect_utils as utils -from ironic.drivers.modules import inspector from ironic import objects from ironic.tests.unit.db import base as db_base from ironic.tests.unit.objects import utils as obj_utils sushy = importutils.try_import('sushy') -CONF = inspector.CONF @mock.patch('time.sleep', lambda sec: None) @@ -104,7 +103,7 @@ class SwiftCleanUp(db_base.DbTestCase): @mock.patch.object(swift, 'SwiftAPI', autospec=True) def test_clean_up_swift_entries(self, swift_api_mock): CONF.set_override('data_backend', 'swift', group='inventory') - container = 'introspection_data' + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') swift_obj_mock = swift_api_mock.return_value with task_manager.acquire(self.context, self.node.uuid, @@ -118,7 +117,7 @@ class SwiftCleanUp(db_base.DbTestCase): @mock.patch.object(swift, 'SwiftAPI', autospec=True) def test_clean_up_swift_entries_with_404_exception(self, swift_api_mock): CONF.set_override('data_backend', 'swift', group='inventory') - container = 'introspection_data' + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') swift_obj_mock = swift_api_mock.return_value with task_manager.acquire(self.context, self.node.uuid, @@ -133,7 +132,7 @@ class SwiftCleanUp(db_base.DbTestCase): @mock.patch.object(swift, 'SwiftAPI', autospec=True) def test_clean_up_swift_entries_with_fail_exception(self, swift_api_mock): CONF.set_override('data_backend', 'swift', group='inventory') - container = 'introspection_data' + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') swift_obj_mock = swift_api_mock.return_value with task_manager.acquire(self.context, self.node.uuid, @@ -149,7 +148,7 @@ class SwiftCleanUp(db_base.DbTestCase): @mock.patch.object(swift, 'SwiftAPI', autospec=True) def test_clean_up_swift_entries_with_fail_exceptions(self, swift_api_mock): CONF.set_override('data_backend', 'swift', group='inventory') - container = 'introspection_data' + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') swift_obj_mock = swift_api_mock.return_value with task_manager.acquire(self.context, self.node.uuid, @@ -172,115 +171,93 @@ class IntrospectionDataStorageFunctionsTestCase(db_base.DbTestCase): super(IntrospectionDataStorageFunctionsTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context) - def test_store_introspection_data_db(self): - CONF.set_override('data_backend', 'database', - group='inventory') - fake_introspection_data = {'inventory': self.fake_inventory_data, - **self.fake_plugin_data} + def test_store_inspection_data_db(self): + CONF.set_override('data_backend', 'database', group='inventory') fake_context = ironic_context.RequestContext() - utils.store_introspection_data(self.node, fake_introspection_data, - fake_context) + utils.store_inspection_data(self.node, self.fake_inventory_data, + self.fake_plugin_data, fake_context) stored = objects.NodeInventory.get_by_node_id(self.context, self.node.id) self.assertEqual(self.fake_inventory_data, stored["inventory_data"]) self.assertEqual(self.fake_plugin_data, stored["plugin_data"]) - @mock.patch.object(utils, '_store_introspection_data_in_swift', + @mock.patch.object(utils, '_store_inspection_data_in_swift', autospec=True) - def test_store_introspection_data_swift(self, mock_store_data): + def test_store_inspection_data_swift(self, mock_store_data): CONF.set_override('data_backend', 'swift', group='inventory') CONF.set_override( - 'swift_data_container', 'introspection_data', + 'swift_data_container', 'inspection_data', group='inventory') - fake_introspection_data = { - "inventory": self.fake_inventory_data, **self.fake_plugin_data} fake_context = ironic_context.RequestContext() - utils.store_introspection_data(self.node, fake_introspection_data, - fake_context) + utils.store_inspection_data(self.node, self.fake_inventory_data, + self.fake_plugin_data, fake_context) mock_store_data.assert_called_once_with( self.node.uuid, inventory_data=self.fake_inventory_data, plugin_data=self.fake_plugin_data) - def test_store_introspection_data_nostore(self): + def test_store_inspection_data_nostore(self): CONF.set_override('data_backend', 'none', group='inventory') - fake_introspection_data = { - "inventory": self.fake_inventory_data, **self.fake_plugin_data} fake_context = ironic_context.RequestContext() - ret = utils.store_introspection_data(self.node, - fake_introspection_data, - fake_context) - self.assertIsNone(ret) - - def test__node_inventory_convert(self): - required_output = {"inventory": self.fake_inventory_data, - "plugin_data": self.fake_plugin_data} - input_given = {} - input_given["inventory_data"] = self.fake_inventory_data - input_given["plugin_data"] = self.fake_plugin_data - input_given["booom"] = "boom" - ret = utils._node_inventory_convert(input_given) - self.assertEqual(required_output, ret) - - @mock.patch.object(utils, '_node_inventory_convert', autospec=True) - @mock.patch.object(objects, 'NodeInventory', spec_set=True, autospec=True) - def test_get_introspection_data_db(self, mock_inventory, mock_convert): - CONF.set_override('data_backend', 'database', - group='inventory') - fake_introspection_data = {'inventory': self.fake_inventory_data, - 'plugin_data': self.fake_plugin_data} + utils.store_inspection_data(self.node, self.fake_inventory_data, + self.fake_plugin_data, fake_context) + self.assertRaises(exception.NodeInventoryNotFound, + objects.NodeInventory.get_by_node_id, + self.context, self.node.id) + + def test_get_inspection_data_db(self): + CONF.set_override('data_backend', 'database', group='inventory') + obj_utils.create_test_inventory( + self.context, self.node, + inventory_data=self.fake_inventory_data, + plugin_data=self.fake_plugin_data) fake_context = ironic_context.RequestContext() - mock_inventory.get_by_node_id.return_value = fake_introspection_data - utils.get_introspection_data(self.node, fake_context) - mock_convert.assert_called_once_with(fake_introspection_data) - - @mock.patch.object(objects, 'NodeInventory', spec_set=True, autospec=True) - def test_get_introspection_data_db_exception(self, mock_inventory): - CONF.set_override('data_backend', 'database', - group='inventory') + ret = utils.get_inspection_data(self.node, fake_context) + fake_inspection_data = {'inventory': self.fake_inventory_data, + 'plugin_data': self.fake_plugin_data} + self.assertEqual(ret, fake_inspection_data) + + def test_get_inspection_data_db_exception(self): + CONF.set_override('data_backend', 'database', group='inventory') fake_context = ironic_context.RequestContext() - mock_inventory.get_by_node_id.side_effect = [ - exception.NodeInventoryNotFound(self.node.uuid)] self.assertRaises( - exception.NodeInventoryNotFound, utils.get_introspection_data, + exception.NodeInventoryNotFound, utils.get_inspection_data, self.node, fake_context) - @mock.patch.object(utils, '_get_introspection_data_from_swift', - autospec=True) - def test_get_introspection_data_swift(self, mock_get_data): + @mock.patch.object(utils, '_get_inspection_data_from_swift', autospec=True) + def test_get_inspection_data_swift(self, mock_get_data): CONF.set_override('data_backend', 'swift', group='inventory') CONF.set_override( - 'swift_data_container', 'introspection_data', + 'swift_data_container', 'inspection_data', group='inventory') fake_context = ironic_context.RequestContext() - utils.get_introspection_data(self.node, fake_context) - mock_get_data.assert_called_once_with( - self.node.uuid) + ret = utils.get_inspection_data(self.node, fake_context) + mock_get_data.assert_called_once_with(self.node.uuid) + self.assertEqual(mock_get_data.return_value, ret) - @mock.patch.object(utils, '_get_introspection_data_from_swift', - autospec=True) - def test_get_introspection_data_swift_exception(self, mock_get_data): + @mock.patch.object(utils, '_get_inspection_data_from_swift', autospec=True) + def test_get_inspection_data_swift_exception(self, mock_get_data): CONF.set_override('data_backend', 'swift', group='inventory') CONF.set_override( - 'swift_data_container', 'introspection_data', + 'swift_data_container', 'inspection_data', group='inventory') fake_context = ironic_context.RequestContext() mock_get_data.side_effect = exception.SwiftObjectNotFoundError() self.assertRaises( - exception.NodeInventoryNotFound, utils.get_introspection_data, + exception.NodeInventoryNotFound, utils.get_inspection_data, self.node, fake_context) - def test_get_introspection_data_nostore(self): + def test_get_inspection_data_nostore(self): CONF.set_override('data_backend', 'none', group='inventory') fake_context = ironic_context.RequestContext() self.assertRaises( - exception.NodeInventoryNotFound, utils.get_introspection_data, + exception.NodeInventoryNotFound, utils.get_inspection_data, self.node, fake_context) @mock.patch.object(swift, 'SwiftAPI', autospec=True) - def test__store_introspection_data_in_swift(self, swift_api_mock): - container = 'introspection_data' + def test__store_inspection_data_in_swift(self, swift_api_mock): + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') - utils._store_introspection_data_in_swift( + utils._store_inspection_data_in_swift( self.node.uuid, self.fake_inventory_data, self.fake_plugin_data) swift_obj_mock = swift_api_mock.return_value object_name = 'inspector_data-' + str(self.node.uuid) @@ -291,23 +268,22 @@ class IntrospectionDataStorageFunctionsTestCase(db_base.DbTestCase): container)]) @mock.patch.object(swift, 'SwiftAPI', autospec=True) - def test__get_introspection_data_from_swift(self, swift_api_mock): - container = 'introspection_data' + def test__get_inspection_data_from_swift(self, swift_api_mock): + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') swift_obj_mock = swift_api_mock.return_value swift_obj_mock.get_object.side_effect = [ self.fake_inventory_data, self.fake_plugin_data ] - ret = utils._get_introspection_data_from_swift(self.node.uuid) + ret = utils._get_inspection_data_from_swift(self.node.uuid) req_ret = {"inventory": self.fake_inventory_data, "plugin_data": self.fake_plugin_data} self.assertEqual(req_ret, ret) @mock.patch.object(swift, 'SwiftAPI', autospec=True) - def test__get_introspection_data_from_swift_exception(self, - swift_api_mock): - container = 'introspection_data' + def test__get_inspection_data_from_swift_exception(self, swift_api_mock): + container = 'inspection_data' CONF.set_override('swift_data_container', container, group='inventory') swift_obj_mock = swift_api_mock.return_value swift_obj_mock.get_object.side_effect = [ @@ -315,5 +291,5 @@ class IntrospectionDataStorageFunctionsTestCase(db_base.DbTestCase): self.fake_plugin_data ] self.assertRaises(exception.SwiftObjectNotFoundError, - utils._get_introspection_data_from_swift, + utils._get_inspection_data_from_swift, self.node.uuid) diff --git a/ironic/tests/unit/drivers/modules/test_pxe.py b/ironic/tests/unit/drivers/modules/test_pxe.py index e7d444104..f16366470 100644 --- a/ironic/tests/unit/drivers/modules/test_pxe.py +++ b/ironic/tests/unit/drivers/modules/test_pxe.py @@ -550,6 +550,8 @@ class PXEBootTestCase(db_base.DbTestCase): def test_prepare_instance_ramdisk_pxe_conf_exists(self): self._test_prepare_instance_ramdisk(config_file_exits=False) + @mock.patch.object(boot_mode_utils, 'configure_secure_boot_if_needed', + autospec=True) @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(pxe_utils, 'create_pxe_config', autospec=True) @@ -567,7 +569,7 @@ class PXEBootTestCase(db_base.DbTestCase): self, exec_mock, write_file_mock, render_mock, api_url_mock, boot_opt_mock, get_image_info_mock, cache_mock, dhcp_factory_mock, create_pxe_config_mock, switch_pxe_config_mock, - set_boot_device_mock): + set_boot_device_mock, mock_conf_sec_boot): image_info = {'kernel': ['ins_kernel_id', '/path/to/kernel'], 'ramdisk': ['ins_ramdisk_id', '/path/to/ramdisk'], 'stage2': ['ins_stage2_id', '/path/to/stage2'], @@ -611,6 +613,7 @@ class PXEBootTestCase(db_base.DbTestCase): set_boot_device_mock.assert_called_once_with(task, boot_devices.PXE, persistent=True) + self.assertFalse(mock_conf_sec_boot.called) @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @@ -786,11 +789,13 @@ class PXEAnacondaDeployTestCase(db_base.DbTestCase): task.driver.deploy.prepare(task) mock_prepare_instance.assert_called_once_with(mock.ANY, task) + @mock.patch.object(boot_mode_utils, 'configure_secure_boot_if_needed', + autospec=True) @mock.patch.object(pxe_utils, 'clean_up_pxe_env', autospec=True) @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) @mock.patch.object(deploy_utils, 'try_set_boot_device', autospec=True) def test_reboot_to_instance(self, mock_set_boot_dev, mock_image_info, - mock_cleanup_pxe_env): + mock_cleanup_pxe_env, mock_conf_sec_boot): image_info = {'kernel': ('', '/path/to/kernel'), 'ramdisk': ('', '/path/to/ramdisk'), 'stage2': ('', '/path/to/stage2'), @@ -802,6 +807,7 @@ class PXEAnacondaDeployTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.deploy.reboot_to_instance(task) mock_set_boot_dev.assert_called_once_with(task, boot_devices.DISK) + mock_conf_sec_boot.assert_called_once_with(task) mock_cleanup_pxe_env.assert_called_once_with(task, image_info, ipxe_enabled=False) diff --git a/ironic/tests/unit/drivers/modules/test_snmp.py b/ironic/tests/unit/drivers/modules/test_snmp.py index 5391d7ac5..e1b6fc1df 100644 --- a/ironic/tests/unit/drivers/modules/test_snmp.py +++ b/ironic/tests/unit/drivers/modules/test_snmp.py @@ -46,6 +46,41 @@ class SNMPClientTestCase(base.TestCase): self.value = 'value' @mock.patch.object(pysnmp, 'SnmpEngine', autospec=True) + def test__get_client(self, mock_snmpengine): + driver_info = db_utils.get_test_snmp_info( + snmp_address=self.address, + snmp_port=self.port, + snmp_user='test-user', + snmp_auth_protocol='sha', + snmp_auth_key='test-auth-key', + snmp_priv_protocol='aes', + snmp_priv_key='test-priv-key', + snmp_context_engine_id='test-engine-id', + snmp_context_name='test-context-name', + snmp_version='3') + node = obj_utils.get_test_node( + self.context, + driver_info=driver_info) + info = snmp._parse_driver_info(node) + + client = snmp._get_client(info) + + mock_snmpengine.assert_called_once_with() + self.assertEqual(self.address, client.address) + self.assertEqual(int(self.port), client.port) + self.assertEqual(snmp.SNMP_V3, client.version) + self.assertNotIn('read_community', client.__dict__) + self.assertNotIn('write_community', client.__dict__) + self.assertEqual('test-user', client.user) + self.assertEqual(pysnmp.usmHMACSHAAuthProtocol, client.auth_proto) + self.assertEqual('test-auth-key', client.auth_key) + self.assertEqual(pysnmp.usmAesCfb128Protocol, client.priv_proto) + self.assertEqual('test-priv-key', client.priv_key) + self.assertEqual('test-engine-id', client.context_engine_id) + self.assertEqual('test-context-name', client.context_name) + self.assertEqual(mock_snmpengine.return_value, client.snmp_engine) + + @mock.patch.object(pysnmp, 'SnmpEngine', autospec=True) def test___init__(self, mock_snmpengine): client = snmp.SNMPClient(self.address, self.port, snmp.SNMP_V1) mock_snmpengine.assert_called_once_with() diff --git a/ironic/tests/unit/drivers/test_fake_hardware.py b/ironic/tests/unit/drivers/test_fake_hardware.py index 70460a6a4..637f52bf9 100644 --- a/ironic/tests/unit/drivers/test_fake_hardware.py +++ b/ironic/tests/unit/drivers/test_fake_hardware.py @@ -17,6 +17,8 @@ """Test class for Fake driver.""" +import time +from unittest import mock from ironic.common import boot_devices from ironic.common import boot_modes @@ -26,6 +28,7 @@ from ironic.common import indicator_states from ironic.common import states from ironic.conductor import task_manager from ironic.drivers import base as driver_base +from ironic.drivers.modules import fake from ironic.tests.unit.db import base as db_base from ironic.tests.unit.db import utils as db_utils @@ -164,3 +167,29 @@ class FakeHardwareTestCase(db_base.DbTestCase): self.assertEqual({}, self.driver.inspect.get_properties()) self.driver.inspect.validate(self.task) self.driver.inspect.inspect_hardware(self.task) + + def test_parse_sleep_range(self): + self.assertEqual((0, 0), fake.parse_sleep_range('0')) + self.assertEqual((0, 0), fake.parse_sleep_range('')) + self.assertEqual((1, 1), fake.parse_sleep_range('1')) + self.assertEqual((1, 10), fake.parse_sleep_range('1,10')) + self.assertEqual((10, 20), fake.parse_sleep_range('10, 20')) + + @mock.patch.object(time, 'sleep', autospec=True) + def test_sleep_zero(self, mock_sleep): + fake.sleep("0") + mock_sleep.assert_not_called() + + @mock.patch.object(time, 'sleep', autospec=True) + def test_sleep_one(self, mock_sleep): + fake.sleep("1") + mock_sleep.assert_called_once_with(1) + + @mock.patch.object(time, 'sleep', autospec=True) + def test_sleep_range(self, mock_sleep): + for i in range(100): + fake.sleep("1,10") + for call in mock_sleep.call_args_list: + v = call[0][0] + self.assertGreaterEqual(v, 1) + self.assertLessEqual(v, 10) diff --git a/ironic/tests/unit/objects/utils.py b/ironic/tests/unit/objects/utils.py index 26c3a22e7..979ab28a2 100644 --- a/ironic/tests/unit/objects/utils.py +++ b/ironic/tests/unit/objects/utils.py @@ -380,3 +380,15 @@ class SchemasTestMixIn(object): "for %s, schema key %s has invalid %s " "field %s" % (payload, schema_key, resource, key)) + + +def create_test_inventory(ctxt, node, **kw): + """Create and return a test node inventory object.""" + inv = objects.NodeInventory(ctxt) + if not isinstance(node, str): + node = node.id + kw['node_id'] = node + for key, value in kw.items(): + setattr(inv, key, value) + inv.create() + return inv |