openstack/ironic
Code Issues Proposed changes

Merge "Migrate python-oneviewclient validations to Ironic OneView drivers"

Browse Source
This commit is contained in:
Zuul 2017-11-01 20:35:41 +00:00 committed by Gerrit Code Review
commit 569d3af276
10 changed files with 450 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

302
ironic/drivers/modules/oneview/common.py
View File

@ -12,7 +12,9 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_log import log as logging
from oslo_serialization import jsonutils
from oslo_utils import importutils
from six.moves.urllib import parse
@ -226,43 +228,25 @@ def get_oneview_info(node):
def validate_oneview_resources_compatibility(oneview_client, task):
"""Validate if the node configuration is consistent with OneView.
This method calls python-oneviewclient functions to validate if the node
This method calls hpOneView functions to validate if the node
configuration is consistent with the OneView resources it represents,
including server_hardware_uri, server_hardware_type_uri,
server_profile_template_uri, enclosure_group_uri and node ports. Also
verifies if a Server Profile is applied to the Server Hardware the node
represents when in pre-allocation model. If any validation fails,
python-oneviewclient will raise an appropriate OneViewException.
including serverHardwareUri, serverHardwareTypeUri, serverGroupUri
serverProfileTemplateUri, enclosureGroupUri and node ports. If any
validation fails, the driver will raise an appropriate OneViewError.
:param oneview_client: an instance of the OneView client
:param: task: a TaskManager instance containing the node to act on.
:raises: OneViewError if any validation fails.
"""
node_ports = task.ports
ports = task.ports
oneview_info = get_oneview_info(task.node)
try:
spt_uuid = oneview_utils.get_uuid_from_uri(
oneview_info.get("server_profile_template_uri")
)
oneview_client.validate_node_server_profile_template(oneview_info)
oneview_client.validate_node_server_hardware_type(oneview_info)
oneview_client.validate_node_enclosure_group(oneview_info)
oneview_client.validate_node_server_hardware(
oneview_info,
task.node.properties.get('memory_mb'),
task.node.properties.get('cpus')
)
oneview_client.is_node_port_mac_compatible_with_server_hardware(
oneview_info, node_ports
)
oneview_client.validate_server_profile_template_mac_type(spt_uuid)
except oneview_exceptions.OneViewException as oneview_exc:
msg = (_("Error validating node resources with OneView: %s") %
oneview_exc)
raise exception.OneViewError(error=msg)
_validate_node_server_profile_template(oneview_client, oneview_info)
_validate_node_server_hardware_type(oneview_client, oneview_info)
_validate_node_enclosure_group(oneview_client, oneview_info)
_validate_server_profile_template_mac_type(oneview_client, oneview_info)
_validate_node_port_mac_server_hardware(
oneview_client, oneview_info, ports)
def _verify_node_info(node_namespace, node_info_dict, info_required):
@ -292,8 +276,8 @@ def _verify_node_info(node_namespace, node_info_dict, info_required):
def node_has_server_profile(func):
"""Checks if the node's Server Hardware has a Server Profile associated.
Decorator to execute before the function execution if the Server Profile
is applied to the Server Hardware.
Decorator to execute before the function execution to check if the Server
Profile is applied to the Server Hardware.
:param func: a given decorated function.
"""
@ -322,3 +306,257 @@ def has_server_profile(task, client):
{"node": task.node.uuid, "message": exc}
)
raise exception.OneViewError(error=exc)
def _get_server_hardware_mac_from_ilo(oneview_client, server_hardware):
"""Get the MAC of Server Hardware's iLO controller.
:param: oneview_client: an instance of the HPE OneView client
:param: server_hardware: a server hardware uuid or uri
:return: MAC of Server Hardware's iLO controller.
:raises: InvalidParameterValue if required iLO credentials are missing.
:raises: OneViewError if can't get mac from a server hardware via iLO or
if fails to get JSON object with the default path.
"""
try:
client = get_ilorest_client(oneview_client, server_hardware)
ilo_path = "/rest/v1/systems/1"
hardware = jsonutils.loads(client.get(ilo_path).text)
hardware_mac = hardware['HostCorrelation']['HostMACAddress'][0]
except redfish.JsonDecodingError as exc:
LOG.error("Failed in JSON object getting path: %s", ilo_path)
raise exception.OneViewError(error=exc)
except (ValueError, TypeError, IndexError) as exc:
LOG.error(
"Failed to get mac from server hardware %(server_hardware)s "
"via iLO. Error: %(message)s", {
"server_hardware": server_hardware.get("uri"),
"message": exc
}
)
raise exception.OneViewError(error=exc)
return hardware_mac
def _get_server_hardware_mac(server_hardware):
"""Get the MAC address of the first PXE bootable port of an Ethernet port.
:param: server_hardware: OneView Server Hardware object
:return: MAC of the first Ethernet and function 'a' port of the
Server Hardware object
:raises: OneViewError if there is no Ethernet port on the Server Hardware
or if there is no portMap on the Server Hardware requested
"""
sh_physical_port = None
if server_hardware.get('portMap'):
for device in server_hardware.get(
'portMap', {}).get('deviceSlots', ()):
for physical_port in device.get('physicalPorts', ()):
if physical_port.get('type') == 'Ethernet':
sh_physical_port = physical_port
break
if sh_physical_port:
for virtual_port in sh_physical_port.get('virtualPorts', ()):
# NOTE(nicodemos): Ironic oneview drivers needs to use a
# port that type is Ethernet and function identifier 'a' for
# this FlexNIC to be able to make a deploy using PXE.
if virtual_port.get('portFunction') == 'a':
return virtual_port.get('mac', ()).lower()
raise exception.OneViewError(
_("There is no Ethernet port on the Server Hardware: %s") %
server_hardware.get('uri'))
else:
raise exception.OneViewError(
_("The Server Hardware: %s doesn't have a list of adapters/slots, "
"their ports and attributes. This information is available only "
"for blade servers. Is this a rack server?") %
server_hardware.get('uri'))
def _validate_node_server_profile_template(oneview_client, oneview_info):
"""Validate if the Server Profile Template is consistent.
:param: oneview_client: an instance of the HPE OneView client
:param: oneview_info: the OneView related info in an Ironic node
:raises: OneViewError if the node's Server Profile Template is not
consistent
"""
server_profile_template = oneview_client.server_profile_templates.get(
oneview_info['server_profile_template_uri'])
server_hardware = oneview_client.server_hardware.get(
oneview_info['server_hardware_uri'])
_validate_server_profile_template_server_hardware_type(
server_profile_template, server_hardware)
_validate_spt_enclosure_group(server_profile_template, server_hardware)
_validate_server_profile_template_manage_boot(server_profile_template)
def _validate_server_profile_template_server_hardware_type(
server_profile_template, server_hardware):
"""Validate if the Server Hardware Types are the same.
Validate if the Server Profile Template and the Server Hardware have the
same Server Hardware Type
:param: server_profile_template: OneView Server Profile Template object
:param: server_hardware: OneView Server Hardware object
:raises: OneViewError if the Server Profile Template and the Server
Hardware does not have the same Server Hardware Type
"""
spt_server_hardware_type_uri = (
server_profile_template.get('serverHardwareTypeUri')
)
sh_server_hardware_type_uri = server_hardware.get('serverHardwareTypeUri')
if spt_server_hardware_type_uri != sh_server_hardware_type_uri:
message = _(
"Server profile template %(spt_uri)s serverHardwareTypeUri is "
"inconsistent with server hardware %(server_hardware_uri)s "
"serverHardwareTypeUri.") % {
'spt_uri': server_profile_template.get('uri'),
'server_hardware_uri': server_hardware.get('uri')}
raise exception.OneViewError(message)
def _validate_spt_enclosure_group(server_profile_template, server_hardware):
"""Validate Server Profile Template's Enclosure Group and Server Hardware's.
:param: server_profile_template: OneView Server Profile Template object
:param: server_hardware: OneView Server Hardware object
:raises: OneViewError if the Server Profile Template's Enclosure Group does
not match the Server Hardware's
"""
spt_enclosure_group_uri = server_profile_template.get('enclosureGroupUri')
sh_enclosure_group_uri = server_hardware.get('serverGroupUri')
if spt_enclosure_group_uri != sh_enclosure_group_uri:
message = _("Server profile template %(spt_uri)s enclosureGroupUri is "
"inconsistent with server hardware %(sh_uri)s "
"serverGroupUri.") % {
'spt_uri': server_profile_template.get('uri'),
'sh_uri': server_hardware.get('uri')}
raise exception.OneViewError(message)
def _validate_server_profile_template_manage_boot(server_profile_template):
"""Validate if the Server Profile Template allows to manage the boot order.
:param: server_profile_template: OneView Server Profile Template object
:raises: OneViewError if the Server Profile Template does not allows to
manage the boot order.
"""
manage_boot = server_profile_template.get('boot', {}).get('manageBoot')
if not manage_boot:
message = _("Server Profile Template: %s, does not allow to manage "
"boot order.") % server_profile_template.get('uri')
raise exception.OneViewError(message)
def _validate_node_server_hardware_type(oneview_client, oneview_info):
"""Validate if the node's Server Hardware Type matches Server Hardware's.
:param: oneview_client: the HPE OneView Client
:param: oneview_info: the OneView related info in an Ironic node
:raises: OneViewError if the node's Server Hardware Type group doesn't
match the Server Hardware's
"""
node_server_hardware_type_uri = oneview_info['server_hardware_type_uri']
server_hardware = oneview_client.server_hardware.get(
oneview_info['server_hardware_uri'])
server_hardware_sht_uri = server_hardware.get('serverHardwareTypeUri')
if server_hardware_sht_uri != node_server_hardware_type_uri:
message = _("Node server_hardware_type_uri is inconsistent "
"with OneView's server hardware %(server_hardware_uri)s "
"serverHardwareTypeUri.") % {
'server_hardware_uri': server_hardware.get('uri')}
raise exception.OneViewError(message)
def _validate_node_enclosure_group(oneview_client, oneview_info):
"""Validate if the node's Enclosure Group matches the Server Hardware's.
:param: oneview_client: an instance of the HPE OneView client
:param: oneview_info: the OneView related info in an Ironic node
:raises: OneViewError if the node's enclosure group doesn't match the
Server Hardware's
"""
server_hardware = oneview_client.server_hardware.get(
oneview_info['server_hardware_uri'])
sh_enclosure_group_uri = server_hardware.get('serverGroupUri')
node_enclosure_group_uri = oneview_info['enclosure_group_uri']
if node_enclosure_group_uri and (
sh_enclosure_group_uri != node_enclosure_group_uri):
message = _(
"Node enclosure_group_uri '%(node_enclosure_group_uri)s' "
"is inconsistent with OneView's server hardware "
"serverGroupUri '%(sh_enclosure_group_uri)s' of "
"ServerHardware %(server_hardware)s") % {
'node_enclosure_group_uri': node_enclosure_group_uri,
'sh_enclosure_group_uri': sh_enclosure_group_uri,
'server_hardware': server_hardware.get('uri')}
raise exception.OneViewError(message)
def _validate_node_port_mac_server_hardware(oneview_client,
oneview_info, ports):
"""Validate if a port matches the node's Server Hardware's MAC.
:param: oneview_client: an instance of the HPE OneView client
:param: oneview_info: the OneView related info in an Ironic node
:param: ports: a list of Ironic node's ports
:raises: OneViewError if there is no port with MAC address matching one
in OneView
"""
server_hardware = oneview_client.server_hardware.get(
oneview_info['server_hardware_uri'])
if not ports:
return
# NOTE(nicodemos) If hponeview client's unable to get the MAC of the Server
# Hardware and raises an exception, the driver will try to get it from
# the iLOrest client.
try:
mac = _get_server_hardware_mac(server_hardware)
except exception.OneViewError:
mac = _get_server_hardware_mac_from_ilo(
oneview_client, server_hardware)
incompatible_macs = []
for port in ports:
if port.address.lower() == mac.lower():
return
incompatible_macs.append(port.address)
message = _("The ports of the node are not compatible with its "
"server hardware %(server_hardware_uri)s. There are no Ironic "
"port MAC's: %(port_macs)s, that matches with the "
"server hardware's MAC: %(server_hardware_mac)s") % {
'server_hardware_uri': server_hardware.get('uri'),
'port_macs': ', '.join(incompatible_macs),
'server_hardware_mac': mac}
raise exception.OneViewError(message)
def _validate_server_profile_template_mac_type(oneview_client, oneview_info):
"""Validate if the node's Server Profile Template's MAC type is physical.
:param: oneview_client: an instance of the HPE OneView client
:param: oneview_info: the OneView related info in an Ironic node
:raises: OneViewError if the node's Server Profile Template's MAC type is
not physical
"""
server_profile_template = oneview_client.server_profile_templates.get(
oneview_info['server_profile_template_uri']
)
if server_profile_template.get('macType') != 'Physical':
message = _("The server profile template %s is not set to use "
"physical MAC.") % server_profile_template.get('uri')
raise exception.OneViewError(message)

