Revert "Get a new OneView client when needed"

Reverting these changes because python-hpOneView does not provide HTTPS
secure connection with custom CAcert and could cause a possible security issue.

This reverts commit faf3f6b210b3c3ed604c55efb79b0db1936b7fad.

Change-Id: I7032e548365c405b00feedd367b497b95cbf1942

11 files changed, 218 insertions, 131 deletions

diff --git a/ironic/drivers/modules/oneview/common.py b/ironic/drivers/modules/oneview/common.py
index 2bd23436c..122c847f2 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(server_hardware):
+def get_ilorest_client(oneview_client, server_hardware):
     """Generate an instance of the iLORest library client.
 
-    :param server_hardware: a server hardware uuid or uri
+    :param oneview_client: an instance of a python-hpOneView
+    :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(task):
+def validate_oneview_resources_compatibility(oneview_client, 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(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)
+        has_server_profile(task, self.client)
         return func(self, *args, **kwargs)
     return inner
 
 
-def has_server_profile(task):
+def has_server_profile(task, client):
     """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')
-        oneview_client.server_profiles.get(profile)
+        client.server_profiles.get(profile)
     except client_exception.HPOneViewException as exc:
         LOG.error(
             "Failed to get server profile from OneView appliance for"
@@ -279,9 +279,10 @@ def has_server_profile(task):
         raise exception.OneViewError(error=exc)
 
 
-def _get_server_hardware_mac_from_ilo(server_hardware):
+def _get_server_hardware_mac_from_ilo(oneview_client, 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.
@@ -289,7 +290,7 @@ def _get_server_hardware_mac_from_ilo(server_hardware):
              if fails to get JSON object with the default path.
     """
     try:
-        client = get_ilorest_client(server_hardware)
+        client = get_ilorest_client(oneview_client, server_hardware)
         ilo_path = "/rest/v1/systems/1"
         hardware = jsonutils.loads(client.get(ilo_path).text)
         hardware_mac = hardware['HostCorrelation']['HostMACAddress'][0]
@@ -496,7 +497,8 @@ 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(server_hardware)
+        mac = _get_server_hardware_mac_from_ilo(
+            oneview_client, 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 5bf4cdf7e..3f2704986 100644
--- a/ironic/drivers/modules/oneview/deploy.py
+++ b/ironic/drivers/modules/oneview/deploy.py
@@ -66,7 +66,9 @@ class OneViewPeriodicTasks(object):
             node = objects.Node.get(context, node_uuid)
 
             try:
-                oneview_using = deploy_utils.is_node_in_use_by_oneview(node)
+                oneview_using = deploy_utils.is_node_in_use_by_oneview(
+                    self.client, node
+                )
             except exception.OneViewError as e:
                 # NOTE(xavierr): Skip this node and process the
                 # remaining nodes. This node will be checked in
@@ -126,7 +128,7 @@ class OneViewPeriodicTasks(object):
 
                 try:
                     oneview_using = deploy_utils.is_node_in_use_by_oneview(
-                        node
+                        self.client, node
                     )
                 except exception.OneViewError as e:
                     # NOTE(xavierr): Skip this node and process the
@@ -216,6 +218,10 @@ 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()
 
@@ -223,30 +229,30 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
     def validate(self, task):
         common.verify_node_info(task.node)
         try:
-            common.validate_oneview_resources_compatibility(task)
+            common.validate_oneview_resources_compatibility(self.client, 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(task)
+        deploy_utils.prepare(self.client, 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(task)
+            deploy_utils.tear_down(self.client, task)
         return super(OneViewIscsiDeploy, self).tear_down(task)
 
     @METRICS.timer('OneViewIscsiDeploy.prepare_cleaning')
     def prepare_cleaning(self, task):
-        deploy_utils.prepare_cleaning(task)
+        deploy_utils.prepare_cleaning(self.client, 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(task)
+        deploy_utils.tear_down_cleaning(self.client, task)
         super(OneViewIscsiDeploy, self).tear_down_cleaning(task)
 
 
@@ -255,6 +261,10 @@ 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()
 
@@ -262,28 +272,28 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks):
     def validate(self, task):
         common.verify_node_info(task.node)
         try:
-            common.validate_oneview_resources_compatibility(task)
+            common.validate_oneview_resources_compatibility(self.client, 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(task)
+        deploy_utils.prepare(self.client, 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(task)
+            deploy_utils.tear_down(self.client, task)
         return super(OneViewAgentDeploy, self).tear_down(task)
 
     @METRICS.timer('OneViewAgentDeploy.prepare_cleaning')
     def prepare_cleaning(self, task):
-        deploy_utils.prepare_cleaning(task)
+        deploy_utils.prepare_cleaning(self.client, 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(task)
+        deploy_utils.tear_down_cleaning(self.client, 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 a8a05b0a1..9b6b31b1d 100644
--- a/ironic/drivers/modules/oneview/deploy_utils.py
+++ b/ironic/drivers/modules/oneview/deploy_utils.py
@@ -32,13 +32,14 @@ def get_properties():
     return common.COMMON_PROPERTIES
 
 
-def prepare(task):
+def prepare(client, 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
@@ -54,13 +55,14 @@ def prepare(task):
                 {"instance_name": instance_display_name,
                  "instance_uuid": instance_uuid}
             )
-            allocate_server_hardware_to_ironic(task.node, server_profile_name)
+            allocate_server_hardware_to_ironic(client, task.node,
+                                               server_profile_name)
         except exception.OneViewError as e:
             raise exception.InstanceDeployFailure(node=task.node.uuid,
                                                   reason=e)
 
 
-def tear_down(task):
+def tear_down(client, task):
     """Remove Server profile and update the node when tear down.
 
     This method is responsible for power a Server Hardware off, remove a Server
@@ -68,24 +70,26 @@ def tear_down(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(task)
+        deallocate_server_hardware_from_ironic(client, task)
     except exception.OneViewError as e:
         raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e)
 
 
-def prepare_cleaning(task):
+def prepare_cleaning(client, 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
@@ -94,7 +98,8 @@ def prepare_cleaning(task):
     """
     try:
         server_profile_name = "Ironic Cleaning [%s]" % task.node.uuid
-        allocate_server_hardware_to_ironic(task.node, server_profile_name)
+        allocate_server_hardware_to_ironic(client, 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
@@ -105,7 +110,7 @@ def prepare_cleaning(task):
                                             reason=e)
 
 
-def tear_down_cleaning(task):
+def tear_down_cleaning(client, 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
@@ -113,13 +118,14 @@ def tear_down_cleaning(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(task)
+        deallocate_server_hardware_from_ironic(client, task)
     except exception.OneViewError as e:
         raise exception.NodeCleaningFailure(node=task.node.uuid, reason=e)
 
@@ -165,9 +171,10 @@ 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(node):
+def is_node_in_use_by_oneview(client, 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.
@@ -178,7 +185,6 @@ def is_node_in_use_by_oneview(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
@@ -190,9 +196,10 @@ def is_node_in_use_by_oneview(node):
                                          predicate, positive, negative)
 
 
-def is_node_in_use_by_ironic(node):
+def is_node_in_use_by_ironic(client, 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.
@@ -203,7 +210,6 @@ def is_node_in_use_by_ironic(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
@@ -274,9 +280,11 @@ def _del_applied_server_profile_uri_field(node):
     node.save()
 
 
-def allocate_server_hardware_to_ironic(node, server_profile_name):
+def allocate_server_hardware_to_ironic(client, 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
@@ -284,8 +292,7 @@ def allocate_server_hardware_to_ironic(node, server_profile_name):
             Hardware to ironic
 
     """
-    client = common.get_hponeview_client()
-    node_in_use_by_oneview = is_node_in_use_by_oneview(node)
+    node_in_use_by_oneview = is_node_in_use_by_oneview(client, node)
 
     if not node_in_use_by_oneview:
         oneview_info = common.get_oneview_info(node)
@@ -340,17 +347,17 @@ def allocate_server_hardware_to_ironic(node, server_profile_name):
         raise exception.OneViewError(error=msg)
 
 
-def deallocate_server_hardware_from_ironic(task):
+def deallocate_server_hardware_from_ironic(client, 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(node):
+    if is_node_in_use_by_ironic(client, 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 f06652dc5..40d674547 100644
--- a/ironic/drivers/modules/oneview/inspect.py
+++ b/ironic/drivers/modules/oneview/inspect.py
@@ -30,6 +30,10 @@ 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()
 
@@ -50,7 +54,7 @@ class OneViewInspect(inspector.Inspector):
         common.verify_node_info(task.node)
 
         try:
-            common.validate_oneview_resources_compatibility(task)
+            common.validate_oneview_resources_compatibility(self.client, task)
         except exception.OneViewError as oneview_exc:
             raise exception.InvalidParameterValue(oneview_exc)
 
@@ -58,7 +62,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(
-            task.node, profile_name
+            self.client, task.node, profile_name
         )
         return super(OneViewInspect, self).inspect_hardware(task)
 
@@ -89,6 +93,8 @@ class OneViewInspect(inspector.Inspector):
         if state_before == states.INSPECTING and state_after in [
                 states.MANAGEABLE, states.INSPECTFAIL
         ]:
-            deploy_utils.deallocate_server_hardware_from_ironic(task.node)
+            deploy_utils.deallocate_server_hardware_from_ironic(
+                self.client, task.node
+            )
 
         return result
diff --git a/ironic/drivers/modules/oneview/management.py b/ironic/drivers/modules/oneview/management.py
index f164c2a9a..bf6549c22 100644
--- a/ironic/drivers/modules/oneview/management.py
+++ b/ironic/drivers/modules/oneview/management.py
@@ -68,8 +68,9 @@ 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(server_hardware)
+            ilo_client = common.get_ilorest_client(client, server_hardware)
             boot_device = BOOT_DEVICE_MAP_ILO.get(boot_device)
             body = {
                 "Boot": {
@@ -92,8 +93,9 @@ 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(server_hardware)
+    ilo_client = common.get_ilorest_client(client, server_hardware)
     response = ilo_client.get(path=ILO_SYSTEM_PATH,
                               headers=ILO_REQUEST_HEADERS)
     boot = response.dict.get('Boot')
@@ -112,7 +114,7 @@ def set_boot_device(task):
     :raises: OneViewError if the communication with OneView fails
     """
     client = common.get_hponeview_client()
-    common.has_server_profile(task)
+    common.has_server_profile(task, client)
     driver_internal_info = task.node.driver_internal_info
     next_boot_device = driver_internal_info.get('next_boot_device')
 
@@ -161,6 +163,10 @@ 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()
 
@@ -181,9 +187,12 @@ class OneViewManagement(base.ManagementInterface):
                  resources in OneView
         """
         common.verify_node_info(task.node)
+
         try:
-            common.validate_oneview_resources_compatibility(task)
-            if not deploy_utils.is_node_in_use_by_ironic(task.node):
+            common.validate_oneview_resources_compatibility(self.client, task)
+            if not deploy_utils.is_node_in_use_by_ironic(
+                self.client, task.node
+            ):
                 raise exception.InvalidParameterValue(
                     _("Node %s is not in use by ironic.") % task.node.uuid)
         except exception.OneViewError as oneview_exc:
@@ -255,7 +264,6 @@ 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
@@ -264,7 +272,7 @@ class OneViewManagement(base.ManagementInterface):
         server_profile = driver_info.get('applied_server_profile_uri')
 
         try:
-            profile = client.server_profiles.get(server_profile)
+            profile = self.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 3cedca81a..ab0091f55 100644
--- a/ironic/drivers/modules/oneview/power.py
+++ b/ironic/drivers/modules/oneview/power.py
@@ -56,6 +56,10 @@ 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()
 
@@ -84,9 +88,9 @@ class OneViewPower(base.PowerInterface):
         common.verify_node_info(task.node)
 
         try:
-            common.validate_oneview_resources_compatibility(task)
+            common.validate_oneview_resources_compatibility(self.client, task)
 
-            if deploy_utils.is_node_in_use_by_oneview(task.node):
+            if deploy_utils.is_node_in_use_by_oneview(self.client, task.node):
                 raise exception.InvalidParameterValue(
                     _("Node %s is in use by OneView.") % task.node.uuid)
 
@@ -104,9 +108,8 @@ class OneViewPower(base.PowerInterface):
                  resource
         """
         server_hardware = task.node.driver_info.get('server_hardware_uri')
-        client = common.get_hponeview_client()
         try:
-            server_hardware = client.server_hardware.get(server_hardware)
+            server_hardware = self.client.server_hardware.get(server_hardware)
         except client_exception.HPOneViewException as exc:
             LOG.error(
                 "Error getting power state for node %(node)s. Error:"
@@ -132,8 +135,7 @@ 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.
         """
-        client = common.get_hponeview_client()
-        if deploy_utils.is_node_in_use_by_oneview(task.node):
+        if deploy_utils.is_node_in_use_by_oneview(self.client, task.node):
             raise exception.PowerStateFailure(_(
                 "Cannot set power state '%(power_state)s' to node %(node)s. "
                 "The node is in use by OneView.") %
@@ -155,19 +157,19 @@ class OneViewPower(base.PowerInterface):
         try:
             if power_state == states.POWER_ON:
                 management.set_boot_device(task)
-                client.server_hardware.update_power_state(
+                self.client.server_hardware.update_power_state(
                     SET_POWER_STATE_MAP.get(power_state),
                     server_hardware, timeout=timeout)
             elif power_state == states.REBOOT:
-                client.server_hardware.update_power_state(
+                self.client.server_hardware.update_power_state(
                     SET_POWER_STATE_MAP.get(states.POWER_OFF), server_hardware,
                     timeout=timeout)
                 management.set_boot_device(task)
-                client.server_hardware.update_power_state(
+                self.client.server_hardware.update_power_state(
                     SET_POWER_STATE_MAP.get(states.POWER_ON), server_hardware,
                     timeout=timeout)
             else:
-                client.server_hardware.update_power_state(
+                self.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 2641c202b..0755d5c06 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_common.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_common.py
@@ -285,7 +285,8 @@ 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(task)
+            common.validate_oneview_resources_compatibility(oneview_client,
+                                                            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 526edd494..7304786de 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py
@@ -81,6 +81,9 @@ 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')
@@ -111,7 +114,9 @@ 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.node)
+        mock_is_node_in_use_by_oneview.assert_called_once_with(
+            self.deploy.client, self.node
+        )
         self.assertTrue(self.os_primary.update_node.called)
         self.assertTrue(self.os_primary.do_provisioning_action.called)
         self.assertTrue(self.node.maintenance)
@@ -128,7 +133,9 @@ 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.node)
+        mock_is_node_in_use_by_oneview.assert_called_once_with(
+            self.deploy.client, self.node
+        )
         self.assertFalse(self.os_primary.update_node.called)
         self.assertFalse(self.os_primary.do_provisioning_action.called)
         self.assertFalse(self.node.maintenance)
@@ -144,7 +151,9 @@ 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.node)
+        mock_is_node_in_use_by_oneview.assert_called_once_with(
+            self.deploy.client, self.node
+        )
         self.assertFalse(self.os_primary.update_node.called)
         self.assertFalse(self.os_primary.do_provisioning_action.called)
         self.assertFalse(self.node.maintenance)
@@ -160,7 +169,9 @@ 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.node)
+        mock_is_node_in_use_by_oneview.assert_called_once_with(
+            self.deploy.client, self.node
+        )
         self.assertTrue(self.os_primary.update_node.called)
         self.assertTrue(self.os_primary.do_provisioning_action.called)
         self.assertFalse(self.node.maintenance)
@@ -175,7 +186,9 @@ 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.node)
+        mock_is_node_in_use_by_oneview.assert_called_once_with(
+            self.deploy.client, self.node
+        )
         self.assertFalse(self.os_primary.update_node.called)
         self.assertFalse(self.os_primary.do_provisioning_action.called)
         self.assertTrue(self.node.maintenance)
@@ -192,7 +205,9 @@ 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.node)
+        mock_is_node_in_use_by_oneview.assert_called_once_with(
+            self.deploy.client, self.node
+        )
         self.assertFalse(self.os_primary.update_node.called)
         self.assertFalse(self.os_primary.do_provisioning_action.called)
         self.assertTrue(self.node.maintenance)
@@ -231,6 +246,7 @@ 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):
@@ -254,7 +270,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
                                                node_id=self.node.id)
         self.info = common.get_oneview_info(self.node)
 
-    def test_get_properties(self):
+    def test_get_properties(self, mock_get_ov_client):
         expected = common.COMMON_PROPERTIES
         self.assertEqual(expected, self.driver.deploy.get_properties())
 
@@ -262,17 +278,19 @@ 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):
+    def test_validate(self, iscsi_deploy_validate_mock,
+                      mock_validate_resources, mock_ov_client):
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
             task.driver.deploy.validate(task)
-            self.assertTrue(mock_validate.called)
+            self.assertTrue(mock_validate_resources.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):
+            self, allocate_server_hardware_mock, iscsi_deploy_prepare_mock,
+            mock_get_ov_client):
         self.node.provision_state = states.DEPLOYING
         self.node.save()
         with task_manager.acquire(self.context, self.node.uuid) as task:
@@ -281,7 +299,8 @@ 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):
+    def test_prepare_active_node(
+            self, iscsi_deploy_prepare_mock, mock_get_ov_client):
         """Ensure nodes in running states are not inadvertently changed."""
         test_states = list(states.STABLE_STATES)
         test_states.extend([
@@ -299,13 +318,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):
+    def test_deploy(self, iscsi_deploy_mock, mock_get_ov_client):
         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):
+    def test_tear_down(self, iscsi_tear_down_mock, mock_get_ov_client):
         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)
@@ -315,7 +334,8 @@ 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,):
+            self, deallocate_server_hardware_mock, iscsi_tear_down_mock,
+            mock_get_ov_client):
         CONF.conductor.automated_clean = False
         iscsi_tear_down_mock.return_value = states.DELETED
 
