class ProfilesTest(unittest.TestCase):
def setUp(self):
super(ProfilesTest, self).setUp()
self.host = 'http://1.2.3.4'
self.connection = connection(self.host)
self.settings = settings(self.connection)
self.servers = servers(self.connection)
self.profile = profile
@mock.patch.object(settings, 'get_spps')
def test_make_firmware_exists(self, mock_get_spps):
baseline = 'SPP2016020_2015_1204_63.iso'
# build a FW response dictionary
fw_driver = self.build_get_spp_response()
# return the FW response when get_spps() is called
mock_get_spps.return_value = [fw_driver]
firmware = self.profile.make_firmware_dict(settings, baseline)
self.assertIsNotNone(firmware)
self.assertEqual(
{'manageFirmware': True, 'firmwareBaselineUri': '/rest/firmware-drivers/SPP2016020_2015_1204_63',
'forceInstallFirmware': False}, firmware)
@mock.patch.object(settings, 'get_spps')
def test_make_firmware_does_not_exist(self, mock_get_spps):
baseline = 'SPP20160201_2015_1204_63.iso'
# build a FW response dictionary
fw_driver = self.build_get_spp_response()
# return the FW response when get_spps() is called
mock_get_spps.return_value = [fw_driver]
try:
self.profile.make_firmware_dict(settings, baseline)
except HPOneViewInvalidResource as hp_exception:
self.assertEqual(hp_exception.args[0], 'ERROR: Locating Firmware Baseline SPP\n Baseline: '
'"SPP20160201_2015_1204_63.iso" can not be located')
else:
self.fail("Expected Exception")
def test_make_local_storage_with_bl(self):
sht = self.build_gen8_bl_sht()
local_storage = self.profile.make_local_storage_dict(
sht, 'RAID0', False, False, 2, 'Operating System')
self.assertIsNotNone(local_storage)
self.assertEqual(
{'controllers': [
{'slotNumber': '0', 'logicalDrives': [
{'driveTechnology': None, 'driveName': 'Operating System', 'raidLevel': 'RAID0',
'bootable': False, 'numPhysicalDrives': 2}], 'importConfiguration': True,
'mode': 'RAID', 'initialize': False, 'managed': True}
]},
local_storage)
def test_make_local_storage_with_dl(self):
sht = self.build_dl_sht()
try:
self.profile.make_local_storage_dict(
sht, 'RAID0', False, False, 2, 'Operating System')
except HPOneViewInvalidResource as hp_exception:
self.assertEqual(
hp_exception.args[0], 'Local storage management is not supported on DL servers')
else:
self.fail("Expected Exception")
def test_make_local_storage_no_model(self):
sht = self.build_gen8_bl_sht()
sht.pop('model', None)
try:
self.profile.make_local_storage_dict(
sht, 'RAID0', False, False, 2, 'Operating System')
except HPOneViewInvalidResource as hp_exception:
self.assertEqual(
hp_exception.args[0], 'Error, can not retrieve server model')
else:
self.fail("Expected Exception")
def test_make_boot_gen8_bl(self):
sht = self.build_gen8_bl_sht()
boot_order = ['CD', 'Floppy', 'USB', 'HardDisk', 'PXE']
boot, boot_mode = self.profile.make_boot_settings_dict(
servers, sht, False, boot_order, 'BIOS', 'Auto')
self.assertEqual(
{'manageBoot': True, 'order': ['CD', 'Floppy', 'USB', 'HardDisk', 'PXE']}, boot)
self.assertIsNone(boot_mode)
def test_make_boot_gen8_bl_disable_boot(self):
sht = self.build_gen8_bl_sht()
boot_order = []
try:
self.profile.make_boot_settings_dict(
servers, sht, True, boot_order, 'BIOS', 'Auto')
except HPOneViewInvalidResource as hp_exception:
self.assertEqual(
hp_exception.msg, 'Error: bootMode cannot be disabled on BL servers')
else:
self.fail("Expected Exception")
def test_make_boot_gen9_bl(self):
sht = self.build_gen9_bl_sht()
boot_order = ['CD', 'USB', 'HardDisk', 'PXE']
boot, boot_mode = self.profile.make_boot_settings_dict(
servers, sht, False, boot_order, 'UEFI', 'Auto')
self.assertEqual(
{'order': ['CD', 'USB', 'HardDisk', 'PXE'], 'manageBoot': True}, boot)
self.assertEqual(
{'manageMode': True, 'mode': 'UEFI', 'pxeBootPolicy': 'Auto'}, boot_mode)
def test_make_boot_gen9_bl_missing_order_options(self):
sht = self.build_gen9_bl_sht()
boot_order = ['CD', 'USB', 'HardDisk']
try:
self.profile.make_boot_settings_dict(
servers, sht, False, boot_order, 'UEFI', 'Auto')
except HPOneViewInvalidResource as hp_exception:
self.assertEqual(hp_exception.args[0], 'Error: All supported boot options are required. The supported '
'options are: CD; USB; HardDisk; PXE')
else:
self.fail("Expected Exception")
def test_make_boot_gen9_bl_mismatch_order_options(self):
sht = self.build_gen9_bl_sht()
boot_order = ['CD', 'USB', 'HardDisk', 'Floppy']
try:
self.profile.make_boot_settings_dict(
servers, sht, False, boot_order, 'UEFI', 'Auto')
except HPOneViewInvalidResource as hp_exception:
self.assertEqual(hp_exception.args[0], 'Error: "Floppy" are not supported boot options for this server '
'hardware type. The supported options are: CD; USB; HardDisk; PXE')
else:
self.fail("Expected Exception")
@mock.patch(mock_builtin('open'))
def test_make_bios(self, mock_open):
filename = 'bios_list'
mock_file = mock.Mock()
mock_file.read.return_value = self.build_bios_list()
mock_open.return_value = mock_file
bios = self.profile.make_bios_dict(filename)
self.assertIsNotNone(bios)
self.assertEqual(
{'manageBios': True, 'overriddenSettings': [{'value': '2', 'id': '134'}]}, bios)
@mock.patch(mock_builtin('open'))
def test_make_bios_with_defaukt_options(self, mock_open):
filename = 'bios_list'
mock_file = mock.Mock()
mock_file.read.return_value = self.build_bios_list_without_options()
mock_open.return_value = mock_file
bios = self.profile.make_bios_dict(filename)
self.assertIsNotNone(bios)
self.assertEqual(
{'manageBios': True, 'overriddenSettings': [{'id': '134'}]}, bios)
@mock.patch(mock_builtin('open'))
def test_make_bios_invalid_json(self, mock_open):
filename = 'bios_list'
mock_file = mock.Mock()
mock_file.read.return_value = 'adfadsf'
mock_open.return_value = mock_file
try:
self.profile.make_bios_dict(filename)
except ValueError as value_error:
self.assertEqual(value_error.args[0], "Error: Cannot parse BIOS JSON file. JSON must be well-formed.")
else:
self.fail("Expected Exception")
def test_add_new_connection(self):
sp = self.build_server_profile_without_conns()
profile.add_connection(sp,
id=3,
port_id=None,
name="New Connection",
function_type='Ethernet',
requested_mbps=2500,
network_uri='/rest/ethernet-networks/1f2bf8e2-3e1a-42a8-9aff-64b04314bf3c',
boot={
"priority": "NotBootable"
})
self.assertEqual(sp, self.build_server_profile_with_added_conn())
def test_add_connection_with_same_name(self):
sp = self.build_server_profile_with_added_conn()
self.assertRaises(HPOneViewException, profile.add_connection, sp,
id=3,
port_id=None,
name="New Connection",
function_type='Ethernet',
requested_mbps=2500,
network_uri='/rest/ethernet-networks/1f2bf8e2-3e1a-42a8-9aff-64b04314bf3c',
boot={
"priority": "NotBootable"
})
def test_add_connection_with_same_id(self):
sp = self.build_server_profile_with_added_conn()
profile.add_connection(sp,
id=3,
port_id=None,
name="Network A",
function_type='Ethernet',
requested_mbps=2500,
network_uri='/rest/ethernet-networks/1f2bf8e2-3e1a-42a8-9aff-64b04314bf3c',
boot={
"priority": "NotBootable"
})
sp_expected = self.build_server_profile_with_added_conn()
sp_expected['connections'][0]['name'] = 'Network A'
self.assertEqual(sp, sp_expected)
def test_remove_existent_connection(self):
sp = self.build_server_profile_with_added_conn()
profile.remove_connection(sp,
connection_name="New Connection")
self.assertEqual(sp, self.build_server_profile_without_conns())
def test_remove_nonexistent_connection(self):
sp = self.build_server_profile_with_added_conn()
profile.remove_connection(sp,
connection_name="New Connection NO")
self.assertEqual(sp, self.build_server_profile_with_added_conn())
# helper functions
def build_dl_sht(self):
return {
'type': 'server-hardware-type-4',
'category': 'server-hardware-types',
'name': 'DL360p Gen8 1',
'description': None,
'uri': '/rest/server-hardware-types/F8DDCB66-2EA3-4A29-BA8A-337DD121B',
'model': 'ProLiant DL360p Gen8',
'formFactor': '1U',
'biosSettings': [],
'storageCapabilities': {
'raidLevels': ['RAID0', 'RAID1', 'RAID1ADM', 'RAID10', 'RAID5', 'RAID6'],
'controllerModes': ['RAID'],
'driveTechnologies': ['SasHdd', 'SataHdd', 'SasSsd', 'SataSsd'],
'maximumDrives': 10
},
'pxeBootPolicies': ['IPv4'],
'bootModes': ['BIOS'],
'adapters': [],
'bootCapabilities': ['CD', 'Floppy', 'USB', 'HardDisk', 'PXE'],
'capabilities': ['ManageBIOS', 'ManageLocalStorage', 'ManageBootOrder', 'FirmwareUpdate']
}
def build_gen8_bl_sht(self):
return {
'type': 'server-hardware-type-4',
'category': 'server-hardware-types',
'name': 'BL460c Gen8 1',
'description': None,
'uri': '/rest/server-hardware-types/E322DD37-2ED3-4FFE-8C20-2F0D3BA559',
'model': 'ProLiant BL460c Gen8',
'formFactor': 'HalfHeight',
'biosSettings': [],
'storageCapabilities': {
'raidLevels': ['RAID0', 'RAID1'],
'controllerModes': ['RAID'],
'driveTechnologies': ['SasHdd', 'SataHdd', 'SasSsd', 'SataSsd'],
'maximumDrives': 2
},
'pxeBootPolicies': ['IPv4'],
'bootModes': ['BIOS'],
'adapters': [],
'bootCapabilities': ['CD', 'Floppy', 'USB', 'HardDisk', 'FibreChannelHba', 'PXE'],
'capabilities': ['ManageBIOS', 'VirtualUUID', 'ManageLocalStorage', 'VirtualWWN', 'ManageBootOrder',
'VCConnections', 'VirtualMAC', 'FirmwareUpdate']
}
def build_gen9_bl_sht(self):
return {
'type': 'server-hardware-type-4',
'category': 'server-hardware-types',
'name': 'BL460c Gen9 1',
'description': None,
'uri': '/rest/server-hardware-types/0D2A55D6-F261-445A-BB24-9508E257',
'model': 'ProLiant BL460c Gen9',
'formFactor': 'HalfHeight',
'biosSettings': [],
'storageCapabilities': {
'raidLevels': ['RAID0', 'RAID1'],
'controllerModes': ['RAID', 'HBA'],
'driveTechnologies': ['SasHdd', 'SataHdd', 'SasSsd', 'SataSsd'],
'maximumDrives': 2
},
'pxeBootPolicies': ['Auto', 'IPv6ThenIPv4', 'IPv4', 'IPv4ThenIPv6', 'IPv6'],
'bootModes': ['UEFIOptimized', 'BIOS', 'UEFI'],
'adapters': [],
'bootCapabilities': ['CD', 'USB', 'HardDisk', 'FibreChannelHba', 'PXE'],
'capabilities': ['ManageBIOS', 'VirtualUUID', 'ManageLocalStorage', 'VirtualWWN', 'ManageBootOrder',
'VCConnections', 'VirtualMAC', 'FirmwareUpdate']
}
def build_get_spp_response(self):
return {
'type': 'firmware-baselines',
'bundleType': 'SPP',
'resourceId': 'SPP2016020_2015_1204_63',
'uuid': 'SPP2016020_2015_1204_63',
'xmlKeyName': 'bp002524',
'isoFileName': 'SPP2016020_2015_1204_63.iso',
'baselineShortName': 'SPP 2016.02.0',
'bundleSize': 5821517824,
'version': '2016.02.0',
'releaseDate': '2015-12-04T11:24:27.773Z',
'supportedOSList': ['Microsoft Windows Server 2008 R2'],
'supportedLanguages': 'English (US), Japanese, Chinese (Simplified)',
'fwComponents': [],
'swPackagesFullPath': '/mnt/fwbundles/SPP2016020_2015_1204_63/hp/swpackages/',
'state': 'Created',
'lastTaskUri': '',
'hpsumVersion': '750_b42',
'description': 'The Service Pack for ProLiant (SPP) is a comprehensive systems software and firmware update'
'solution, which is delivered as a single ISO image.',
'name': 'Service Pack for ProLiant',
'status': 'OK',
'category': 'firmware-drivers',
'uri': '/rest/firmware-drivers/SPP2016020_2015_1204_63'
}
def build_bios_list(self):
return json.dumps([{
'id': '134',
'help': 'Controls the Virtual Install Disk. The Virtual\nInstall Disk may contain drivers specific to this'
'server\nthat an OS may use during installation.',
'name': 'Virtual Install Disk',
'options': [
{
'id': '2',
'name': 'Disabled'
}
]
}])
def build_bios_list_without_options(self):
return json.dumps([{
'id': '134',
'help': 'Controls the Virtual Install Disk.',
'name': 'Virtual Install Disk'
}])
def build_server_profile_without_conns(self):
server_profile = {
'name': 'server profile name',
'connections': []
}
return server_profile
def build_server_profile_with_added_conn(self):
server_profile = {
'name': 'server profile name',
'connections': [{'boot': {'priority': 'NotBootable'},
'functionType': 'Ethernet',
'id': 3,
'name': 'New Connection',
'networkUri': '/rest/ethernet-networks/1f2bf8e2-3e1a-42a8-9aff-64b04314bf3c',
'portId': None,
'requestedMbps': 2500,
'mac': None,
'requestedVFs': 'Auto',
'wwnn': None,
'wwpn': None}]}
return server_profile
class OneViewClientTest(unittest.TestCase):
def __mock_file_open(self, json_config_content):
# Simulates a TextIOWrapper (file output)
return io.StringIO(json_config_content)
@mock.patch.object(connection, 'login')
def setUp(self, mock_login):
super(OneViewClientTest, self).setUp()
config = {
"ip": "172.16.102.59",
"proxy": "127.0.0.1:3128",
"credentials": {
"authLoginDomain": "",
"userName": "******",
"password": ""
}
}
self._oneview = OneViewClient(config)
def test_raise_error_invalid_proxy(self):
config = {
"ip": "172.16.102.59",
"proxy": "3128",
"credentials": {
"authLoginDomain": "",
"userName": "******",
"password": ""
}
}
try:
OneViewClient(config)
except ValueError as e:
self.assertTrue("Proxy" in e.args[0])
else:
self.fail()
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_from_json_file(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": ""
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertIsInstance(oneview_client, OneViewClient)
self.assertEqual("172.16.102.59", oneview_client.connection.get_host())
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_from_json_file_with_sessionID(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": "",
"sessionID": "123"
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertIsInstance(oneview_client, OneViewClient)
self.assertEqual("172.16.102.59", oneview_client.connection.get_host())
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_from_json_file_with_only_sessionID(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"credentials": {
"sessionID": "123"
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertIsInstance(oneview_client, OneViewClient)
self.assertEqual("172.16.102.59", oneview_client.connection.get_host())
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_default_api_version(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": ""
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertEqual(300, oneview_client.connection._apiVersion)
self.assertEqual(300, oneview_client.api_version)
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_configured_api_version(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"api_version": 200,
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": ""
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertEqual(200, oneview_client.connection._apiVersion)
self.assertEqual(200, oneview_client.api_version)
@mock.patch.object(connection, 'login')
@mock.patch.object(connection, 'set_proxy')
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_MINIMAL)
def test_from_minimal_environment_variables(self, mock_set_proxy,
mock_login):
oneview_client = OneViewClient.from_environment_variables()
mock_login.assert_called_once_with(
dict(userName='******',
password='******',
authLoginDomain='',
sessionID=''))
mock_set_proxy.assert_not_called()
self.assertEqual(300, oneview_client.connection._apiVersion)
@mock.patch.object(connection, 'login')
@mock.patch.object(connection, 'set_proxy')
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_MINIMAL_WITH_SESSIONID)
def test_from_minimal_environment_variables_with_sessionID(
self, mock_set_proxy, mock_login):
oneview_client = OneViewClient.from_environment_variables()
mock_login.assert_called_once_with(
dict(userName='', password='', authLoginDomain='',
sessionID='123'))
mock_set_proxy.assert_not_called()
self.assertEqual(300, oneview_client.connection._apiVersion)
@mock.patch.object(connection, 'login')
@mock.patch.object(connection, 'set_proxy')
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_FULL)
def test_from_full_environment_variables(self, mock_set_proxy, mock_login):
oneview_client = OneViewClient.from_environment_variables()
mock_login.assert_called_once_with(
dict(userName='******',
password='******',
authLoginDomain='authdomain',
sessionID=''))
mock_set_proxy.assert_called_once_with('172.16.100.195', 9999)
self.assertEqual(201, oneview_client.connection._apiVersion)
self.assertEqual(
oneview_client.create_image_streamer_client().connection.get_host(
), OS_ENVIRON_CONFIG_FULL['ONEVIEWSDK_IMAGE_STREAMER_IP'])
@mock.patch.object(connection, 'login')
@mock.patch.object(connection, 'set_proxy')
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_FULL_WITH_SESSIONID)
def test_from_full_environment_variables_with_sessionID(
self, mock_set_proxy, mock_login):
oneview_client = OneViewClient.from_environment_variables()
mock_login.assert_called_once_with(
dict(userName='******',
password='******',
authLoginDomain='',
sessionID='123'))
mock_set_proxy.assert_called_once_with('172.16.100.195', 9999)
self.assertEqual(201, oneview_client.connection._apiVersion)
self.assertEqual(
oneview_client.create_image_streamer_client().connection.get_host(
), OS_ENVIRON_CONFIG_FULL_WITH_SESSIONID[
'ONEVIEWSDK_IMAGE_STREAMER_IP'])
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_FULL)
@mock.patch.object(OneViewClient, '__init__')
def test_from_environment_variables_is_passing_right_arguments_to_the_constructor(
self, mock_cls):
mock_cls.return_value = None
OneViewClient.from_environment_variables()
mock_cls.assert_called_once_with({
'api_version': 201,
'proxy': '172.16.100.195:9999',
'timeout': '20',
'ip': '172.16.100.199',
'ssl_certificate': '',
'image_streamer_ip': '172.172.172.172',
'credentials': {
'userName': '******',
'password': '******',
'authLoginDomain': 'authdomain',
'sessionID': ''
}
})
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_FULL_WITH_SESSIONID)
@mock.patch.object(OneViewClient, '__init__')
def test_from_environment_variables_is_passing_right_arguments_to_the_constructor_with_sessionID(
self, mock_cls):
mock_cls.return_value = None
OneViewClient.from_environment_variables()
mock_cls.assert_called_once_with({
'api_version': 201,
'proxy': '172.16.100.195:9999',
'timeout': '20',
'ip': '172.16.100.199',
'image_streamer_ip': '172.172.172.172',
'ssl_certificate': '',
'credentials': {
'userName': '******',
'password': '******',
'authLoginDomain': '',
'sessionID': '123'
}
})
@mock.patch.dict('os.environ', OS_ENVIRON_CONFIG_MINIMAL_WITH_SESSIONID)
@mock.patch.object(OneViewClient, '__init__')
def test_from_environment_variables_is_passing_right_arguments_to_the_constructor_with_only_sessionID(
self, mock_cls):
mock_cls.return_value = None
OneViewClient.from_environment_variables()
mock_cls.assert_called_once_with({
'api_version': 300,
'proxy': '',
'timeout': None,
'ip': '172.16.100.199',
'image_streamer_ip': '',
'ssl_certificate': '',
'credentials': {
'userName': '',
'password': '',
'authLoginDomain': '',
'sessionID': '123'
}
})
@mock.patch.object(connection, 'login')
def test_create_image_streamer_client_without_image_streamer_ip(
self, mock_login):
config = {
"ip": "172.16.102.59",
"credentials": {
"userName": "******",
"password": "******"
}
}
client = OneViewClient(config)
client.connection.set_session_id('123')
i3s = client.create_image_streamer_client()
self.assertEqual(i3s.connection.get_session_id(),
client.connection.get_session_id())
self.assertEqual(i3s.connection._apiVersion, client.api_version)
self.assertEqual(i3s.connection.get_host(), None)
self.assertEqual(client.connection.get_host(), "172.16.102.59")
@mock.patch.object(connection, 'login')
def test_create_image_streamer_client_with_image_streamer_ip(
self, mock_login):
config = {
"ip": "172.16.102.59",
"image_streamer_ip": "172.16.102.50",
"credentials": {
"userName": "******",
"password": "******"
}
}
client = OneViewClient(config)
client.connection.set_session_id('124')
i3s = client.create_image_streamer_client()
self.assertEqual(i3s.connection.get_session_id(),
client.connection.get_session_id())
self.assertEqual(i3s.connection._apiVersion, client.api_version)
self.assertEqual(i3s.connection.get_host(), "172.16.102.50")
self.assertEqual(client.connection.get_host(), "172.16.102.59")
def test_fc_networks_has_right_type(self):
self.assertIsInstance(self._oneview.fc_networks, FcNetworks)
def test_fc_networks_has_value(self):
self.assertIsNotNone(self._oneview.fc_networks)
def test_lazy_loading_fc_networks(self):
fcn = self._oneview.fc_networks
self.assertEqual(fcn, self._oneview.fc_networks)
def test_connection_type(self):
self.assertIsInstance(self._oneview.connection, connection)
def test_fcoe_networks_has_right_type(self):
self.assertIsInstance(self._oneview.fcoe_networks, FcoeNetworks)
def test_fcoe_networks_has_value(self):
self.assertIsNotNone(self._oneview.fcoe_networks)
def test_lazy_loading_fcoe_networks(self):
fcn = self._oneview.fcoe_networks
self.assertEqual(fcn, self._oneview.fcoe_networks)
def test_metric_streaming_has_right_type(self):
self.assertIsInstance(self._oneview.metric_streaming, MetricStreaming)
def test_metric_streaming_has_value(self):
self.assertIsNotNone(self._oneview.metric_streaming)
def test_lazy_loading_enclosure_groups(self):
enclosure_groups = self._oneview.enclosure_groups
self.assertEqual(enclosure_groups, self._oneview.enclosure_groups)
def test_lazy_loading_tasks(self):
tasks = self._oneview.tasks
self.assertEqual(tasks, self._oneview.tasks)
def test_lazy_loading_connection_templates(self):
connection_templates = self._oneview.connection_templates
self.assertEqual(connection_templates,
self._oneview.connection_templates)
def test_lazy_loading_switch_types(self):
switch_types = self._oneview.switch_types
self.assertEqual(switch_types, self._oneview.switch_types)
def test_lazy_loading_network_sets(self):
network_sets = self._oneview.network_sets
self.assertEqual(network_sets, self._oneview.network_sets)
def test_lazy_loading_fabrics(self):
fabrics = self._oneview.fabrics
self.assertEqual(fabrics, self._oneview.fabrics)
def test_lazy_loading_metric_streaming(self):
metric = self._oneview.metric_streaming
self.assertEqual(metric, self._oneview.metric_streaming)
def test_lazy_loading_enclosures(self):
enclosures = self._oneview.enclosures
self.assertEqual(enclosures, self._oneview.enclosures)
def test_lazy_loading_switches(self):
switches = self._oneview.switches
self.assertEqual(switches, self._oneview.switches)
def test_lazy_loading_ethernet_networks(self):
ethernet_networks = self._oneview.ethernet_networks
self.assertEqual(ethernet_networks, self._oneview.ethernet_networks)
def test_lazy_loading_server_hardware(self):
server_hardware = self._oneview.server_hardware
self.assertEqual(server_hardware, self._oneview.server_hardware)
def test_interconnect_link_topologies_has_right_type(self):
self.assertIsInstance(self._oneview.interconnect_link_topologies,
InterconnectLinkTopologies)
def test_interconnect_link_topologies_has_value(self):
self.assertIsNotNone(self._oneview.interconnect_link_topologies)
def test_lazy_loading_interconnect_link_topologies(self):
interconnect_link_topologies = self._oneview.interconnect_link_topologies
self.assertEqual(interconnect_link_topologies,
self._oneview.interconnect_link_topologies)
def test_sas_interconnect_types_has_right_type(self):
self.assertIsInstance(self._oneview.sas_interconnect_types,
SasInterconnectTypes)
def test_lazy_loading_sas_interconnect_types(self):
sas_interconnect_types = self._oneview.sas_interconnect_types
self.assertEqual(sas_interconnect_types,
self._oneview.sas_interconnect_types)
def test_interconnects_has_right_type(self):
self.assertIsInstance(self._oneview.interconnects, Interconnects)
def test_interconnects_has_value(self):
self.assertIsNotNone(self._oneview.interconnects)
def test_lazy_loading_interconnects(self):
interconnects = self._oneview.interconnects
self.assertEqual(interconnects, self._oneview.interconnects)
def test_certificate_authority_has_right_type(self):
self.assertIsInstance(self._oneview.certificate_authority,
CertificateAuthority)
def test_certificate_authority_has_value(self):
self.assertIsNotNone(self._oneview.certificate_authority)
def test_lazy_loading_certificate_authority(self):
certificates = self._oneview.certificate_authority
self.assertEqual(certificates, self._oneview.certificate_authority)
def test_lazy_loading_connections(self):
connections = self._oneview.connections
self.assertEqual(connections, self._oneview.connections)
def test_lazy_loading_server_hardware_types(self):
server_hardware_types = self._oneview.server_hardware_types
self.assertEqual(server_hardware_types,
self._oneview.server_hardware_types)
def test_lazy_loading_id_pools_vsn_ranges(self):
id_pools_vsn_ranges = self._oneview.id_pools_vsn_ranges
self.assertEqual(id_pools_vsn_ranges,
self._oneview.id_pools_vsn_ranges)
def test_id_pools_vsn_ranges_has_right_type(self):
self.assertIsInstance(self._oneview.id_pools_vsn_ranges, IdPoolsRanges)
def test_id_pools_vsn_ranges_has_right_value(self):
self.assertEqual('/rest/id-pools/vsn/ranges',
self._oneview.id_pools_vsn_ranges._client._uri)
def test_lazy_loading_id_pools_vmac_ranges(self):
id_pools_vmac_ranges = self._oneview.id_pools_vmac_ranges
self.assertEqual(id_pools_vmac_ranges,
self._oneview.id_pools_vmac_ranges)
def test_id_pools_vmac_ranges_has_right_type(self):
self.assertIsInstance(self._oneview.id_pools_vmac_ranges,
IdPoolsRanges)
def test_id_pools_vmac_ranges_has_right_value(self):
self.assertEqual('/rest/id-pools/vmac/ranges',
self._oneview.id_pools_vmac_ranges._client._uri)
def test_lazy_loading_id_pools_vwwn_ranges(self):
id_pools_vwwn_ranges = self._oneview.id_pools_vwwn_ranges
self.assertEqual(id_pools_vwwn_ranges,
self._oneview.id_pools_vwwn_ranges)
def test_id_pools_vwwn_ranges_has_right_type(self):
self.assertIsInstance(self._oneview.id_pools_vwwn_ranges,
IdPoolsRanges)
def test_id_pools_vwwn_ranges_has_right_value(self):
self.assertEqual('/rest/id-pools/vwwn/ranges',
self._oneview.id_pools_vwwn_ranges._client._uri)
def test_id_pools_ipv4_ranges_has_right_type(self):
self.assertIsInstance(self._oneview.id_pools_ipv4_ranges,
IdPoolsIpv4Ranges)
def test_id_pools_ipv4_ranges_lazy_loading(self):
id_pools_ipv4_ranges = self._oneview.id_pools_ipv4_ranges
self.assertEqual(id_pools_ipv4_ranges,
self._oneview.id_pools_ipv4_ranges)
def test_id_pools_ipv4_subnets_has_right_type(self):
self.assertIsInstance(self._oneview.id_pools_ipv4_subnets,
IdPoolsIpv4Subnets)
def test_id_pools_ipv4_subnets_lazy_loading(self):
id_pools_ipv4_subnets = self._oneview.id_pools_ipv4_subnets
self.assertEqual(id_pools_ipv4_subnets,
self._oneview.id_pools_ipv4_subnets)
def test_id_pools_has_right_type(self):
self.assertIsInstance(self._oneview.id_pools, IdPools)
def test_id_pools_lazy_loading(self):
id_pools = self._oneview.id_pools
self.assertEqual(id_pools, self._oneview.id_pools)
def test_lazy_loading_logical_enclosures(self):
logical_enclosures = self._oneview.logical_enclosures
self.assertEqual(logical_enclosures, self._oneview.logical_enclosures)
def test_lazy_loading_interconnect_types(self):
interconnect_types = self._oneview.interconnect_types
self.assertEqual(interconnect_types, self._oneview.interconnect_types)
def test_lazy_loading_logical_downlinks(self):
logical_downlinks = self._oneview.logical_downlinks
self.assertEqual(logical_downlinks, self._oneview.logical_downlinks)
def test_lazy_loading_storage_systems(self):
storage_systems = self._oneview.storage_systems
self.assertEqual(storage_systems, self._oneview.storage_systems)
def test_lazy_loading_storage_pools(self):
storage_pools = self._oneview.storage_pools
self.assertEqual(storage_pools, self._oneview.storage_pools)
def test_lazy_loading_firmware_drivers(self):
firmware_drivers = self._oneview.firmware_drivers
self.assertEqual(firmware_drivers, self._oneview.firmware_drivers)
def test_lazy_loading_firmware_bundles(self):
firmware_bundles = self._oneview.firmware_bundles
self.assertEqual(firmware_bundles, self._oneview.firmware_bundles)
def test_migratable_vc_domains_has_right_type(self):
self.assertIsInstance(self._oneview.migratable_vc_domains,
MigratableVcDomains)
def test_migratable_vc_domains_lazy_loading(self):
migratable_vc_domains = self._oneview.migratable_vc_domains
self.assertEqual(migratable_vc_domains,
self._oneview.migratable_vc_domains)
def test_power_devices_has_right_type(self):
self.assertIsInstance(self._oneview.power_devices, PowerDevices)
def test_power_devices_has_value(self):
self.assertIsNotNone(self._oneview.power_devices)
def test_lazy_loading_power_devices(self):
power_devices = self._oneview.power_devices
self.assertEqual(power_devices, self._oneview.power_devices)
def test_racks_has_right_type(self):
self.assertIsInstance(self._oneview.racks, Racks)
def test_racks_has_value(self):
self.assertIsNotNone(self._oneview.racks)
def test_lazy_loading_racks(self):
racks = self._oneview.racks
self.assertEqual(racks, self._oneview.racks)
def test_roles_has_right_type(self):
self.assertIsInstance(self._oneview.roles, Roles)
def test_roles_lazy_loading(self):
roles = self._oneview.roles
self.assertEqual(roles, self._oneview.roles)
def test_san_managers_has_right_type(self):
self.assertIsInstance(self._oneview.san_managers, SanManagers)
def test_san_managers_has_value(self):
self.assertIsNotNone(self._oneview.san_managers)
def test_lazy_loading_san_managers(self):
san_managers = self._oneview.san_managers
self.assertEqual(san_managers, self._oneview.san_managers)
def test_endpoints_has_right_type(self):
self.assertIsInstance(self._oneview.endpoints, Endpoints)
def test_endpoints_has_value(self):
self.assertIsNotNone(self._oneview.endpoints)
def test_lazy_loading_endpoints(self):
endpoints = self._oneview.endpoints
self.assertEqual(endpoints, self._oneview.endpoints)
def test_logical_interconnect_groups_has_right_type(self):
self.assertIsInstance(self._oneview.logical_interconnect_groups,
LogicalInterconnectGroups)
def test_logical_interconnect_groups_has_value(self):
self.assertIsNotNone(self._oneview.logical_interconnect_groups)
def test_lazy_loading_logical_interconnect_groups(self):
logical_interconnect_groups = self._oneview.logical_interconnect_groups
self.assertEqual(logical_interconnect_groups,
self._oneview.logical_interconnect_groups)
def test_logical_switch_groups_has_right_type(self):
self.assertIsInstance(self._oneview.logical_switch_groups,
LogicalSwitchGroups)
def test_logical_switch_groups_has_value(self):
self.assertIsNotNone(self._oneview.logical_switch_groups)
def test_lazy_loading_logical_switch_groups(self):
logical_switch_groups = self._oneview.logical_switch_groups
self.assertEqual(logical_switch_groups,
self._oneview.logical_switch_groups)
def test_logical_switches_has_right_type(self):
self.assertIsInstance(self._oneview.logical_switches, LogicalSwitches)
def test_lazy_loading_logical_switches(self):
logical_switches = self._oneview.logical_switches
self.assertEqual(logical_switches, self._oneview.logical_switches)
def test_logical_interconnects_has_right_type(self):
self.assertIsInstance(self._oneview.logical_interconnects,
LogicalInterconnects)
def test_logical_interconnects_has_value(self):
self.assertIsNotNone(self._oneview.logical_interconnects)
def test_lazy_loading_logical_interconnects(self):
logical_interconnects = self._oneview.logical_interconnects
self.assertEqual(logical_interconnects,
self._oneview.logical_interconnects)
def test_sas_logical_interconnects_has_right_type(self):
self.assertIsInstance(self._oneview.sas_logical_interconnects,
SasLogicalInterconnects)
def test_lazy_loading_sas_logical_interconnects(self):
sas_logical_interconnects = self._oneview.sas_logical_interconnects
self.assertEqual(sas_logical_interconnects,
self._oneview.sas_logical_interconnects)
def test_storage_volume_templates_has_right_type(self):
self.assertIsInstance(self._oneview.storage_volume_templates,
StorageVolumeTemplates)
def test_storage_volume_templates_has_value(self):
self.assertIsNotNone(self._oneview.storage_volume_templates)
def test_lazy_loading_storage_volume_templates(self):
storage_volume_templates = self._oneview.storage_volume_templates
self.assertEqual(storage_volume_templates,
self._oneview.storage_volume_templates)
def test_storage_volume_attachments_has_right_type(self):
self.assertIsInstance(self._oneview.storage_volume_attachments,
StorageVolumeAttachments)
def test_storage_volume_attachments_has_value(self):
self.assertIsNotNone(self._oneview.storage_volume_attachments)
def test_lazy_loading_storage_volume_attachments(self):
storage_volume_attachments = self._oneview.storage_volume_attachments
self.assertEqual(storage_volume_attachments,
self._oneview.storage_volume_attachments)
def test_uplink_sets_has_right_type(self):
self.assertIsInstance(self._oneview.uplink_sets, UplinkSets)
def test_uplink_sets_has_value(self):
self.assertIsNotNone(self._oneview.uplink_sets)
def test_lazy_loading_uplink_sets(self):
copy_uplink_sets = self._oneview.uplink_sets
self.assertEqual(copy_uplink_sets, self._oneview.uplink_sets)
def test_backups_has_right_type(self):
self.assertIsInstance(self._oneview.backups, Backups)
def test_lazy_loading_backups(self):
copy_backups = self._oneview.backups
self.assertEqual(copy_backups, self._oneview.backups)
def test_restores_has_right_type(self):
self.assertIsInstance(self._oneview.restores, Restores)
def test_lazy_loading_restores(self):
copy_restores = self._oneview.restores
self.assertEqual(copy_restores, self._oneview.restores)
def test_scopes_has_right_type(self):
self.assertIsInstance(self._oneview.scopes, Scopes)
def test_lazy_loading_scopes(self):
copy_scopes = self._oneview.scopes
self.assertEqual(copy_scopes, self._oneview.scopes)
def test_sas_logical_interconnect_groups_has_right_type(self):
self.assertIsInstance(self._oneview.sas_logical_interconnect_groups,
SasLogicalInterconnectGroups)
def test_lazy_loading_sas_logical_interconnect_groups(self):
sas_logical_interconnect_groups = self._oneview.sas_logical_interconnect_groups
self.assertEqual(sas_logical_interconnect_groups,
self._oneview.sas_logical_interconnect_groups)
def test_login_details_has_right_type(self):
self.assertIsInstance(self._oneview.login_details, LoginDetails)
def test_lazy_loading_login_details(self):
login_details = self._oneview.login_details
self.assertEqual(login_details, self._oneview.login_details)
def test_unmanaged_devices_has_right_type(self):
self.assertIsInstance(self._oneview.unmanaged_devices,
UnmanagedDevices)
def test_volumes_has_right_type(self):
self.assertIsInstance(self._oneview.volumes, Volumes)
def test_volumes_has_value(self):
self.assertIsNotNone(self._oneview.volumes)
def test_lazy_loading_volumes(self):
copy_volumes = self._oneview.volumes
self.assertEqual(copy_volumes, self._oneview.volumes)
def test_sas_logical_jbod_attachments_right_type(self):
self.assertIsInstance(self._oneview.sas_logical_jbod_attachments,
SasLogicalJbodAttachments)
def test_lazy_loading_sas_logical_jbod_attachments(self):
sas_logical_jbod_attachments = self._oneview.sas_logical_jbod_attachments
self.assertEqual(sas_logical_jbod_attachments,
self._oneview.sas_logical_jbod_attachments)
def test_server_profile_templates_has_right_type(self):
self.assertIsInstance(self._oneview.server_profile_templates,
ServerProfileTemplate)
def test_server_profile_templates_has_value(self):
self.assertIsNotNone(self._oneview.server_profile_templates)
def test_lazy_loading_server_profile_templates(self):
server_profile_templates = self._oneview.server_profile_templates
self.assertEqual(server_profile_templates,
self._oneview.server_profile_templates)
def test_server_profiles_has_right_type(self):
self.assertIsInstance(self._oneview.server_profiles, ServerProfiles)
def test_server_profiles_has_value(self):
self.assertIsNotNone(self._oneview.server_profiles)
def test_lazy_loading_server_profiles(self):
server_profiles = self._oneview.server_profiles
self.assertEqual(server_profiles, self._oneview.server_profiles)
def test_datacenters_has_right_type(self):
self.assertIsInstance(self._oneview.datacenters, Datacenters)
def test_lazy_loading_datacenters(self):
datacenters = self._oneview.datacenters
self.assertEqual(datacenters, self._oneview.datacenters)
def test_managed_sans_has_right_type(self):
self.assertIsInstance(self._oneview.managed_sans, ManagedSANs)
def test_lazy_loading_managed_sans(self):
managed_sans = self._oneview.managed_sans
self.assertEqual(managed_sans, self._oneview.managed_sans)
def test_sas_interconnects_has_right_type(self):
self.assertIsInstance(self._oneview.sas_interconnects,
SasInterconnects)
def test_lazy_loading_sas_interconnects(self):
sas_interconnects = self._oneview.sas_interconnects
self.assertEqual(sas_interconnects, self._oneview.sas_interconnects)
def test_drive_enclosure_has_right_type(self):
self.assertIsInstance(self._oneview.drive_enclosures, DriveEnclosures)
def test_lazy_loading_drive_enclosure(self):
drive_enclosures = self._oneview.drive_enclosures
self.assertEqual(drive_enclosures, self._oneview.drive_enclosures)
def test_sas_logical_jbods_has_right_type(self):
self.assertIsInstance(self._oneview.sas_logical_jbods, SasLogicalJbods)
def test_lazy_loading_sas_logical_jbods(self):
sas_logical_jbods = self._oneview.sas_logical_jbods
self.assertEqual(sas_logical_jbods, self._oneview.sas_logical_jbods)
def test_internal_link_sets_has_right_type(self):
self.assertIsInstance(self._oneview.internal_link_sets,
InternalLinkSets)
def test_lazy_loading_internal_link_sets(self):
internal_links = self._oneview.internal_link_sets
self.assertEqual(internal_links, self._oneview.internal_link_sets)
def test_index_resources_has_right_type(self):
self.assertIsInstance(self._oneview.index_resources, IndexResources)
def test_lazy_loading_index_resources(self):
index_resources = self._oneview.index_resources
self.assertEqual(index_resources, self._oneview.index_resources)
def test_labels_has_right_type(self):
self.assertIsInstance(self._oneview.labels, Labels)
def test_lazy_loading_labels(self):
labels = self._oneview.labels
self.assertEqual(labels, self._oneview.labels)
def test_alerts_has_right_type(self):
self.assertIsInstance(self._oneview.alerts, Alerts)
def test_lazy_loading_alerts(self):
alerts = self._oneview.alerts
self.assertEqual(alerts, self._oneview.alerts)
def test_events_has_right_type(self):
self.assertIsInstance(self._oneview.events, Events)
def test_lazy_loading_events(self):
events = self._oneview.events
self.assertEqual(events, self._oneview.events)
def test_os_deployment_plans_has_right_type(self):
self.assertIsInstance(self._oneview.os_deployment_plans,
OsDeploymentPlans)
def test_lazy_loading_os_deployment_plans(self):
os_deployment_plans = self._oneview.os_deployment_plans
self.assertEqual(os_deployment_plans,
self._oneview.os_deployment_plans)
def test_os_deployment_servers_has_right_type(self):
self.assertIsInstance(self._oneview.os_deployment_servers,
OsDeploymentServers)
def test_lazy_loading_os_deployment_servers(self):
os_deployment_servers = self._oneview.os_deployment_servers
self.assertEqual(os_deployment_servers,
self._oneview.os_deployment_servers)
def test_certificate_rabbitmq_has_right_type(self):
self.assertIsInstance(self._oneview.certificate_rabbitmq,
CertificateRabbitMQ)
def test_lazy_loading_certificate_rabbitmq(self):
certificate_rabbitmq = self._oneview.certificate_rabbitmq
self.assertEqual(certificate_rabbitmq,
self._oneview.certificate_rabbitmq)
def test_users_has_right_type(self):
self.assertIsInstance(self._oneview.users, Users)
def test_lazy_loading_users(self):
user = self._oneview.users
self.assertEqual(user, self._oneview.users)
def test_appliance_node_information_has_right_type(self):
self.assertIsInstance(self._oneview.appliance_node_information,
ApplianceNodeInformation)
def test_lazy_loading_appliance_node_information(self):
appliance_node_information = self._oneview.appliance_node_information
self.assertEqual(appliance_node_information,
self._oneview.appliance_node_information)
def test_appliance_time_and_locale_configuration_has_right_type(self):
self.assertIsInstance(
self._oneview.appliance_time_and_locale_configuration,
ApplianceTimeAndLocaleConfiguration)
def test_lazy_loading_appliance_time_and_locale_configuration(self):
appliance_time_and_locale_configuration = self._oneview.appliance_time_and_locale_configuration
self.assertEqual(appliance_time_and_locale_configuration,
self._oneview.appliance_time_and_locale_configuration)
def test_should_get_appliance_current_version_and_minimum_version(self):
self.assertIsInstance(self._oneview.versions, Versions)
def test_lazy_loading_appliance_version_information(self):
versions = self._oneview.versions
self.assertEqual(versions, self._oneview.versions)
class OneViewClientTest(unittest.TestCase):
def __mock_file_open(self, json_config_content):
# Simulates a TextIOWrapper (file output)
return io.StringIO(json_config_content)
@mock.patch.object(connection, 'login')
def setUp(self, mock_login):
super(OneViewClientTest, self).setUp()
config = {
"ip": "172.16.102.59",
"proxy": "127.0.0.1:3128",
"credentials": {
"authLoginDomain": "",
"userName": "******",
"password": ""
}
}
self._oneview = OneViewClient(config)
def test_raise_error_invalid_proxy(self):
config = {
"ip": "172.16.102.59",
"proxy": "3128",
"credentials": {
"authLoginDomain": "",
"userName": "******",
"password": ""
}
}
try:
OneViewClient(config)
except ValueError as e:
self.assertTrue("Proxy" in e.args[0])
else:
self.fail()
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_from_json_file(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": ""
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertIsInstance(oneview_client, OneViewClient)
self.assertEqual("172.16.102.59", oneview_client.connection.get_host())
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_default_api_version(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": ""
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertEqual(200, oneview_client.connection._apiVersion)
@mock.patch.object(connection, 'login')
@mock.patch(mock_builtin('open'))
def test_configured_api_version(self, mock_open, mock_login):
json_config_content = u"""{
"ip": "172.16.102.59",
"api_version": 300,
"credentials": {
"userName": "******",
"authLoginDomain": "",
"password": ""
}
}"""
mock_open.return_value = self.__mock_file_open(json_config_content)
oneview_client = OneViewClient.from_json_file("config.json")
self.assertEqual(300, oneview_client.connection._apiVersion)
def test_fc_networks_has_right_type(self):
self.assertIsInstance(self._oneview.fc_networks, FcNetworks)
def test_fc_networks_has_value(self):
self.assertIsNotNone(self._oneview.fc_networks)
def test_lazy_loading_fc_networks(self):
fcn = self._oneview.fc_networks
self.assertEqual(fcn, self._oneview.fc_networks)
def test_connection_type(self):
self.assertIsInstance(self._oneview.connection, connection)
def test_fcoe_networks_has_right_type(self):
self.assertIsInstance(self._oneview.fcoe_networks, FcoeNetworks)
def test_fcoe_networks_has_value(self):
self.assertIsNotNone(self._oneview.fcoe_networks)
def test_lazy_loading_fcoe_networks(self):
fcn = self._oneview.fcoe_networks
self.assertEqual(fcn, self._oneview.fcoe_networks)
def test_metric_streaming_has_right_type(self):
self.assertIsInstance(self._oneview.metric_streaming, MetricStreaming)
def test_metric_streaming_has_value(self):
self.assertIsNotNone(self._oneview.metric_streaming)
def test_lazy_loading_enclosure_groups(self):
enclosure_groups = self._oneview.enclosure_groups
self.assertEqual(enclosure_groups, self._oneview.enclosure_groups)
def test_lazy_loading_tasks(self):
tasks = self._oneview.tasks
self.assertEqual(tasks, self._oneview.tasks)
def test_lazy_loading_connection_templates(self):
connection_templates = self._oneview.connection_templates
self.assertEqual(connection_templates,
self._oneview.connection_templates)
def test_lazy_loading_switch_types(self):
switch_types = self._oneview.switch_types
self.assertEqual(switch_types, self._oneview.switch_types)
def test_lazy_loading_network_sets(self):
network_sets = self._oneview.network_sets
self.assertEqual(network_sets, self._oneview.network_sets)
def test_lazy_loading_fabrics(self):
fabrics = self._oneview.fabrics
self.assertEqual(fabrics, self._oneview.fabrics)
def test_lazy_loading_metric_streaming(self):
metric = self._oneview.metric_streaming
self.assertEqual(metric, self._oneview.metric_streaming)
def test_lazy_loading_enclosures(self):
enclosures = self._oneview.enclosures
self.assertEqual(enclosures, self._oneview.enclosures)
def test_lazy_loading_switches(self):
switches = self._oneview.switches
self.assertEqual(switches, self._oneview.switches)
def test_lazy_loading_ethernet_networks(self):
ethernet_networks = self._oneview.ethernet_networks
self.assertEqual(ethernet_networks, self._oneview.ethernet_networks)
def test_lazy_loading_server_hardware(self):
server_hardware = self._oneview.server_hardware
self.assertEqual(server_hardware, self._oneview.server_hardware)
def test_interconnects_has_right_type(self):
self.assertIsInstance(self._oneview.interconnects, Interconnects)
def test_interconnects_has_value(self):
self.assertIsNotNone(self._oneview.interconnects)
def test_lazy_loading_interconnects(self):
interconnects = self._oneview.interconnects
self.assertEqual(interconnects, self._oneview.interconnects)
def test_lazy_loading_connections(self):
connections = self._oneview.connections
self.assertEqual(connections, self._oneview.connections)
def test_lazy_loading_server_hardware_types(self):
server_hardware_types = self._oneview.server_hardware_types
self.assertEqual(server_hardware_types,
self._oneview.server_hardware_types)
def test_lazy_loading_id_pools_vsn_ranges(self):
id_pools_vsn_ranges = self._oneview.id_pools_vsn_ranges
self.assertEqual(id_pools_vsn_ranges,
self._oneview.id_pools_vsn_ranges)
def test_lazy_loading_id_pools_vmac_ranges(self):
id_pools_vmac_ranges = self._oneview.id_pools_vmac_ranges
self.assertEqual(id_pools_vmac_ranges,
self._oneview.id_pools_vmac_ranges)
def test_lazy_loading_id_pools_vwwn_ranges(self):
id_pools_vwwn_ranges = self._oneview.id_pools_vwwn_ranges
self.assertEqual(id_pools_vwwn_ranges,
self._oneview.id_pools_vwwn_ranges)
def test_lazy_loading_logical_enclosures(self):
logical_enclosures = self._oneview.logical_enclosures
self.assertEqual(logical_enclosures, self._oneview.logical_enclosures)
def test_lazy_loading_interconnect_types(self):
interconnect_types = self._oneview.interconnect_types
self.assertEqual(interconnect_types, self._oneview.interconnect_types)
def test_lazy_loading_logical_downlinks(self):
logical_downlinks = self._oneview.logical_downlinks
self.assertEqual(logical_downlinks, self._oneview.logical_downlinks)
def test_lazy_loading_storage_systems(self):
storage_systems = self._oneview.storage_systems
self.assertEqual(storage_systems, self._oneview.storage_systems)
def test_lazy_loading_storage_pools(self):
storage_pools = self._oneview.storage_pools
self.assertEqual(storage_pools, self._oneview.storage_pools)
def test_lazy_loading_firmware_drivers(self):
firmware_drivers = self._oneview.firmware_drivers
self.assertEqual(firmware_drivers, self._oneview.firmware_drivers)
def test_lazy_loading_firmware_bundles(self):
firmware_bundles = self._oneview.firmware_bundles
self.assertEqual(firmware_bundles, self._oneview.firmware_bundles)
def test_power_devices_has_right_type(self):
self.assertIsInstance(self._oneview.power_devices, PowerDevices)
def test_power_devices_has_value(self):
self.assertIsNotNone(self._oneview.power_devices)
def test_lazy_loading_power_devices(self):
power_devices = self._oneview.power_devices
self.assertEqual(power_devices, self._oneview.power_devices)
def test_logical_interconnect_groups_has_right_type(self):
self.assertIsInstance(self._oneview.logical_interconnect_groups,
LogicalInterconnectGroups)
def test_logical_interconnect_groups_has_value(self):
self.assertIsNotNone(self._oneview.logical_interconnect_groups)
def test_lazy_loading_logical_interconnect_groups(self):
logical_interconnect_groups = self._oneview.logical_interconnect_groups
self.assertEqual(logical_interconnect_groups,
self._oneview.logical_interconnect_groups)
def test_logical_switch_groups_has_right_type(self):
self.assertIsInstance(self._oneview.logical_switch_groups,
LogicalSwitchGroups)
def test_logical_switch_groups_has_value(self):
self.assertIsNotNone(self._oneview.logical_switch_groups)
def test_lazy_loading_logical_switch_groups(self):
logical_switch_groups = self._oneview.logical_switch_groups
self.assertEqual(logical_switch_groups,
self._oneview.logical_switch_groups)
def test_logical_interconnects_has_right_type(self):
self.assertIsInstance(self._oneview.logical_interconnects,
LogicalInterconnects)
def test_logical_interconnects_has_value(self):
self.assertIsNotNone(self._oneview.logical_interconnects)
def test_lazy_loading_logical_interconnects(self):
logical_interconnects = self._oneview.logical_interconnects
self.assertEqual(logical_interconnects,
self._oneview.logical_interconnects)
def test_storage_volume_templates_has_right_type(self):
self.assertIsInstance(self._oneview.storage_volume_templates,
StorageVolumeTemplates)
def test_storage_volume_templates_has_value(self):
self.assertIsNotNone(self._oneview.storage_volume_templates)
def test_lazy_loading_storage_volume_templates(self):
storage_volume_templates = self._oneview.storage_volume_templates
self.assertEqual(storage_volume_templates,
self._oneview.storage_volume_templates)
def test_storage_volume_attachments_has_right_type(self):
self.assertIsInstance(self._oneview.storage_volume_attachments,
StorageVolumeAttachments)
def test_storage_volume_attachments_has_value(self):
self.assertIsNotNone(self._oneview.storage_volume_attachments)
def test_lazy_loading_storage_volume_attachments(self):
storage_volume_attachments = self._oneview.storage_volume_attachments
self.assertEqual(storage_volume_attachments,
self._oneview.storage_volume_attachments)
def test_uplink_sets_has_right_type(self):
self.assertIsInstance(self._oneview.uplink_sets, UplinkSets)
def test_uplink_sets_has_value(self):
self.assertIsNotNone(self._oneview.uplink_sets)
def test_lazy_loading_uplink_sets(self):
copy_uplink_sets = self._oneview.uplink_sets
self.assertEqual(copy_uplink_sets, self._oneview.uplink_sets)
def test_volumes_has_right_type(self):
self.assertIsInstance(self._oneview.volumes, Volumes)
def test_volumes_has_value(self):
self.assertIsNotNone(self._oneview.volumes)
def test_lazy_loading_volumes(self):
copy_volumes = self._oneview.volumes
self.assertEqual(copy_volumes, self._oneview.volumes)
def test_server_profile_templates_has_right_type(self):
self.assertIsInstance(self._oneview.server_profile_templates,
ServerProfileTemplate)
def test_lazy_loading_server_profile_templates(self):
server_profile_templates = self._oneview.server_profile_templates
self.assertEqual(server_profile_templates,
self._oneview.server_profile_templates)