From faf3f6b210b3c3ed604c55efb79b0db1936b7fad Mon Sep 17 00:00:00 2001 From: Stenio Araujo Date: Mon, 9 Oct 2017 14:48:47 -0300 Subject: [PATCH] Get a new OneView client when needed OneView has the time to expire an active session defined through an idle time. This idle time is 24 hours by default. The previous client, python-oneviewclient, used by the hardware type OneView had a reauthentication mechanism that would ensure the new session was created when the old one expired. With the migration to python-hpOneView, the mechanism to reauthenticate does not exist. This solution creates a new instance of the client when it is needed. Change-Id: Id112e84f7d050d818e3cd9bf02cd9cfe4716ef32 Closes-Bug: 1693788 --- ironic/drivers/modules/oneview/common.py | 26 +++--- ironic/drivers/modules/oneview/deploy.py | 34 +++----- .../drivers/modules/oneview/deploy_utils.py | 43 +++++----- ironic/drivers/modules/oneview/inspect.py | 12 +-- ironic/drivers/modules/oneview/management.py | 22 ++---- ironic/drivers/modules/oneview/power.py | 22 +++--- .../drivers/modules/oneview/test_common.py | 3 +- .../drivers/modules/oneview/test_deploy.py | 79 ++++++------------- .../modules/oneview/test_deploy_utils.py | 21 ++--- .../modules/oneview/test_management.py | 49 +++++------- .../drivers/modules/oneview/test_power.py | 38 ++++----- 11 files changed, 131 insertions(+), 218 deletions(-) diff --git a/ironic/drivers/modules/oneview/common.py b/ironic/drivers/modules/oneview/common.py index 122c847f28..2bd23436c9 100644 --- a/ironic/drivers/modules/oneview/common.py +++ b/ironic/drivers/modules/oneview/common.py @@ -95,15 +95,15 @@ def get_hponeview_client(): return hponeview_client.OneViewClient(config) -def get_ilorest_client(oneview_client, server_hardware): +def get_ilorest_client(server_hardware): """Generate an instance of the iLORest library client. - :param oneview_client: an instance of a python-hpOneView - :param: server_hardware: a server hardware uuid or uri + :param server_hardware: a server hardware uuid or uri :returns: an instance of the iLORest client :raises: InvalidParameterValue if mandatory information is missing on the node or on invalid input. """ + oneview_client = get_hponeview_client() remote_console = oneview_client.server_hardware.get_remote_console_url( server_hardware ) @@ -196,7 +196,7 @@ def get_oneview_info(node): return oneview_info -def validate_oneview_resources_compatibility(oneview_client, task): +def validate_oneview_resources_compatibility(task): """Validate if the node configuration is consistent with OneView. This method calls hpOneView functions to validate if the node @@ -205,11 +205,11 @@ def validate_oneview_resources_compatibility(oneview_client, task): serverProfileTemplateUri, enclosureGroupUri and node ports. If any validation fails, the driver will raise an appropriate OneViewError. - :param oneview_client: an instance of the OneView client :param: task: a TaskManager instance containing the node to act on. :raises: OneViewError if any validation fails. """ ports = task.ports + oneview_client = get_hponeview_client() oneview_info = get_oneview_info(task.node) _validate_node_server_profile_template(oneview_client, oneview_info) @@ -254,22 +254,22 @@ def node_has_server_profile(func): """ def inner(self, *args, **kwargs): task = args[0] - has_server_profile(task, self.client) + has_server_profile(task) return func(self, *args, **kwargs) return inner -def has_server_profile(task, client): +def has_server_profile(task): """Checks if the node's Server Hardware has a Server Profile associated. Function to check if the Server Profile is applied to the Server Hardware. - :param client: an instance of the OneView client :param task: a TaskManager instance containing the node to act on. """ + oneview_client = get_hponeview_client() try: profile = task.node.driver_info.get('applied_server_profile_uri') - client.server_profiles.get(profile) + oneview_client.server_profiles.get(profile) except client_exception.HPOneViewException as exc: LOG.error( "Failed to get server profile from OneView appliance for" @@ -279,10 +279,9 @@ def has_server_profile(task, client): raise exception.OneViewError(error=exc) -def _get_server_hardware_mac_from_ilo(oneview_client, server_hardware): +def _get_server_hardware_mac_from_ilo(server_hardware): """Get the MAC of Server Hardware's iLO controller. - :param: oneview_client: an instance of the HPE OneView client :param: server_hardware: a server hardware uuid or uri :return: MAC of Server Hardware's iLO controller. :raises: InvalidParameterValue if required iLO credentials are missing. @@ -290,7 +289,7 @@ def _get_server_hardware_mac_from_ilo(oneview_client, server_hardware): if fails to get JSON object with the default path. """ try: - client = get_ilorest_client(oneview_client, server_hardware) + client = get_ilorest_client(server_hardware) ilo_path = "/rest/v1/systems/1" hardware = jsonutils.loads(client.get(ilo_path).text) hardware_mac = hardware['HostCorrelation']['HostMACAddress'][0] @@ -497,8 +496,7 @@ def _validate_node_port_mac_server_hardware(oneview_client, try: mac = _get_server_hardware_mac(server_hardware) except exception.OneViewError: - mac = _get_server_hardware_mac_from_ilo( - oneview_client, server_hardware) + mac = _get_server_hardware_mac_from_ilo(server_hardware) incompatible_macs = [] for port in ports: diff --git a/ironic/drivers/modules/oneview/deploy.py b/ironic/drivers/modules/oneview/deploy.py index 3f2704986f..5bf4cdf7e0 100644 --- a/ironic/drivers/modules/oneview/deploy.py +++ b/ironic/drivers/modules/oneview/deploy.py @@ -66,9 +66,7 @@ class OneViewPeriodicTasks(object): node = objects.Node.get(context, node_uuid) try: - oneview_using = deploy_utils.is_node_in_use_by_oneview( - self.client, node - ) + oneview_using = deploy_utils.is_node_in_use_by_oneview(node) except exception.OneViewError as e: # NOTE(xavierr): Skip this node and process the # remaining nodes. This node will be checked in @@ -128,7 +126,7 @@ class OneViewPeriodicTasks(object): try: oneview_using = deploy_utils.is_node_in_use_by_oneview( - self.client, node + node ) except exception.OneViewError as e: # NOTE(xavierr): Skip this node and process the @@ -218,10 +216,6 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks): oneview_driver = common.ISCSI_PXE_ONEVIEW - def __init__(self): - super(OneViewIscsiDeploy, self).__init__() - self.client = common.get_hponeview_client() - def get_properties(self): return deploy_utils.get_properties() @@ -229,30 +223,30 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks): def validate(self, task): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility(self.client, task) + common.validate_oneview_resources_compatibility(task) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) super(OneViewIscsiDeploy, self).validate(task) @METRICS.timer('OneViewIscsiDeploy.prepare') def prepare(self, task): - deploy_utils.prepare(self.client, task) + deploy_utils.prepare(task) super(OneViewIscsiDeploy, self).prepare(task) @METRICS.timer('OneViewIscsiDeploy.tear_down') def tear_down(self, task): if not CONF.conductor.automated_clean: - deploy_utils.tear_down(self.client, task) + deploy_utils.tear_down(task) return super(OneViewIscsiDeploy, self).tear_down(task) @METRICS.timer('OneViewIscsiDeploy.prepare_cleaning') def prepare_cleaning(self, task): - deploy_utils.prepare_cleaning(self.client, task) + deploy_utils.prepare_cleaning(task) return super(OneViewIscsiDeploy, self).prepare_cleaning(task) @METRICS.timer('OneViewIscsiDeploy.tear_down_cleaning') def tear_down_cleaning(self, task): - deploy_utils.tear_down_cleaning(self.client, task) + deploy_utils.tear_down_cleaning(task) super(OneViewIscsiDeploy, self).tear_down_cleaning(task) @@ -261,10 +255,6 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks): oneview_driver = common.AGENT_PXE_ONEVIEW - def __init__(self): - super(OneViewAgentDeploy, self).__init__() - self.client = common.get_hponeview_client() - def get_properties(self): return deploy_utils.get_properties() @@ -272,28 +262,28 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks): def validate(self, task): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility(self.client, task) + common.validate_oneview_resources_compatibility(task) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) super(OneViewAgentDeploy, self).validate(task) @METRICS.timer('OneViewAgentDeploy.prepare') def prepare(self, task): - deploy_utils.prepare(self.client, task) + deploy_utils.prepare(task) super(OneViewAgentDeploy, self).prepare(task) @METRICS.timer('OneViewAgentDeploy.tear_down') def tear_down(self, task): if not CONF.conductor.automated_clean: - deploy_utils.tear_down(self.client, task) + deploy_utils.tear_down(task) return super(OneViewAgentDeploy, self).tear_down(task) @METRICS.timer('OneViewAgentDeploy.prepare_cleaning') def prepare_cleaning(self, task): - deploy_utils.prepare_cleaning(self.client, task) + deploy_utils.prepare_cleaning(task) return super(OneViewAgentDeploy, self).prepare_cleaning(task) @METRICS.timer('OneViewAgentDeploy.tear_down_cleaning') def tear_down_cleaning(self, task): - deploy_utils.tear_down_cleaning(self.client, task) + deploy_utils.tear_down_cleaning(task) super(OneViewAgentDeploy, self).tear_down_cleaning(task) diff --git a/ironic/drivers/modules/oneview/deploy_utils.py b/ironic/drivers/modules/oneview/deploy_utils.py index 9b6b31b1df..a8a05b0a17 100644 --- a/ironic/drivers/modules/oneview/deploy_utils.py +++ b/ironic/drivers/modules/oneview/deploy_utils.py @@ -32,14 +32,13 @@ def get_properties(): return common.COMMON_PROPERTIES -def prepare(client, task): +def prepare(task): """Apply Server Profile and update the node when preparing. This method is responsible for applying a Server Profile to the Server Hardware and add the uri of the applied Server Profile in the node's 'applied_server_profile_uri' field on properties/capabilities. - :param client: an instance of the OneView client :param task: A TaskManager object :raises InstanceDeployFailure: If the node doesn't have the needed OneView informations, if Server Hardware is in use by an OneView user, or @@ -55,14 +54,13 @@ def prepare(client, task): {"instance_name": instance_display_name, "instance_uuid": instance_uuid} ) - allocate_server_hardware_to_ironic(client, task.node, - server_profile_name) + allocate_server_hardware_to_ironic(task.node, server_profile_name) except exception.OneViewError as e: raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e) -def tear_down(client, task): +def tear_down(task): """Remove Server profile and update the node when tear down. This method is responsible for power a Server Hardware off, remove a Server @@ -70,26 +68,24 @@ def tear_down(client, task): Profile from the node's 'applied_server_profile_uri' in properties/capabilities. - :param client: an instance of the OneView client :param task: A TaskManager object :raises InstanceDeployFailure: If node has no uri of applied Server Profile, or if some error occur while deleting Server Profile. """ try: - deallocate_server_hardware_from_ironic(client, task) + deallocate_server_hardware_from_ironic(task) except exception.OneViewError as e: raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e) -def prepare_cleaning(client, task): +def prepare_cleaning(task): """Apply Server Profile and update the node when preparing cleaning. This method is responsible for applying a Server Profile to the Server Hardware and add the uri of the applied Server Profile in the node's 'applied_server_profile_uri' field on properties/capabilities. - :param client: an instance of the OneView client :param task: A TaskManager object :raises NodeCleaningFailure: If the node doesn't have the needed OneView informations, if Server Hardware is in use by an OneView user, or @@ -98,8 +94,7 @@ def prepare_cleaning(client, task): """ try: server_profile_name = "Ironic Cleaning [%s]" % task.node.uuid - allocate_server_hardware_to_ironic(client, task.node, - server_profile_name) + allocate_server_hardware_to_ironic(task.node, server_profile_name) except exception.OneViewError as e: oneview_error = common.SERVER_HARDWARE_ALLOCATION_ERROR driver_internal_info = task.node.driver_internal_info @@ -110,7 +105,7 @@ def prepare_cleaning(client, task): reason=e) -def tear_down_cleaning(client, task): +def tear_down_cleaning(task): """Remove Server profile and update the node when tear down cleaning. This method is responsible for power a Server Hardware off, remove a Server @@ -118,14 +113,13 @@ def tear_down_cleaning(client, task): Profile from the node's 'applied_server_profile_uri' in properties/capabilities. - :param client: an instance of the OneView client :param task: A TaskManager object :raises NodeCleaningFailure: If node has no uri of applied Server Profile, or if some error occur while deleting Server Profile. """ try: - deallocate_server_hardware_from_ironic(client, task) + deallocate_server_hardware_from_ironic(task) except exception.OneViewError as e: raise exception.NodeCleaningFailure(node=task.node.uuid, reason=e) @@ -171,10 +165,9 @@ def _is_node_in_use(server_hardware, applied_sp_uri, by_oneview=False): operation(applied_sp_uri, server_profile_uri)) -def is_node_in_use_by_oneview(client, node): +def is_node_in_use_by_oneview(node): """Check if node is in use by OneView user. - :param client: an instance of the OneView client :param node: an ironic node object :returns: Boolean value. True if node is in use by OneView, False otherwise. @@ -185,6 +178,7 @@ def is_node_in_use_by_oneview(client, node): """ positive = _("Node '%s' is in use by OneView.") % node.uuid negative = _("Node '%s' is not in use by OneView.") % node.uuid + client = common.get_hponeview_client() def predicate(server_hardware, applied_sp_uri): # Check if Profile exists in Oneview and it is different of the one @@ -196,10 +190,9 @@ def is_node_in_use_by_oneview(client, node): predicate, positive, negative) -def is_node_in_use_by_ironic(client, node): +def is_node_in_use_by_ironic(node): """Check if node is in use by ironic in OneView. - :param client: an instance of the HPE OneView client :param node: an ironic node object :returns: Boolean value. True if node is in use by ironic, False otherwise. @@ -210,6 +203,7 @@ def is_node_in_use_by_ironic(client, node): """ positive = _("Node '%s' is in use by Ironic.") % node.uuid negative = _("Node '%s' is not in use by Ironic.") % node.uuid + client = common.get_hponeview_client() def predicate(server_hardware, applied_sp_uri): # Check if Profile exists in Oneview and it is equals of the one @@ -280,11 +274,9 @@ def _del_applied_server_profile_uri_field(node): node.save() -def allocate_server_hardware_to_ironic(client, node, - server_profile_name): +def allocate_server_hardware_to_ironic(node, server_profile_name): """Allocate Server Hardware to ironic. - :param client: an instance of the OneView client :param node: an ironic node object :param server_profile_name: a formatted string with the Server Profile name @@ -292,7 +284,8 @@ def allocate_server_hardware_to_ironic(client, node, Hardware to ironic """ - node_in_use_by_oneview = is_node_in_use_by_oneview(client, node) + client = common.get_hponeview_client() + node_in_use_by_oneview = is_node_in_use_by_oneview(node) if not node_in_use_by_oneview: oneview_info = common.get_oneview_info(node) @@ -347,17 +340,17 @@ def allocate_server_hardware_to_ironic(client, node, raise exception.OneViewError(error=msg) -def deallocate_server_hardware_from_ironic(client, task): +def deallocate_server_hardware_from_ironic(task): """Deallocate Server Hardware from ironic. - :param client: an instance of the OneView client :param task: a TaskManager object :raises OneViewError: if an error occurs while deallocating the Server Hardware to ironic """ + client = common.get_hponeview_client() node = task.node - if is_node_in_use_by_ironic(client, node): + if is_node_in_use_by_ironic(node): oneview_info = common.get_oneview_info(node) server_profile_uri = oneview_info.get('applied_server_profile_uri') diff --git a/ironic/drivers/modules/oneview/inspect.py b/ironic/drivers/modules/oneview/inspect.py index 40d6745472..f06652dc53 100644 --- a/ironic/drivers/modules/oneview/inspect.py +++ b/ironic/drivers/modules/oneview/inspect.py @@ -30,10 +30,6 @@ METRICS = metrics_utils.get_metrics_logger(__name__) class OneViewInspect(inspector.Inspector): """Interface for in band inspection.""" - def __init__(self): - super(OneViewInspect, self).__init__() - self.client = common.get_hponeview_client() - def get_properties(self): return deploy_utils.get_properties() @@ -54,7 +50,7 @@ class OneViewInspect(inspector.Inspector): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility(self.client, task) + common.validate_oneview_resources_compatibility(task) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) @@ -62,7 +58,7 @@ class OneViewInspect(inspector.Inspector): def inspect_hardware(self, task): profile_name = 'Ironic Inspecting [%s]' % task.node.uuid deploy_utils.allocate_server_hardware_to_ironic( - self.client, task.node, profile_name + task.node, profile_name ) return super(OneViewInspect, self).inspect_hardware(task) @@ -93,8 +89,6 @@ class OneViewInspect(inspector.Inspector): if state_before == states.INSPECTING and state_after in [ states.MANAGEABLE, states.INSPECTFAIL ]: - deploy_utils.deallocate_server_hardware_from_ironic( - self.client, task.node - ) + deploy_utils.deallocate_server_hardware_from_ironic(task.node) return result diff --git a/ironic/drivers/modules/oneview/management.py b/ironic/drivers/modules/oneview/management.py index bf6549c221..f164c2a9a8 100644 --- a/ironic/drivers/modules/oneview/management.py +++ b/ironic/drivers/modules/oneview/management.py @@ -68,9 +68,8 @@ def set_onetime_boot(task): persistent = next_boot_device.get('persistent') if not persistent: - client = common.get_hponeview_client() server_hardware = task.node.driver_info.get('server_hardware_uri') - ilo_client = common.get_ilorest_client(client, server_hardware) + ilo_client = common.get_ilorest_client(server_hardware) boot_device = BOOT_DEVICE_MAP_ILO.get(boot_device) body = { "Boot": { @@ -93,9 +92,8 @@ def _is_onetime_boot(task): False otherwise. """ - client = common.get_hponeview_client() server_hardware = task.node.driver_info.get('server_hardware_uri') - ilo_client = common.get_ilorest_client(client, server_hardware) + ilo_client = common.get_ilorest_client(server_hardware) response = ilo_client.get(path=ILO_SYSTEM_PATH, headers=ILO_REQUEST_HEADERS) boot = response.dict.get('Boot') @@ -114,7 +112,7 @@ def set_boot_device(task): :raises: OneViewError if the communication with OneView fails """ client = common.get_hponeview_client() - common.has_server_profile(task, client) + common.has_server_profile(task) driver_internal_info = task.node.driver_internal_info next_boot_device = driver_internal_info.get('next_boot_device') @@ -163,10 +161,6 @@ def set_boot_device(task): class OneViewManagement(base.ManagementInterface): - def __init__(self): - super(OneViewManagement, self).__init__() - self.client = common.get_hponeview_client() - def get_properties(self): return deploy_utils.get_properties() @@ -187,12 +181,9 @@ class OneViewManagement(base.ManagementInterface): resources in OneView """ common.verify_node_info(task.node) - try: - common.validate_oneview_resources_compatibility(self.client, task) - if not deploy_utils.is_node_in_use_by_ironic( - self.client, task.node - ): + common.validate_oneview_resources_compatibility(task) + if not deploy_utils.is_node_in_use_by_ironic(task.node): raise exception.InvalidParameterValue( _("Node %s is not in use by ironic.") % task.node.uuid) except exception.OneViewError as oneview_exc: @@ -264,6 +255,7 @@ class OneViewManagement(base.ManagementInterface): """ driver_internal_info = task.node.driver_internal_info next_boot_device = driver_internal_info.get('next_boot_device') + client = common.get_hponeview_client() if next_boot_device: return next_boot_device @@ -272,7 +264,7 @@ class OneViewManagement(base.ManagementInterface): server_profile = driver_info.get('applied_server_profile_uri') try: - profile = self.client.server_profiles.get(server_profile) + profile = client.server_profiles.get(server_profile) except client_exception.HPOneViewException as exc: msg = _("Error getting boot device from OneView. Error: %s") % exc raise exception.OneViewError(msg) diff --git a/ironic/drivers/modules/oneview/power.py b/ironic/drivers/modules/oneview/power.py index ab0091f550..3cedca81ad 100644 --- a/ironic/drivers/modules/oneview/power.py +++ b/ironic/drivers/modules/oneview/power.py @@ -56,10 +56,6 @@ SET_POWER_STATE_MAP = { class OneViewPower(base.PowerInterface): - def __init__(self): - super(OneViewPower, self).__init__() - self.client = common.get_hponeview_client() - def get_properties(self): return deploy_utils.get_properties() @@ -88,9 +84,9 @@ class OneViewPower(base.PowerInterface): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility(self.client, task) + common.validate_oneview_resources_compatibility(task) - if deploy_utils.is_node_in_use_by_oneview(self.client, task.node): + if deploy_utils.is_node_in_use_by_oneview(task.node): raise exception.InvalidParameterValue( _("Node %s is in use by OneView.") % task.node.uuid) @@ -108,8 +104,9 @@ class OneViewPower(base.PowerInterface): resource """ server_hardware = task.node.driver_info.get('server_hardware_uri') + client = common.get_hponeview_client() try: - server_hardware = self.client.server_hardware.get(server_hardware) + server_hardware = client.server_hardware.get(server_hardware) except client_exception.HPOneViewException as exc: LOG.error( "Error getting power state for node %(node)s. Error:" @@ -135,7 +132,8 @@ class OneViewPower(base.PowerInterface): :raises: PowerStateFailure if the power couldn't be set to power_state. :raises: OneViewError if OneView fails setting the power state. """ - if deploy_utils.is_node_in_use_by_oneview(self.client, task.node): + client = common.get_hponeview_client() + if deploy_utils.is_node_in_use_by_oneview(task.node): raise exception.PowerStateFailure(_( "Cannot set power state '%(power_state)s' to node %(node)s. " "The node is in use by OneView.") % @@ -157,19 +155,19 @@ class OneViewPower(base.PowerInterface): try: if power_state == states.POWER_ON: management.set_boot_device(task) - self.client.server_hardware.update_power_state( + client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(power_state), server_hardware, timeout=timeout) elif power_state == states.REBOOT: - self.client.server_hardware.update_power_state( + client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(states.POWER_OFF), server_hardware, timeout=timeout) management.set_boot_device(task) - self.client.server_hardware.update_power_state( + client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(states.POWER_ON), server_hardware, timeout=timeout) else: - self.client.server_hardware.update_power_state( + client.server_hardware.update_power_state( SET_POWER_STATE_MAP.get(power_state), server_hardware, timeout=timeout) except client_exception.HPOneViewException as exc: diff --git a/ironic/tests/unit/drivers/modules/oneview/test_common.py b/ironic/tests/unit/drivers/modules/oneview/test_common.py index 0755d5c06a..2641c202b9 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_common.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_common.py @@ -285,8 +285,7 @@ class OneViewCommonTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, self.node.uuid) as task: task.ports = [fake_port] - common.validate_oneview_resources_compatibility(oneview_client, - task) + common.validate_oneview_resources_compatibility(task) self.assertTrue(mock_sp_template.called) self.assertTrue(mock_sh_type.called) self.assertTrue(mock_enclosure.called) diff --git a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py index 7304786de0..526edd4940 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py @@ -81,9 +81,6 @@ def _setup_node_in_cleanfailed_state_without_oneview_error(node): class OneViewDriverDeploy(deploy.OneViewPeriodicTasks): oneview_driver = 'fake_oneview' - def __init__(self): - self.client = mock.MagicMock() - @mock.patch('ironic.objects.Node', spec_set=True, autospec=True) @mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview') @@ -114,9 +111,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.deploy._periodic_check_nodes_taken_by_oneview( self.os_primary, self.context ) - mock_is_node_in_use_by_oneview.assert_called_once_with( - self.deploy.client, self.node - ) + mock_is_node_in_use_by_oneview.assert_called_once_with(self.node) self.assertTrue(self.os_primary.update_node.called) self.assertTrue(self.os_primary.do_provisioning_action.called) self.assertTrue(self.node.maintenance) @@ -133,9 +128,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.deploy._periodic_check_nodes_taken_by_oneview( self.os_primary, self.context ) - mock_is_node_in_use_by_oneview.assert_called_once_with( - self.deploy.client, self.node - ) + mock_is_node_in_use_by_oneview.assert_called_once_with(self.node) self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertFalse(self.node.maintenance) @@ -151,9 +144,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.deploy._periodic_check_nodes_taken_by_oneview( self.os_primary, self.context ) - mock_is_node_in_use_by_oneview.assert_called_once_with( - self.deploy.client, self.node - ) + mock_is_node_in_use_by_oneview.assert_called_once_with(self.node) self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertFalse(self.node.maintenance) @@ -169,9 +160,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.deploy._periodic_check_nodes_freed_by_oneview( self.os_primary, self.context ) - mock_is_node_in_use_by_oneview.assert_called_once_with( - self.deploy.client, self.node - ) + mock_is_node_in_use_by_oneview.assert_called_once_with(self.node) self.assertTrue(self.os_primary.update_node.called) self.assertTrue(self.os_primary.do_provisioning_action.called) self.assertFalse(self.node.maintenance) @@ -186,9 +175,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.deploy._periodic_check_nodes_freed_by_oneview( self.os_primary, self.context ) - mock_is_node_in_use_by_oneview.assert_called_once_with( - self.deploy.client, self.node - ) + mock_is_node_in_use_by_oneview.assert_called_once_with(self.node) self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertTrue(self.node.maintenance) @@ -205,9 +192,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.deploy._periodic_check_nodes_freed_by_oneview( self.os_primary, self.context ) - mock_is_node_in_use_by_oneview.assert_called_once_with( - self.deploy.client, self.node - ) + mock_is_node_in_use_by_oneview.assert_called_once_with(self.node) self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertTrue(self.node.maintenance) @@ -246,7 +231,6 @@ class OneViewPeriodicTasks(db_base.DbTestCase): self.assertNotIn('oneview_error', self.node.driver_internal_info) -@mock.patch.object(common, 'get_hponeview_client') class OneViewIscsiDeployTestCase(db_base.DbTestCase): def setUp(self): @@ -270,7 +254,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): node_id=self.node.id) self.info = common.get_oneview_info(self.node) - def test_get_properties(self, mock_get_ov_client): + def test_get_properties(self): expected = common.COMMON_PROPERTIES self.assertEqual(expected, self.driver.deploy.get_properties()) @@ -278,19 +262,17 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): spect_set=True, autospec=True) @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate', spec_set=True, autospec=True) - def test_validate(self, iscsi_deploy_validate_mock, - mock_validate_resources, mock_ov_client): + def test_validate(self, iscsi_deploy_validate_mock, mock_validate): with task_manager.acquire(self.context, self.node.uuid, shared=False) as task: task.driver.deploy.validate(task) - self.assertTrue(mock_validate_resources.called) + self.assertTrue(mock_validate.called) iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task) @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True) @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') def test_prepare( - self, allocate_server_hardware_mock, iscsi_deploy_prepare_mock, - mock_get_ov_client): + self, allocate_server_hardware_mock, iscsi_deploy_prepare_mock): self.node.provision_state = states.DEPLOYING self.node.save() with task_manager.acquire(self.context, self.node.uuid) as task: @@ -299,8 +281,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): self.assertTrue(allocate_server_hardware_mock.called) @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True) - def test_prepare_active_node( - self, iscsi_deploy_prepare_mock, mock_get_ov_client): + def test_prepare_active_node(self, iscsi_deploy_prepare_mock): """Ensure nodes in running states are not inadvertently changed.""" test_states = list(states.STABLE_STATES) test_states.extend([ @@ -318,13 +299,13 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): mock.ANY, task) @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'deploy', autospec=True) - def test_deploy(self, iscsi_deploy_mock, mock_get_ov_client): + def test_deploy(self, iscsi_deploy_mock): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.deploy.deploy(task) iscsi_deploy_mock.assert_called_once_with(mock.ANY, task) @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', autospec=True) - def test_tear_down(self, iscsi_tear_down_mock, mock_get_ov_client): + def test_tear_down(self, iscsi_tear_down_mock): iscsi_tear_down_mock.return_value = states.DELETED with task_manager.acquire(self.context, self.node.uuid) as task: returned_state = task.driver.deploy.tear_down(task) @@ -334,8 +315,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', autospec=True) @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') def test_tear_down_with_automated_clean_disabled( - self, deallocate_server_hardware_mock, iscsi_tear_down_mock, - mock_get_ov_client): + self, deallocate_server_hardware_mock, iscsi_tear_down_mock,): CONF.conductor.automated_clean = False iscsi_tear_down_mock.return_value = states.DELETED @@ -349,8 +329,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): autospec=True) @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') def test_prepare_cleaning( - self, allocate_server_hardware_mock, iscsi_prep_clean_mock, - mock_get_ov_client): + self, allocate_server_hardware_mock, iscsi_prep_clean_mock): iscsi_prep_clean_mock.return_value = states.CLEANWAIT with task_manager.acquire(self.context, self.node.uuid) as task: ret = task.driver.deploy.prepare_cleaning(task) @@ -362,8 +341,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): autospec=True) @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') def test_tear_down_cleaning( - self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock, - mock_get_ov_client): + self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock): iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT with task_manager.acquire(self.context, self.node.uuid) as task: @@ -372,7 +350,6 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): self.assertTrue(deallocate_server_hardware_mock.called) -@mock.patch.object(common, 'get_hponeview_client') class OneViewAgentDeployTestCase(db_base.DbTestCase): def setUp(self): super(OneViewAgentDeployTestCase, self).setUp() @@ -395,7 +372,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): node_id=self.node.id) self.info = common.get_oneview_info(self.node) - def test_get_properties(self, mock_get_ov_client): + def test_get_properties(self): expected = common.COMMON_PROPERTIES self.assertEqual(expected, self.driver.deploy.get_properties()) @@ -403,19 +380,17 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): spect_set=True, autospec=True) @mock.patch.object(agent.AgentDeploy, 'validate', spec_set=True, autospec=True) - def test_validate(self, agent_deploy_validate_mock, - mock_validate_resources, mock_ov_client): + def test_validate(self, agent_deploy_validate_mock, mock_validate): with task_manager.acquire(self.context, self.node.uuid, shared=False) as task: task.driver.deploy.validate(task) - self.assertTrue(mock_validate_resources.called) + self.assertTrue(mock_validate.called) agent_deploy_validate_mock.assert_called_once_with(mock.ANY, task) @mock.patch.object(agent.AgentDeploy, 'prepare', autospec=True) @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') def test_prepare( - self, allocate_server_hardware_mock, agent_deploy_prepare_mock, - mock_get_ov_client): + self, allocate_server_hardware_mock, agent_deploy_prepare_mock): self.node.provision_state = states.DEPLOYING self.node.save() with task_manager.acquire(self.context, self.node.uuid) as task: @@ -424,8 +399,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): self.assertTrue(allocate_server_hardware_mock.called) @mock.patch.object(agent.AgentDeploy, 'prepare', autospec=True) - def test_prepare_active_node( - self, agent_deploy_prepare_mock, mock_get_ov_client): + def test_prepare_active_node(self, agent_deploy_prepare_mock): """Ensure nodes in running states are not inadvertently changed.""" test_states = list(states.STABLE_STATES) test_states.extend([states.CLEANING, @@ -441,7 +415,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): mock.ANY, task) @mock.patch.object(agent.AgentDeploy, 'deploy', autospec=True) - def test_deploy(self, agent_deploy_mock, mock_get_ov_client): + def test_deploy(self, agent_deploy_mock): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.deploy.deploy(task) agent_deploy_mock.assert_called_once_with(mock.ANY, task) @@ -450,8 +424,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): autospec=True) @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') def test_tear_down_with_automated_clean_disabled( - self, deallocate_server_hardware_mock, agent_tear_down_mock, - mock_get_ov_client): + self, deallocate_server_hardware_mock, agent_tear_down_mock): CONF.conductor.automated_clean = False agent_tear_down_mock.return_value = states.DELETED with task_manager.acquire(self.context, self.node.uuid) as task: @@ -463,8 +436,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): @mock.patch.object(agent.AgentDeploy, 'prepare_cleaning', autospec=True) @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') def test_prepare_cleaning( - self, allocate_server_hardware_mock, - agent_prep_clean_mock, mock_get_ov_client): + self, allocate_server_hardware_mock, agent_prep_clean_mock): agent_prep_clean_mock.return_value = states.CLEANWAIT with task_manager.acquire(self.context, self.node.uuid) as task: ret = task.driver.deploy.prepare_cleaning(task) @@ -475,8 +447,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): @mock.patch.object(agent.AgentDeploy, 'tear_down_cleaning', autospec=True) @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') def test_tear_down_cleaning( - self, deallocate_server_hardware_mock, - agent_tear_down_clean_mock, mock_get_ov_client): + self, deallocate_server_hardware_mock, agent_tear_down_clean_mock): agent_tear_down_clean_mock.return_value = states.CLEANWAIT with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.deploy.tear_down_cleaning(task) diff --git a/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py b/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py index 44929456a6..97b99eef10 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py @@ -55,14 +55,12 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): # Tests for prepare def test_prepare_node_is_in_use_by_oneview(self, mock_oneview_client): """`prepare` behavior when the node has a Profile on OneView.""" - client = mock_oneview_client() deploy_utils.is_node_in_use_by_oneview.return_value = True with task_manager.acquire(self.context, self.node.uuid) as task: task.node.provision_state = states.DEPLOYING self.assertRaises( exception.InstanceDeployFailure, deploy_utils.prepare, - client, task ) @@ -72,7 +70,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): """`prepare` behavior when the node is free from OneView standpoint.""" with task_manager.acquire(self.context, self.node.uuid) as task: task.node.provision_state = states.DEPLOYING - deploy_utils.prepare(mock_oneview_client(), task) + deploy_utils.prepare(task) self.assertTrue(mock_save.called) # Tests for tear_down @@ -86,7 +84,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): self.assertIn( 'applied_server_profile_uri', task.node.driver_info ) - deploy_utils.tear_down(client, task) + deploy_utils.tear_down(task) self.assertNotIn( 'applied_server_profile_uri', task.node.driver_info ) @@ -101,7 +99,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): self.assertFalse( 'applied_server_profile_uri' in task.node.driver_info ) - deploy_utils.prepare_cleaning(mock_oneview_client(), task) + deploy_utils.prepare_cleaning(task) self.assertTrue( 'applied_server_profile_uri' in task.node.driver_info ) @@ -118,7 +116,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): task.node.driver_info['applied_server_profile_uri'] = ( 'same/sp_applied' ) - deploy_utils.prepare_cleaning(client, task) + deploy_utils.prepare_cleaning(task) self.assertFalse(mock_node_save.called) def test_prepare_cleaning_node_is_in_use_by_oneview( @@ -130,7 +128,6 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): self.assertRaises( exception.NodeCleaningFailure, deploy_utils.prepare_cleaning, - mock_oneview_client(), task ) @@ -145,7 +142,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): self.assertTrue( 'applied_server_profile_uri' in task.node.driver_info ) - deploy_utils.tear_down_cleaning(client, task) + deploy_utils.tear_down_cleaning(task) self.assertFalse( 'applied_server_profile_uri' in task.node.driver_info ) @@ -296,7 +293,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, self.node.uuid) as task: deploy_utils.allocate_server_hardware_to_ironic( - client, task.node, 'serverProfileName' + task.node, 'serverProfileName' ) self.assertTrue(mock_node_save.called) self.assertIn('applied_server_profile_uri', task.node.driver_info) @@ -320,7 +317,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): 'any/applied_sp_uri/' ) deploy_utils.allocate_server_hardware_to_ironic( - client, task.node, 'serverProfileName' + task.node, 'serverProfileName' ) self.assertTrue(mock_node_save.called) @@ -335,9 +332,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase): task.node.driver_info['applied_server_profile_uri'] = ( 'any/applied_sp_uri/' ) - deploy_utils.deallocate_server_hardware_from_ironic( - client, task - ) + deploy_utils.deallocate_server_hardware_from_ironic(task) self.assertTrue(client.server_profiles.delete.called) self.assertNotIn( 'applied_server_profile_uri', task.node.driver_info diff --git a/ironic/tests/unit/drivers/modules/oneview/test_management.py b/ironic/tests/unit/drivers/modules/oneview/test_management.py index af48dbe9b1..0d06a0c996 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_management.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_management.py @@ -214,7 +214,6 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase): ) -@mock.patch.object(common, 'get_hponeview_client') class OneViewManagementDriverTestCase(db_base.DbTestCase): def setUp(self): @@ -237,7 +236,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): spect_set=True, autospec=True) @mock.patch.object(common, 'validate_oneview_resources_compatibility', spect_set=True, autospec=True) - def test_validate(self, mock_validate, mock_ironic_node, mock_ov_client): + def test_validate(self, mock_validate, mock_ironic_node): mock_ironic_node.return_value = True with task_manager.acquire(self.context, self.node.uuid, shared=False) as task: @@ -246,15 +245,13 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic', spect_set=True, autospec=True) - def test_validate_for_node_not_in_use_by_ironic( - self, mock_ironic_node, mock_get_ov_client - ): + def test_validate_for_node_not_in_use_by_ironic(self, mock_ironic_node): mock_ironic_node.return_value = False with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.management.validate, task) - def test_validate_fail(self, mock_get_ov_client): + def test_validate_fail(self): node = obj_utils.create_test_node( self.context, uuid=uuidutils.generate_uuid(), id=999, driver='fake_oneview' @@ -264,19 +261,19 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): task.driver.management.validate, task) @mock.patch.object(common, 'validate_oneview_resources_compatibility') - def test_validate_fail_exception(self, mock_validate, mock_get_ov_client): + def test_validate_fail_exception(self, mock_validate): mock_validate.side_effect = exception.OneViewError('message') with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.management.validate, task) - def test_get_properties(self, mock_get_ov_client): + def test_get_properties(self): expected = common.COMMON_PROPERTIES self.assertItemsEqual(expected, self.driver.management.get_properties()) - def test_set_boot_device_persistent_true(self, mock_get_ov_client): + def test_set_boot_device_persistent_true(self): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.management.set_boot_device( task, boot_devices.PXE, True) @@ -287,7 +284,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): next_boot_device.get('boot_device'), boot_devices.PXE) self.assertTrue(next_boot_device.get('persistent')) - def test_set_boot_device_persistent_false(self, mock_get_ov_client): + def test_set_boot_device_persistent_false(self): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.management.set_boot_device( task, boot_devices.PXE, False) @@ -298,7 +295,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): next_boot_device.get('boot_device'), boot_devices.PXE) self.assertFalse(next_boot_device.get('persistent')) - def test_set_boot_device_invalid_device(self, mock_get_ov_client): + def test_set_boot_device_invalid_device(self): with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.management.set_boot_device, @@ -306,7 +303,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): driver_internal_info = task.node.driver_internal_info self.assertNotIn('next_boot_device', driver_internal_info) - def test_get_supported_boot_devices(self, mock_get_ov_client): + def test_get_supported_boot_devices(self): with task_manager.acquire(self.context, self.node.uuid) as task: expected = [ boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM @@ -316,10 +313,10 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): task.driver.management.get_supported_boot_devices(task), ) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(common, 'get_ilorest_client') - def test_get_boot_device( - self, mock_ilo_client, mock_get_ov_client): - client = mock_get_ov_client() + def test_get_boot_device(self, mock_ilo_client, mock_ov_client): + client = mock_ov_client() ilo_client = mock_ilo_client() self.driver.management.client = client device_mapping = management.BOOT_DEVICE_MAP_ONEVIEW.items() @@ -337,11 +334,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): self.assertTrue(ilo_client.get.called) @mock.patch.object(common, 'get_ilorest_client') - def test_get_boot_device_from_next_boot_device( - self, mock_ilo_client, mock_get_ov_client): - client = mock_get_ov_client() + def test_get_boot_device_from_next_boot_device(self, mock_ilo_client): ilo_client = mock_ilo_client() - self.driver.management.client = client with task_manager.acquire(self.context, self.node.uuid) as task: driver_internal_info = task.node.driver_internal_info @@ -355,13 +349,12 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): } response = self.driver.management.get_boot_device(task) self.assertEqual(expected_response, response) - self.assertFalse(client.get_boot_order.called) self.assertFalse(ilo_client.get.called) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(common, 'get_ilorest_client') - def test_get_boot_device_fail( - self, mock_ilo_client, mock_get_ov_client): - client = mock_get_ov_client() + def test_get_boot_device_fail(self, mock_ilo_client, mock_ov_client): + client = mock_ov_client() ilo_client = mock_ilo_client() self.driver.management.client = client exc = client_exception.HPOneViewException() @@ -376,14 +369,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): self.assertFalse(ilo_client.get.called) @mock.patch.object(common, 'get_ilorest_client') - def test_get_boot_device_unknown_device( - self, mock_ilo_client, mock_get_ov_client): - client = mock_get_ov_client() + def test_get_boot_device_unknown_device(self, mock_ilo_client): ilo_client = mock_ilo_client() - order = ['Eggs', 'Bacon'] - profile = {'boot': {'order': order}} - client.server_profiles.get.return_value = profile - self.driver.management.client = client with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.InvalidParameterValue, @@ -392,7 +379,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): ) self.assertFalse(ilo_client.get.called) - def test_get_sensors_data_not_implemented(self, mock_get_ov_client): + def test_get_sensors_data_not_implemented(self): with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( NotImplementedError, diff --git a/ironic/tests/unit/drivers/modules/oneview/test_power.py b/ironic/tests/unit/drivers/modules/oneview/test_power.py index f4cb60055e..193d71ac11 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_power.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_power.py @@ -33,7 +33,6 @@ from ironic.tests.unit.objects import utils as obj_utils client_exception = importutils.try_import('hpOneView.exceptions') -@mock.patch.object(common, 'get_hponeview_client') class OneViewPowerDriverTestCase(db_base.DbTestCase): def setUp(self): @@ -54,12 +53,12 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): deploy_utils.is_node_in_use_by_oneview = mock.Mock(return_value=False) @mock.patch.object(common, 'validate_oneview_resources_compatibility') - def test_validate(self, mock_validate, mock_get_ov_client): + def test_validate(self, mock_validate): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.power.validate(task) self.assertTrue(mock_validate.called) - def test_validate_missing_parameter(self, mock_get_ov_client): + def test_validate_missing_parameter(self): node = obj_utils.create_test_node( self.context, uuid=uuidutils.generate_uuid(), id=999, driver='fake_oneview') @@ -70,7 +69,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): task) @mock.patch.object(common, 'validate_oneview_resources_compatibility') - def test_validate_exception(self, mock_validate, mock_get_ov_client): + def test_validate_exception(self, mock_validate): mock_validate.side_effect = exception.OneViewError('message') with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( @@ -78,7 +77,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): task.driver.power.validate, task) - def test_validate_node_in_use_by_oneview(self, mock_get_ov_client): + def test_validate_node_in_use_by_oneview(self): deploy_utils.is_node_in_use_by_oneview.return_value = True with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( @@ -86,34 +85,34 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): task.driver.power.validate, task) - def test_get_properties(self, mock_get_ov_client): + def test_get_properties(self): expected = common.COMMON_PROPERTIES self.assertEqual(expected, self.driver.power.get_properties()) + @mock.patch.object(common, 'get_hponeview_client') def test_get_power_state(self, mock_get_ov_client): client = mock_get_ov_client() server_hardware = {'powerState': 'On'} client.server_hardware.get.return_value = server_hardware - self.driver.power.client = client with task_manager.acquire(self.context, self.node.uuid) as task: power_state = self.driver.power.get_power_state(task) self.assertEqual(states.POWER_ON, power_state) + @mock.patch.object(common, 'get_hponeview_client') def test_get_power_state_fail(self, mock_get_ov_client): client = mock_get_ov_client() exc = client_exception.HPOneViewException() client.server_hardware.get.side_effect = exc - self.driver.power.client = client with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.OneViewError, self.driver.power.get_power_state, task) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_on(self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() - self.driver.power.client = client server_hardware = self.node.driver_info.get('server_hardware_uri') with task_manager.acquire(self.context, self.node.uuid) as task: self.driver.power.set_power_state(task, states.POWER_ON) @@ -122,10 +121,10 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): update.assert_called_once_with(power.POWER_ON, server_hardware, timeout=-1) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_off(self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() - self.driver.power.client = client server_hardware = self.node.driver_info.get('server_hardware_uri') with task_manager.acquire(self.context, self.node.uuid) as task: self.driver.power.set_power_state(task, states.POWER_OFF) @@ -134,10 +133,10 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): update.assert_called_once_with(power.POWER_OFF, server_hardware, timeout=-1) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_reboot(self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() - self.driver.power.client = client server_hardware = self.node.driver_info.get('server_hardware_uri') with task_manager.acquire(self.context, self.node.uuid) as task: self.driver.power.set_power_state(task, states.REBOOT) @@ -146,12 +145,12 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): update = client.server_hardware.update_power_state update.assert_has_calls(calls) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_on_fail(self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() exc = client_exception.HPOneViewException() client.server_hardware.update_power_state.side_effect = exc - self.driver.power.client = client with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.OneViewError, @@ -160,13 +159,13 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): states.POWER_ON) mock_set_boot_device.assert_called_once_with(task) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_off_fail( self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() exc = client_exception.HPOneViewException() client.server_hardware.update_power_state.side_effect = exc - self.driver.power.client = client with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.OneViewError, @@ -175,16 +174,15 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): states.POWER_OFF) self.assertFalse(mock_set_boot_device.called) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_reboot_fail_with_hardware_on( self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() server_hardware = {'powerState': 'On'} client.server_hardware.get.return_value = server_hardware - self.driver.power.client = client exc = client_exception.HPOneViewException() client.server_hardware.update_power_state.side_effect = exc - self.driver.power.client = client with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.OneViewError, @@ -192,16 +190,15 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): task) self.assertFalse(mock_set_boot_device.called) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_reboot_fail_with_hardware_off( self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() server_hardware = {'powerState': 'Off'} client.server_hardware.get.return_value = server_hardware - self.driver.power.client = client exc = client_exception.HPOneViewException() client.server_hardware.update_power_state.side_effect = exc - self.driver.power.client = client with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.OneViewError, @@ -210,8 +207,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): mock_set_boot_device.assert_called_once_with(task) @mock.patch.object(management, 'set_boot_device') - def test_set_power_invalid_state( - self, mock_set_boot_device, mock_get_ov_client): + def test_set_power_invalid_state(self, mock_set_boot_device): with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises( exception.InvalidParameterValue, @@ -220,13 +216,13 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): 'fake_state') self.assertFalse(mock_set_boot_device.called) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_reboot_with_hardware_on( self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() server_hardware = {'powerState': 'On'} client.server_hardware.get.return_value = server_hardware - self.driver.power.client = client server_hardware = self.node.driver_info.get('server_hardware_uri') with task_manager.acquire(self.context, self.node.uuid) as task: self.driver.power.reboot(task) @@ -236,13 +232,13 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase): update.assert_has_calls(calls) mock_set_boot_device.assert_called_once_with(task) + @mock.patch.object(common, 'get_hponeview_client') @mock.patch.object(management, 'set_boot_device') def test_set_power_reboot_with_hardware_off( self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client() server_hardware = {'powerState': 'Off'} client.server_hardware.get.return_value = server_hardware - self.driver.power.client = client server_hardware = self.node.driver_info.get('server_hardware_uri') with task_manager.acquire(self.context, self.node.uuid) as task: self.driver.power.reboot(task, timeout=-1)