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)