@@ -329,7 +349,8 @@ 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):
+            self, allocate_server_hardware_mock, iscsi_prep_clean_mock,
+            mock_get_ov_client):
         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)
@@ -341,7 +362,8 @@ 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):
+            self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock,
+            mock_get_ov_client):
         iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
@@ -350,6 +372,7 @@ 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()
@@ -372,7 +395,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
                                                node_id=self.node.id)
         self.info = common.get_oneview_info(self.node)
 
-    def test_get_properties(self):
+    def test_get_properties(self, mock_get_ov_client):
         expected = common.COMMON_PROPERTIES
         self.assertEqual(expected, self.driver.deploy.get_properties())
 
@@ -380,17 +403,19 @@ 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):
+    def test_validate(self, agent_deploy_validate_mock,
+                      mock_validate_resources, mock_ov_client):
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
             task.driver.deploy.validate(task)
-            self.assertTrue(mock_validate.called)
+            self.assertTrue(mock_validate_resources.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):
+            self, allocate_server_hardware_mock, agent_deploy_prepare_mock,
+            mock_get_ov_client):
         self.node.provision_state = states.DEPLOYING
         self.node.save()
         with task_manager.acquire(self.context, self.node.uuid) as task:
@@ -399,7 +424,8 @@ 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):
+    def test_prepare_active_node(
+            self, agent_deploy_prepare_mock, mock_get_ov_client):
         """Ensure nodes in running states are not inadvertently changed."""
         test_states = list(states.STABLE_STATES)
         test_states.extend([states.CLEANING,
@@ -415,7 +441,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
                     mock.ANY, task)
 
     @mock.patch.object(agent.AgentDeploy, 'deploy', autospec=True)
-    def test_deploy(self, agent_deploy_mock):
+    def test_deploy(self, agent_deploy_mock, mock_get_ov_client):
         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)