6
ironic/drivers/modules/oneview/deploy.py
View File

@ -230,8 +230,7 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
def validate(self, task):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
common.validate_oneview_resources_compatibility(self.client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
super(OneViewIscsiDeploy, self).validate(task)
@ -275,8 +274,7 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks):
def validate(self, task):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
common.validate_oneview_resources_compatibility(self.client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
super(OneViewAgentDeploy, self).validate(task)

3
ironic/drivers/modules/oneview/inspect.py
View File

@ -59,8 +59,7 @@ class OneViewInspect(inspector.Inspector):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
common.validate_oneview_resources_compatibility(self.client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)

3
ironic/drivers/modules/oneview/management.py
View File

@ -191,8 +191,7 @@ class OneViewManagement(base.ManagementInterface):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
common.validate_oneview_resources_compatibility(self.client, task)
if not deploy_utils.is_node_in_use_by_ironic(
self.client, task.node

9
ironic/drivers/modules/oneview/power.py
View File

@ -90,15 +90,12 @@ class OneViewPower(base.PowerInterface):
common.verify_node_info(task.node)
try:
if deploy_utils.is_node_in_use_by_oneview(
self.client, task.node
):
common.validate_oneview_resources_compatibility(self.client, task)
if deploy_utils.is_node_in_use_by_oneview(self.client, task.node):
raise exception.InvalidParameterValue(
_("Node %s is in use by OneView.") % task.node.uuid)
common.validate_oneview_resources_compatibility(
self.oneview_client, task
)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)

155
ironic/tests/unit/drivers/modules/oneview/test_common.py
View File

@ -14,6 +14,7 @@
# under the License.
import mock
from oslo_utils import importutils
from ironic.common import exception
@ -239,35 +240,139 @@ class OneViewCommonTestCase(db_base.DbTestCase):
{"a": '', "b": None, "c": "something"},
["a", "b", "c"])
@mock.patch.object(common, 'get_oneview_client', spec_set=True,
autospec=True)
@mock.patch.object(common, 'get_hponeview_client', autospec=True)
@mock.patch.object(common, '_validate_node_server_profile_template')
@mock.patch.object(common, '_validate_node_server_hardware_type')
@mock.patch.object(common, '_validate_node_enclosure_group')
@mock.patch.object(common, '_validate_node_port_mac_server_hardware')
@mock.patch.object(common, '_validate_server_profile_template_mac_type')
def test_validate_oneview_resources_compatibility(
self, mock_get_ov_client):
self, mock_spt_mac_type, mock_port_mac_sh, mock_enclosure,
mock_sh_type, mock_sp_template, mock_hponeview):
"""Validate compatibility of resources.
1) Check validate_node_server_profile_template method is called
2) Check validate_node_server_hardware_type method is called
3) Check validate_node_enclosure_group method is called
4) Check validate_node_server_hardware method is called
5) Check is_node_port_mac_compatible_with_server_hardware method
is called
6) Check validate_server_profile_template_mac_type method is called
1) Check _validate_node_server_profile_template method is called
2) Check _validate_node_server_hardware_type method is called
3) Check _validate_node_enclosure_group method is called
4) Check _validate_node_port_mac_server_hardware method is called
5) Check _validate_server_profile_template_mac_type method is called
"""
oneview_client = mock_get_ov_client()
oneview_client = mock_hponeview()
fake_port = db_utils.create_test_port()
fake_port.address = 'AA:BB:CC:DD:EE'
fake_device = {'physicalPorts': [
{'type': 'Ethernet',
'virtualPorts': [
{'portFunction': 'a',
'mac': 'AA:BB:CC:DD:EE'}
]}
]}
fake_spt = {
'serverHardwareTypeUri': 'fake_sht_uri',
'enclosureGroupUri': 'fake_eg_uri',
'macType': 'Physical',
'boot': {'manageBoot': True}
}
fake_sh = {
'serverHardwareTypeUri': 'fake_sht_uri',
'serverGroupUri': 'fake_eg_uri',
'processorCoreCount': 4,
'processorCount': 2,
'memoryMb': 4096,
'portMap': {'deviceSlots': [fake_device]}
}
oneview_client.server_profile_templates.get.return_value = fake_spt
oneview_client.server_hardware.get.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
task.ports = [fake_port]
common.validate_oneview_resources_compatibility(oneview_client,
task)
self.assertTrue(
oneview_client.validate_node_server_profile_template.called)
self.assertTrue(
oneview_client.validate_node_server_hardware_type.called)
self.assertTrue(
oneview_client.validate_node_enclosure_group.called)
self.assertTrue(
oneview_client.validate_node_server_hardware.called)
self.assertTrue(
oneview_client.
is_node_port_mac_compatible_with_server_hardware.called)
self.assertTrue(
oneview_client.
validate_server_profile_template_mac_type.called)
self.assertTrue(mock_sp_template.called)
self.assertTrue(mock_sh_type.called)
self.assertTrue(mock_enclosure.called)
self.assertTrue(mock_port_mac_sh.called)
self.assertTrue(mock_spt_mac_type.called)
@mock.patch.object(common, 'get_hponeview_client', autospec=True)
def test__validate_server_profile_template_mac_type_virtual(
self, mock_hponeview):
oneview_client = mock_hponeview()
fake_spt = {'macType': 'Virtual'}
oneview_client.server_hardware.get.return_value = fake_spt
oneview_info = {'server_profile_template_uri': 'fake_uri'}
self.assertRaises(exception.OneViewError,
common._validate_server_profile_template_mac_type,
oneview_client, oneview_info)
@mock.patch.object(common, 'get_hponeview_client', autospec=True)
def test__validate_node_port_mac_server_hardware_invalid(
self, mock_hponeview):
oneview_client = mock_hponeview()
fake_device = {
'physicalPorts': [
{'type': 'notEthernet',
'mac': '00:11:22:33:44',
'virtualPorts': [{
'portFunction': 'a',
'mac': 'AA:BB:CC:DD:EE'}]},
{'type': 'Ethernet',
'mac': '11:22:33:44:55',
'virtualPorts': [{
'portFunction': 'a',
'mac': 'BB:CC:DD:EE:FF'}]}]}
fake_sh = {'portMap': {'deviceSlots': [fake_device]}}
fake_port = db_utils.create_test_port(address='AA:BB:CC:DD:EE')
oneview_client.server_hardware.get.return_value = fake_sh
oneview_info = db_utils.get_test_oneview_driver_info()
self.assertRaises(exception.OneViewError,
common._validate_node_port_mac_server_hardware,
oneview_client, oneview_info, [fake_port])
@mock.patch.object(common, 'get_hponeview_client', autospec=True)
def test__validate_node_enclosure_group_invalid(self, mock_hponeview):
oneview_client = mock_hponeview()
fake_sh = {'serverGroupUri': 'invalid_fake_eg_uri'}
oneview_client.server_hardware.get.return_value = fake_sh
oneview_info = {'server_hardware_uri': 'fake_sh_uri',
'enclosure_group_uri': 'fake_eg_uri'}
self.assertRaises(exception.OneViewError,
common._validate_node_enclosure_group,
oneview_client, oneview_info)
@mock.patch.object(common, 'get_hponeview_client', autospec=True)
def test__validate_node_server_hardware_type(self, mock_hponeview):
oneview_client = mock_hponeview()
fake_sh = {'serverHardwareTypeUri': 'invalid_fake_sh_uri'}
oneview_client.server_hardware.get.return_value = fake_sh
oneview_info = {'server_hardware_uri': 'fake_sh_uri',
'server_hardware_type_uri': 'fake_sht_uri'}
self.assertRaises(exception.OneViewError,
common._validate_node_server_hardware_type,
oneview_client, oneview_info)
def test__validate_server_profile_template_manage_boot_false(self):
fake_spt = {'boot': {'manageBoot': False}}
self.assertRaises(exception.OneViewError,
common._validate_server_profile_template_manage_boot,
fake_spt)
def test__validate_spt_enclosure_group_invalid(self):
fake_spt = {'enclosureGroupUri': 'fake_eg_uri'}
fake_sh = {'serverGroupUri': 'invalid_fake_eg_uri'}
self.assertRaises(exception.OneViewError,
common._validate_spt_enclosure_group,
fake_spt, fake_sh)
def test__validate_server_profile_template_server_hardware_type(self):
fake_spt = {'serverHardwareTypeUri': 'fake_sht_uri'}
fake_sh = {'serverHardwareTypeUri': 'invalid_fake_sht_uri'}
self.assertRaises(
exception.OneViewError,
common._validate_server_profile_template_server_hardware_type,
fake_spt, fake_sh
)

