x/python-oneviewclient
Code Issues Proposed changes
python-oneviewclient/oneview_client/tests/test_oneview_client.py
Sinval Neto 654fd4db93 Adding check for missing configuration values 
The python-oneviewclient must raise exceptions when 'manager_url'
configuration parameter has a null or empty value. Some checks
were changed and added to oneview_client.client.

Change-Id: I22984cd6757a7816e323bd156eefda086aa06364
2015-10-02 13:31:02 +00:00

655 lines
25 KiB
Python
Raw Blame History

# -*- encoding: utf-8 -*-
#
# (c) Copyright 2015 Hewlett Packard Enterprise Development LP
# Copyright 2015 Universidade Federal de Campina Grande
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import mock
import requests
import retrying
import six.moves.http_client as http_client
import unittest
from oneview_client import client
from oneview_client import exceptions
from oneview_client import states
PROPERTIES_DICT = {"cpu_arch": "x86_64",
"cpus": "8",
"local_gb": "10",
"memory_mb": "4096",
"capabilities": "server_hardware_type_uri:fake_sht_uri,"
"enclosure_group_uri:fake_eg_uri"}
DRIVER_INFO_DICT = {'server_hardware_uri': 'fake_sh_uri',
'server_profile_template_uri': 'fake_spt_uri'}
class OneViewClientAuthTestCase(unittest.TestCase):
def setUp(self):
super(OneViewClientAuthTestCase, self).setUp()
self.manager_url = 'https://1.2.3.4'
self.username = 'user'
self.password = 'password'
@mock.patch.object(requests, 'post')
def test_authenticate(self, mock_post):
client.Client(self.manager_url,
self.username,
self.password)
mock_post.assert_called_once_with(
'https://1.2.3.4/rest/login-sessions',
data=json.dumps({"userName": "user", "password": "password"}),
headers={'content-type': 'application/json'},
verify=True
)
@mock.patch.object(requests, 'post')
def test_authenticate_insecure(self, mock_post):
client.Client(self.manager_url,
self.username,
self.password,
allow_insecure_connections=True)
mock_post.assert_called_once_with(
'https://1.2.3.4/rest/login-sessions',
data=json.dumps({"userName": "user", "password": "password"}),
headers={'content-type': 'application/json'},
verify=False
)
@mock.patch.object(requests, 'post')
def test_authenticate_invalid_credentials(self, mock_post):
response = mock_post.return_value
response.status_code = http_client.BAD_REQUEST
mock_post.return_value = response
self.assertRaises(
exceptions.OneViewNotAuthorizedException,
client.Client,
self.manager_url,
'any',
'any'
)
@mock.patch.object(client.Client, '_authenticate', autospec=True)
def test_get_session(self, mock__authenticate):
reference = "xyz"
response = mock__authenticate.return_value
response.status_code = http_client.OK
response.json = mock.MagicMock(return_value={"sessionID": reference})
mock__authenticate.return_value = response
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
session_id = oneview_client.get_session()
self.assertEqual(reference, session_id)
@mock.patch.object(client.Client, '_authenticate', autospec=True)
class OneViewClientTestCase(unittest.TestCase):
def setUp(self):
super(OneViewClientTestCase, self).setUp()
self.manager_url = 'https://1.2.3.4'
self.username = 'user'
self.password = 'password'
@mock.patch.object(client.Client, 'set_node_power_state', autospec=True)
@mock.patch.object(client.Client, 'get_node_power_state', autospec=True)
def test_power_on_server_on(self, mock_get_pstate, mock_set_pstate,
mock__authenticate):
driver_info = {"server_hardware_uri": "/any"}
mock_get_pstate.return_value = states.ONEVIEW_POWER_ON
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
oneview_client.power_on(driver_info)
mock_get_pstate.assert_called_once_with(oneview_client, driver_info)
self.assertFalse(mock_set_pstate.called)
@mock.patch.object(client.Client, 'set_node_power_state', autospec=True)
@mock.patch.object(client.Client, 'get_node_power_state', autospec=True)
def test_power_on_server_off(self, mock_get_pstate, mock_set_pstate,
mock__authenticate):
driver_info = {"server_hardware_uri": "/any"}
mock_get_pstate.return_value = states.ONEVIEW_POWER_OFF
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
oneview_client.power_on(driver_info)
mock_get_pstate.assert_called_once_with(oneview_client, driver_info)
mock_set_pstate.assert_called_once_with(oneview_client, driver_info,
states.ONEVIEW_POWER_ON)
@mock.patch.object(client.Client, 'set_node_power_state', autospec=True)
@mock.patch.object(client.Client, 'get_node_power_state', autospec=True)
def test_power_off_server_off(self, mock_get_pstate, mock_set_pstate,
mock__authenticate):
driver_info = {"server_hardware_uri": "/any"}
mock_get_pstate.return_value = states.ONEVIEW_POWER_OFF
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
oneview_client.power_off(driver_info)
mock_get_pstate.assert_called_once_with(oneview_client, driver_info)
self.assertFalse(mock_set_pstate.called)
@mock.patch.object(client.Client, 'set_node_power_state', autospec=True)
@mock.patch.object(client.Client, 'get_node_power_state', autospec=True)
def test_power_off_server_on(self, mock_get_pstate, mock_set_pstate,
mock__authenticate):
driver_info = {"server_hardware_uri": "/any"}
mock_get_pstate.return_value = states.ONEVIEW_POWER_ON
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
oneview_client.power_off(driver_info)
mock_get_pstate.assert_called_once_with(oneview_client, driver_info)
mock_set_pstate.assert_called_once_with(oneview_client, driver_info,
states.ONEVIEW_POWER_OFF,
client.PRESS_AND_HOLD)
@mock.patch.object(client.Client, '_wait_for_task_to_complete',
autospec=True)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
@mock.patch.object(client.Client, 'get_node_power_state', autospec=True)
def test_set_power_state_server_hardware(self, mock_get_node_power,
mock__prepare_do_request,
mock__wait_for_task,
mock__authenticate):
mock_get_node_power.return_value = states.ONEVIEW_POWER_ON
mock__prepare_do_request.return_value = {}
driver_info = {"server_hardware_uri": "/any"}
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
oneview_client.set_node_power_state(
driver_info,
states.ONEVIEW_POWER_ON
)
mock__prepare_do_request.assert_called_once_with(
oneview_client,
uri='/any/powerState',
body={'powerControl': client.MOMENTARY_PRESS,
'powerState': states.ONEVIEW_POWER_ON},
request_type=client.PUT_REQUEST_TYPE,
)
@mock.patch.object(requests, 'put', autospec=True)
def test_set_power_state_nonexistent_server_hardware(
self, mock_do_request, mock__authenticate):
class Response(object):
status_code = 404
def json(self):
return {
"errorCode": "RESOURCE_NOT_FOUND",
"details": "Resource not found, ID = /any_invalid",
}
mock_do_request.return_value = Response()
driver_info = {"server_hardware_uri": "/any_invalid"}
target_state = states.ONEVIEW_POWER_ON
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaises(
exceptions.OneViewResourceNotFoundError,
oneview_client.set_node_power_state, driver_info, target_state
)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
@mock.patch.object(client.Client, 'get_node_power_state', autospec=True)
def test_set_power_state_server_hardware_power_status_error(
self, mock_get_node_power, mock__prepare_do_request, mock__authenticate
):
power = states.ONEVIEW_ERROR
mock_get_node_power.return_value = power
mock__prepare_do_request.return_value = {
"taskState": "Error",
"percentComplete": 100
}
driver_info = {"server_hardware_uri": "/any"}
target_state = "On"
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaises(
exceptions.OneViewErrorStateSettingPowerState,
oneview_client.set_node_power_state, driver_info, target_state
)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
def test_get_server_hardware_nonexistent(self, mock__prepare_do_request,
mock__authenticate):
mock__prepare_do_request.return_value = {"error": "resource not found"}
driver_info = {"server_hardware_uri": ""}
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaises(
exceptions.OneViewResourceNotFoundError,
oneview_client.get_server_hardware,
driver_info
)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
@mock.patch.object(client.Client, 'get_server_profile_from_hardware',
autospec=True)
def test_set_boot_device_nonexistent_resource_uri(self,
mock_get_server_profile,
mock__prepare_do_request,
mock__authenticate):
driver_info = {}
new_first_boot_device = "None"
mock__prepare_do_request.return_value = {
"errorCode": "RESOURCE_NOT_FOUND",
"data": None
}
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaises(
exceptions.OneViewResourceNotFoundError,
oneview_client.set_boot_device,
driver_info,
new_first_boot_device
)
@mock.patch.object(client.Client, 'get_boot_order', autospec=True)
def test_set_boot_device_nonexistent_resource_first_boot_device(
self, mock_get_boot_order, mock__authenticate
):
driver_info = {}
new_first_boot_device = None
mock_get_boot_order.return_value = []
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaises(
exceptions.OneViewBootDeviceInvalidError,
oneview_client.set_boot_device,
driver_info,
new_first_boot_device
)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
@mock.patch.object(client.Client, 'get_boot_order', autospec=True)
def test_get_server_profile_from_hardware(self, mock_get_boot_order,
mock_get_server_hardware,
mock__prepare_do_request,
mock__authenticate):
driver_info = {}
new_first_boot_device = "any_boot_device"
mock_get_boot_order.return_value = []
mock_get_server_hardware.return_value = {}
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaises(
exceptions.OneViewServerProfileAssociatedError,
oneview_client.set_boot_device,
driver_info,
new_first_boot_device
)
mock_get_server_hardware.return_value = {"serverProfileUri": "any_uri"}
mock__prepare_do_request.return_value = {}
self.assertRaises(
exceptions.OneViewResourceNotFoundError,
oneview_client.set_boot_device,
driver_info,
new_first_boot_device
)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
def test__wait_for_task_to_complete(self, mock__prepare_do_request,
mock__authenticate):
task = {
"uri": "/any_uri",
"taskState": "Something",
"percentComplete": 100
}
oneview_client = client.Client(self.manager_url,
self.username,
self.password,
max_polling_attempts=1)
mock__prepare_do_request.return_value = task
oneview_client._wait_for_task_to_complete(task)
@mock.patch.object(client.Client, '_prepare_and_do_request', autospec=True)
def test__wait_for_task_to_complete_timeout(self, mock__prepare_do_request,
mock__authenticate):
task = {
"uri": "/any_uri",
"taskState": "Something",
"percentComplete": 30
}
oneview_client = client.Client(self.manager_url,
self.username,
self.password,
max_polling_attempts=1)
mock__prepare_do_request.return_value = task
self.assertRaises(
retrying.RetryError,
oneview_client._wait_for_task_to_complete,
task,
)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
def test_validate_node_server_hardware_inconsistent_memorymb_value(
self, mock_get_server_hardware, mock__authenticate
):
mock_get_server_hardware.return_value = {
"memoryMb": 1,
"processorCoreCount": 1,
"processorCount": 1,
}
driver_info = {
"server_hardware_uri": "/any_uri",
}
node_memorymb = 2
node_cpus = 1
exc_expected_msg = (
"Node memory_mb is inconsistent with OneView's server"
" hardware /any_uri memoryMb."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client.validate_node_server_hardware,
driver_info,
node_memorymb,
node_cpus
)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
def test_validate_node_server_hardware_inconsistent_cpus_value(
self, mock_get_server_hardware, mock__authenticate
):
mock_get_server_hardware.return_value = {
"memoryMb": 1,
"processorCoreCount": 2,
"processorCount": 3,
}
driver_info = {
"server_hardware_uri": "/any_uri",
}
node_memorymb = 1
node_cpus = 3
exc_expected_msg = (
"Node cpus is inconsistent with OneView's server"
" hardware /any_uri cpus."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client.validate_node_server_hardware,
driver_info,
node_memorymb,
node_cpus
)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
def test_validate_node_server_hardware_type_inconsistent_sht_uri(
self, mock_get_server_hardware, mock__authenticate
):
mock_get_server_hardware.return_value = {
"serverHardwareTypeUri": "/incosistent_uri"
}
driver_info = {
"server_hardware_uri": "/any_serveruri",
"server_hardware_type_uri": "/any_uri",
}
exc_expected_msg = (
"Node server_hardware_type_uri is inconsistent with"
" OneView's server hardware /any_serveruri serverHardwareTypeUri."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client.validate_node_server_hardware_type,
driver_info
)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
def test_validate_node_enclosure_group_inconsistent(
self, mock_get_server_hardware, mock__authenticate
):
driver_info = {
"server_hardware_uri": "/any_uri",
"enclosure_group_uri": "/inconsistent_uri"
}
exc_expected_msg = (
"Node enclosure_group_uri is inconsistent with"
" OneView's server hardware /any_uri serverGroupUri."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client.validate_node_enclosure_group,
driver_info
)
@mock.patch.object(client.Client, 'get_server_profile_from_hardware',
autospec=True)
def test_check_node_port_mac_incompatible_with_server_profile(
self, mock_server_profile, mock__authenticate
):
mock_server_profile.return_value = {
"uri": "/anyuri",
"connections": [
{'boot': {'priority': u'Primary'},
'mac': u'56:88:7B:C0:00:0B'}
]
}
exc_expected_msg = (
"The ports of the node are not compatible with its"
" server profile /anyuri."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client
.is_node_port_mac_compatible_with_server_profile,
{},
{}
)
@mock.patch.object(client.Client, 'get_server_profile_from_hardware',
autospec=True)
def test_check_node_port_mac_no_primary_boot_connection(
self, mock_server_profile, mock__authenticate
):
mock_server_profile.return_value = {
"uri": "/anyuri",
"connections": [
{'boot': {'priority': u'NotBootable'},
'mac': u'56:88:7B:C0:00:0B'}
]
}
exc_expected_msg = (
"No primary boot connection configured for server profile"
" /anyuri."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client
.is_node_port_mac_compatible_with_server_profile,
{},
{}
)
@mock.patch.object(client.Client, 'get_server_profile_template',
autospec=True)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
def test_validate_node_server_profile_template_inconsistent_sht(
self, mock_server_hardware, mock_server_template, mock__authenticate
):
mock_server_hardware.return_value = {
'serverHardwareTypeUri': '/sht_uri',
'serverGroupUri': 'eg_uri'}
mock_server_template.return_value = {
'serverHardwareTypeUri': '/inconsistent_uri',
'enclosureGroupUri': '/inconsistent_uri'}
driver_info = {
"server_hardware_uri": "/any_uri",
"server_profile_template_uri": "/profile_uri"
}
exc_expected_msg = (
"Server profile template /profile_uri serverHardwareTypeUri is"
" inconsistent with server hardware /any_uri"
" serverHardwareTypeUri."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client.validate_node_server_profile_template,
driver_info
)
@mock.patch.object(client.Client, 'get_server_profile_template',
autospec=True)
@mock.patch.object(client.Client, 'get_server_hardware', autospec=True)
def test_validate_node_server_profile_template_inconsistent_eg(
self, mock_server_hardware, mock_server_template, mock__authenticate
):
mock_server_hardware.return_value = {
'serverHardwareTypeUri': '/sht_uri',
'serverGroupUri': 'eg_uri'}
mock_server_template.return_value = {
'serverHardwareTypeUri': '/sht_uri',
'enclosureGroupUri': '/inconsistent_uri'}
driver_info = {
"server_hardware_uri": "/any_uri",
"server_profile_template_uri": "/profile_uri"
}
exc_expected_msg = (
"Server profile template /profile_uri enclosureGroupUri is"
" inconsistent with server hardware /any_uri"
" serverGroupUri."
)
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
self.assertRaisesRegexp(
exceptions.OneViewInconsistentResource,
exc_expected_msg,
oneview_client.validate_node_server_profile_template,
driver_info
)
@mock.patch.object(client.Client, 'get_oneview_version')
def test_verify_oneview_version(self, mock_get_oneview_version,
mock__authenticate):
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
mock_get_oneview_version.return_value = {
'minimumVersion': 120,
'currentVersion': 200
}
oneview_client.verify_oneview_version()
mock_get_oneview_version.assert_called_once_with()
@mock.patch.object(client.Client, 'get_oneview_version')
def test_verify_oneview_version_fail(self, mock_get_oneview_version,
mock__authenticate):
oneview_client = client.Client(self.manager_url,
self.username,
self.password)
mock_get_oneview_version.return_value = {
'minimumVersion': 120,
'currentVersion': 120
}
self.assertRaises(
exceptions.IncompatibleOneViewAPIVersion,
oneview_client.verify_oneview_version
)
View Git Blame Copy Permalink