@@ -424,7 +450,8 @@ 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):
+            self, deallocate_server_hardware_mock, agent_tear_down_mock,
+            mock_get_ov_client):
         CONF.conductor.automated_clean = False
         agent_tear_down_mock.return_value = states.DELETED
         with task_manager.acquire(self.context, self.node.uuid) as task:
@@ -436,7 +463,8 @@ 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):
+            self, allocate_server_hardware_mock,
+            agent_prep_clean_mock, mock_get_ov_client):
         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)
@@ -447,7 +475,8 @@ 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):
+            self, deallocate_server_hardware_mock,
+            agent_tear_down_clean_mock, mock_get_ov_client):
         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 97b99eef1..44929456a 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py
@@ -55,12 +55,14 @@ 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
             )
 
@@ -70,7 +72,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(task)
+            deploy_utils.prepare(mock_oneview_client(), task)
             self.assertTrue(mock_save.called)
 
     # Tests for tear_down
@@ -84,7 +86,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             self.assertIn(
                 'applied_server_profile_uri', task.node.driver_info
             )
-            deploy_utils.tear_down(task)
+            deploy_utils.tear_down(client, task)
             self.assertNotIn(
                 'applied_server_profile_uri', task.node.driver_info
             )
@@ -99,7 +101,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             self.assertFalse(
                 'applied_server_profile_uri' in task.node.driver_info
             )
