Merge "Migrate oneview hardware type to use python-hpOneView"

8 files changed, 495 insertions, 729 deletions

diff --git a/ironic/tests/unit/drivers/modules/oneview/test_common.py b/ironic/tests/unit/drivers/modules/oneview/test_common.py
index 56e29395c..5ed590fb0 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_common.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_common.py
@@ -17,7 +17,6 @@ import mock
 from oslo_utils import importutils
 
 from ironic.common import exception
-from ironic.common import states
 from ironic.conductor import task_manager
 from ironic.drivers.modules.oneview import common
 from ironic.tests.unit.conductor import mgr_utils
@@ -26,7 +25,6 @@ from ironic.tests.unit.db import utils as db_utils
 from ironic.tests.unit.objects import utils as obj_utils
 
 hponeview_client = importutils.try_import('hpOneView.oneview_client')
-oneview_states = importutils.try_import('oneview_client.states')
 
 
 class OneViewCommonTestCase(db_base.DbTestCase):
@@ -258,24 +256,6 @@ class OneViewCommonTestCase(db_base.DbTestCase):
                                      {"a": '', "b": None, "c": "something"},
                                      ["a", "b", "c"])
 
-    def _test_translate_oneview_states(self, power_state_to_translate,
-                                       expected_translated_power_state):
-        translated_power_state = common.translate_oneview_power_state(
-            power_state_to_translate)
-        self.assertEqual(translated_power_state,
-                         expected_translated_power_state)
-
-    def test_all_scenarios_for_translate_oneview_states(self):
-        self._test_translate_oneview_states(
-            oneview_states.ONEVIEW_POWERING_OFF, states.POWER_ON)
-        self._test_translate_oneview_states(
-            oneview_states.ONEVIEW_POWER_OFF, states.POWER_OFF)
-        self._test_translate_oneview_states(
-            oneview_states.ONEVIEW_POWERING_ON, states.POWER_OFF)
-        self._test_translate_oneview_states(
-            oneview_states.ONEVIEW_RESETTING, states.REBOOT)
-        self._test_translate_oneview_states("anything", states.ERROR)
-
     @mock.patch.object(common, 'get_oneview_client', spec_set=True,
                        autospec=True)
     def test_validate_oneview_resources_compatibility(
diff --git a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py
index b49edd749..098a54f64 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py
@@ -99,7 +99,6 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
         self.config(password='password', group='oneview')
 
         mgr_utils.mock_the_extension_manager(driver='fake_oneview')
-
         self.driver = driver_factory.get_driver('fake_oneview')
         self.deploy = OneViewDriverDeploy()
         self.os_primary = mock.MagicMock(spec=METHODS)
@@ -119,9 +118,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.oneview_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)
@@ -139,9 +136,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.oneview_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)
@@ -158,9 +153,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.oneview_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)
@@ -177,9 +170,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.oneview_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)
@@ -195,9 +186,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.oneview_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)
@@ -215,9 +204,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.oneview_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)
@@ -245,8 +232,8 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
     ):
         mock_node_get.get.return_value = self.node
         _setup_node_in_cleanfailed_state_without_oneview_error(self.node)
-        self.os_primary.iter_nodes.return_value = \
-            nodes_taken_on_cleanfail_no_info
+        self.os_primary.iter_nodes.return_value = (
+            nodes_taken_on_cleanfail_no_info)
         self.deploy._periodic_check_nodes_taken_on_cleanfail(
             self.os_primary, self.context
         )
@@ -258,7 +245,6 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
         self.assertNotIn('oneview_error', self.node.driver_internal_info)
 
 
-@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
 class OneViewIscsiDeployTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -282,35 +268,32 @@ 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())
 
     @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate',
                        spec_set=True, autospec=True)
-    def test_validate(self, iscsi_deploy_validate_mock, mock_get_ov_client):
+    def test_validate(self, iscsi_deploy_validate):
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
             task.driver.deploy.validate(task)
-            iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
+            iscsi_deploy_validate.assert_called_once_with(mock.ANY, task)
 
-    @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare',
-                       spec_set=True, autospec=True)
+    @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):
+                     iscsi_deploy_prepare_mock):
         self.node.provision_state = states.DEPLOYING
         self.node.save()
-        with task_manager.acquire(self.context, self.node.uuid,
-                                  shared=False) as task:
+        with task_manager.acquire(self.context, self.node.uuid) as task:
             task.driver.deploy.prepare(task)
             iscsi_deploy_prepare_mock.assert_called_once_with(mock.ANY, task)
             self.assertTrue(allocate_server_hardware_mock.called)
 
     @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare',
                        spec_set=True, 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([states.CLEANING,
@@ -328,7 +311,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
 
     @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'deploy',
                        spec_set=True, 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,
                                   shared=False) as task:
             task.driver.deploy.deploy(task)
@@ -336,7 +319,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
 
     @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', spec_set=True,
                        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,
                                   shared=False) as task:
@@ -348,9 +331,7 @@ class OneViewIscsiDeployTestCase(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,
-        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
 
@@ -364,8 +345,8 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
     @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare_cleaning',
                        spec_set=True, 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):
+    def test_prepare_cleaning(
+            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,
                                   shared=False) as task:
@@ -378,9 +359,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
                        spec_set=True, 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,
@@ -390,7 +369,6 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
             self.assertTrue(deallocate_server_hardware_mock.called)
 
 
-@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
 class OneViewAgentDeployTestCase(db_base.DbTestCase):
     def setUp(self):
         super(OneViewAgentDeployTestCase, self).setUp()
@@ -413,13 +391,13 @@ 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())
 
     @mock.patch.object(agent.AgentDeploy, 'validate',
                        spec_set=True, autospec=True)
-    def test_validate(self, agent_deploy_validate_mock, mock_get_ov_client):
+    def test_validate(self, agent_deploy_validate_mock):
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
             task.driver.deploy.validate(task)
@@ -428,8 +406,8 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
     @mock.patch.object(agent.AgentDeploy, 'prepare',
                        spec_set=True, 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):
+    def test_prepare(
+            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,
@@ -440,8 +418,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
 
     @mock.patch.object(agent.AgentDeploy, 'prepare',
                        spec_set=True, 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,
@@ -459,7 +436,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
 
     @mock.patch.object(agent.AgentDeploy, 'deploy',
                        spec_set=True, 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,
                                   shared=False) as task:
             task.driver.deploy.deploy(task)
@@ -469,9 +446,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,
@@ -484,8 +459,8 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
     @mock.patch.object(agent.AgentDeploy, 'prepare_cleaning',
                        spec_set=True, 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):
+    def test_prepare_cleaning(
+            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,
                                   shared=False) as task:
@@ -498,9 +473,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
                        spec_set=True, 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,
                                   shared=False) as 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 fe94e74b9..cd2548ff1 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py
@@ -14,6 +14,7 @@
 #    under the License.
 
 import mock
+
 from oslo_utils import importutils
 
 from ironic.common import driver_factory
@@ -31,7 +32,7 @@ from ironic.tests.unit.objects import utils as obj_utils
 oneview_models = importutils.try_import('oneview_client.models')
 
 
-@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
+@mock.patch.object(common, 'get_hponeview_client')
 class OneViewDeployUtilsTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -49,394 +50,292 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
             driver_info=db_utils.get_test_oneview_driver_info(),
         )
         self.info = common.get_oneview_info(self.node)