24
ironic/tests/unit/drivers/modules/oneview/test_deploy.py
View File

@ -278,10 +278,16 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
expected = common.COMMON_PROPERTIES
self.assertEqual(expected, self.driver.deploy.get_properties())
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate', autospec=True)
def test_validate(self, iscsi_deploy_validate_mock, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid) as task:
@mock.patch.object(common, 'validate_oneview_resources_compatibility',
spect_set=True, autospec=True)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate',
spec_set=True, autospec=True)
def test_validate(self, iscsi_deploy_validate_mock,
mock_validate_resources, mock_ov_client):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.validate(task)
self.assertTrue(mock_validate_resources.called)
iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True)
@ -397,10 +403,16 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
expected = common.COMMON_PROPERTIES
self.assertEqual(expected, self.driver.deploy.get_properties())
@mock.patch.object(agent.AgentDeploy, 'validate', autospec=True)
def test_validate(self, agent_deploy_validate_mock, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid) as task:
@mock.patch.object(common, 'validate_oneview_resources_compatibility',
spect_set=True, autospec=True)
@mock.patch.object(agent.AgentDeploy, 'validate',
spec_set=True, autospec=True)
def test_validate(self, agent_deploy_validate_mock,
mock_validate_resources, mock_ov_client):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.validate(task)
self.assertTrue(mock_validate_resources.called)
agent_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare', autospec=True)