-            deploy_utils.prepare_cleaning(task)
+            deploy_utils.prepare_cleaning(mock_oneview_client(), task)
             self.assertTrue(
                 'applied_server_profile_uri' in task.node.driver_info
             )
@@ -116,7 +118,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             task.node.driver_info['applied_server_profile_uri'] = (
                 'same/sp_applied'
             )
-            deploy_utils.prepare_cleaning(task)
+            deploy_utils.prepare_cleaning(client, task)
             self.assertFalse(mock_node_save.called)
 
     def test_prepare_cleaning_node_is_in_use_by_oneview(
@@ -128,6 +130,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             self.assertRaises(
                 exception.NodeCleaningFailure,
                 deploy_utils.prepare_cleaning,
+                mock_oneview_client(),
                 task
             )
 
@@ -142,7 +145,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             self.assertTrue(
                 'applied_server_profile_uri' in task.node.driver_info
             )
-            deploy_utils.tear_down_cleaning(task)
+            deploy_utils.tear_down_cleaning(client, task)
             self.assertFalse(
                 'applied_server_profile_uri' in task.node.driver_info
             )
@@ -293,7 +296,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
             deploy_utils.allocate_server_hardware_to_ironic(
-                task.node, 'serverProfileName'
+                client, task.node, 'serverProfileName'
             )
             self.assertTrue(mock_node_save.called)
             self.assertIn('applied_server_profile_uri', task.node.driver_info)
@@ -317,7 +320,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
                 'any/applied_sp_uri/'
             )
             deploy_utils.allocate_server_hardware_to_ironic(
-                task.node, 'serverProfileName'
+                client, task.node, 'serverProfileName'
             )
             self.assertTrue(mock_node_save.called)
 