+        deploy_utils.is_node_in_use_by_oneview = mock.Mock(return_value=False)
+        deploy_utils.is_node_in_use_by_ironic = mock.Mock(return_value=True)
 
     # Tests for prepare
-    def test_prepare_node_is_in_use_by_oneview(self, mock_get_ov_client):
-        """`prepare` behavior when the node already has a Profile on OneView.
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_server_hardware = oneview_models.ServerHardware()
-        fake_server_hardware.server_profile_uri = "/any/sp_uri"
-        oneview_client.get_server_hardware.return_value = fake_server_hardware
-
+    def test_prepare_node_is_in_use_by_oneview(self, mock_oneview_client):
+        """`prepare` behavior when the node has a Profile on OneView."""
+        deploy_utils.is_node_in_use_by_oneview.return_value = True
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            task.node.driver_info = driver_info
             task.node.provision_state = states.DEPLOYING
             self.assertRaises(
                 exception.InstanceDeployFailure,
                 deploy_utils.prepare,
-                oneview_client,
                 task
             )
 
     @mock.patch.object(objects.Node, 'save')
     def test_prepare_node_is_successfuly_allocated_to_ironic(
-        self, mock_node_save, mock_get_ov_client
-    ):
-        """`prepare` behavior when the node is free from OneView standpoint.
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = None
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
+            self, mock_save, mock_oneview_client):
+        """`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(oneview_client, task)
-            self.assertTrue(oneview_client.clone_template_and_apply.called)
-            self.assertTrue(oneview_client.get_server_profile_from_hardware)
+            deploy_utils.prepare(task)
+            self.assertTrue(mock_save.called)
 
     # Tests for tear_down
-    def test_tear_down(self, mock_get_ov_client):
-        """`tear_down` behavior when node already has Profile applied
-
-        """
-        sp_uri = '/rest/server-profiles/1234556789'
-        ov_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        ov_client = mock_get_ov_client.return_value
-        ov_client.get_server_hardware_by_uuid.return_value = fake_sh
-
+    def test_tear_down(self, mock_oneview_client):
+        """`tear_down` behavior when node already has Profile applied."""
+        oneview_client = mock_oneview_client()
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = \
+            task.node.driver_info['applied_server_profile_uri'] = (
                 '/rest/server-profiles/1234556789'
-            task.node.driver_info = driver_info
-
-            self.assertIn(
-                'applied_server_profile_uri', task.node.driver_info
             )
-            deploy_utils.tear_down(ov_client, task)
-            self.assertNotIn(
-                'applied_server_profile_uri', task.node.driver_info
+            self.assertTrue(
+                'applied_server_profile_uri' in task.node.driver_info
             )
-        self.assertTrue(
-            ov_client.delete_server_profile.called
-        )
+            deploy_utils.tear_down(task)
+            self.assertFalse(
+                'applied_server_profile_uri' in task.node.driver_info
+            )
+            self.assertTrue(oneview_client.server_profiles.delete.called)
 
     # Tests for prepare_cleaning
     @mock.patch.object(objects.Node, 'save')
     def test_prepare_cleaning_when_node_does_not_have_sp_applied(
-        self, mock_node_save, mock_get_ov_client
-    ):
-        """`prepare_cleaning` behavior when node is free
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = None
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
+            self, mock_save, mock_oneview_client):
+        """`prepare_cleaning` behavior when node is free."""
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            deploy_utils.prepare_cleaning(oneview_client, task)
-            self.assertTrue(oneview_client.clone_template_and_apply.called)
+            self.assertFalse(
+                'applied_server_profile_uri' in task.node.driver_info
+            )
+            deploy_utils.prepare_cleaning(task)
+            self.assertTrue(
+                'applied_server_profile_uri' in task.node.driver_info
+            )
 
     @mock.patch.object(objects.Node, 'save')
     def test_prepare_cleaning_when_node_has_sp_applied(
-        self, mock_node_save, mock_get_ov_client
-    ):
-        """`prepare_cleaning` behavior when node already has Profile applied
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = 'same/sp_applied'
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-
+            self, mock_node_save, mock_oneview_client):
+        """`prepare_cleaning` behavior when node has Profile applied."""
+        oneview_client = mock_oneview_client()
+        oneview_client.server_hardware.get.return_value = {
+            'serverProfileUri': 'same/sp_applied'
+        }
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'same/sp_applied'
-            task.node.driver_info = driver_info
-
-            deploy_utils.prepare_cleaning(oneview_client, task)
-            self.assertFalse(oneview_client.clone_template_and_apply.called)
+            task.node.driver_info['applied_server_profile_uri'] = (
+                'same/sp_applied'
+            )
+            deploy_utils.prepare_cleaning(task)
+            self.assertFalse(mock_node_save.called)
 
     def test_prepare_cleaning_node_is_in_use_by_oneview(
-        self, mock_get_ov_client
-    ):
-        """`prepare_cleaning` behavior when node has Server Profile on OneView
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_server_hardware = oneview_models.ServerHardware()
-        fake_server_hardware.server_profile_uri = "/any/sp_uri"
-        oneview_client.get_server_hardware.return_value = fake_server_hardware
+            self, mock_oneview_client):
+        """`prepare_cleaning` behavior when node has Profile on OneView."""
+        deploy_utils.is_node_in_use_by_oneview.return_value = True
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            task.node.driver_info = driver_info
-            task.node.provision_state = states.DEPLOYING
             self.assertRaises(
                 exception.NodeCleaningFailure,
                 deploy_utils.prepare_cleaning,
-                oneview_client,
                 task
             )
 
     # Tests for tear_down_cleaning
-    def test_tear_down_cleaning(self, mock_get_ov_client):
-        """Checks if Server Profile was deleted and its uri removed
-
-        """
-        sp_uri = '/rest/server-profiles/1234556789'
-        ov_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        ov_client = mock_get_ov_client.return_value
-        ov_client.get_server_hardware_by_uuid.return_value = fake_sh
-
+    def test_tear_down_cleaning(self, mock_oneview_client):
+        """Check if Server Profile was deleted and its uri removed."""
+        oneview_client = mock_oneview_client()
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = \
+            task.node.driver_info['applied_server_profile_uri'] = (
                 '/rest/server-profiles/1234556789'
-            task.node.driver_info = driver_info
-
-            self.assertIn('applied_server_profile_uri', task.node.driver_info)
-            deploy_utils.tear_down_cleaning(ov_client, task)
-            self.assertNotIn('applied_server_profile_uri',
-                             task.node.driver_info)
-            self.assertTrue(ov_client.delete_server_profile.called)
+            )
+            self.assertTrue(
+                'applied_server_profile_uri' in task.node.driver_info
+            )
+            deploy_utils.tear_down_cleaning(task)
+            self.assertFalse(
+                'applied_server_profile_uri' in task.node.driver_info
+            )
+            self.assertTrue(oneview_client.server_profiles.delete.called)
 
     # Tests for is_node_in_use_by_oneview