14
ironic/tests/unit/drivers/modules/oneview/test_inspect.py
View File

@ -16,7 +16,7 @@
import mock
from ironic.conductor import task_manager
from ironic.drivers.modules.oneview import common as oneview_common
from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy_utils
from ironic.tests.unit.conductor import mgr_utils
from ironic.tests.unit.db import base as db_base
@ -43,13 +43,13 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
shared=True) as task:
self.assertEqual(expected, task.driver.inspect.get_properties())
@mock.patch.object(oneview_common, 'verify_node_info')
def test_validate(self, mock_verify_node_info):
@mock.patch.object(common, 'validate_oneview_resources_compatibility')
def test_validate(self, mock_validate):
self.config(enabled=False, group='inspector')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.inspect.validate(task)
mock_verify_node_info.assert_called_once_with(task.node)
self.assertTrue(mock_validate.called)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic):
@ -78,13 +78,13 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
shared=True) as task:
self.assertEqual(expected, task.driver.inspect.get_properties())
@mock.patch.object(oneview_common, 'verify_node_info')
def test_validate(self, mock_verify_node_info):
@mock.patch.object(common, 'validate_oneview_resources_compatibility')
def test_validate(self, mock_validate):
self.config(enabled=False, group='inspector')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.inspect.validate(task)
mock_verify_node_info.assert_called_once_with(task.node)
self.assertTrue(mock_validate.called)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic):