@@ -332,7 +335,9 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             task.node.driver_info['applied_server_profile_uri'] = (
                 'any/applied_sp_uri/'
             )
-            deploy_utils.deallocate_server_hardware_from_ironic(task)
+            deploy_utils.deallocate_server_hardware_from_ironic(
+                client, 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 0d06a0c99..af48dbe9b 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_management.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_management.py
@@ -214,6 +214,7 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
             )
 
 
+@mock.patch.object(common, 'get_hponeview_client')
 class OneViewManagementDriverTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -236,7 +237,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):
+    def test_validate(self, mock_validate, mock_ironic_node, mock_ov_client):
         mock_ironic_node.return_value = True
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
@@ -245,13 +246,15 @@ 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):
+    def test_validate_for_node_not_in_use_by_ironic(
+        self, mock_ironic_node, mock_get_ov_client
+    ):
         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):
+    def test_validate_fail(self, mock_get_ov_client):
         node = obj_utils.create_test_node(
             self.context, uuid=uuidutils.generate_uuid(),
             id=999, driver='fake_oneview'
@@ -261,19 +264,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):
+    def test_validate_fail_exception(self, mock_validate, mock_get_ov_client):
         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):
+    def test_get_properties(self, mock_get_ov_client):
         expected = common.COMMON_PROPERTIES
         self.assertItemsEqual(expected,
                               self.driver.management.get_properties())
 
