class PasswordStr():
def __init__(self, driver):
self.driver = driver
self.log = log()
self.PwdStr = PwdStrategy(self.driver)
self.cmf = commonFun(driver)
self.getElem = getElement(driver)
self.cnEnde = cnEncode()
self.dataFile = dataFileName()
self.frameElem = frameElement(self.driver)
self.commonsuite = CommonSuiteData(driver)
self.user = UserPage(self.driver)
self.session = sessionConfig(self.driver)
self.conStr = conversationStrategy(driver)
self.conuser = User(driver)
self.resource = Resource(driver)
self.account = Accountmgr(driver)
u'''提示框元素路径'''
def save_msg(self):
save_msg = "html/body/div[1]/div/table/tbody/tr[2]/td[2]/div/table/tbody/tr[2]/td[2]/div"
return save_msg
u'''获取测试数据
Parameters:
sheetname:sheet名称
return：表格数据
'''
def get_table_data(self, sheetname):
dataFile = dataFileName()
filePath = dataFile.get_password_stratrgy_test_data_url()
authFileData = dataFile.get_data(filePath, sheetname)
return authFileData
u'''切换至会话配置模块'''
def switch_to_session_module(self):
self.frameElem.switch_to_content()
self.frameElem.switch_to_top()
self.cmf.select_menu(u"策略配置")
self.cmf.select_menu(u"策略配置", u"会话配置")
u'''切换至资源模块'''
def switch_to_resource_module(self):
self.frameElem.switch_to_content()
self.frameElem.switch_to_top()
self.cmf.select_menu(u"运维管理")
self.cmf.select_menu(u"运维管理", u"资源")
u'''切换至密码策略'''
def switch_to_pwdStr_module(self):
self.frameElem.switch_to_content()
self.frameElem.switch_to_top()
self.cmf.select_menu(u"策略配置")
self.cmf.select_menu(u"策略配置", u"密码策略")
#添加策略
def add_strategy_001(self):
#日志开始记录
self.log.log_start("pwdStrategy")
#获取数据
strategy_data = self.get_table_data("add_strategy")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strategy_data)):
data = strategy_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.add_pwd_button()
self.PwdStr.set_pwd_name(data[2])
self.PwdStr.term_of_validity(data[3])
self.PwdStr.password_length_min(data[4])
self.PwdStr.password_length_max(data[5])
self.PwdStr.set_lower_case(data[6])
self.PwdStr.set_capital(data[7])
self.PwdStr.set_minimum_digital(data[8])
self.PwdStr.set_Minimum_symbol(data[9])
self.PwdStr.set_prohibition_of_using_keywords(data[10])
self.PwdStr.add_using_keywords_button()
self.PwdStr.save_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
self.PwdStr.return_button()
except Exception as e:
print("Policy adding error: ") + str(e)
self.log.log_end("pwdStrategy")
#编辑策略test
def edit_strategy_002(self):
#日志开始记录
self.log.log_start("editPwdStrategy")
#获取数据
strategy_data = self.get_table_data("edit_strategy")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strategy_data)):
data = strategy_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.edit(data[2])
self.PwdStr.set_pwd_name(data[3])
self.PwdStr.term_of_validity(data[4])
self.PwdStr.password_length_min(data[5])
self.PwdStr.password_length_max(data[6])
self.PwdStr.set_lower_case(data[7])
self.PwdStr.set_capital(data[8])
self.PwdStr.set_minimum_digital(data[9])
self.PwdStr.set_Minimum_symbol(data[10])
self.PwdStr.set_prohibition_of_using_keywords(data[11])
self.PwdStr.add_using_keywords_button()
self.PwdStr.save_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
self.PwdStr.return_button()
except Exception as e:
print("Policy edit error: ") + str(e)
self.log.log_end("editPwdStrategy")
#策略校验
def check_strategy_003(self):
#日志开始记录
self.log.log_start("checkPwdStrategy")
#获取数据
strategy_data = self.get_table_data("check_strategy")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strategy_data)):
data = strategy_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.add_pwd_button()
self.PwdStr.set_pwd_name(data[2])
self.PwdStr.term_of_validity(data[3])
self.PwdStr.password_length_min(data[4])
self.PwdStr.password_length_max(data[5])
self.PwdStr.set_lower_case(data[6])
self.PwdStr.set_capital(data[7])
self.PwdStr.set_minimum_digital(data[8])
self.PwdStr.set_Minimum_symbol(data[9])
self.PwdStr.set_prohibition_of_using_keywords(data[10])
self.PwdStr.add_using_keywords_button()
self.PwdStr.save_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
self.PwdStr.return_button()
except Exception as e:
print("Policy checkout error: ") + str(e)
self.log.log_end("checkeditPwdStrategy")
#检索名称test
def search_strategy_004(self):
#日志开始记录
self.log.log_start("searchPwdStrategy")
#获取数据
strategy_data = self.get_table_data("search_strategy")
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strategy_data)):
data = strategy_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.PwdStr.search_name(data[2])
self.PwdStr.click_search_button()
self.PwdStr.click_reset_button()
self.PwdStr.click_search_button()
#清空标识状态
flag = False
self.log.log_detail(data[0], True)
except Exception as e:
print("Policy search error: ") + str(e)
self.log.log_end("searchPwdStrategy")
#删除单个策略
def del_sing_policy_005(self):
#日志开始记录
self.log.log_start("delPwdStrategy")
#获取数据
strategy_data = self.get_table_data("del_strategy")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strategy_data)):
data = strategy_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.del_sing_strategy(data[2])
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
#校验删除后的名称是否存在
if self.cmf.is_namevalue_exsit(data[2],
"fortStrategyPasswordName"):
print("Delete success")
except Exception as e:
print("Policy del error: ") + str(e)
self.log.log_end("delPwdStrategy")
#与密码策略关联的会话配置
def session_association_007(self):
#日志开始记录
self.log.log_start("sessionAssociation")
#获取数据
strate_data = self.get_table_data("configure_strateg")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strate_data)):
data = strate_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.switch_to_session_module()
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.set_pwd_strategy(data[4])
self.session.add_session(data[2])
self.session.add_locking_time(data[3])
self.session.save_global_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
except Exception as e:
print("session association error: ") + str(e)
self.log.log_end("sessionAssociation")
#与密码策略关联的用户
def user_association_008(self):
#日志开始记录
self.log.log_start("userAssociation")
#获取数据
strate_data = self.get_table_data("user_association")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strate_data)):
data = strate_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.conuser.switch_to_user_module()
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.user_edit(data[2])
self.PwdStr.set_pwd(data[9])
self.PwdStr.set_pwd_agin(data[10])
self.user.save_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
self.user.click_back_button()
except Exception as e:
print("user association error: ") + str(e)
self.log.log_end("userAssociation")
#为Windows资源添加密码策略
def resource_association_009(self):
#日志开始记录
self.log.log_start("resourAcessociation")
#获取数据
strate_data = self.get_table_data("resource_association")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strate_data)):
data = strate_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.commonsuite.sys_switch_to_dep()
self.switch_to_resource_module()
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.resource_edit(data[2])
self.PwdStr.set_resource_strategy(data[8])
self.resource.click_save_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
self.PwdStr.return_button()
except Exception as e:
print("resour acessociation error: ") + str(e)
self.log.log_end("resourAcessociation")
#为Windows资源账号添加密码策略
def resource_account_association_010(self):
#日志开始记录
self.log.log_start("resourAceccountAssociation")
#获取数据
strate_data = self.get_table_data("resource_account_association")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strate_data)):
data = strate_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.PwdStr.account_manage(data[2])
self.account.click_account_add()
self.PwdStr.set_resource_account_name(data[3])
self.PwdStr.set_resource_account_pwd(data[4])
self.PwdStr.set_resource_account_pwdagin(data[5])
self.PwdStr.save_account()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
#点击资源账号编辑页面返回
self.PwdStr.return_button()
#点击资源账号页面返回
self.PwdStr.return_button()
except Exception as e:
print("resour aceccount association error: ") + str(e)
self.log.log_end("resourAceccountAssociation")
#删除全部策略
def del_all_policy_006(self):
#日志开始记录
self.log.log_start("delAllPwdStrategy")
#获取数据
strategy_data = self.get_table_data("del_all_strategy")
#保存弹框
saveMsg = self.save_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(strategy_data)):
data = strategy_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.commonsuite.dep_switch_to_sys()
self.switch_to_pwdStr_module()
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.select_all_button()
self.PwdStr.del_button()
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
self.cmf.test_win_check_point("xpath", saveMsg, data, flag)
#校验删除后的名称是否存在
if self.cmf.is_namevalue_exsit(data[2],
"fortStrategyPasswordName"):
print("Delete all success")
except Exception as e:
print("Policy delAll error: ") + str(e)
self.log.log_end("delAllPwdStrategy")
#if __name__ == "__main__":
# browser = setDriver().set_local_driver()
# commonSuite = CommonSuiteData(browser)
# pwdCase = PasswordStr(browser)
# commonSuite.pwdstr_module_prefix_condition()
# pwdCase.add_strategy_001()
# pwdCase.edit_strategy_002()
# pwdCase.check_strategy_003()
# pwdCase.search_strategy_004()
# pwdCase.del_sing_policy_005()
# pwdCase.session_association_007()
# pwdCase.user_association_008()
# pwdCase.resource_association_009()
# pwdCase.resource_account_association_010()
# pwdCase.del_all_policy_006()
# commonSuite.pwdstr_module_post_condition()
class testAccapproval(object):
def __init__(self, driver):
self.driver = driver
self.log = log()
self.data = dataFileName()
self.cmf = commonFun(driver)
self.acproval = Accapproval(driver)
self.comsuit = CommonSuiteData(self.driver)
self.loginElem = loginPage(self.driver)
self.authElem = AuthorizationPage(self.driver)
self.flow = Flowcontrol(self.driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_accapproval_data(self, sheetname):
dataFile = dataFileName()
acpPath = dataFile.get_accapproval_test_data_url()
acpData = dataFile.get_data(acpPath, sheetname)
return acpData
u'''添加访问审批'''
def add_access_approvel_001(self):
#日志开始记录
self.log.log_start("add_access_approvel")
#获取访问审批的数据
acpData = self.get_accapproval_data("add_access_approvel")
for dataRow in range(len(acpData)):
data = acpData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
if dataRow == 1:
self.acproval.click_access_approval_button(data[2])
#设置开关状态
self.authElem.set_switch_on()
self.authElem.click_add_approval_level()
self.authElem.click_add_approval(data[3])
#添加审批人
self.authElem.set_select_user_search_button()
self.acproval.check_user(data[4])
self.authElem.set_ok_button()
#设置审批级别中的通过审批人个数
self.acproval.select_approval_num(data[3], data[5])
except Exception as e:
print ("add_access_approvell fail: ") + str(e)
self.log.log_detail(u"添加访问审批成功", True)
#点击保存
self.authElem.approval_save_button()
self.cmf.click_login_msg_button()
#点击返回
self.authElem.approval_back_button()
self.log.log_end("add_access_approvel")
u'''访问审批通过流程控制拒绝审批'''
def access_deny_approvel_002(self):
self.cmf.select_role_by_text(u"运维操作员")
#日志开始记录
self.log.log_start("access_deny_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("access_approvel_sso")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("deny_approvel")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_access_approval_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print ("access_deny_approvel fail: ") + str(e)
self.log.log_end("access_deny_approvel")
u'''访问审批通过流程控制同意审批'''
def access_agree_approvel_003(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("access_agree_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("access_approvel_sso")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("agree_approvel")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_access_approval_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print ("access_agree_approvel fail: ") + str(e)
self.log.log_end("access_agree_approvel")
u'''紧急运维通过流程控制拒绝审批'''
def urgent_deny_approvel_004(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("urgent_deny_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("urgent_approvel")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("deny_approvel")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_urgent_operation_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print ("urgent_deny_approvel fail: ") + str(e)
self.log.log_end("urgent_deny_approvel")
u'''紧急运维通过流程控制同意审批'''
def urgent_agree_approvel_005(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("urgent_agree_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("urgent_approvel")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("agree_urgent")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_urgent_operation_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print ("urgent_agree_approvel fail: ") + str(e)
self.log.log_end("urgent_agree_approvel")
u'''访问审批流程任务查询'''
def access_query_process_task_006(self):
#日志开始记录
self.log.log_start("access_query_process_task")
#获取流程任务查询的数据
taskData = self.get_accapproval_data("process_task")
for dataRow in range(len(taskData)):
data = taskData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
if dataRow == 1:
self.acproval.user_login(data[1])
self.flow.query_process_task(data)
self.log.log_detail(data[0], True)
except Exception as e:
print ("access_query_process_task fail: ") + str(e)
self.log.log_end("access_query_process_task")
u'''访问审批个人历史查询'''
def access_query_personal_history_007(self):
#日志开始记录
self.log.log_start("access_query_personal_history")
#获取个人历史查询的数据
perData = self.get_accapproval_data("personal_history")
for dataRow in range(len(perData)):
data = perData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_personal_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print ("access_query_personal_history fail: ") + str(e)
self.loginElem.quit()
self.log.log_end("access_query_personal_history")
u'''访问审批申请历史查询'''
def access_query_apply_history_008(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("access_query_apply_history")
#获取申请历史查询的数据
applyData = self.get_accapproval_data("apply_history")
for dataRow in range(len(applyData)):
data = applyData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_apply_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print ("access_query_apply_history fail: ") + str(e)
self.log.log_end("access_query_apply_history")
u'''访问审批全部历史查询'''
def access_query_all_history_009(self):
self.comsuit.dep_switch_to_sys()
#日志开始记录
self.log.log_start("access_query_all_history")
#获取全部历史查询的数据
allData = self.get_accapproval_data("all_history")
for dataRow in range(len(allData)):
data = allData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_all_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print ("access_query_all_history fail: ") + str(e)
self.log.log_end("access_query_all_history")
u'''访问审批部门历史查询'''
def access_query_department_history_010(self):
self.comsuit.sys_switch_to_dep()
#日志开始记录
self.log.log_start("access_query_department_history")
#获取流程任务查询的数据
deprtData = self.get_accapproval_data("department_history")
for dataRow in range(len(deprtData)):
data = deprtData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_department_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print ("access_query_department_history fail: ") + str(e)
self.log.log_end("access_query_department_history")
class testDobapproval(object):
def __init__(self, driver):
self.driver = driver
self.log = log()
self.data = dataFileName()
self.cmf = commonFun(driver)
self.double = Dobapproval(driver)
self.comsuit = CommonSuiteData(self.driver)
self.loginElem = loginPage(self.driver)
self.authElem = AuthorizationPage(self.driver)
self.acproval = Accapproval(driver)
self.flow = Flowcontrol(self.driver)
self.frameElem = frameElement(self.driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_double_data(self, sheetname):
dataFile = dataFileName()
dobPath = dataFile.get_double_license_test_data_url()
dobData = dataFile.get_data(dobPath, sheetname)
return dobData
u'''添加双人授权'''
def add_double_license_001(self):
#日志开始记录
self.log.log_start("add_double_license")
#获取双人授权的数据
dobData = self.get_double_data("add_double_license")
for dataRow in range(len(dobData)):
data = dobData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.double.click_double_license_button(data[1])
self.authElem.click_all_approver()
self.authElem.click_all_candidate()
self.authElem.click_start_association()
self.authElem.click_create_relate()
self.cmf.click_login_msg_button()
#点击返回
self.authElem.click_child_page_back_button()
self.log.log_detail(u"添加双人授权成功", True)
except Exception as e:
print("add_double_license fail: ") + str(e)
self.log.log_end("add_double_license")
u'''双人审批同终端审批'''
def same_termina_approvel_002(self):
self.cmf.select_role_by_text(u"运维操作员")
#日志开始记录
self.log.log_start("same_termina_approvel")
#获取双人审批申请的数据
dobData = self.get_double_data("double_license_sso")
for dataRow in range(len(dobData)):
data = dobData[dataRow]
try:
#如果是第1行,读取数据
if dataRow == 1:
self.double.send_double_license_applicant(data)
self.double.check_ico_len(data[1])
self.loginElem.quit()
except Exception as e:
print("same_termina_approvel fail: ") + str(e)
self.log.log_end("same_termina_approvel")
u'''双人审批申请人已下线审批过期'''
def termina_expired_approvel_003(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("Expired_approvel")
#获取双人审批申请的数据
dobData = self.get_double_data("double_license_sso")
expData = self.get_double_data("termina_approvel")
for dataRow in range(len(dobData)):
data = dobData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow == 2:
self.double.send_double_license_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.double.approver_by_process_approval(expData, number)
except Exception as e:
print("Expired_approvel fail: ") + str(e)
self.log.log_end("Expired_approvel")
u'''双人审批审批人拒绝申请'''
def termina_deny_approvel_004(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("deny_double_approvel")
#获取双人审批申请的数据
dobData = self.get_double_data("double_license_sso")
expData = self.get_double_data("deny_approvel")
for dataRow in range(len(dobData)):
data = dobData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow == 2:
self.double.send_double_license_applicant(data)
number = self.acproval.get_new_process_number()
self.double.approver_remote_approval(expData, number)
self.cmf.select_menu(u"运维操作", u"SSO")
self.double.check_ico_len(data[1])
self.loginElem.quit()
except Exception as e:
print("deny_double_approvel fail: ") + str(e)
self.log.log_end("deny_double_approvel")
u'''双人审批审批人同意申请'''
def termina_agree_approvel_005(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("agree_double_approvel")
#获取双人审批申请的数据
dobData = self.get_double_data("double_license_sso")
expData = self.get_double_data("agree_approvel")
for dataRow in range(len(dobData)):
data = dobData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow == 2:
self.double.send_double_license_applicant(data)
number = self.acproval.get_new_process_number()
self.double.approver_remote_approval(expData, number)
self.cmf.select_menu(u"运维操作", u"SSO")
self.double.check_ico_len(data[1])
self.loginElem.quit()
except Exception as e:
print("agree_double_approvel fail: ") + str(e)
self.log.log_end("agree_double_approvel")
u'''访问审批流程任务查询'''
def double_query_process_task_006(self):
#日志开始记录
self.log.log_start("double_query_process_task")
#获取流程任务查询的数据
taskData = self.get_double_data("process_task")
for dataRow in range(len(taskData)):
data = taskData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
if dataRow == 1:
self.acproval.user_login(data[1])
self.flow.query_process_task(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("double_query_process_task fail: ") + str(e)
self.log.log_end("double_query_process_task")
u'''访问审批个人历史查询'''
def double_query_personal_history_007(self):
#日志开始记录
self.log.log_start("double_query_personal_history")
#获取个人历史查询的数据
perData = self.get_double_data("personal_history")
for dataRow in range(len(perData)):
data = perData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_personal_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("double_query_personal_history fail: ") + str(e)
self.loginElem.quit()
self.log.log_end("double_query_personal_history")
u'''访问审批申请历史查询'''
def double_query_apply_history_008(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("double_query_apply_history")
#获取申请历史查询的数据
applyData = self.get_double_data("apply_history")
for dataRow in range(len(applyData)):
data = applyData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_apply_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("double_query_apply_history fail: ") + str(e)
self.log.log_end("double_query_apply_history")
u'''访问审批全部历史查询'''
def double_query_all_history_009(self):
self.comsuit.dep_switch_to_sys()
#日志开始记录
self.log.log_start("double_query_all_history")
#获取全部历史查询的数据
allData = self.get_double_data("all_history")
for dataRow in range(len(allData)):
data = allData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_all_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("double_query_all_history fail: ") + str(e)
self.log.log_end("double_query_all_history")
u'''访问审批部门历史查询'''
def double_query_department_history_010(self):
self.comsuit.sys_switch_to_dep()
#日志开始记录
self.log.log_start("double_query_department_history")
#获取流程任务查询的数据
deprtData = self.get_double_data("department_history")
for dataRow in range(len(deprtData)):
data = deprtData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_department_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("double_query_department_history fail: ") + str(e)
self.log.log_end("double_query_department_history")
class testAccapproval(object):
def __init__(self, driver):
self.driver = driver
self.log = log()
self.data = dataFileName()
self.cmf = commonFun(driver)
self.acproval = Accapproval(driver)
self.comsuit = CommonSuiteData(self.driver)
self.loginElem = loginPage(self.driver)
self.authElem = AuthorizationPage(self.driver)
self.flow = Flowcontrol(self.driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_accapproval_data(self, sheetname):
dataFile = dataFileName()
acpPath = dataFile.get_accapproval_test_data_url()
acpData = dataFile.get_data(acpPath, sheetname)
return acpData
u'''添加访问审批'''
def add_access_approvel_001(self):
#日志开始记录
self.log.log_start("add_access_approvel")
#获取访问审批的数据
acpData = self.get_accapproval_data("add_access_approvel")
for dataRow in range(len(acpData)):
data = acpData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
if dataRow == 1:
self.acproval.click_access_approval_button(data[2])
#设置开关状态
self.authElem.set_switch_on()
self.authElem.click_add_approval_level()
self.authElem.click_add_approval(data[3])
#添加审批人
self.authElem.set_select_user_search_button()
self.acproval.check_user(data[4])
self.authElem.set_ok_button()
#设置审批级别中的通过审批人个数
self.acproval.select_approval_num(data[3], data[5])
except Exception as e:
print("add_access_approvell fail: ") + str(e)
self.log.log_detail(u"添加访问审批成功", True)
#点击保存
self.authElem.approval_save_button()
self.cmf.click_login_msg_button()
#点击返回
self.authElem.approval_back_button()
self.log.log_end("add_access_approvel")
u'''访问审批通过流程控制拒绝审批'''
def access_deny_approvel_002(self):
self.cmf.select_role_by_text(u"运维操作员")
#日志开始记录
self.log.log_start("access_deny_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("access_approvel_sso")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("deny_approvel")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_access_approval_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print("access_deny_approvel fail: ") + str(e)
self.log.log_end("access_deny_approvel")
u'''访问审批通过流程控制同意审批'''
def access_agree_approvel_003(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("access_agree_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("access_approvel_sso")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("agree_approvel")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_access_approval_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print("access_agree_approvel fail: ") + str(e)
self.log.log_end("access_agree_approvel")
u'''紧急运维通过流程控制拒绝审批'''
def urgent_deny_approvel_004(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("urgent_deny_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("urgent_approvel")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("deny_approvel")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_urgent_operation_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print("urgent_deny_approvel fail: ") + str(e)
self.log.log_end("urgent_deny_approvel")
u'''紧急运维通过流程控制同意审批'''
def urgent_agree_approvel_005(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("urgent_agree_approvel")
#获取访问审批申请的数据
appData = self.get_accapproval_data("urgent_approvel")
#获取访问审批审批的数据
acpData = self.get_accapproval_data("agree_urgent")
for dataRow in range(len(appData)):
data = appData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.acproval.send_urgent_operation_applicant(data)
number = self.acproval.get_new_process_number()
self.loginElem.quit()
self.acproval.approval_by_approver(acpData, number)
except Exception as e:
print("urgent_agree_approvel fail: ") + str(e)
self.log.log_end("urgent_agree_approvel")
u'''访问审批流程任务查询'''
def access_query_process_task_006(self):
#日志开始记录
self.log.log_start("access_query_process_task")
#获取流程任务查询的数据
taskData = self.get_accapproval_data("process_task")
for dataRow in range(len(taskData)):
data = taskData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
if dataRow == 1:
self.acproval.user_login(data[1])
self.flow.query_process_task(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("access_query_process_task fail: ") + str(e)
self.log.log_end("access_query_process_task")
u'''访问审批个人历史查询'''
def access_query_personal_history_007(self):
#日志开始记录
self.log.log_start("access_query_personal_history")
#获取个人历史查询的数据
perData = self.get_accapproval_data("personal_history")
for dataRow in range(len(perData)):
data = perData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_personal_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("access_query_personal_history fail: ") + str(e)
self.loginElem.quit()
self.log.log_end("access_query_personal_history")
u'''访问审批申请历史查询'''
def access_query_apply_history_008(self):
self.comsuit.use_new_user_login()
#日志开始记录
self.log.log_start("access_query_apply_history")
#获取申请历史查询的数据
applyData = self.get_accapproval_data("apply_history")
for dataRow in range(len(applyData)):
data = applyData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_apply_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("access_query_apply_history fail: ") + str(e)
self.log.log_end("access_query_apply_history")
u'''访问审批全部历史查询'''
def access_query_all_history_009(self):
self.comsuit.dep_switch_to_sys()
#日志开始记录
self.log.log_start("access_query_all_history")
#获取全部历史查询的数据
allData = self.get_accapproval_data("all_history")
for dataRow in range(len(allData)):
data = allData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_all_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("access_query_all_history fail: ") + str(e)
self.log.log_end("access_query_all_history")
u'''访问审批部门历史查询'''
def access_query_department_history_010(self):
self.comsuit.sys_switch_to_dep()
#日志开始记录
self.log.log_start("access_query_department_history")
#获取流程任务查询的数据
deprtData = self.get_accapproval_data("department_history")
for dataRow in range(len(deprtData)):
data = deprtData[dataRow]
try:
#如果不是第1行,读取数据
if dataRow != 0:
self.flow.query_department_history(data)
self.log.log_detail(data[0], True)
except Exception as e:
print("access_query_department_history fail: ") + str(e)
self.log.log_end("access_query_department_history")
