def _verify_resource_deleted(resource):
logger.info("Verify Deleting the resource %s from scope" % resource.name)
EditScopes.click_edit_scope_button()
EditScopes.click_remove_resources_button()
EditScopes.input_and_select_remove_resource_category(resource.category)
VerifyScopes.verify_resource_deleted(resource)
return True
def validate_resource_can_be_added_to_scope(*scope_obj):
""" Validate Resource Can Be Added To Scope """
logger.info("Validate Resource Can Be Added To Scope")
navigate()
if isinstance(scope_obj, test_data.DataObj):
scope_obj = [scope_obj]
elif isinstance(scope_obj, tuple):
scope_obj = list(scope_obj[0])
fail_if_exist = 0
# Looping to edit all the resourcs present in the resources.txt file
for scope in scope_obj:
logger.info("Editing scope %s" % scope.name)
# Selecting the given scope
if CommonOperationScopes.select_scope(scope.name):
# Clicking on edit button and verifying the edit options page
EditScopes.click_edit_scope_button()
EditScopes.wait_edit_scope_dialog_open()
# Verify resources
if scope.has_property("resources"):
_Add_Resource_To_Scope(scope.resources)
EditScopes.click_cancel_button()
EditScopes.wait_edit_scope_dialog_close()
if fail_if_exist > 0:
return False
return True
def delete_alert_filter(*alert_obj):
""" Deleting the Alert Filters created
"""
navigate()
if isinstance(alert_obj, test_data.DataObj):
alert_obj = [alert_obj]
elif isinstance(alert_obj, tuple):
alert_obj = list(alert_obj[0])
total = len(alert_obj)
not_exists = 0
deleted = 0
for alert in alert_obj:
if VerifyAlertFilter.verify_alert_exist_in_alert_table(
alert.name, 5, False) is True:
DeleteALertFilter.click_action_menu_delete()
DeleteALertFilter.click_delete_alert_filter(alert.name)
DeleteALertFilter.click_ok_delete_filter()
VerifyAlertFilter.verify_alert_filter_is_deleted(alert.name)
deleted += 1
else:
logger.warn("Alert Filter '%s' does NOT exist! ..." % alert.name)
not_exists += 1
continue
if total - not_exists == 0:
logger.warn("no alert filter to delete! all filter(s) is NOT existing")
return False
elif deleted < total:
logger.warn(
"not all of the alert filter(s) is successfully deleted - %s out of %s deleted "
% (deleted, total))
return False
logger.info(
"all of the alert filter(s) is successfully deleted - %s out of %s " %
(deleted, total))
return True
def select_scope(scope_name):
""" Select Scope """
logger.info("Selecting scope %s :" % scope_name)
navigate()
CommonOperationScopes.select_scope(scope_name)
VerifyScopes.verify_scope_created(scope_name)
return True
def verify_overview_section(de_obj):
FusionUIBase.select_view_by_name('Overview')
logger.info("Verifying configuration in Overview view...")
# if hasattr(de_obj, "drive_enclosures"):
# VerifyDriveEnclosures.verify_drive_enclosures_exist(de_obj.logical_interconnect)
if hasattr(de_obj, "state"):
VerifyDriveEnclosures.verify_drive_enclosure_state(
'Overview', de_obj.state)
if hasattr(de_obj, "power"):
VerifyDriveEnclosures.verify_drive_enclosure_power(
'Overview', de_obj.power)
if hasattr(de_obj, "logical_interconnect"):
VerifyDriveEnclosures.verify_drive_enclosure_logical_interconnect(
'Overview', de_obj.logical_interconnect)
if hasattr(de_obj, "number_of_drives"):
VerifyDriveEnclosures.verify_drive_enclosure_number_of_drives(
'Overview', de_obj.number_of_drives)
if hasattr(de_obj, "temperature"):
VerifyDriveEnclosures.verify_drive_enclosure_temperature(
'Overview', de_obj.temperature)
if hasattr(de_obj, "model"):
VerifyDriveEnclosures.verify_drive_enclosure_model(
'Overview', de_obj.model)
if hasattr(de_obj, "interconnect_bay_set"):
VerifyDriveEnclosures.verify_drive_enclosure_interconnect_bay_set(
'Overview', de_obj.interconnect_bay_set)
def verify_bay_hover_over(cls, drive):
drive_bay = drive.bay
drive_status = drive.status
drive_capacity = drive.capacity
drive_type = drive.type
drive_logical_jbod = drive.logical_jbod
drive_server_profile = drive.server_profile
if drive.model == 'empty':
logger.info('''Skipping verification of hover over for empty bay.
No information for hover over to display''')
else:
ui_lib.move_to_element_verify_visible_move_away(
DriveEnclosuresElements.ID_DRIVE_BAY_BY_NUMBER % drive_bay,
DriveEnclosuresElements.ID_DRIVE_STATUS_IN_HOVER_OVER %
drive_status,
DriveEnclosuresElements.ID_DRIVE_BAY_NUMBER_IN_HOVER_OVER %
drive_bay,
DriveEnclosuresElements.ID_DRIVE_TYPE_IN_HOVER_OVER %
drive_type,
DriveEnclosuresElements.ID_DRIVE_CAPACITY_IN_HOVER_OVER %
drive_capacity,
DriveEnclosuresElements.ID_DRIVE_LOGICAL_JBOD_IN_HOVER_OVER %
drive_logical_jbod,
DriveEnclosuresElements.ID_DRIVE_SERVER_PROFILE_IN_HOVER_OVER %
drive_server_profile)
def _click_used_by_server_profile(sht_name):
# check server hardware type information by server profile
from FusionLibrary.ui.business_logic.servers.serverprofiles import CommonOperationServerProfile
try:
CommonOperationServerHardwareType.click_used_by_server_profile()
except:
logger.warn(
"Server hardware type [ %s ] are not used by any server profile" %
sht_name)
return False
server_profile_list = CommonOperationServerProfile.get_server_profile_list(
)
for sp_name in server_profile_list:
CommonOperationServerProfile.click_server_profile(sp_name)
FusionUIBase.select_view_by_name('General', fail_if_false=False)
got_sht_name = CommonOperationServerProfile.get_server_hardware_type_of_server_profile(
sp_name, fail_if_false=False)
if got_sht_name != sht_name:
ui_lib.get_s2l().capture_page_screenshot()
logger.warn(
"Server profile [%s] doesn't have server hardware type [%s]" %
(sp_name, sht_name))
return False
logger.info("Server profile [%s] has server hardware type [%s]" %
(sp_name, sht_name))
return True
def close_connection(ssh):
try:
log.info("Closing Connection HP5900 Switch")
ssh.close()
except:
log.info("Could not close connection")
quit()
def verify_server_hardware_type(hardware_types_obj):
""" Delete Hardware Type
Arguments:
<servertype>
name* -- Specify server hardware type name should be verified.
* Required Arguments
Example:
data/enclosures -> @{TestData.servertypes.VerifyServerTypes.Gen8}}
data/enclosures -> @{TestData.servertypes.VerifyServerTypes.Gen9}}
<servertypes>
<VerifyServerTypes>
<Gen8>
<servertype name="BL465c Gen8 2" />
</Gen8>>
<Gen9>
<servertype name="DL180 Gen9 1" />
</Gen9>
</VerifyServerTypes>
</servertypes>
"""
navigate()
count = 0
for n, sht_obj in enumerate(hardware_types_obj):
logger.info("{2} No: {0} --- Total: {1} {2}".format(
(n + 1), len(hardware_types_obj), '-' * 14))
logger.info("Verifying a server hardware type is used by ")
if not select_server_hardware_type(sht_obj.name):
continue
# check the sht name is used by server hardware
if not _click_used_by_server_hardware(sht_obj.name):
continue
# navigate to server hardware type page, continue the remaining verification
navigate()
select_server_hardware_type(sht_obj.name)
# check the sht name is used by server profile
if not _click_used_by_server_profile(sht_obj.name):
continue
count += 1
if count == 0:
msg = "No target server hardware type exists!"
logger.warn(msg)
return False
if count != len(hardware_types_obj):
logger.warn("Not able to verify all server hardware type!")
return False
return True
def _click_used_by_server_hardware(sht_name):
from FusionLibrary.ui.business_logic.servers.serverhardware import CommonOperationServerHardware
try:
CommonOperationServerHardwareType.click_used_by_server_hardware()
except:
logger.warn(
"Server hardware type [ %s ] are not used by any server hardware" %
sht_name)
return False
server_name_list = CommonOperationServerHardware.get_server_hardware_list()
for server_name in server_name_list:
CommonOperationServerHardware.click_server_hardware(server_name)
FusionUIBase.select_view_by_name(view_name='Hardware',
timeout=8,
fail_if_false=False)
got_sht_name = CommonOperationServerHardware.get_server_hardware_type(
server_name, fail_if_false=False)
if got_sht_name != sht_name:
ui_lib.get_s2l().capture_page_screenshot()
logger.warn(
"Server hardware [%s] doesn't have server hardware type [%s]" %
(server_name, sht_name))
return False
logger.info("Server hardware [%s] has server hardware type [%s]" %
(server_name, sht_name))
return True
def delete_firmware_bundle(obj_fwbundle):
logger.info("Deleting the firmware bundles..")
""" Navigate to Firmware Bundle Page """
navigate()
fail_count = 0
spp_len = len(obj_fwbundle)
for spp in obj_fwbundle:
logger.info("Deleting Firmware Bundle %s" % spp.firmwarename)
""" Split the firmware to name and version """
fwname = (spp.firmwarename).split(",")
sppname = fwname[0].strip()
firmwareversion = fwname[1].strip()
""" Select the firmware in Firmware bundle page """
if not CommonOperationFirmwareBundle.click_firmware_bundle(
sppname, firmwareversion, fail_if_false=False):
fail_count += 1
continue
RemoveFirmwareBundle.select_action_delete()
RemoveFirmwareBundle.wait_remove_firmware_bundle_dialog_open()
if RemoveFirmwareBundle.wait_yes_remove_button_shown():
RemoveFirmwareBundle.click_yes_remove_button()
else:
RemoveFirmwareBundle.click_remove_bundle_button()
RemoveFirmwareBundle.wait_remove_firmware_bundle_dialog_close()
RemoveFirmwareBundle.wait_firmware_bundle_removed(
sppname, firmwareversion)
if fail_count > 0:
ui_lib.fail_test("<%s> of <%s> firmware bundle select failed!" %
(str(fail_count), str(spp_len)))
def delete_networks(*net_obj):
""" Delete Network """
FusionUIBase.navigate_to_section(SectionType.NETWORKS)
if isinstance(net_obj, test_data.DataObj):
net_obj = [net_obj]
elif isinstance(net_obj, tuple):
net_obj = list(net_obj)
count = 0
for n, net in enumerate(net_obj):
logger.info("{2} No: {0} --- Total: {1} {2}".format((n + 1),
len(net_obj),
'-' * 14))
logger.info("Deleting a network with name %s" % net.name)
if not select_network(net.name):
count += 1
continue
delete_network(net.name)
if count > 0:
logger.warn(
"Not able to delete some of networks, please check warning message"
)
return False
return True
def enable_switch_port(*switch_obj):
""" Enable / Disable switch port
Example:
| Switch Enable Port | @{switch_list}
"""
if isinstance(switch_obj, test_data.DataObj):
switch_obj = [switch_obj]
elif isinstance(switch_obj, tuple):
switch_obj = list(switch_obj[0])
navigate()
for switch in switch_obj:
logger.info("\nEditing Switch %s..." % switch.name)
if (switch.name == ""):
logger._warn("Mandatory field - name can't be empty")
continue
if not select_switch(switch.name):
FusionUIBase.fail_test_or_return_false(
"Switch [%s] is not selected " % switch.name)
port_number = switch.port[2:]
if int(switch.port[:1]) >= 2:
port_number = str(int(port_number) + int(switch.increment))
if CommonOperationSwitches.edit_switch_port(port_number) is None:
CommonOperationSwitches.click_ok_edit()
return None
CommonOperationSwitches.click_ok_edit()
return CommonOperationSwitches.get_port_status(port_number)
def configure_network(self, body):
"""
Creates the vSwitch or distributed vSwitch depending on the type
provided and its port groups.
:param dict body: JSON body
:return list: List of results for each network configuration
"""
if not body.get('config', []):
log.warn('No network configurations found')
return self.results
if not self._validate_and_set_host(body.get('host')):
return self.results
for net in body['config']:
if not net.get('name'):
log.warn('Missing required attribute: name')
self.results.append({'ports': 'Unknown', 'status': 'Fail'})
continue
if net.get('type') == 'vss':
self._configure_vswitch(net)
elif net.get('type') == 'vds':
self._configure_distributed_switch(net)
else:
log.info('Unknown network type provided {}'.format(
net['type']))
self.results.append({'ports': net['name'], 'status': 'Fail'})
log.debug('Results\n{}'.format(self.results))
return self.results
def populate_role_flag(self, features, populates):
"""This flag is used to control whether to populate the role"""
for populate in populates:
if populate in features:
logger.info("%s needs to populate the role." % populate)
return True
return False
def assign_scope_bulk_networks(*scope_obj):
""" Edit Scope """
logger.info("Edit Scope")
navigate()
if isinstance(scope_obj, test_data.DataObj):
scope_obj = [scope_obj]
elif isinstance(scope_obj, tuple):
scope_obj = list(scope_obj[0])
fail_if_exist = 0
# Looping to edit all the resources present in the resources.txt file
for scope in scope_obj:
logger.info("Editing scope %s" % scope.name)
if scope.has_property("new_name"):
if scope.new_name != scope.name and VerifyScopes.verify_scope_existed(scope.new_name, 5, False):
fail_if_exist += 1
logger.warn("scope %s already exists, can't edit scope" % scope.new_name)
continue
# Selecting the given scope
if CommonOperationScopes.select_scope(scope.name):
# Clicking on edit button and verifying the edit options page
CommonOperationScopes.wait_for_scopes_load()
EditScopes.click_edit_scope_button()
EditScopes.wait_edit_scope_dialog_open()
EditScopes.click_add_resources_button()
EditScopes.wait_add_resources_dialog_open()
EditScopes.input_and_select_resource_category(scope.category)
CommonOperationScopes.load_bulk_enets()
EditScopes.click_add_button()
EditScopes.wait_add_resources_dialog_close()
EditScopes.click_ok_button()
EditScopes.wait_edit_scope_dialog_close()
if fail_if_exist > 0:
return FusionUIBase.fail_test_or_return_false("Failed to assign bulk resource")
return True
def edit_settings_storage_volume_template(reqdtemplatevolumecreation):
FusionUIBase.navigate_to_section(SectionType.VOLUME_TEMPLATES)
volume_template_list = CommonOperationVolumeTemplates.get_volume_template_list(
)
if len(volume_template_list) == 0:
ui_lib.fail_test(
"no volume template existing, not able to edit setting for volume template !"
)
else:
name = volume_template_list[0]
logger.info(
"Editing settings for a volume template with name '{0}'".format(name))
select_storage_template(name)
EditVolumeTemplatesSettings.select_actions_edit_settings()
EditVolumeTemplatesSettings.wait_edit_settings_dialog_shown()
if reqdtemplatevolumecreation.lower() == 'true':
EditVolumeTemplatesSettings.tick_require_template_for_volume_creation()
elif reqdtemplatevolumecreation.lower() == 'false':
EditVolumeTemplatesSettings.not_tick_require_template_for_volume_creation(
)
else:
ui_lib.fail_test(
"Invalid value '%s' for 'reqdtemplatevolumecreation', please specify 'True' or 'False'"
% reqdtemplatevolumecreation)
EditVolumeTemplatesSettings.click_ok()
EditVolumeTemplatesSettings.wait_edit_settings_dialog_disappear()
FusionUIBase.show_activity_sidebar()
CommonOperationVolumeTemplates.wait_activity_edit_settings_ok(timeout=10)
FusionUIBase.show_activity_sidebar()
CommonOperationVolumeTemplates.wait_volume_template_status_ok(name)
logger.info(
"Edit setting for volume template {0} successfully".format(name))
return True
def remove_directory_user_or_group(*user_obj):
'''
remove active directory or ldap users and groups listed in the dcs_data.xml file
'''
# retrieving data from data file
if isinstance(user_obj, test_data.DataObj):
user_obj = [user_obj]
elif isinstance(user_obj, tuple):
user_obj = list(user_obj)
navigate()
error = 0
for userGroup in user_obj:
if (userGroup.has_property("domainName")):
GeneralUserandGroups.click_user(userGroup.name,
userGroup.domainName, True)
RemoveUser.click_action_remove_user_button()
# make sure the remove dialog is displayed
RemoveUser.wait_remove_user_dialog_shown()
# delete the user
RemoveUser.click_yes_remove_button()
RemoveUser.wait_cannot_remove_user_dialog_disappear()
if not VerifyUser.verify_user_not_exist(
userGroup.name, userGroup.domainName, True):
logger.warn("Not able to remove group %s" % userGroup.name)
error += 1
else:
logger.info("Successfully removed %s" % userGroup.name)
if error > 0:
return False
else:
return True
def delete_storage_volume_template(volume_template, fail_if_false=True):
select_storage_template(volume_template)
DeleteVolumeTemplates.select_actions_delete()
DeleteVolumeTemplates.wait_delete_dialog_shown()
DeleteVolumeTemplates.click_yes_delete_button()
DeleteVolumeTemplates.wait_delete_dialog_disappear()
FusionUIBase.show_activity_sidebar()
FusionUIBase.wait_activity_action_ok(volume_template,
message="Delete",
timeout=20)
FusionUIBase.show_activity_sidebar()
if CommonOperationVolumeTemplates.wait_volume_template_show_not_found(
volume_template, timeout=15, fail_if_false=False):
logger.info(
"Volume template status appear as 'not found', remove storage system {0} successfully."
.format(volume_template))
return True
elif CommonOperationVolumeTemplates.verify_volume_template_not_exist(
volume_template, timeout=5, fail_if_false=False):
logger.info(
"Remove volume template {0} successfully".format(volume_template))
return True
else:
if fail_if_false is True:
ui_lib.fail_test("The volume template does not disappear in 20s!")
else:
logger.warn("The volume template does not disappear in 20s!")
return False
def verify_drives_view(drive_enclosure_object):
for drive_enclosure in drive_enclosure_object:
FusionUIBase.click_item_from_master_table(drive_enclosure.name)
FusionUIBase.select_view_by_name('Drives')
logger.info("Verifying Drives View for Drive Enclosure: %s" %
drive_enclosure.name)
for drive in drive_enclosure.drives:
VerifyDriveEnclosures.verify_drives_view_drive_status(drive)
VerifyDriveEnclosures.verify_drives_view_drive_model(drive)
VerifyDriveEnclosures.verify_drives_view_drive_type(drive)
VerifyDriveEnclosures.verify_drives_view_drive_capacity(drive)
VerifyDriveEnclosures.verify_drives_view_drive_logical_jbod(drive)
VerifyDriveEnclosures.verify_drives_view_drive_server_profile(
drive)
if drive.model == 'empty':
logger.info(
'No further verification required for empty drive in bay %s'
% drive.bay)
else:
# Add back in after F636 is dev complete
# VerifyDriveEnclosures.verify_drives_view_drive_uid_toggle(drive)
VerifyDriveEnclosures.verify_collapser(drive)
def verify_error_msg_for_duplicate_scope(*scopes_obj):
logger.info("Create and verify Scope")
navigate()
if isinstance(scopes_obj, test_data.DataObj):
scopes_obj = [scopes_obj]
elif isinstance(scopes_obj, tuple):
scopes_obj = list(scopes_obj[0])
for scope in scopes_obj:
have_resource = False
CreateScopes.click_create_scope_button()
logger.info("Creating scope %s" % scope.name)
CreateScopes.wait_create_scope_dialog_open()
CreateScopes.input_name(scope.name)
if hasattr(scope, 'description'):
CreateScopes.input_description(scope.description)
if hasattr(scope, 'resources'):
for resource in enumerate(scope.resources):
have_resource = True
_Add_Resource_To_Scope_Add(resource)
CreateScopes.click_create_plus_button()
validate_msg = CommonOperationScopes.get_scopename_validate_message()
err_msg = CommonOperationScopes.get_scope_error_message()
CreateScopes.click_cancel_button()
CreateScopes.wait_create_scope_dialog_close()
if validate_msg is not None:
return validate_msg
if err_msg is not None:
return err_msg
else:
return FusionUIBase.fail_test_or_return_false("Failed to find the element")
def http_directory_download_files(self,
webfilelist,
localpath,
threadlimit=2):
"""
Download multiple files in parallel using ThreadPool
"""
workers = ThreadPool(threadlimit)
arglist = []
while True:
if webfilelist:
fileurl = webfilelist.pop()
filename = fileurl.rsplit('/', 1)[-1]
localfile = localpath + '//' + filename
if os.path.isfile(localfile):
# Skip if file already exists in local path
logger.info(
"File '{}' already exists in local path".format(
filename),
also_console=True)
continue
arglist.append((fileurl, localfile))
else:
break
workers.map(self.helper_thread, arglist)
workers.close()
workers.join()
def remove_san_manager(name, fail_if_false=True):
select_san_manager(name)
RemoveSANMangers.select_action_remove()
RemoveSANMangers.wait_remove_san_manager_dialog_shown()
RemoveSANMangers.click_yes_remove()
RemoveSANMangers.wait_remove_san_manager_dialog_disappear()
FusionUIBase.show_activity_sidebar()
FusionUIBase.wait_activity_action_ok(name,
"Remove SAN manager",
timeout=50)
FusionUIBase.show_activity_sidebar()
if CommonOperationSANMangers.wait_san_manager_show_not_found(
name, timeout=15, fail_if_false=False):
logger.info(
"SAN manager status appear as 'not found', remove san manager {0} successfully."
.format(name))
return True
elif CommonOperationSANMangers.verify_san_manager_not_exist(
name, timeout=5, fail_if_false=False):
logger.info("Remove SAN manager {0} successfully".format(name))
return True
else:
if fail_if_false is True:
ui_lib.fail_test("The SAN manager does not disappear in 20s!")
else:
logger.warn("The SAN manager does not disappear in 20s!")
def _set_server_profile(self, uri):
"""
Configures the Object attribute profile with information received
:param uri: (String) URI
:return: None
"""
# Workaround of not being an object for the keywords
# Fixme: Modularize the keywords
self.filter = False
self.server = self.fusion_api_get_server_profiles(uri=uri)
if self.server['status_code'] != 200:
# Reset variable to None due to lack of information
self.server = None
logging.info("{} is invalid.".format(uri))
self.filter = True
return None
if self.server.get('status') == "Critical" and \
self.server.get('state') != "Normal":
_ = "{} is reporting {} status.".format(self.server.get('name'),
self.server.get('status'))
logging.info(_)
self.filter = True
return None
def _get_os_profile_dict(self, body, bulk=False):
"""
Returns the JSON object after processing the initial input from
:param body: JSON object
:param bulk: (Boolean) Flag for bulk provisioning
:return: DICT holding OS profile information
"""
required_attrs = [
'os_name', 'os_repo', 'deployment_network', 'ilo_user', 'ilo_pass'
]
if not set(required_attrs).issubset(body.keys()):
m = "Missing required attributes."
m += "\nRequired attributes are {}".format(required_attrs)
m += "\nFound attributes are {}".format(body.keys())
logging.info(m)
self.filter = True
return None
rst = {
'os_name': body.get('os_name'),
'os_repo': body.get('os_repo'),
'kickstart': body.get('kickstart', ''),
'custom_script': body.get('custom_script', ''),
'spp': body.get('spp', '')
}
if bulk:
rst['storage_driver'] = body.get('storage_driver', '')
rst['network_driver'] = body.get('network_driver', '')
else:
rst['storage'] = {"drivers": body.get('storage_driver', '')}
rst['network'] = {"drivers": body.get('network_driver', '')}
return rst
def generate_payload(self, server_uri, body):
"""
Helper method for generating the request body required by CPT Deploy OS
:param server_uri: URI of the server to be provisioned
:param body: JSON Object containing OS profile information
:return: JSON Object
"""
self._set_server_profile(server_uri)
if not self.server:
logging.debug("{} has been discarded.".format(server_uri))
raise AssertionError('Unable to create payload.')
b = self._get_os_profile_dict(body)
b['host'] = self._get_host_dict(body)
b['boot_mode'] = self._get_boot_mode()
b['network'].update(self._get_net_dict(body.get('deployment_network')))
b['storage'].update(self._get_storage_dict())
b['ilo'] = self._get_ilo_dict(body.get('ilo_user'),
body.get('ilo_pass'))
if self.filter:
logging.info(
"Server profile at {} is discarded".format(server_uri))
raise AssertionError('Unable to create payload.')
logging.debug("Input for CPT:\n {}".format(b))
return b
def _get_net_dict(self, net):
"""
Returns the DICT containing network details required for deployment
:param net: (String) name of the network
:return: JSON dict containing mac, pos
"""
uri = self._get_network_uri(net)
# ServerProfileV7 and below don't have connectionSettings
# In case of upgrade test cases.
if int(self.server.get('type').split('V')[1]) < 8:
con = self.server.get('connections', [])
else:
con = self.server['connectionSettings'].get('connections')
nets = sorted(con, key=lambda p: p['id'])
for c, k in enumerate(nets):
if k['networkUri'] == uri:
return {'mac': k['mac'], 'pos': c + 1}
m = "Server profile {} did not contain ".format(
self.server.get('name'))
m += "deployment network connection {}".format(net)
logging.info(m)
self.filter = True
def _get_network_uri(self, net):
"""
Returns the URI of the network\network set
:param net: (String) name of the network\network set
:return: (String) URI
"""
p = '?&filter="\'name\'==\'{}\'"'.format(net)
r = self.fusion_api_get_ethernet_networks(param=p)
if r['count'] == 0:
# check for networkset
r = self.fusion_api_get_network_set(param=p)
if r['count'] == 0:
m = "Unable to find {} network/network set.".format(net)
m += "Please provide the right deployment ethernet network/network set"
logging.info(m)
self.filter = True
return
elif r['count'] > 1:
m = "Something went wrong. Unable to retrieve {} URI".format(net)
logging.info(m)
self.filter = True
return
return r['members'][0]['uri']
def wait_logical_switch_group_status_not_found(cls, lsg_name, timeout=5, fail_if_false=True):
logger.info("wait for Logical Switch Group status to change to 'not found'")
if ui_lib.wait_for_element_visible(cls.e.ID_TABLE_LOGICAL_SWITCH_GROUP_NOT_FOUND % lsg_name, timeout=timeout, fail_if_false=fail_if_false):
logger.debug("Logical Switch Group '%s' status successfully changed to 'not found'" % lsg_name)
return True
else:
msg = "failed to wait for Logical Switch Group '%s' status to change to 'not found'" % lsg_name
return FusionUIBase.fail_test_or_return_false(msg, fail_if_false=fail_if_false)
def wait_delete_logical_switch_group_dialog_open(cls, timeout=5, fail_if_false=True):
logger.info("waiting for dialog 'Delete Logical Switch Group' to open ...")
if ui_lib.wait_for_element_visible(cls.e.ID_DIALOG_DELETE_LOGICAL_SWITCH_GROUP, timeout=timeout, fail_if_false=fail_if_false):
logger.debug("dialog 'Delete Logical Switch Group' successfully opened")
return True
else:
msg = "failed to wait for dialog 'Delete Logical Switch Group' to open within %s seconds" % timeout
return FusionUIBase.fail_test_or_return_false(msg, fail_if_false=fail_if_false)