-    def test_set_boot_device_persistent_true(self):
+    def test_set_boot_device_persistent_true(self, mock_get_ov_client):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             task.driver.management.set_boot_device(
                 task, boot_devices.PXE, True)
@@ -284,7 +287,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):
+    def test_set_boot_device_persistent_false(self, mock_get_ov_client):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             task.driver.management.set_boot_device(
                 task, boot_devices.PXE, False)
@@ -295,7 +298,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):
+    def test_set_boot_device_invalid_device(self, mock_get_ov_client):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(exception.InvalidParameterValue,
                               task.driver.management.set_boot_device,
@@ -303,7 +306,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):
+    def test_get_supported_boot_devices(self, mock_get_ov_client):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             expected = [
                 boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM
@@ -313,10 +316,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_ov_client):
-        client = mock_ov_client()
+    def test_get_boot_device(
+            self, mock_ilo_client, mock_get_ov_client):
+        client = mock_get_ov_client()
         ilo_client = mock_ilo_client()
         self.driver.management.client = client
         device_mapping = management.BOOT_DEVICE_MAP_ONEVIEW.items()
@@ -334,8 +337,11 @@ 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):
+    def test_get_boot_device_from_next_boot_device(
+            self, mock_ilo_client, mock_get_ov_client):
+        client = mock_get_ov_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
@@ -349,12 +355,13 @@ 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_ov_client):
-        client = mock_ov_client()
+    def test_get_boot_device_fail(
+            self, mock_ilo_client, mock_get_ov_client):
+        client = mock_get_ov_client()
         ilo_client = mock_ilo_client()
         self.driver.management.client = client
         exc = client_exception.HPOneViewException()