-    def test_is_node_in_use_by_oneview(self, mock_get_ov_client):
-        """Node has a Server Profile applied by a third party user.
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_server_hardware = oneview_models.ServerHardware()
-        fake_server_hardware.server_profile_uri = "/any/sp_uri"
-
+    def test_is_node_in_use_by_oneview(self, mock_oneview_client):
+        """Node has a Server Profile applied by a third party user."""
+        server_hardware = {
+            'serverProfileUri': '/rest/server-profile/123456789'
+        }
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            task.node.driver_info = driver_info
+            task.node.driver_info['applied_server_profile_uri'] = (
+                '/rest/server-profile/987654321'
+            )
             self.assertTrue(
-                deploy_utils.is_node_in_use_by_oneview(oneview_client,
-                                                       task.node)
+                deploy_utils._is_node_in_use(
+                    server_hardware,
+                    task.node.driver_info['applied_server_profile_uri'],
+                    by_oneview=True
+                )
             )
 
     def test_is_node_in_use_by_oneview_no_server_profile(
-        self, mock_get_ov_client
-    ):
-        """Node has no Server Profile.
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = None
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
+            self, mock_oneview_client):
+        """Node has no Server Profile."""
+        server_hardware = {'serverProfileUri': None}
         with task_manager.acquire(self.context, self.node.uuid) as task:
+            task.node.driver_info['applied_server_profile_uri'] = (
+                '/rest/server-profile/123456789'
+            )
             self.assertFalse(
-                deploy_utils.is_node_in_use_by_oneview(oneview_client,
-                                                       task.node)
+                deploy_utils._is_node_in_use(
+                    server_hardware,
+                    task.node.driver_info['applied_server_profile_uri'],
+                    by_oneview=True
+                )
             )
 
     def test_is_node_in_use_by_oneview_same_server_profile_applied(
-        self, mock_get_ov_client
-    ):
-        """Node's Server Profile uri is the same applied by ironic.
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = 'same/applied_sp_uri/'
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-
+            self, mock_oneview_client):
+        """Check if node's Server Profile uri is the same applied by ironic."""
+        server_hardware = {
+            'serverProfileUri': '/rest/server-profile/123456789'
+        }
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'same/applied_sp_uri/'
-            task.node.driver_info = driver_info
+            task.node.driver_info['applied_server_profile_uri'] = (
+                '/rest/server-profile/123456789'
+            )
             self.assertFalse(
-                deploy_utils.is_node_in_use_by_oneview(oneview_client,
-                                                       task.node)
+                deploy_utils._is_node_in_use(
+                    server_hardware,
+                    task.node.driver_info['applied_server_profile_uri'],
+                    by_oneview=True
+                )
             )
 
     # Tests for is_node_in_use_by_ironic
-    def test_is_node_in_use_by_ironic(self, mock_get_ov_client):
-        """Node has a Server Profile applied by ironic.
-
-        """
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = "same/applied_sp_uri/"
-
-        ov_client = mock_get_ov_client.return_value
-        ov_client.get_server_hardware_by_uuid.return_value = fake_sh
-
+    def test_is_node_in_use_by_ironic(self, mock_oneview_client):
+        """Node has a Server Profile applied by ironic."""
+        server_hardware = {'serverProfileUri': 'same/applied_sp_uri/'}
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'same/applied_sp_uri/'
-            task.node.driver_info = driver_info
+            task.node.driver_info['applied_server_profile_uri'] = (
+                'same/applied_sp_uri/'
+            )
             self.assertTrue(
-                deploy_utils.is_node_in_use_by_ironic(ov_client, task.node)
+                deploy_utils._is_node_in_use(
+                    server_hardware,
+                    task.node.driver_info['applied_server_profile_uri'],
+                    by_oneview=False
+                )
             )
 
     def test_is_node_in_use_by_ironic_no_server_profile(
-        self, mock_get_ov_client
-    ):
-        """Node has no Server Profile.
-
-        """
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = None
-
-        ov_client = mock_get_ov_client.return_value
-        ov_client.get_server_hardware_by_uuid.return_value = fake_sh
-
+            self, mock_oneview_client):
+        """Node has no Server Profile."""
+        server_hardware = {'serverProfileUri': None}
         with task_manager.acquire(self.context, self.node.uuid) as task:
+            task.node.driver_info['applied_server_profile_uri'] = (
+                '/applied_sp_uri/'
+            )
             self.assertFalse(
-                deploy_utils.is_node_in_use_by_ironic(ov_client, task.node)
+                deploy_utils._is_node_in_use(
+                    server_hardware,
+                    task.node.driver_info['applied_server_profile_uri'],
+                    by_oneview=False
+                )
             )
 
-    # Tests for _add_applied_server_profile_uri_field
-    def test__add_applied_server_profile_uri_field(self, mock_get_ov_client):
-        """Checks if applied_server_profile_uri was added to driver_info.
+    def test__create_profile_from_template(self, mock_oneview_client):
+        """Check if the server_profile was created from template."""
+        server_hardware_uri = "server_hardware/12456789"
+        sp_template_uri = "server_profile_template_uri/13245798"
+        oneview_client = mock_oneview_client()
+        oneview_client.server_profile_templates.\
+            get_new_profile.return_value = {}
+        server_profile = {"name": "server_profile_name",
+                          "serverHardwareUri": server_hardware_uri,
+                          "serverProfileTemplateUri": ""}
+        deploy_utils._create_profile_from_template(
+            oneview_client,
+            "server_profile_name",
+            server_hardware_uri,
+            sp_template_uri
+        )
+        oneview_client.server_profiles.create.assert_called_with(
+            server_profile)
 
-        """
+    # Tests for _add_applied_server_profile_uri_field
+    @mock.patch.object(objects.Node, 'save')
+    def test__add_applied_server_profile_uri_field(
+            self, save, mock_oneview_client):
+        """Check if applied_server_profile_uri was added to driver_info."""
+        server_profile = {'uri': 'any/applied_sp_uri/'}
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            task.node.driver_info = driver_info
-            fake_server_profile = oneview_models.ServerProfile()
-            fake_server_profile.uri = 'any/applied_sp_uri/'
-
-            self.assertNotIn('applied_server_profile_uri',
-                             task.node.driver_info)
+            task.node.driver_info.pop('applied_server_profile_uri', None)
+            self.assertNotIn(
+                'applied_server_profile_uri', task.node.driver_info
+            )
             deploy_utils._add_applied_server_profile_uri_field(
                 task.node,
-                fake_server_profile
+                server_profile
             )
             self.assertIn('applied_server_profile_uri', task.node.driver_info)
 
     # Tests for _del_applied_server_profile_uri_field
-    def test__del_applied_server_profile_uri_field(self, mock_get_ov_client):
-        """Checks if applied_server_profile_uri was removed from driver_info.
-
-        """
+    @mock.patch.object(objects.Node, 'save')
+    def test__del_applied_server_profile_uri_field(
+            self, save, mock_oneview_client):
+        """Check if applied_server_profile_uri was removed from driver_info."""
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
-            task.node.driver_info = driver_info
-
+            task.node.driver_info['applied_server_profile_uri'] = (
+                'any/applied_sp_uri/'
+            )
             self.assertIn('applied_server_profile_uri', task.node.driver_info)
             deploy_utils._del_applied_server_profile_uri_field(task.node)
