def wait_until_discover_device_successfully(self, switchName=None, ipAdd=None, timeOut=constants.SELENPY_SYNCSWITCH_TIMEOUT, closeWindow=True):
"""Wait until the discover device switch successful in SNMP Status Window.
... We have 4 arguments:
... - 'switchName': name of switch
... - 'ipAdd': IP address of switch
... - 'timeOut'
... - 'closeWindow'"""
self.snmpStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.snmpStatusIframe)
self.snmpTaskStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.snmpTaskStatusIframe)
self._wait_for_processing()
self.snmpStatusTbl.wait_until_element_is_visible()
waitSwitchDiscover = "Discover Devices"+ "--" + switchName + "--" + ipAdd
for i in range(0, int(timeOut)):
self.refreshBtn.click_element()
time.sleep(1) # hard sleep to waiting for the status changing to successful
returnRow = self.snmpStatusTbl._get_table_row_map_with_header("Action Type--Device--IP Address", waitSwitchDiscover, "--")
if(returnRow > 0):
i += 1
else:
break
driver.unselect_frame()
if closeWindow:
self.close_snmp_status_window()
def create_cabling(self, typeConnect="Connect", cableFrom=None, cableTo=None, mpoTab=None, mpoType=None, mpoBranches=None, portsTo=None, delimiter=","):
"""typeConnect': Connect or Disconnect
... 'cableFrom': the source tree node (containing the end point). Ex: Site/Building/Floor 01/Room 01/1:1 Rack 001/Switch 01/01
... 'cableTo': the destination tree node (not containing the end point). Ex: Site/Building/Floor 01/Room 01/1:1 Rack 001/Switch 01
... 'mpoTab': when cabling for mpo port type(2 options: Mpo12, Mpo24)
... 'mpoType': Options: Mpo12_Mpo12, Mpo12_4xLC, Mpo12_6xLC, Mpo24_Mpo24, Mpo24_12xLC, Mpo24_3xMpo12, Mpo24_2xMpo12, Mpo12_6xLC_EB
... 'mpoBranches': when cabling for mpo port type(is depended on mpo_type). Ex: B1,B2,B3
... 'portsTo': containing 1 or many end points. Ex: 02,03,04. Quantity of ports_to must be equal quantity of mpo_branches
... 'delimiter': the delimiter for mpo_branches and ports_to, the default value is ,"""
listPortTo = portsTo.split(delimiter)
if mpoBranches is not None:
listMpoBranch = mpoBranches.split(delimiter)
driver.select_frame(connection.cablingFrame)
self._wait_for_processing()
connection.cabTreeFromDiv.click_tree_node(cableFrom)
connection._select_mpo_connection_tab(mpoTab)
connection._select_mpo_connection_type(mpoType)
temp = 0
for portTo in listPortTo:
if mpoBranches is not None:
connection._select_mpo_branch(listMpoBranch[temp])
pathTo = cableTo + "/" + portTo
connection.cabTreeToDiv.click_tree_node(pathTo)
connection._set_connection(typeConnect)
self._wait_for_processing(3)
temp += 1
driver.unselect_frame()
def create_quareo_unmanaged_connections(self,
filterType,
typeConnect="Connect",
cableFrom=None,
cableTo=None,
portsTo=None,
delimiter=","):
"""typeConnect': Connect or Disconnect
... 'filterType': Unassigned Quareo ports OR Assigned Quareo ports
... 'cableFrom': the source tree node (containing the end point). Ex: Site/Building/Floor 01/Room 01/1:1 Rack 001/Switch 01/01
... 'cableTo': the destination tree node (not containing the end point). Ex: Site/Building/Floor 01/Room 01/1:1 Rack 001/Switch 01
... 'portsTo': containing 1 or many end points. Ex: 02,03,04. Quantity of ports_to must be equal quantity of mpo_branches
... 'delimiter': the delimiter for mpo_branches and ports_to, the default value is ,"""
self._filter_on_quareo_unmanaged(filterType)
listPortTo = portsTo.split(delimiter)
driver.select_frame(self.qUCIframe)
self._wait_for_processing()
self._click_tree_node(self.treeFromDiv, cableFrom)
temp = 0
for portTo in listPortTo:
pathTo = cableTo + "/" + portTo
self._click_tree_node(self.treeToDiv, pathTo)
connection._set_connection(typeConnect)
self._wait_for_processing()
temp += 1
driver.unselect_frame()
def save_patching_window(self):
self.save_dialog()
self._wait_for_processing()
if self.patchingIframe.is_element_existed():
driver.select_frame(self.patchingIframe)
self._wait_for_processing()
driver.unselect_frame()
def wait_until_synchronize_successfully(self, switchName=None, ipAdd=None, timeOut=constants.SELENPY_SYNCSWITCH_TIMEOUT, closeWindow=True):
"""Use to wait until the status of switch change to "Scheduled" in SNMP Status Window
... We have 4 arguments:
... - 'switchName': name of switch
... - 'ipAdd': IP address of switch
... - 'timeOut'
... - 'closeWindow'"""
self.snmpStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.snmpStatusIframe)
self.snmpTaskStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.snmpTaskStatusIframe)
self.snmpStatusTbl.wait_until_element_is_visible()
pssInfo = "Poll Switch Status"+ "--" + switchName + "--" + ipAdd + "--" + "Scheduled"
ddErrorInfo = "Discover Devices Information"+ "--" + switchName + "--" + ipAdd + "--" + "Scheduled For Automatic Retry"
for i in range(0, timeOut):
self.refreshBtn.click_element()
time.sleep(1) # hard sleep to waiting for the status changing to successful
pssRow = self.snmpStatusTbl._get_table_row_map_with_header("Action Type--Device--IP Address--Status", pssInfo, "--")
ddErrorRow = self.snmpStatusTbl._get_table_row_map_with_header("Action Type--Device--IP Address--Status", ddErrorInfo, "--")
if pssRow > 0:
syncTime = utils.get_current_date_time(resultFormat="%#m/%#d/%#Y %I:%M")
break
elif ddErrorRow > 0:
utils.fatal_error("This managed switch cannot be synchronized. Please double-check it")
else:
i += 1
driver.unselect_frame()
if closeWindow:
self.close_snmp_status_window()
return syncTime
def check_task_list_information_on_patching_window(self, position, name,
taskType, treeFrom,
connectionType, treeTo):
self.dynamicTaskListTable.arguments = [position]
self.dynamicTaskName.arguments = [
self.dynamicTaskListTable.locator(), name
]
self.dynamicTaskType.arguments = [
self.dynamicTaskListTable.locator(), taskType
]
self.dynamicTaskTreeFrom.arguments = [
self.dynamicTaskListTable.locator(), treeFrom
]
self.dynamicTaskConnectType.arguments = [
self.dynamicTaskListTable.locator(), connectionType
]
self.dynamicTaskTreeTo.arguments = [
self.dynamicTaskListTable.locator(), treeTo
]
driver.select_frame(self.patchingIframe)
self.dynamicTaskTreeTo.mouse_over()
SeleniumAssert.element_should_be_visible(self.dynamicTaskName)
SeleniumAssert.element_should_be_visible(self.dynamicTaskType)
SeleniumAssert.element_should_be_visible(self.dynamicTaskTreeFrom)
SeleniumAssert.element_should_be_visible(self.dynamicTaskConnectType)
SeleniumAssert.element_should_be_visible(self.dynamicTaskTreeTo)
driver.unselect_frame()
def open_trace_window_on_cabling(self, treePanel=None, treeNode=None):
driver.select_frame(connection.cablingFrame)
self._wait_for_processing()
if treePanel is not None and treeNode is not None:
if treePanel == "From":
self._click_tree_node(connection.cabTreeFromDiv, treeNode)
elif treePanel == "To":
self._click_tree_node(connection.cabTreeToDiv, treeNode)
connection.traceBtn.click_visible_element()
driver.unselect_frame()
def _check_connect_button_state(self, frame, isEnabled):
driver.select_frame(frame)
self.dynamicConnectionBtn.arguments = ["Connect"]
if isEnabled:
SeleniumAssert.element_attribute_value_should_not_contain(
self.dynamicConnectionBtn, "src", "Disabled")
else:
SeleniumAssert.element_attribute_value_should_contain(
self.dynamicConnectionBtn, "src", "Disabled")
driver.unselect_frame()
def check_multiple_checkboxes_states_on_event_notification_profiles_page(
self, events, enabled, selected, delimiter=","):
"""state: Enabled, Disabled, Selected, Unselected"""
listEvents = events.split(delimiter)
driver.select_frame(self.uniqueIframe)
for event in listEvents:
self.dynamicEventChk.arguments = [event]
self._check_multiple_states_of_checkbox(self.dynamicEventChk,
enabled, selected)
driver.unselect_frame()
def check_port_status_on_cabling_window(self, treePanel=None, treeNode=None, expectedStatus=None):
driver.select_frame(connection.cablingFrame)
self._wait_for_processing()
if treePanel is not None and treeNode is not None:
if treePanel == "From":
self._click_tree_node(connection.cabTreeFromDiv, treeNode)
SeleniumAssert.element_attribute_value_should_contain(connection.cableFromPathDiv, "textContent", expectedStatus)
elif treePanel == "To":
self._click_tree_node(connection.cabTreeToDiv, treeNode)
SeleniumAssert.element_attribute_value_should_contain(connection.cableToPathDiv, "textContent", expectedStatus)
driver.unselect_frame()
def delete_layer_image_files(self, layerName):
driver.select_frame(self.uniqueIframe)
self.layerImageTbl.wait_until_page_contains_element()
tableRow = self.layerImageTbl._get_table_row_map_with_header(
"Name", layerName, delimiter=",")
if tableRow > 0:
self.layerImageTbl._click_table_cell(tableRow, column=1)
self.deleteBtn.click_visible_element()
driver.unselect_frame()
self.confirmDialogBtn.click_visible_element()
else:
driver.unselect_frame()
def add_layer_image_files(self, name, imagePath):
driver.select_frame(self.uniqueIframe)
self.addBtn.wait_until_page_contains_element()
self.addBtn.click_visible_element()
self.layerNameTxt.wait_until_element_is_visible()
self.layerNameTxt.input_text(name)
administration.uploadFileTxt.choose_file(imagePath)
# if backgroundColor is not None:
# select background color (waiting for aTiep)
self.saveBtn.click_visible_element()
driver.unselect_frame()
if self.confirmDialogBtn.is_element_existed():
self.confirmDialogBtn.click_visible_element()
def check_port_status_on_patching_window(self, statusPanel, treeNode,
status):
if statusPanel == "From":
self.click_tree_node_patching("From", treeNode)
self.dynamicPortStatus.arguments = [
self.statusFromDiv.locator(), status
]
else:
self.click_tree_node_patching("To", treeNode)
self.dynamicPortStatus.arguments = [
self.statusToDiv.locator(), status
]
driver.select_frame(self.patchingIframe)
SeleniumAssert.element_should_be_visible(self.dynamicPortStatus)
driver.unselect_frame()
def _clear_sub_logging_options(self,
subFeature,
checkboxes=None,
selectedCheckboxes=None,
clearingMethod=None,
clearEntries=None,
daysReminder=None,
selectedDate=None,
delimiter=","):
driver.select_frame(self.uniqueIframe)
if checkboxes is not None:
listCheckbox = checkboxes.split(delimiter)
listSelectedCheckbox = selectedCheckboxes.split(delimiter)
for i in range(0, len(listCheckbox)):
self.dynamicTrackLoggingChk.arguments = [listCheckbox[i]]
self.dynamicTrackLoggingChk.select_checkbox(
listSelectedCheckbox[i])
if clearingMethod is not None:
self.dynamicClearingMethodExpandBtn.arguments = [subFeature]
self.dynamicClearingMethodExpandBtn.click_visible_element()
self.dynamicSelectedClearingMethod.arguments = [
subFeature, clearingMethod
]
self.dynamicSelectedClearingMethod.click_visible_element()
if clearEntries is not None:
self.dynamicClearEntriesCbb.arguments = [subFeature]
self.dynamicSelectedClearEntriesLi.arguments = [
subFeature, clearEntries
]
self.dynamicClearEntriesCbb.wait_until_element_is_visible()
self.dynamicClearEntriesCbb.click_visible_element()
self.dynamicSelectedClearEntriesLi.click_visible_element()
if daysReminder is not None:
self.dynamicDaysReminderTxt.arguments = [subFeature]
self.dynamicDaysReminderTxt.wait_until_element_is_visible()
self.dynamicDaysReminderTxt.set_customize_attribute_for_element_by_js(
"value", daysReminder)
if selectedDate is not None:
self.dynamicSelectedDateTxt.arguments = [subFeature]
self.dynamicClearSelectedDateBtn.arguments = [subFeature]
self.dynamicSelectedDateTxt.wait_until_element_is_visible()
self.dynamicClearSelectedDateBtn.click_visible_element()
self.dynamicSelectedDateTxt.input_text(selectedDate)
self.dynamicDeleteLoggingBtn.arguments = [subFeature]
self.dynamicDeleteLoggingBtn.click_visible_element()
driver.unselect_frame()
self.confirmDialogBtn.click_visible_element()
self.confirmDialogBtn.click_visible_element()
def _check_event_exist_state_in_add_event_log_filter(
self, events, stateExist, delimiter=","):
""""stateExist: True, False"""
listEvents = events.split(delimiter)
driver.select_frame(self.uniqueIframe)
for event in listEvents:
self.dynamicEventsItem.arguments = [event]
if stateExist:
SeleniumAssert.page_should_contain_element(
self.dynamicEventsItem,
self.dynamicEventsItem.locator() + " does not exist")
else:
SeleniumAssert.page_should_not_contain_element(
self.dynamicEventsItem,
self.dynamicEventsItem.locator() + " exists")
driver.unselect_frame()
def _check_icon_object_on_connections_window(self,
frame,
treePanel,
fromDivTree,
toDivTree,
treeNode,
icon,
delimiter="/"):
self._does_frame_tree_node_exist(frame, treePanel, fromDivTree,
toDivTree, treeNode, delimiter)
nodeXpath = self._build_page_tree_node_xpath(treePanel, fromDivTree,
toDivTree, treeNode,
delimiter)
driver.select_frame(frame)
self.treeObjectIcon.arguments = [nodeXpath, icon]
SeleniumAssert.element_should_be_visible(self.treeObjectIcon)
driver.unselect_frame()
def wait_until_device_synchronize_successfully(self,
ipAdd=None,
timeOut=constants.
SELENPY_SYNCSWITCH_TIMEOUT):
self.syncStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.syncStatusIframe)
self._wait_for_processing()
for i in range(0, timeOut):
ipAddExist = self.syncStatusTbl._get_table_row_map_with_header(
"IP Address", ipAdd)
self.refreshBtn.click_visible_element()
# time.sleep(1.5) # hard sleep to waiting for the status changing to successful
self._wait_for_processing()
if ipAddExist == 0:
break
i += 1
driver.unselect_frame()
def fill_event_notification_profile(self,
profileName=None,
profileDescription=None,
events=None,
locationPath=None,
integrationService=None,
sendEmail=None,
emailServer=None,
recipients=None,
delimiter="/"):
### Step 1 - Input Name & Description ####
driver.select_frame(self.uniqueIframe)
if profileName is not None or profileDescription is not None:
self.eventProfileNameTxt.input_text(profileName)
self.eventProfileDescriptionTxt.input_text(profileDescription)
self.nextStep1Btn.click_visible_element()
self._wait_for_processing()
self.profileEventsTbl.wait_until_element_is_visible()
### Step 2 - Select Events ###
if events is not None:
self.select_events_in_event_notification_profiles(
events, delimiter)
self.nextOtherStepBtn.click_visible_element()
self.profileLocationTree.wait_until_element_is_visible()
### Step 3 - Select Location ###
if locationPath is not None:
self._click_tree_node_checkbox(self.profileLocationTree,
locationPath, delimiter)
self.nextOtherStepBtn.click_visible_element()
self.emailServerCbb.wait_until_element_is_visible()
### Step 4 - Input Information for Notification Method ###
# ## For Integration Service
if integrationService is not None:
self.useIntegrationServiceOnlyChk
# ## For Email
if sendEmail is not None:
self.sendEmailChk.select_checkbox(sendEmail)
self.emailSeverSlb.select_from_list_by_label(emailServer)
self.recipientsTxt.input_text(recipients)
self.includeEventDetailsChk.select_checkbox()
driver.unselect_frame()
def check_trace_object_on_patching(self,
indexObject,
mpoType=None,
objectPosition=None,
objectPath=None,
objectType=None,
portIcon=None,
connectionType=None,
scheduleIcon=None,
informationDevice=None):
driver.select_frame(self.patchingIframe)
self._wait_for_processing()
self.patchingTraceDiv.wait_until_page_contains_element()
self._check_trace_object(self.patchingTraceDiv, indexObject, mpoType,
objectPosition, objectPath, objectType,
portIcon, connectionType, scheduleIcon,
informationDevice)
driver.unselect_frame()
def _check_mpo_connection_type_icon_not_exist(self,
frame,
mpoConnectionType,
mpoConnectionTab=None):
''''mpoConnectionType': Options: Mpo12_Mpo12, Mpo12_4xLC, Mpo12_6xLC, Mpo24_Mpo24, Mpo24_12xLC, Mpo24_3xMpo12, Mpo24_2xMpo12, Mpo12_6xLC_EB'''
driver.select_frame(frame)
self._select_mpo_connection_tab(mpoConnectionTab)
self.dynamicConnectionType.arguments = [
mpoConnectionType, mpoConnectionType
]
self.dynamicDisabledConnectionType.arguments = [
mpoConnectionType, mpoConnectionType
]
SeleniumAssert.element_should_not_be_visible(
self.dynamicConnectionType)
SeleniumAssert.element_should_not_be_visible(
self.dynamicDisabledConnectionType)
driver.unselect_frame()
def check_synchronize_switch_successfully(self, switchName=None, ipAdd=None, closeWindow=True):
"""Use to check the status of switch change to "Scheduled" in SNMP Status Window.
... We have 3 arguments:
... - 'switchName': name of switch
... - 'ipAdd': IP address of switch
... - 'closeWindow'"""
self.snmpStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.snmpStatusIframe)
self.snmpTaskStatusIframe.wait_until_page_contains_element()
driver.select_frame(self.snmpTaskStatusIframe)
self.snmpStatusTbl.wait_until_element_is_visible()
switchStatus = switchName + "--" + ipAdd + "--" + "Scheduled"
returnRow = self.snmpStatusTbl._get_table_row_map_with_header("Device--IP Address--Status", switchStatus, "--")
Assert.should_be_true(returnRow > 0, "Switch synchronize successfully.")
driver.unselect_frame()
if closeWindow:
self.close_snmp_status_window()
def move_services(self, viewObjectFilter=None, moveTreeNode=None, moveTo=None, viewServiceFilter=None, selectObjects=None, moveServiceFrom=None, moveServiceTo=None, delimiterTree="/"):
services.serviceIframe.wait_until_page_contains_element()
driver.select_frame(services.serviceIframe)
# Select Object To Move
if viewObjectFilter is not None:
self.viewFilterCbb.wait_until_element_is_visible()
self.viewFilterCbb.select_from_list_by_label(viewObjectFilter)
self.moveTreeDiv.click_tree_node(moveTreeNode, delimiterTree)
driver.unselect_frame()
self.dialogOkBtn.click_visible_element()
self._select_iframe(services.serviceIframe, services.leftTreeDiv)
# Select New Location
services.rightTreeDiv.wait_until_element_is_visible()
if moveTo is not None:
services.rightTreeDiv.click_tree_node(moveTo, delimiterTree)
self.moveBtn.click_visible_element()
# Move Services For Object
if viewServiceFilter is not None:
self.viewServiceFilterCbb.select_from_list_by_label(viewServiceFilter)
if selectObjects is not None:
listObject = selectObjects.split(",")
for selectobject in listObject:
returnRow = self.selectObjectTbl._get_table_row_map_with_header("Object", selectobject)
self.selectObjectTbl._click_table_cell(returnRow, 2)
if moveServiceFrom is not None:
services.leftTreeDiv.click_tree_node(moveServiceFrom, delimiterTree)
if moveServiceTo is not None:
services.rightTreeDiv.click_tree_node(moveServiceTo, delimiterTree)
self.moveBtn.click_visible_element()
driver.unselect_frame()
self.confirmDialogBtn.click_visible_element()
driver.select_frame(services.serviceIframe)
self.moveBtn.wait_until_element_attribute_contains("disabled", "true")
driver.unselect_frame()
self.dialogOkBtn.click_visible_element()
def create_port_fields_data(self,
connectionId=None,
serviceTicketId=None,
cordLength=None,
cordType=None,
cordColor=None,
portField1=None,
portField2=None,
portField3=None,
portField4=None,
portField5=None,
fieldLabel1=None,
fieldLabel2=None,
fieldLabel3=None,
fieldLabel4=None,
fieldLabel5=None):
driver.select_frame(self.uniqueIframe)
administration._wait_for_sub_page_display("Port Fields")
self._set_port_fields_checkbox("Connection ID", connectionId)
self._set_port_fields_checkbox("Service Ticket ID", serviceTicketId)
self._set_port_fields_checkbox("Cord Length", cordLength)
self._set_port_fields_checkbox("Cord Type", cordType)
self._set_port_fields_checkbox("Cord Color", cordColor)
portFieldList = ["Field 1", "Field 2", "Field 3", "Field 4", "Field 5"]
portFieldStatusList = [
portField1, portField2, portField3, portField4, portField5
]
portFieldLabelList = [
fieldLabel1, fieldLabel2, fieldLabel3, fieldLabel4, fieldLabel5
]
for i in range(len(portFieldList)):
self._set_port_fields_checkbox(portFieldList[i],
portFieldStatusList[i])
self._enter_field_label(portFieldList[i], portFieldLabelList[i])
self.saveBtn.click_visible_element()
driver.unselect_frame()
self.dialogOkBtn.click_visible_element()
self.dialogOkBtn.wait_until_element_is_not_visible()
def complete_work_order(self, woNames, delimiter=","):
self._select_iframe(workOrders.woQueueIframe, self.markCompleteBtn)
temp = 0
while temp < constants.SELENPY_DEFAULT_TIMEOUT:
if self.editBtn.is_element_inactive():
self.select_object_on_wo_queue_table(woNames, delimiter)
self.woQueueTbl.wait_for_element_outer_html_not_change()
else:
break
temp += 1
count = 0
while count < constants.SELENPY_DEFAULT_TIMEOUT:
if not self.dialogOkBtn.return_wait_for_element_visible_status():
self.markCompleteBtn.click_element()
driver.unselect_frame()
else:
break
count += 1
self.dialogOkBtn.click_visible_element()
driver.select_frame(workOrders.woQueueIframe)
self._wait_for_processing()
driver.unselect_frame()
def _check_icon_mpo_port_type_on_connections_window(
self,
frame,
treePanel,
fromDivTree,
toDivTree,
treeNode,
portType,
isExisted,
delimiter="/"):
self._does_frame_tree_node_exist(frame, treePanel, fromDivTree,
toDivTree, treeNode, delimiter)
nodeXpath = self._build_page_tree_node_xpath(treePanel, fromDivTree,
toDivTree, treeNode,
delimiter)
driver.select_frame(frame)
self.treePortTypeIcon.arguments = [nodeXpath, portType]
if isExisted:
SeleniumAssert.element_should_be_visible(self.treePortTypeIcon)
else:
SeleniumAssert.element_should_not_be_visible(self.treePortTypeIcon)
driver.unselect_frame()
def _check_mpo_connection_type_state(self,
frame,
mpoConnectionType,
isEnabled,
mpoConnectionTab=None):
''''mpoConnectionType': Options: Mpo12_Mpo12, Mpo12_4xLC, Mpo12_6xLC, Mpo24_Mpo24, Mpo24_12xLC, Mpo24_3xMpo12, Mpo24_2xMpo12, Mpo12_6xLC_EB'''
driver.select_frame(frame)
self._select_mpo_connection_tab(mpoConnectionTab)
if isEnabled:
self.dynamicConnectionType.arguments = [
mpoConnectionType, mpoConnectionType
]
elementEnabledExist = self.dynamicConnectionType.return_wait_for_element_visible_status(
3)
Assert.should_be_true(elementEnabledExist)
else:
self.dynamicDisabledConnectionType.arguments = [
mpoConnectionType, mpoConnectionType
]
elementDisabledExist = self.dynamicDisabledConnectionType.return_wait_for_element_visible_status(
3)
Assert.should_be_true(elementDisabledExist)
driver.unselect_frame()
def click_add_conduits_button(self):
driver.select_frame(self.conduitsFrame)
self.addConduitBtn.click_visible_element()
self.treeFromDiv.wait_until_element_is_visible()
driver.unselect_frame()
def close_add_conduits_window(self):
driver.select_frame(self.conduitsFrame)
self.addConduitsCancelBtn.click_visible_element()
driver.unselect_frame()
def create_patching(self,
patchFrom,
patchTo,
portsFrom,
portsTo,
typeConnect="Connect",
mpoTab=None,
mpoType=None,
mpoBranches=None,
delimiter=",",
delimiterTree="/",
createWo=True,
clickNext=True):
"""'type': Connect or Disconnect
... 'patchFrom': the source tree node (not containing the end point). Ex: Site/Building/Floor 01/Room 01/1:1 Rack 001/Switch 01
... 'patchTo': the destination tree node (not containing the end point). Ex: Site/Building/Floor 01/Room 01/1:1 Rack 001/Switch 01
... 'mpoTab': when patching for mpo port type(2 options: Mpo12, Mpo24)
... 'mpoType': Options: Mpo12_Mpo12, Mpo12_4xLC, Mpo12_6xLC, Mpo24_Mpo24, Mpo24_12xLC, Mpo24_3xMpo12, Mpo24_2xMpo12, Mpo12_6xLC_EB (*Mpo12-3xMpo12* and *Mpo12-2xMpo12*) => describe 3xMpo12-Mpo24, 2xMpo12-Mpo24
... 'mpoBranches': when patching for mpo port type(is depended on mpo_type). Ex: B1,B2,B3
... 'portsFrom': containing 1 or many end points. Ex: 02,03,04. Quantity of ports_to must be equal quantity of mpo_branches
... 'portsTo': containing 1 or many end points. Ex: 02,03,04. Quantity of ports_to must be equal quantity of mpo_branches
... 'delimiter': the delimiter for mpo_branches and ports_to, the default value is ,"""
listPortFrom = portsFrom.split(delimiter)
listPortTo = portsTo.split(delimiter)
numberPortFrom = len(listPortFrom)
numberPortTo = len(listPortTo)
driver.select_frame(self.patchingIframe)
self._wait_for_processing()
self.treeFromDiv.wait_until_element_is_visible()
self._wait_for_loading_tree()
if mpoBranches is None:
pathFrom = patchFrom + delimiterTree + portsFrom
self.treeFromDiv.click_tree_node(pathFrom, delimiterTree)
pathTo = patchTo + delimiterTree + portsTo
self.treeToDiv.click_tree_node(pathTo, delimiterTree)
connection._set_connection(typeConnect)
self._wait_for_processing()
else:
listMpoBranch = mpoBranches.split(delimiter)
temp = 0
for branch in listMpoBranch:
if numberPortFrom == 1:
pathFrom = patchFrom + delimiterTree + portsFrom
else:
pathFrom = patchFrom + delimiterTree + listPortFrom[temp]
self.treeFromDiv.click_tree_node(pathFrom, delimiterTree)
if temp == 0:
connection._select_mpo_connection_tab(mpoTab)
connection._select_mpo_connection_type(mpoType)
connection._select_mpo_branch(branch)
if numberPortTo == 1:
pathTo = patchTo + delimiterTree + portsTo
else:
pathTo = patchTo + delimiterTree + listPortTo[temp]
self.treeToDiv.click_tree_node(pathTo, delimiterTree)
connection._set_connection(typeConnect)
self._wait_for_processing()
temp += 1
connection.createWoChk.select_checkbox(createWo)
driver.unselect_frame()
if clickNext:
self.save_patching_window()
def _select_iframe(self, frame, waitElement):
frame.wait_until_page_contains_element()
driver.select_frame(frame)
waitElement.wait_until_page_contains_element()