@@ -369,8 +376,14 @@ 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):
+    def test_get_boot_device_unknown_device(
+            self, mock_ilo_client, mock_get_ov_client):
+        client = mock_get_ov_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,
@@ -379,7 +392,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
             )
             self.assertFalse(ilo_client.get.called)
 
-    def test_get_sensors_data_not_implemented(self):
+    def test_get_sensors_data_not_implemented(self, mock_get_ov_client):
         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 193d71ac1..f4cb60055 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_power.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_power.py
@@ -33,6 +33,7 @@ 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):
@@ -53,12 +54,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):
+    def test_validate(self, mock_validate, mock_get_ov_client):
         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):
+    def test_validate_missing_parameter(self, mock_get_ov_client):
         node = obj_utils.create_test_node(
             self.context, uuid=uuidutils.generate_uuid(),
             id=999, driver='fake_oneview')
@@ -69,7 +70,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
                 task)
 
     @mock.patch.object(common, 'validate_oneview_resources_compatibility')
-    def test_validate_exception(self, mock_validate):
+    def test_validate_exception(self, mock_validate, mock_get_ov_client):
         mock_validate.side_effect = exception.OneViewError('message')
         with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(
@@ -77,7 +78,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
                 task.driver.power.validate,
                 task)
 
-    def test_validate_node_in_use_by_oneview(self):
+    def test_validate_node_in_use_by_oneview(self, mock_get_ov_client):
         deploy_utils.is_node_in_use_by_oneview.return_value = True
         with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(
@@ -85,34 +86,34 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
                 task.driver.power.validate,
                 task)
 
-    def test_get_properties(self):
+    def test_get_properties(self, mock_get_ov_client):
         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)
@@ -121,10 +122,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)
@@ -133,10 +134,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)
@@ -145,12 +146,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,
@@ -159,13 +160,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,
@@ -174,15 +175,16 @@ 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,
@@ -190,15 +192,16 @@ 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,
@@ -207,7 +210,8 @@ 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):
+    def test_set_power_invalid_state(
+            self, mock_set_boot_device, mock_get_ov_client):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(
                 exception.InvalidParameterValue,
@@ -216,13 +220,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)
@@ -232,13 +236,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)