-            self.assertNotIn('applied_server_profile_uri',
-                             task.node.driver_info)
+            self.assertNotIn(
+                'applied_server_profile_uri', task.node.driver_info
+            )
 
     # Tests for allocate_server_hardware_to_ironic
     @mock.patch.object(objects.Node, 'save')
     def test_allocate_server_hardware_to_ironic(
-        self, mock_node_save, mock_get_ov_client
-    ):
-        """Checks if a Server Profile was created and its uri is in driver_info.
-
-        """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = None
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
+            self, mock_node_save, mock_oneview_client):
+        """Check if a Profile was created and its uri is in driver_info."""
+        oneview_client = mock_oneview_client()
+        server_hardware = {'serverProfileUri': None}
+        oneview_client.server_hardware.get.return_value = server_hardware
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
             deploy_utils.allocate_server_hardware_to_ironic(
-                oneview_client, task.node, 'serverProfileName'
+                task.node, 'serverProfileName'
             )
-            self.assertTrue(oneview_client.clone_template_and_apply.called)
+            self.assertTrue(mock_node_save.called)
             self.assertIn('applied_server_profile_uri', task.node.driver_info)
 
     @mock.patch.object(objects.Node, 'save')
-    @mock.patch.object(deploy_utils,
-                       '_del_applied_server_profile_uri_field')
     def test_allocate_server_hardware_to_ironic_node_has_server_profile(
-        self, mock_delete_applied_sp, mock_node_save, mock_get_ov_client
-    ):
-        """Tests server profile allocation when applied_server_profile_uri exists.
+            self, mock_node_save, mock_oneview_client):
+        """Test profile allocation when applied_server_profile_uri exists.
 
         This test consider that no Server Profile is applied on the Server
         Hardware but the applied_server_profile_uri remained on the node. Thus,
         the conductor should remove the value and apply a new server profile to
         use the node.
         """
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = None
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
+        oneview_client = mock_oneview_client()
+        server_hardware = {'serverProfileUri': None}
+        oneview_client.server_hardware.get.return_value = server_hardware
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
-            task.node.driver_info = driver_info
-
+            task.node.driver_info['applied_server_profile_uri'] = (
+                'any/applied_sp_uri/'
+            )
             deploy_utils.allocate_server_hardware_to_ironic(
-                oneview_client, task.node, 'serverProfileName'
+                task.node, 'serverProfileName'
             )
-            self.assertTrue(mock_delete_applied_sp.called)
+            self.assertTrue(mock_node_save.called)
 
     # Tests for deallocate_server_hardware_from_ironic
     @mock.patch.object(objects.Node, 'save')
     def test_deallocate_server_hardware_from_ironic(
-        self, mock_node_save, mock_get_ov_client
-    ):
-        oneview_client = mock_get_ov_client()
-
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = 'any/applied_sp_uri/'
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        mock_get_ov_client.return_value = oneview_client
-
+            self, mock_node_save, mock_oneview_client):
+        oneview_client = mock_oneview_client()
+        server_hardware = {'serverProfileUri': 'any/applied_sp_uri/'}
+        oneview_client.server_hardware.get.return_value = server_hardware
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
-            task.node.driver_info = driver_info
-
-            deploy_utils.deallocate_server_hardware_from_ironic(
-                oneview_client, task.node
+            task.node.driver_info['applied_server_profile_uri'] = (
+                'any/applied_sp_uri/'
             )
-            self.assertTrue(oneview_client.delete_server_profile.called)
-            self.assertNotIn(
-                'applied_server_profile_uri', task.node.driver_info
-            )
-
-    @mock.patch.object(objects.Node, 'save')
-    def test_deallocate_server_hardware_from_ironic_missing_profile_uuid(
-        self, mock_node_save, mock_get_ov_client
-    ):
-        """Test for case when server profile application fails.
-
-        Due to an error when applying Server Profile in OneView,
-        the node will have no Server Profile uuid in the
-        'applied_server_profile_uri' namespace. When the method
-        tested is called without Server Profile uuid, the client
-        will raise a ValueError when trying to delete the profile,
-        this error is converted to an OneViewError.
-        """
-
-        ov_client = mock_get_ov_client.return_value
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = 'any/applied_sp_uri/'
-        ov_client.get_server_hardware_by_uuid.return_value = fake_sh
-        ov_client.delete_server_profile.side_effect = ValueError
-        mock_get_ov_client.return_value = ov_client
-
-        with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
-            task.node.driver_info = driver_info
-            self.assertRaises(
-                exception.OneViewError,
-                deploy_utils.deallocate_server_hardware_from_ironic,
-                ov_client,
-                task.node
-            )
-            self.assertTrue(ov_client.delete_server_profile.called)
-            self.assertIn(
-                'applied_server_profile_uri', task.node.driver_info
+            deploy_utils.deallocate_server_hardware_from_ironic(task)
+            self.assertTrue(mock_node_save.called)
+            self.assertTrue(
+                'applied_server_profile_uri' not in task.node.driver_info
             )
diff --git a/ironic/tests/unit/drivers/modules/oneview/test_inspect.py b/ironic/tests/unit/drivers/modules/oneview/test_inspect.py
index ebc01b101..9f7b43918 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_inspect.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_inspect.py
@@ -24,8 +24,6 @@ from ironic.tests.unit.db import utils as db_utils
 from ironic.tests.unit.objects import utils as obj_utils
 
 
-@mock.patch.object(
-    oneview_common, 'get_oneview_client', spec_set=True, autospec=True)
 class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -39,15 +37,14 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
             driver_info=db_utils.get_test_oneview_driver_info(),
         )
 
-    def test_get_properties(self, mock_get_ov_client):
+    def test_get_properties(self):
         expected = deploy_utils.get_properties()
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=True) as task:
             self.assertEqual(expected, task.driver.inspect.get_properties())
 
-    @mock.patch.object(oneview_common, 'verify_node_info', spec_set=True,
-                       autospec=True)
-    def test_validate(self, mock_verify_node_info, mock_get_ov_client):
+    @mock.patch.object(oneview_common, 'verify_node_info')
+    def test_validate(self, mock_verify_node_info):
         self.config(enabled=False, group='inspector')
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
@@ -55,16 +52,13 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
             mock_verify_node_info.assert_called_once_with(task.node)
 
     @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
-    def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic,
-                              mock_get_ov_client):
+    def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic):
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
             task.driver.inspect.inspect_hardware(task)
             self.assertTrue(mock_allocate_server_hardware_to_ironic.called)
 
 
-@mock.patch.object(
-    oneview_common, 'get_oneview_client', spec_set=True, autospec=True)
 class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -78,15 +72,14 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
             driver_info=db_utils.get_test_oneview_driver_info(),
         )
 
-    def test_get_properties(self, mock_get_ov_client):
+    def test_get_properties(self):
         expected = deploy_utils.get_properties()
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=True) as task:
             self.assertEqual(expected, task.driver.inspect.get_properties())
 
-    @mock.patch.object(oneview_common, 'verify_node_info', spec_set=True,
-                       autospec=True)
-    def test_validate(self, mock_verify_node_info, mock_get_ov_client):
+    @mock.patch.object(oneview_common, 'verify_node_info')
+    def test_validate(self, mock_verify_node_info):
         self.config(enabled=False, group='inspector')
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
@@ -94,8 +87,7 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
             mock_verify_node_info.assert_called_once_with(task.node)
 
     @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
-    def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic,
-                              mock_get_ov_client):
+    def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic):
         with task_manager.acquire(self.context, self.node.uuid,
                                   shared=False) as task:
             task.driver.inspect.inspect_hardware(task)
diff --git a/ironic/tests/unit/drivers/modules/oneview/test_management.py b/ironic/tests/unit/drivers/modules/oneview/test_management.py
index 1e88f8fb5..f64009972 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_management.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_management.py
@@ -22,6 +22,7 @@ from ironic.common import driver_factory
 from ironic.common import exception
 from ironic.conductor import task_manager
 from ironic.drivers.modules.oneview import common
+from ironic.drivers.modules.oneview import deploy_utils
 from ironic.drivers.modules.oneview import management
 from ironic.tests.unit.conductor import mgr_utils
 from ironic.tests.unit.db import base as db_base
@@ -29,11 +30,12 @@ from ironic.tests.unit.db import utils as db_utils
 from ironic.tests.unit.objects import utils as obj_utils
 
 
+client_exception = importutils.try_import('hpOneView.exceptions')
 oneview_exceptions = importutils.try_import('oneview_client.exceptions')
 oneview_models = importutils.try_import('oneview_client.models')
 
 
-@mock.patch.object(common, 'get_oneview_client', spect_set=True, autospec=True)
+@mock.patch.object(common, 'get_hponeview_client')
 class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -52,44 +54,61 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
         )
         self.info = common.get_oneview_info(self.node)
 
-    def test_set_boot_device(self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
+    @mock.patch.object(common, 'get_ilorest_client')
+    def test_set_boot_device(
+            self, mock_get_ilo_client, mock_get_ov_client):
+        ilo_client = mock_get_ilo_client()
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
             driver_internal_info = task.node.driver_internal_info
             next_boot_device = {'boot_device': boot_devices.PXE,
-                                'persistent': False}
+                                'persistent': True}
             driver_internal_info['next_boot_device'] = next_boot_device
             task.node.driver_internal_info = driver_internal_info
             management.set_boot_device(task)
-            oneview_client.set_boot_device.assert_called_once_with(
-                self.info,
-                management.BOOT_DEVICE_MAPPING_TO_OV[boot_devices.PXE],
-                onetime=True
-            )
+            self.assertFalse(ilo_client.called)
+            patch = ilo_client.patch
+            self.assertFalse(patch.called)
             driver_internal_info = task.node.driver_internal_info
             self.assertNotIn('next_boot_device', driver_internal_info)
 
-    def test_set_boot_device_persistent(self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-
+    @mock.patch.object(common, 'get_ilorest_client')
+    def test_set_boot_device_not_persistent(
+            self, mock_get_ilo_client, mock_get_ov_client):
+        ilo_client = mock_get_ilo_client()
+        client = mock_get_ov_client()
+        server_profile = {'boot': {'order':
+                          list(management.BOOT_DEVICE_MAP_ONEVIEW_REV)}}
+        client.server_profiles.get.return_value = server_profile
+        boot_device_map_ilo = management.BOOT_DEVICE_MAP_ILO
+        boot_device = boot_device_map_ilo.get(boot_devices.PXE)
+        path = '/rest/v1/Systems/1'
+        body = {
+            "Boot": {
+                "BootSourceOverrideTarget": boot_device,
+                "BootSourceOverrideEnabled": "Once"
+            }
+        }
+        headers = {"Content-Type": "application/json"}
         with task_manager.acquire(self.context, self.node.uuid) as task:
+            driver_info = task.node.driver_info
+            profile_uri = driver_info.get('applied_server_profile_uri')
             driver_internal_info = task.node.driver_internal_info
             next_boot_device = {'boot_device': boot_devices.PXE,
-                                'persistent': True}
+                                'persistent': False}
             driver_internal_info['next_boot_device'] = next_boot_device
             task.node.driver_internal_info = driver_internal_info
             management.set_boot_device(task)
-            oneview_client.set_boot_device.assert_called_once_with(
-                self.info,
-                management.BOOT_DEVICE_MAPPING_TO_OV[boot_devices.PXE],
-                onetime=False
-            )
+            update = client.server_profiles.update
+            update.assert_called_once_with(server_profile, profile_uri)
+            patch = ilo_client.patch
+            patch.assert_called_once_with(
+                path=path, body=body, headers=headers)
             driver_internal_info = task.node.driver_internal_info
             self.assertNotIn('next_boot_device', driver_internal_info)
 
     def test_set_boot_device_invalid_device(self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
+        client = mock_get_ov_client()
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
             driver_internal_info = task.node.driver_internal_info
@@ -100,51 +119,64 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
             self.assertRaises(exception.InvalidParameterValue,
                               management.set_boot_device,
                               task)
-            self.assertFalse(oneview_client.set_boot_device.called)
+            self.assertFalse(client.set_boot_device.called)
             self.assertIn('next_boot_device', driver_internal_info)
 
     def test_set_boot_device_fail_to_get_server_profile(
             self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-        oneview_client.get_server_profile_from_hardware.side_effect = \
-            oneview_exceptions.OneViewException()
+        client = mock_get_ov_client()
+        exc = client_exception.HPOneViewException()
+        client.server_profiles.get.side_effect = exc
 
         with task_manager.acquire(self.context, self.node.uuid) as task:
             driver_internal_info = task.node.driver_internal_info
-            next_boot_device = {'boot_device': 'disk',
+            next_boot_device = {'device': 'disk',
                                 'persistent': True}
             driver_internal_info['next_boot_device'] = next_boot_device
             task.node.driver_internal_info = driver_internal_info
-            self.assertRaises(exception.OneViewError,
-                              management.set_boot_device,
-                              task)
-            self.assertFalse(oneview_client.set_boot_device.called)
+            self.assertRaises(
+                exception.OneViewError,
+                management.set_boot_device,
+                task
+            )
             self.assertIn('next_boot_device', driver_internal_info)
 
-    def test_set_boot_device_without_server_profile(self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-        oneview_client.get_server_profile_from_hardware.return_value = False
-
+    @mock.patch.object(common, 'get_ilorest_client')
+    def test_set_onetime_boot_persistent(
+            self, mock_iloclient, mock_get_ov_client):
+        ilo_client = mock_iloclient()
+        driver_internal_info = self.node.driver_internal_info
+        next_boot_device = {'device': 'disk', 'persistent': False}
+        driver_internal_info['next_boot_device'] = next_boot_device
+        with task_manager.acquire(self.context, self.node.uuid) as task:
+            management.set_onetime_boot(task)
+            self.assertFalse(ilo_client.called)
+            self.assertFalse(ilo_client.patch.called)
+
+    @mock.patch.object(common, 'get_ilorest_client')
+    def test_set_onetime_boot_not_persistent(
+            self, mock_iloclient, mock_get_ov_client):
+        ilo_client = mock_iloclient()
+        boot_device = management.BOOT_DEVICE_MAP_ILO.get(boot_devices.DISK)
+        path = '/rest/v1/Systems/1'
+        body = {
+            "Boot": {
+                "BootSourceOverrideTarget": boot_device,
+                "BootSourceOverrideEnabled": "Once"
+            }
+        }
+        headers = {"Content-Type": "application/json"}
         with task_manager.acquire(self.context, self.node.uuid) as task:
             driver_internal_info = task.node.driver_internal_info
-            next_boot_device = {'device': 'disk',
-                                'persistent': True}
+            next_boot_device = {'boot_device': 'disk', 'persistent': False}
             driver_internal_info['next_boot_device'] = next_boot_device
             task.node.driver_internal_info = driver_internal_info
-            expected_msg = (
-                'A Server Profile is not associated with node %s.'
-                % self.node.uuid
-            )
-            self.assertRaisesRegex(
-                exception.OperationNotPermitted,
-                expected_msg,
-                management.set_boot_device,
-                task
-            )
-            self.assertIn('next_boot_device', driver_internal_info)
+            management.set_onetime_boot(task)
+            self.assertTrue(mock_iloclient.called)
+            ilo_client.patch.assert_called_with(
+                path=path, body=body, headers=headers)
 
 
-@mock.patch.object(common, 'get_oneview_client', spect_set=True, autospec=True)
 class OneViewManagementDriverTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -152,6 +184,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
         self.config(manager_url='https://1.2.3.4', group='oneview')
         self.config(username='user', group='oneview')
         self.config(password='password', group='oneview')
+        self.config(tls_cacert_file='ca_file', group='oneview')
+        self.config(allow_insecure_connections=False, group='oneview')
 
         mgr_utils.mock_the_extension_manager(driver="fake_oneview")
         self.driver = driver_factory.get_driver("fake_oneview")
@@ -163,79 +197,44 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
         )
         self.info = common.get_oneview_info(self.node)
 
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    def test_validate(self, mock_validate, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-        self.driver.management.oneview_client = oneview_client
-
-        fake_server_hardware = oneview_models.ServerHardware()
-        fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
-
-        oneview_client.get_server_hardware_by_uuid.return_value = (
-            fake_server_hardware
-        )
-        mock_get_ov_client.return_value = oneview_client
-
-        driver_info = self.node.driver_info
-        driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
-
-        self.node.driver_info = driver_info
-        self.node.save()
-
+    @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic')
+    @mock.patch.object(common, 'validate_oneview_resources_compatibility')
+    def test_validate(self, mock_validate, mock_ironic_node):
+        mock_ironic_node.return_value = True
         with task_manager.acquire(self.context, self.node.uuid) as task:
             task.driver.management.validate(task)
             self.assertTrue(mock_validate.called)
 
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    def test_validate_for_node_not_in_use_by_ironic(self,
-                                                    mock_validate,
-                                                    mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-
-        fake_server_hardware = oneview_models.ServerHardware()
-        fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
-
-        oneview_client.get_server_hardware_by_uuid.return_value = (
-            fake_server_hardware
-        )
-        mock_get_ov_client.return_value = oneview_client
-
-        driver_info = self.node.driver_info
-        driver_info['applied_server_profile_uri'] = 'other/applied_sp_uri/'
-
-        self.node.driver_info = driver_info
-        self.node.save()
-
+    @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic')
+    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):
-        node = obj_utils.create_test_node(self.context,
-                                          uuid=uuidutils.generate_uuid(),
-                                          id=999,
-                                          driver='fake_oneview')
+    def test_validate_fail(self):
+        node = obj_utils.create_test_node(
+            self.context, uuid=uuidutils.generate_uuid(),
+            id=999, driver='fake_oneview'
+        )
         with task_manager.acquire(self.context, node.uuid) as task:
             self.assertRaises(exception.MissingParameterValue,
                               task.driver.management.validate, task)
 
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    def test_validate_fail_exception(self, mock_validate, mock_get_ov_client):
+    @mock.patch.object(common, 'validate_oneview_resources_compatibility')
+    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)
@@ -246,7 +245,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)
@@ -257,7 +256,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,
@@ -265,38 +264,32 @@ 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]
+            expected = [
+                boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM
+            ]
             self.assertItemsEqual(
                 expected,
                 task.driver.management.get_supported_boot_devices(task),
             )
 
+    @mock.patch.object(common, 'get_hponeview_client')
     def test_get_boot_device(self, mock_get_ov_client):
-        device_mapping = management.BOOT_DEVICE_MAPPING_TO_OV
-        oneview_client = mock_get_ov_client()
-        self.driver.management.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        device_mapping = management.BOOT_DEVICE_MAP_ONEVIEW.items()
         with task_manager.acquire(self.context, self.node.uuid) as task:
             # For each known device on OneView, Ironic should return its
             # counterpart value
-            for device_ironic, device_ov in device_mapping.items():
-                oneview_client.get_boot_order.return_value = [device_ov]
-                expected_response = {
-                    'boot_device': device_ironic,
-                    'persistent': True
-                }
+            for ironic_device, oneview_device in device_mapping:
+                profile = {'boot': {'order': [oneview_device]}}
+                client.server_profiles.get.return_value = profile
+                expected = {'boot_device': ironic_device, 'persistent': True}
                 response = self.driver.management.get_boot_device(task)
-                self.assertEqual(expected_response, response)
-        oneview_client.get_boot_order.assert_called_with(self.info)
-
-    def test_get_boot_device_from_next_boot_device(
-            self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-        self.driver.management.oneview_client = oneview_client
+                self.assertEqual(expected, response)
+                self.assertTrue(client.server_profiles.get.called)
 
+    def test_get_boot_device_from_next_boot_device(self):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             driver_internal_info = task.node.driver_internal_info
             next_boot_device = {'boot_device': boot_devices.DISK,
@@ -309,26 +302,21 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
             }
             response = self.driver.management.get_boot_device(task)
             self.assertEqual(expected_response, response)
-        self.assertFalse(oneview_client.get_boot_order.called)
 
+    @mock.patch.object(common, 'get_hponeview_client')
     def test_get_boot_device_fail(self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-        oneview_client.get_boot_order.side_effect = \
-            oneview_exceptions.OneViewException()
-        self.driver.management.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        exc = client_exception.HPOneViewException()
+        client.server_profiles.get.side_effect = exc
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            self.assertRaises(exception.OneViewError,
-                              self.driver.management.get_boot_device,
-                              task)
-            oneview_client.get_boot_order.assert_called_with(self.info)
-
-    def test_get_boot_device_unknown_device(self, mock_get_ov_client):
-        oneview_client = mock_get_ov_client()
-        oneview_client.get_boot_order.return_value = ["spam",
-                                                      "bacon"]
-        self.driver.management.oneview_client = oneview_client
+            self.assertRaises(
+                exception.OneViewError,
+                self.driver.management.get_boot_device,
+                task
+            )
+            self.assertTrue(client.server_profiles.get.called)
 
+    def test_get_boot_device_unknown_device(self):
         with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(
                 exception.InvalidParameterValue,
@@ -336,7 +324,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
                 task
             )
 
-    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 4c0df08d0..6a8afc295 100644
--- a/ironic/tests/unit/drivers/modules/oneview/test_power.py
+++ b/ironic/tests/unit/drivers/modules/oneview/test_power.py
@@ -24,20 +24,17 @@ from ironic.conductor import task_manager
 from ironic.drivers.modules.oneview import common
 from ironic.drivers.modules.oneview import deploy_utils
 from ironic.drivers.modules.oneview import management
+from ironic.drivers.modules.oneview import power
 from ironic.tests.unit.conductor import mgr_utils
 from ironic.tests.unit.db import base as db_base
 from ironic.tests.unit.db import utils as db_utils
 from ironic.tests.unit.objects import utils as obj_utils
 
+client_exception = importutils.try_import('hpOneView.exceptions')
 oneview_models = importutils.try_import('oneview_client.models')
 oneview_exceptions = importutils.try_import('oneview_client.exceptions')
 
-POWER_ON = 'On'
-POWER_OFF = 'Off'
-ERROR = 'error'
 
-
-@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
 class OneViewPowerDriverTestCase(db_base.DbTestCase):
 
     def setUp(self):
@@ -45,6 +42,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
         self.config(manager_url='https://1.2.3.4', group='oneview')
         self.config(username='user', group='oneview')
         self.config(password='password', group='oneview')
+        self.config(tls_cacert_file='ca_file', group='oneview')
+        self.config(allow_insecure_connections=False, group='oneview')
 
         mgr_utils.mock_the_extension_manager(driver='fake_oneview')
         self.driver = driver_factory.get_driver('fake_oneview')
@@ -55,274 +54,197 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
             driver_info=db_utils.get_test_oneview_driver_info(),
         )
         self.info = common.get_oneview_info(self.node)
+        deploy_utils.is_node_in_use_by_oneview = mock.Mock(return_value=False)
 
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    @mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
-                       spect_set=True, autospec=True)
-    def test_power_interface_validate(self, mock_is_node_in_use_by_oneview,
-                                      mock_validate, mock_get_ov_client):
-        mock_is_node_in_use_by_oneview.return_value = False
+    @mock.patch.object(common, 'validate_oneview_resources_compatibility')
+    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_power_interface_validate_fail(self, mock_get_ov_client):
-        node = obj_utils.create_test_node(self.context,
-                                          uuid=uuidutils.generate_uuid(),
-                                          id=999,
-                                          driver='fake_oneview')
+    def test_validate_missing_parameter(self):
+        node = obj_utils.create_test_node(
+            self.context, uuid=uuidutils.generate_uuid(),
+            id=999, driver='fake_oneview')
         with task_manager.acquire(self.context, node.uuid) as task:
-            self.assertRaises(exception.MissingParameterValue,
-                              task.driver.power.validate, task)
+            self.assertRaises(
+                exception.MissingParameterValue,
+                task.driver.power.validate,
+                task)
 
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    def test_power_interface_validate_fail_exception(self, mock_validate,
-                                                     mock_get_ov_client):
+    @mock.patch.object(common, 'validate_oneview_resources_compatibility')
+    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(exception.InvalidParameterValue,
-                              task.driver.power.validate,
-                              task)
-
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    @mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
-                       spect_set=True, autospec=True)
-    def test_power_validate_fail_node_used_by_oneview(
-            self, mock_is_node_in_use_by_oneview, mock_validate,
-            mock_get_ov_client):
-        mock_validate.return_value = True
-        mock_is_node_in_use_by_oneview.return_value = True
-        with task_manager.acquire(self.context, self.node.uuid) as task:
-            self.assertRaises(exception.InvalidParameterValue,
-                              task.driver.power.validate,
-                              task)
+            self.assertRaises(
+                exception.InvalidParameterValue,
+                task.driver.power.validate,
+                task)
 
-    @mock.patch.object(common, 'validate_oneview_resources_compatibility',
-                       spect_set=True, autospec=True)
-    @mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
-                       spect_set=True, autospec=True)
-    def test_validate_fail_node_in_use_by_oneview(
-            self, mock_is_node_in_use_by_oneview, mock_validate,
-            mock_get_ov_client):
-        mock_validate.return_value = True
-        mock_is_node_in_use_by_oneview.side_effect = (
-            exception.OneViewError('message'))
+    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(exception.InvalidParameterValue,
-                              task.driver.power.validate,
-                              task)
+            self.assertRaises(
+                exception.InvalidParameterValue,
+                task.driver.power.validate,
+                task)
 
-    def test_power_interface_get_properties(self, mock_get_ov_client):
+    def test_get_properties(self):
         expected = common.COMMON_PROPERTIES
-        self.assertItemsEqual(expected, self.driver.power.get_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):
-        oneview_client = mock_get_ov_client()
-        oneview_client.get_node_power_state.return_value = POWER_ON
-        self.driver.power.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        server_hardware = {'powerState': 'On'}
+        client.server_hardware.get.return_value = server_hardware
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            self.driver.power.get_power_state(task)
-        oneview_client.get_node_power_state.assert_called_once_with(self.info)
+            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):
-        oneview_client = mock_get_ov_client()
-        oneview_client.get_node_power_state.side_effect = \
-            oneview_exceptions.OneViewException()
-        self.driver.power.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        exc = client_exception.HPOneViewException()
+        client.server_hardware.get.side_effect = exc
         with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(
                 exception.OneViewError,
                 self.driver.power.get_power_state,
-                task
-            )
+                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):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client = mock_get_ov_client.return_value
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        oneview_client.power_on.return_value = POWER_ON
-        self.driver.power.oneview_client = oneview_client
-
+    def test_set_power_on(self, mock_set_boot_device, mock_get_ov_client):
+        client = mock_get_ov_client()
+        server_hardware = self.node.driver_info.get('server_hardware_uri')
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
             self.driver.power.set_power_state(task, states.POWER_ON)
-            mock_set_boot_device.assert_called_once_with(task)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_on.assert_called_once_with(self.info)
+            self.assertTrue(mock_set_boot_device.called)
+            update = client.server_hardware.update_power_state
+            update.assert_called_once_with(power.POWER_ON, server_hardware)
 
+    @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):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client = mock_get_ov_client.return_value
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        oneview_client.power_off.return_value = POWER_OFF
-        self.driver.power.oneview_client = oneview_client
-
+    def test_set_power_off(self, mock_set_boot_device, mock_get_ov_client):
+        client = mock_get_ov_client()
+        server_hardware = self.node.driver_info.get('server_hardware_uri')
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
             self.driver.power.set_power_state(task, states.POWER_OFF)
             self.assertFalse(mock_set_boot_device.called)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_off.assert_called_once_with(self.info)
+            update = client.server_hardware.update_power_state
+            update.assert_called_once_with(power.POWER_OFF, server_hardware)
 
+    @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):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        exc = oneview_exceptions.OneViewException()
-        oneview_client.power_on.side_effect = exc
-        self.driver.power.oneview_client = oneview_client
+    def test_set_power_reboot(self, mock_set_boot_device, mock_get_ov_client):
+        client = mock_get_ov_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)
+            calls = [mock.call(power.POWER_OFF, server_hardware),
+                     mock.call(power.POWER_ON, server_hardware)]
+            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
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
-            self.assertRaises(exception.OneViewError,
-                              self.driver.power.set_power_state, task,
-                              states.POWER_ON)
+            self.assertRaises(
+                exception.OneViewError,
+                self.driver.power.set_power_state,
+                task,
+                states.POWER_ON)
             mock_set_boot_device.assert_called_once_with(task)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_on.assert_called_once_with(self.info)
 
+    @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):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        exc = oneview_exceptions.OneViewException()
-        oneview_client.power_off.side_effect = exc
-        self.driver.power.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        exc = client_exception.HPOneViewException()
+        client.server_hardware.update_power_state.side_effect = exc
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
-            self.assertRaises(exception.OneViewError,
-                              self.driver.power.set_power_state, task,
-                              states.POWER_OFF)
+            self.assertRaises(
+                exception.OneViewError,
+                self.driver.power.set_power_state,
+                task,
+                states.POWER_OFF)
             self.assertFalse(mock_set_boot_device.called)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_off.assert_called_once_with(self.info)
 
+    @mock.patch.object(common, 'get_hponeview_client')
     @mock.patch.object(management, 'set_boot_device')
-    def test_set_power_invalid_state(
+    def test_reboot_fail_with_hardware_on(
             self, mock_set_boot_device, mock_get_ov_client):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        exc = oneview_exceptions.OneViewException()
-        oneview_client.power_off.side_effect = exc
-        self.driver.power.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        server_hardware = {'powerState': 'On'}
+        client.server_hardware.get.return_value = server_hardware
+        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:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
-            self.assertRaises(exception.InvalidParameterValue,
-                              self.driver.power.set_power_state, task,
-                              'fake state')
+            self.assertRaises(
+                exception.OneViewError,
+                self.driver.power.reboot,
+                task)
             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(
+    def test_reboot_fail_with_hardware_off(
             self, mock_set_boot_device, mock_get_ov_client):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        oneview_client.power_off.return_value = POWER_OFF
-        oneview_client.power_on.return_value = POWER_ON
-        self.driver.power.oneview_client = oneview_client
-
+        client = mock_get_ov_client()
+        server_hardware = {'powerState': 'Off'}
+        client.server_hardware.get.return_value = server_hardware
+        exc = client_exception.HPOneViewException()
+        client.server_hardware.update_power_state.side_effect = exc
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
-            self.driver.power.set_power_state(task, states.REBOOT)
+            self.assertRaises(
+                exception.OneViewError,
+                self.driver.power.reboot,
+                task)
             mock_set_boot_device.assert_called_once_with(task)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_off.assert_called_once_with(self.info)
-            oneview_client.power_off.assert_called_once_with(self.info)
-            oneview_client.power_on.assert_called_once_with(self.info)
 
     @mock.patch.object(management, 'set_boot_device')
-    def test_reboot(
-            self, mock_set_boot_device, mock_get_ov_client):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        oneview_client.power_off.return_value = POWER_OFF
-        oneview_client.power_on.return_value = POWER_ON
-        self.driver.power.oneview_client = oneview_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,
+                self.driver.power.set_power_state,
+                task,
+                '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
+        server_hardware = self.node.driver_info.get('server_hardware_uri')
         with task_manager.acquire(self.context, self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
             self.driver.power.reboot(task)
+            calls = [mock.call(power.POWER_OFF, server_hardware),
+                     mock.call(power.POWER_ON, server_hardware)]
+            update = client.server_hardware.update_power_state
+            update.assert_has_calls(calls)
             mock_set_boot_device.assert_called_once_with(task)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_off.assert_called_once_with(self.info)
-            oneview_client.power_on.assert_called_once_with(self.info)
 
+    @mock.patch.object(common, 'get_hponeview_client')
     @mock.patch.object(management, 'set_boot_device')
-    def test_reboot_fail(
+    def test_set_power_reboot_with_hardware_off(
             self, mock_set_boot_device, mock_get_ov_client):
-
-        sp_uri = '/any/server-profile'
-        oneview_client = mock_get_ov_client()
-        fake_sh = oneview_models.ServerHardware()
-        fake_sh.server_profile_uri = sp_uri
-        oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
-        exc = oneview_exceptions.OneViewException()
-        oneview_client.power_off.side_effect = exc
-        self.driver.power.oneview_client = oneview_client
-
-        with task_manager.acquire(self.context,
-                                  self.node.uuid) as task:
-            driver_info = task.node.driver_info
-            driver_info['applied_server_profile_uri'] = sp_uri
-            task.node.driver_info = driver_info
-            self.assertRaises(exception.OneViewError,
-                              self.driver.power.reboot, task)
-            self.assertFalse(mock_set_boot_device.called)
-            self.info['applied_server_profile_uri'] = sp_uri
-            oneview_client.power_off.assert_called_once_with(self.info)
-            self.assertFalse(oneview_client.power_on.called)
+        client = mock_get_ov_client()
+        server_hardware = {'powerState': 'Off'}
+        client.server_hardware.get.return_value = server_hardware
+        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)
+            update = client.server_hardware.update_power_state
+            update.assert_called_once_with(power.POWER_ON, server_hardware)
+            mock_set_boot_device.assert_called_once_with(task)
diff --git a/ironic/tests/unit/drivers/third_party_driver_mock_specs.py b/ironic/tests/unit/drivers/third_party_driver_mock_specs.py
index 2574743c9..8126f7add 100644
--- a/ironic/tests/unit/drivers/third_party_driver_mock_specs.py
+++ b/ironic/tests/unit/drivers/third_party_driver_mock_specs.py
@@ -162,6 +162,10 @@ HPE_ONEVIEW_STATES_SPEC = (
     'ONEVIEW_ERROR',
 )
 
+REDFISH_SPEC = (
+    'redfish',
+)
+
 SUSHY_CONSTANTS_SPEC = (
     'BOOT_SOURCE_TARGET_PXE',
     'BOOT_SOURCE_TARGET_HDD',
diff --git a/ironic/tests/unit/drivers/third_party_driver_mocks.py b/ironic/tests/unit/drivers/third_party_driver_mocks.py
index 28e374198..f813a69c0 100644
--- a/ironic/tests/unit/drivers/third_party_driver_mocks.py
+++ b/ironic/tests/unit/drivers/third_party_driver_mocks.py
@@ -116,6 +116,14 @@ if 'ironic.drivers.oneview' in sys.modules:
     six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview'])
 
 
+redfish = importutils.try_import('redfish')
+if not redfish:
+    redfish = mock.MagicMock(spec_set=mock_specs.REDFISH_SPEC)
+    sys.modules['redfish'] = redfish
+if 'ironic.drivers.oneview' in sys.modules:
+    six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview'])
+
+
 # attempt to load the external 'python-dracclient' library, which is required
 # by the optional drivers.modules.drac module
 dracclient = importutils.try_import('dracclient')