openstack/deb-python-proliantutils
Code Issues Proposed changes
Files
369f0c38000deaf2cefe3d9aedec5babd2c6f221
deb-python-proliantutils/proliantutils/tests/ilo/test_client.py
Nisha Agarwal d4e83ad3b6 Fix the logic for fetching the gpu device count 
This patch fixes the logic for fetching the
gpu device count on Gen9 and above.
The Active gpu devices are not listed by RIBCL while
it can be achieved via RIS.

Change-Id: Iabac9ab2473848683f0ae7661aac064370c26d9b
2016-06-24 09:24:07 +00:00

545 lines
25 KiB
Python
Raw Blame History

# Copyright 2015 Hewlett-Packard Development Company, L.P.
# All Rights Reserved.
#
# 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.
"""Test class for Client Module."""
import mock
import testtools
from proliantutils.ilo import client
from proliantutils.ilo import ipmi
from proliantutils.ilo import ribcl
from proliantutils.ilo import ris
class IloClientInitTestCase(testtools.TestCase):
@mock.patch.object(ribcl, 'RIBCLOperations')
@mock.patch.object(ris, 'RISOperations')
def test_init(self, ris_mock, ribcl_mock):
ribcl_obj_mock = mock.MagicMock()
ribcl_mock.return_value = ribcl_obj_mock
ribcl_obj_mock.get_product_name.return_value = 'product'
c = client.IloClient("1.2.3.4", "admin", "Admin",
timeout=120, port=4430,
bios_password='foo',
cacert='/somewhere')
ris_mock.assert_called_once_with(
"1.2.3.4", "admin", "Admin", bios_password='foo',
cacert='/somewhere')
ribcl_mock.assert_called_once_with(
"1.2.3.4", "admin", "Admin", 120, 4430, cacert='/somewhere')
self.assertEqual(
{'address': "1.2.3.4", 'username': "admin", 'password': "Admin"},
c.info)
self.assertEqual('product', c.model)
class IloClientTestCase(testtools.TestCase):
@mock.patch.object(ribcl.RIBCLOperations, 'get_product_name')
def setUp(self, product_mock):
super(IloClientTestCase, self).setUp()
product_mock.return_value = 'Gen8'
self.client = client.IloClient("1.2.3.4", "admin", "Admin")
@mock.patch.object(ribcl.RIBCLOperations, 'get_all_licenses')
def test__call_method_ribcl(self, license_mock):
self.client._call_method('get_all_licenses')
license_mock.assert_called_once_with()
@mock.patch.object(ris.RISOperations, 'get_host_power_status')
def test__call_method_ris(self, power_mock):
self.client.model = 'Gen9'
self.client._call_method('get_host_power_status')
power_mock.assert_called_once_with()
@mock.patch.object(ribcl.RIBCLOperations, 'reset_ilo')
def test__call_method_gen9_ribcl(self, ilo_mock):
self.client.model = 'Gen9'
self.client._call_method('reset_ilo')
ilo_mock.assert_called_once_with()
@mock.patch.object(client.IloClient, '_call_method')
def test_set_http_boot_url(self, call_mock):
self.client.set_http_boot_url('fake-url')
call_mock.assert_called_once_with('set_http_boot_url', 'fake-url')
@mock.patch.object(client.IloClient, '_call_method')
def test_set_iscsi_boot_info(self, call_mock):
self.client.set_iscsi_boot_info('c456', 'iqn.2011-07.com:example:123',
'1', '10.10.1.23', '3260', 'CHAP',
'user', 'password')
call_mock.assert_called_once_with('set_iscsi_boot_info', 'c456',
'iqn.2011-07.com:example:123',
'1', '10.10.1.23', '3260',
'CHAP', 'user', 'password')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_product_name(self, call_mock):
self.client.get_product_name()
call_mock.assert_called_once_with('get_product_name')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_all_licenses(self, call_mock):
self.client.get_all_licenses()
call_mock.assert_called_once_with('get_all_licenses')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_power_status(self, call_mock):
self.client.get_host_power_status()
call_mock.assert_called_once_with('get_host_power_status')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_http_boot_url(self, call_mock):
self.client.get_http_boot_url()
call_mock.assert_called_once_with('get_http_boot_url')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_one_time_boot(self, call_mock):
self.client.get_one_time_boot()
call_mock.assert_called_once_with('get_one_time_boot')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_vm_status(self, call_mock):
self.client.get_vm_status('CDROM')
call_mock.assert_called_once_with('get_vm_status', 'CDROM')
@mock.patch.object(client.IloClient, '_call_method')
def test_press_pwr_btn(self, call_mock):
self.client.press_pwr_btn()
call_mock.assert_called_once_with('press_pwr_btn')
@mock.patch.object(client.IloClient, '_call_method')
def test_reset_server(self, call_mock):
self.client.reset_server()
call_mock.assert_called_once_with('reset_server')
@mock.patch.object(client.IloClient, '_call_method')
def test_hold_pwr_btn(self, call_mock):
self.client.hold_pwr_btn()
call_mock.assert_called_once_with('hold_pwr_btn')
@mock.patch.object(client.IloClient, '_call_method')
def test_set_host_power(self, call_mock):
self.client.set_host_power('ON')
call_mock.assert_called_once_with('set_host_power', 'ON')
@mock.patch.object(client.IloClient, '_call_method')
def test_set_one_time_boot(self, call_mock):
self.client.set_one_time_boot('CDROM')
call_mock.assert_called_once_with('set_one_time_boot', 'CDROM')
@mock.patch.object(client.IloClient, '_call_method')
def test_insert_virtual_media(self, call_mock):
self.client.insert_virtual_media(url='fake-url', device='FLOPPY')
call_mock.assert_called_once_with('insert_virtual_media', 'fake-url',
'FLOPPY')
@mock.patch.object(client.IloClient, '_call_method')
def test_eject_virtual_media(self, call_mock):
self.client.eject_virtual_media(device='FLOPPY')
call_mock.assert_called_once_with('eject_virtual_media', 'FLOPPY')
@mock.patch.object(client.IloClient, '_call_method')
def test_set_vm_status(self, call_mock):
self.client.set_vm_status(device='FLOPPY', boot_option='BOOT_ONCE',
write_protect='YES')
call_mock.assert_called_once_with('set_vm_status', 'FLOPPY',
'BOOT_ONCE', 'YES')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_current_boot_mode(self, call_mock):
self.client.get_current_boot_mode()
call_mock.assert_called_once_with('get_current_boot_mode')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_pending_boot_mode(self, call_mock):
self.client.get_pending_boot_mode()
call_mock.assert_called_once_with('get_pending_boot_mode')
@mock.patch.object(client.IloClient, '_call_method')
def test_set_pending_boot_mode(self, call_mock):
self.client.set_pending_boot_mode('UEFI')
call_mock.assert_called_once_with('set_pending_boot_mode', 'UEFI')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_persistent_boot_device(self, call_mock):
self.client.get_persistent_boot_device()
call_mock.assert_called_once_with('get_persistent_boot_device')
@mock.patch.object(client.IloClient, '_call_method')
def test_update_persistent_boot(self, call_mock):
self.client.update_persistent_boot(['HDD'])
call_mock.assert_called_once_with('update_persistent_boot', ['HDD'])
@mock.patch.object(client.IloClient, '_call_method')
def test_get_secure_boot_mode(self, call_mock):
self.client.get_secure_boot_mode()
call_mock.assert_called_once_with('get_secure_boot_mode')
@mock.patch.object(client.IloClient, '_call_method')
def test_set_secure_boot_mode(self, call_mock):
self.client.set_secure_boot_mode(True)
call_mock.assert_called_once_with('set_secure_boot_mode', True)
@mock.patch.object(client.IloClient, '_call_method')
def test_reset_secure_boot_keys(self, call_mock):
self.client.reset_secure_boot_keys()
call_mock.assert_called_once_with('reset_secure_boot_keys')
@mock.patch.object(client.IloClient, '_call_method')
def test_clear_secure_boot_keys(self, call_mock):
self.client.clear_secure_boot_keys()
call_mock.assert_called_once_with('clear_secure_boot_keys')
@mock.patch.object(client.IloClient, '_call_method')
def test_reset_ilo_credential(self, call_mock):
self.client.reset_ilo_credential('password')
call_mock.assert_called_once_with('reset_ilo_credential', 'password')
@mock.patch.object(client.IloClient, '_call_method')
def test_reset_ilo(self, call_mock):
self.client.reset_ilo()
call_mock.assert_called_once_with('reset_ilo')
@mock.patch.object(client.IloClient, '_call_method')
def test_reset_bios_to_default(self, call_mock):
self.client.reset_bios_to_default()
call_mock.assert_called_once_with('reset_bios_to_default')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_uuid(self, call_mock):
self.client.get_host_uuid()
call_mock.assert_called_once_with('get_host_uuid')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_health_data(self, call_mock):
self.client.get_host_health_data('fake-data')
call_mock.assert_called_once_with('get_host_health_data', 'fake-data')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_health_present_power_reading(self, call_mock):
self.client.get_host_health_present_power_reading('fake-data')
call_mock.assert_called_once_with(
'get_host_health_present_power_reading', 'fake-data')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_health_power_supplies(self, call_mock):
self.client.get_host_health_power_supplies('fake-data')
call_mock.assert_called_once_with('get_host_health_power_supplies',
'fake-data')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_health_fan_sensors(self, call_mock):
self.client.get_host_health_fan_sensors('fake-data')
call_mock.assert_called_once_with('get_host_health_fan_sensors',
'fake-data')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_health_temperature_sensors(self, call_mock):
self.client.get_host_health_temperature_sensors('fake-data')
call_mock.assert_called_once_with(
'get_host_health_temperature_sensors', 'fake-data')
@mock.patch.object(client.IloClient, '_call_method')
def test_get_host_health_at_a_glance(self, call_mock):
self.client.get_host_health_at_a_glance('fake-data')
call_mock.assert_called_once_with('get_host_health_at_a_glance',
'fake-data')
@mock.patch.object(ipmi, 'get_nic_capacity')
@mock.patch.object(ribcl.RIBCLOperations,
'get_ilo_firmware_version_as_major_minor')
@mock.patch.object(ribcl.RIBCLOperations, 'get_server_capabilities')
def test_get_server_capabilities(self, cap_mock, maj_min_mock, nic_mock):
info = {'address': "1.2.3.4", 'username': "admin", 'password': "Admin"}
str_val = maj_min_mock.return_value = "2.10"
nic_mock.return_value = '10Gb'
cap_mock.return_value = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen8',
'pci_gpu_devices': '2'}
capabilities = self.client.get_server_capabilities()
expected_capabilities = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen8',
'pci_gpu_devices': '2',
'nic_capacity': '10Gb'}
cap_mock.assert_called_once_with()
nic_mock.assert_called_once_with(self.client.info, str_val)
self.assertEqual(expected_capabilities, capabilities)
self.assertEqual(info, self.client.info)
@mock.patch.object(ipmi, 'get_nic_capacity')
@mock.patch.object(ribcl.RIBCLOperations,
'get_ilo_firmware_version_as_major_minor')
@mock.patch.object(ribcl.RIBCLOperations, 'get_server_capabilities')
def test_get_server_capabilities_no_nic(self, cap_mock, maj_min_mock,
nic_mock):
info = {'address': "1.2.3.4", 'username': "admin", 'password': "Admin"}
str_val = maj_min_mock.return_value = '2.10'
nic_mock.return_value = None
cap_mock.return_value = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen8',
'pci_gpu_devices': '2'}
capabilities = self.client.get_server_capabilities()
expected_capabilities = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen8',
'pci_gpu_devices': '2'}
cap_mock.assert_called_once_with()
nic_mock.assert_called_once_with(self.client.info, str_val)
self.assertEqual(expected_capabilities, capabilities)
self.assertEqual(info, self.client.info)
@mock.patch.object(ipmi, 'get_nic_capacity')
@mock.patch.object(ribcl.RIBCLOperations,
'get_ilo_firmware_version_as_major_minor')
@mock.patch.object(ribcl.RIBCLOperations, 'get_server_capabilities')
def test_get_server_capabilities_no_firmware(self, cap_mock,
maj_min_mock, nic_mock):
maj_min_mock.return_value = None
nic_mock.return_value = None
cap_mock.return_value = {'rom_firmware_version': 'x',
'server_model': 'Gen8',
'pci_gpu_devices': '2'}
expected_capabilities = {'rom_firmware_version': 'x',
'server_model': 'Gen8',
'pci_gpu_devices': '2'}
capabilities = self.client.get_server_capabilities()
self.assertEqual(expected_capabilities, capabilities)
nic_mock.assert_called_once_with(self.client.info, None)
@mock.patch.object(ris.RISOperations,
'get_ilo_firmware_version_as_major_minor')
@mock.patch.object(ipmi, 'get_nic_capacity')
@mock.patch.object(ris.RISOperations, 'get_server_capabilities')
def test_get_server_capabilities_no_nic_Gen9(self, cap_mock, nic_mock,
mm_mock):
str_val = mm_mock.return_value = '2.10'
self.client.model = 'Gen9'
nic_mock.return_value = None
cap_mock.return_value = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen9',
'pci_gpu_devices': 2,
'secure_boot': 'true'}
capabilities = self.client.get_server_capabilities()
cap_mock.assert_called_once_with()
nic_mock.assert_called_once_with(self.client.info, str_val)
expected_capabilities = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen9',
'pci_gpu_devices': 2,
'secure_boot': 'true'}
self.assertEqual(expected_capabilities, capabilities)
@mock.patch.object(ris.RISOperations,
'get_ilo_firmware_version_as_major_minor')
@mock.patch.object(ipmi, 'get_nic_capacity')
@mock.patch.object(ris.RISOperations, 'get_server_capabilities')
def test_get_server_capabilities_Gen9(self, cap_mock, nic_mock,
mm_mock):
str_val = mm_mock.return_value = '2.10'
self.client.model = 'Gen9'
nic_mock.return_value = '10Gb'
cap_mock.return_value = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen9',
'pci_gpu_devices': 2,
'secure_boot': 'true'}
capabilities = self.client.get_server_capabilities()
cap_mock.assert_called_once_with()
nic_mock.assert_called_once_with(self.client.info, str_val)
expected_capabilities = {'ilo_firmware_version': '2.10',
'rom_firmware_version': 'x',
'server_model': 'Gen9',
'pci_gpu_devices': 2,
'secure_boot': 'true',
'nic_capacity': '10Gb'}
self.assertEqual(expected_capabilities, capabilities)
@mock.patch.object(client.IloClient, '_call_method')
def test_activate_license(self, call_mock):
self.client.activate_license('fake-key')
call_mock.assert_called_once_with('activate_license', 'fake-key')
@mock.patch.object(ris.RISOperations, 'eject_virtual_media')
def test_eject_virtual_media_gen9(self, eject_virtual_media_mock):
self.client.model = 'Gen9'
self.client.eject_virtual_media(device='FLOPPY')
eject_virtual_media_mock.assert_called_once_with('FLOPPY')
@mock.patch.object(ribcl.RIBCLOperations, 'eject_virtual_media')
def test_eject_virtual_media_gen8(self, eject_virtual_media_mock):
self.client.model = 'Gen8'
self.client.eject_virtual_media(device='FLOPPY')
eject_virtual_media_mock.assert_called_once_with('FLOPPY')
@mock.patch.object(ris.RISOperations, 'get_vm_status')
def test_get_vm_status_gen9(self, get_vm_status_mock):
self.client.model = 'Gen9'
self.client.get_vm_status(device='FLOPPY')
get_vm_status_mock.assert_called_once_with('FLOPPY')
@mock.patch.object(ribcl.RIBCLOperations, 'get_vm_status')
def test_get_vm_status_gen8(self, get_vm_status_mock):
self.client.model = 'Gen8'
self.client.get_vm_status(device='FLOPPY')
get_vm_status_mock.assert_called_once_with('FLOPPY')
@mock.patch.object(ris.RISOperations, 'set_vm_status')
def test_set_vm_status_gen9(self, set_vm_status_mock):
self.client.model = 'Gen9'
self.client.set_vm_status(device='FLOPPY', boot_option='BOOT_ONCE',
write_protect='YES')
set_vm_status_mock.assert_called_once_with('FLOPPY', 'BOOT_ONCE',
'YES')
@mock.patch.object(ribcl.RIBCLOperations, 'set_vm_status')
def test_set_vm_status_gen8(self, set_vm_status_mock):
self.client.model = 'Gen8'
self.client.set_vm_status(device='FLOPPY', boot_option='BOOT_ONCE',
write_protect='YES')
set_vm_status_mock.assert_called_once_with('FLOPPY', 'BOOT_ONCE',
'YES')
@mock.patch.object(ris.RISOperations, 'insert_virtual_media')
def test_insert_virtual_media_gen9(self, insert_virtual_media_mock):
self.client.model = 'Gen9'
self.client.insert_virtual_media(url="http://ilo/fpy.iso",
device='FLOPPY')
insert_virtual_media_mock.assert_called_once_with("http://ilo/fpy.iso",
"FLOPPY")
@mock.patch.object(ribcl.RIBCLOperations, 'insert_virtual_media')
def test_insert_virtual_media_gen8(self, insert_virtual_media_mock):
self.client.model = 'Gen8'
self.client.insert_virtual_media(url="http://ilo/fpy.iso",
device='FLOPPY')
insert_virtual_media_mock.assert_called_once_with("http://ilo/fpy.iso",
"FLOPPY")
@mock.patch.object(ris.RISOperations, 'get_one_time_boot')
def test_get_one_time_boot_gen9(self, get_one_time_boot_mock):
self.client.model = 'Gen9'
self.client.get_one_time_boot()
get_one_time_boot_mock.assert_called_once_with()
@mock.patch.object(ribcl.RIBCLOperations, 'get_one_time_boot')
def test_get_one_time_boot_gen8(self, get_one_time_boot_mock):
self.client.model = 'Gen8'
self.client.get_one_time_boot()
get_one_time_boot_mock.assert_called_once_with()
@mock.patch.object(ris.RISOperations, 'set_one_time_boot')
def test_set_one_time_boot_gen9(self, set_one_time_boot_mock):
self.client.model = 'Gen9'
self.client.set_one_time_boot('cdrom')
set_one_time_boot_mock.assert_called_once_with('cdrom')
@mock.patch.object(ribcl.RIBCLOperations, 'set_one_time_boot')
def test_set_one_time_boot_gen8(self, set_one_time_boot_mock):
self.client.model = 'Gen8'
self.client.set_one_time_boot('cdrom')
set_one_time_boot_mock.assert_called_once_with('cdrom')
@mock.patch.object(ris.RISOperations, 'update_persistent_boot')
def test_update_persistent_boot_gen9(self, update_persistent_boot_mock):
self.client.model = 'Gen9'
self.client.update_persistent_boot(['cdrom'])
update_persistent_boot_mock.assert_called_once_with(['cdrom'])
@mock.patch.object(ribcl.RIBCLOperations, 'update_persistent_boot')
def test_update_persistent_boot_gen8(self, update_persistent_boot_mock):
self.client.model = 'Gen8'
self.client.update_persistent_boot(['cdrom'])
update_persistent_boot_mock.assert_called_once_with(['cdrom'])
@mock.patch.object(ris.RISOperations, 'get_persistent_boot_device')
def test_get_persistent_boot_device_gen9(self, get_pers_boot_device_mock):
self.client.model = 'Gen9'
self.client.get_persistent_boot_device()
get_pers_boot_device_mock.assert_called_once_with()
@mock.patch.object(ribcl.RIBCLOperations, 'get_persistent_boot_device')
def test_get_persistent_boot_device_gen8(self, get_pers_boot_device_mock):
self.client.model = 'Gen8'
self.client.get_persistent_boot_device()
get_pers_boot_device_mock.assert_called_once_with()
@mock.patch.object(client.IloClient, '_call_method')
def test_update_firmware(self, _call_method_mock):
# | GIVEN |
some_url = 'some-url'
some_component_type = 'ilo'
# | WHEN |
self.client.update_firmware(some_url, some_component_type)
# | THEN |
_call_method_mock.assert_called_once_with('update_firmware',
some_url,
some_component_type)
@mock.patch.object(ris.RISOperations, 'hold_pwr_btn')
def test_hold_pwr_btn_gen9(self, hold_pwr_btn_mock):
self.client.model = 'Gen9'
self.client.hold_pwr_btn()
self.assertTrue(hold_pwr_btn_mock.called)
@mock.patch.object(ribcl.RIBCLOperations, 'hold_pwr_btn')
def test_hold_pwr_btn_gen8(self, hold_pwr_btn_mock):
self.client.model = 'Gen8'
self.client.hold_pwr_btn()
self.assertTrue(hold_pwr_btn_mock.called)
@mock.patch.object(ris.RISOperations, 'set_host_power')
def test_set_host_power_gen9(self, set_host_power_mock):
self.client.model = 'Gen9'
self.client.set_host_power('ON')
set_host_power_mock.assert_called_once_with('ON')
@mock.patch.object(ribcl.RIBCLOperations, 'set_host_power')
def test_set_host_power_gen8(self, set_host_power_mock):
self.client.model = 'Gen8'
self.client.set_host_power('ON')
set_host_power_mock.assert_called_once_with('ON')
@mock.patch.object(ris.RISOperations, 'press_pwr_btn')
def test_press_pwr_btn_gen9(self, press_pwr_btn_mock):
self.client.model = 'Gen9'
self.client.press_pwr_btn()
self.assertTrue(press_pwr_btn_mock.called)
@mock.patch.object(ribcl.RIBCLOperations, 'press_pwr_btn')
def test_press_pwr_btn_gen8(self, press_pwr_btn_mock):
self.client.model = 'Gen8'
self.client.press_pwr_btn()
self.assertTrue(press_pwr_btn_mock.called)
@mock.patch.object(ris.RISOperations, 'reset_server')
def test_reset_server_gen9(self, reset_server_mock):
self.client.model = 'Gen9'
self.client.reset_server()
self.assertTrue(reset_server_mock.called)
@mock.patch.object(ribcl.RIBCLOperations, 'reset_server')
def test_reset_server_gen8(self, reset_server_mock):
self.client.model = 'Gen8'
self.client.reset_server()
self.assertTrue(reset_server_mock.called)
View Git Blame Copy Permalink