18
ironic/tests/unit/drivers/modules/oneview/test_management.py
View File

@ -236,18 +236,22 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
)
self.info = common.get_oneview_info(self.node)
@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_ovclient):
@mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic',
spect_set=True, autospec=True)
@mock.patch.object(common, 'validate_oneview_resources_compatibility',
spect_set=True, autospec=True)
def test_validate(self, mock_validate, mock_ironic_node, mock_ov_client):
mock_ironic_node.return_value = True
with task_manager.acquire(self.context, self.node.uuid) as task:
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.management.validate(task)
self.assertTrue(mock_validate.called)
@mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic')
@mock.patch.object(common, 'validate_oneview_resources_compatibility')
@mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic',
spect_set=True, autospec=True)
def test_validate_for_node_not_in_use_by_ironic(
self, mock_validate, mock_ironic_node, mock_ovclient):
self, mock_ironic_node, mock_get_ov_client
):
mock_ironic_node.return_value = False
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue,

7
releasenotes/notes/oneview-validations-f6d702d1fab77f91.yaml Normal file
View File

@ -0,0 +1,7 @@
---
other:
- |
Adds the implementation of the validations for the OneView hardware type,
migrating from python-oneviewclient library to OneView driver. This process
is part of migrating from ``python-oneviewclient`` to ``python-hpOneView``
and ``python-ilorest-library``.