class testComRuleSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.comm = testCommand(self.browser) #命令规则前置条件 self.comsuit.commandrule_module_prefix_condition() def test_command_rule(self): #添加命令规则 self.comm.add_command_rule_001() #编辑命令规则 self.comm.mod_command_rule_002() #操作命令规则 self.comm.option_command_rule_003() #校验命令规则 self.comm.check_command_rule_004() #命令审批 # self.comm.command_approval_005() #删除命令规则 self.comm.del_command_rule_006() def tearDown(self): #命令规则后置条件 self.comsuit.commandrule_module_post_condition() initDriver().close_driver(self.browser)
class testRetimeRuleSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.retime = testRetime(self.browser) #资源时间规则前置条件 self.comsuit.retimerule_module_prefix_condition() def test_retime_rule(self): #添加资源时间规则 self.retime.add_retime_rule_001() #编辑资源时间规则 self.retime.mod_retime_rule_002() #资源时间规则结果验证 self.retime.add_retime_rule_result_003() #操作资源时间规则 self.retime.option_retime_rule_004() #校验资源时间规则 self.retime.check_retime_rule_005() #删除资源时间规则 self.retime.del_retime_rule_006() def tearDown(self): #资源时间规则后置条件 self.comsuit.retimerule_module_post_condition() initDriver().close_driver(self.browser)
class testAdSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.adMethod = testAdEx(self.browser)
#AD域前置条件
self.commonSuite.ad_module_prefix_condition()
def test_client_method(self):
#发现AD域账号
self.adMethod.ad_extract_001()
#移动AD域账号
self.adMethod.ad_discover_002()
#移动AD域账号校验
self.adMethod.move_user_check_003()
#移动AD域账号密码校验
self.adMethod.ad_pwd_checkout_004()
#设置定时
self.adMethod.cycle_005()
#清空历史记录
self.adMethod.clear_history_006()
def tearDown(self):
#AD域后置条件
self.commonSuite.ad_module_post_condition()
initDriver().close_driver(self.browser)
class testSessionConfigSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.sessionCase = conversationStrategy(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.session_module_prefix_condition()
def test_session(self):
#添加访问失败次数和失败锁定时间
self.sessionCase.add_session_config_001()
#校验访问失败次数和失败锁定时间
self.sessionCase.check_session_config_002()
#单用户登录方式和web超时时间添加
self.sessionCase.sing_user_login_and_session_003()
#单用户登录方式校验
self.sessionCase.check_sing_user_login_004()
def tearDown(self):
#后置条件
self.commonSuite.session_module_post_condition()
#关闭浏览器
self.initDriver.close_driver(self.browser)
class testAppSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.appMethod = testApp(self.browser)
#应用发布前置条件
self.commonSuite.application_module_prefix_condition()
def test_app_method(self):
#添加应用发布
self.appMethod.add_app_001()
#编辑应用发布
self.appMethod.edit_app_002()
#校验应用发布
self.appMethod.check_app_003()
#检索应用发布
self.appMethod.query_app_004()
#添加账号
self.appMethod.add_account_006()
#修改账号
self.appMethod.edit_account_007()
#删除账号
self.appMethod.del_account_008()
#删除应用发布
self.appMethod.del_app_005()
def tearDown(self):
#应用发布后置条件
self.commonSuite.application_module_post_condition()
initDriver().close_driver(self.browser)
class testDepartSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.testdptment = testDepartment(self.browser) #部门前置条件 self.comsuit.depart_module_prefix_condition() def test_department(self): u'''添加和编辑部门''' self.testdptment.add_edit_department_001() u'''上移和下移部门''' self.testdptment.up_down_department_002() u'''上移和下移部门校验''' self.testdptment.up_down_department_check_003() u'''检验添加和编辑部门''' self.testdptment.check_add_edit_department_004() u'''删除部门''' self.testdptment.del_department_005() def tearDown(self): self.comsuit.user_quit() initDriver().close_driver(self.browser)
class TestAlarmSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.alarmCase = AlarmConfig(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.alarm_strategy_module_prefix_condition()
def test_alarm(self):
#为用户添加邮箱
self.alarmCase.mod_user_mail_008()
#配置高危运维
self.alarmCase.command_alarm_level_config_001()
#运行状态告警校验
self.alarmCase.default_alarm_level_checkout_003()
#配置运行状态告警
self.alarmCase.default_alarm_level_config_002()
#配置认证失败告警
self.alarmCase.auth_alarm_level_config_004()
#告警归纳类型检索
self.alarmCase.search_by_type_005()
#告警归纳级别检索
self.alarmCase.search_by_level_006()
def tearDown(self):
#后置条件
self.commonSuite.alarm_strategy_module_post_condition()
#关闭浏览器
self.initDriver.close_driver(self.browser)
class testAdreRuleSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.adrerule = testAddress(self.browser) #地址规则前置条件 self.comsuit.addressrule_module_prefix_condition() def test_address_rule(self): #添加地址规则 self.adrerule.add_address_rule_001() #添加地址规则结果 self.adrerule.add_address_rule_result_002() #编辑地址规则 self.adrerule.mod_address_rule_003() #校验地址规则 self.adrerule.check_address_rule_004() #检索地址规则 self.adrerule.query_address_rule_005() #删除地址规则 self.adrerule.del_address_rule_006() def tearDown(self): #时间规则后置条件 self.comsuit.addressrule_module_post_condition() initDriver().close_driver(self.browser)
class UseAuthSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.useAuthCase = UseAuthorization(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.use_auth_module_prefix_condition()
def test_use_auth(self):
#填写产品信息
self.useAuthCase.add_product_information_001()
#上传logo
self.useAuthCase.upload_logo_upgrade_002()
#产品信息校验
self.useAuthCase.check_product_information_003()
#logo包校验
self.useAuthCase.check_logo_upgrade_004()
#上传授权码
self.useAuthCase.add_product_information_005()
#上传授权码校验
self.useAuthCase.check_updata_auth_006()
def tearDown(self):
self.commonSuite.use_auth_module_post_condition()
self.initDriver.close_driver(self.browser)
class testTimeRuleSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.timerule = testTime(self.browser) #时间规则前置条件 self.comsuit.timerule_module_prefix_condition() def test_time_rule(self): #添加时间规则 self.timerule.add_time_rule_001() #添加时间规则结果 self.timerule.add_time_rule_result_002() #编辑时间规则 self.timerule.mod_time_rule_003() #校验时间规则 self.timerule.check_time_rule_004() #检索时间规则 self.timerule.query_time_rule_005() #删除时间规则 self.timerule.del_time_rule_006() def tearDown(self): #时间规则后置条件 self.comsuit.timerule_module_post_condition() initDriver().close_driver(self.browser)
class testAuthMethodSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.authMethod = testAuthMethod(self.browser)
#认证方式前置条件
self.commonSuite.auth_method_prefix_condition()
def test_auth_method(self):
#添加AD域认证方式
self.authMethod.add_ad_method_001()
#添加radius认证方式
self.authMethod.add_radius_method_002()
#添加AD域+口令认证方式
self.authMethod.add_ad_and_pwd_method_003()
#添加RADIUS+口令认证方式
self.authMethod.add_radius_and_pwd_method_004()
#添加数字证书认证方式
self.authMethod.add_cert_method_005()
#校验认证方式是否添加成功
self.authMethod.auth_method_add_is_success_006()
#修改AD域认证方式
self.authMethod.mod_ad_method_007()
#AD域认证方式校验
self.authMethod.ad_method_checkout_008()
#radius认证方式校验
self.authMethod.radius_checkout_009()
#删除多种认证方式
self.authMethod.del_auth_method_010()
def tearDown(self):
#认证方式后置条件
self.commonSuite.auth_method_post_condition()
initDriver().close_driver(self.browser)
class testPasswdEnvelopeSuit(unittest.TestCase):
def setUp(self):
self.browser = setDriver().set_driver()
self.comsuit = CommonSuiteData(self.browser)
self.testenvelope = testEnvelope(self.browser)
#前置条件
self.comsuit.passwd_envelope_module_prefix_condition()
def test_passwd_envelope(self):
#配置密码信封
self.testenvelope.add_passwd_envelope_001()
#浏览、上传图片
self.testenvelope.upload_passwd_envelope_002()
#同步图片
self.testenvelope.passwd_envelope_image_sync_003()
#编辑密码信封
self.testenvelope.mode_passwd_envelope_004()
#检验密码信封
self.testenvelope.check_passwd_envelope_005()
#后置条件
def tearDown(self):
self.comsuit.passwd_envelope_module_post_condition()
initDriver().close_driver(self.browser)
class testDatabaseResourceSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.linuxresource = testLinuxResource(self.browser) self.database = testDatabaseResource(self.browser) self.account = testResourceAccount(self.browser) #添加数据库前置条件 self.comsuit.database_resource_prefix_condition() # self.comsuit.login_and_switch_to_dep() # self.comsuit.switch_to_moudle(u"运维管理", u"资源") def test_database_resource(self): #------------------------------windows资源----------------------------------- # 添加database资源 self.database.add_database_resource_001() # 编辑database资源 self.database.edit_database_resource_002() # 校验database资源 self.database.check_database_resource_003() # 添加和编辑mysql资源账号 self.account.add_edit_resource_account_001(_testDataPath.DATABASE_TEST_DATA_URL, "add_mysql_account") # 添加和编辑oracle资源账号 self.account.add_edit_resource_account_001(_testDataPath.DATABASE_TEST_DATA_URL, "add_oracle_account") # 添加和编辑bs资源账号 self.account.add_edit_resource_account_001(_testDataPath.DATABASE_TEST_DATA_URL, "add_bs_account") # 添加和编辑sql资源账号 self.account.add_edit_resource_account_001(_testDataPath.DATABASE_TEST_DATA_URL, "add_sql_account") #删除mysql资源账号 self.account.del_resource_account_004(_testDataPath.DATABASE_TEST_DATA_URL, "del_mysql_account") #查询database资源 self.linuxresource.query_resource_004(_testDataPath.DATABASE_TEST_DATA_URL, "query_database_resource") #删除mysql资源 self.linuxresource.del_resource_005(_testDataPath.DATABASE_TEST_DATA_URL, "del_mysql_resource") # #删除db2资源 # self.linuxresource.del_resource_005(_testDataPath.DATABASE_TEST_DATA_URL, "del_db2_resorce") #全选删除资源 #self.linuxresource.bulkdel_resource_006() def tearDown(self): #数据库后置条件 self.comsuit.database_resource_post_condition() initDriver().close_driver(self.browser)
def setUp(self):
self.browser = setDriver().set_driver()
self.comsuit = CommonSuiteData(self.browser)
self.testenvelope = testEnvelope(self.browser)
#前置条件
self.comsuit.passwd_envelope_module_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.authMethod = testAuthMethod(self.browser)
#认证方式前置条件
self.commonSuite.auth_method_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.systemLog = testSystemLog(self.browser)
#配置审计前置条件
self.commonSuite.system_log_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.reportMethod = testConfReport(self.browser)
#配置报表前置条件
self.commonSuite.conf_report_module_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.adMethod = testAdEx(self.browser)
#AD域前置条件
self.commonSuite.ad_module_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.appMethod = testApp(self.browser)
#应用发布前置条件
self.commonSuite.application_module_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.auditLog = testAuditLog(self.browser)
#运维审计检索前置条件
self.commonSuite.audit_log_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.pwdstr = PasswordStr(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.pwdstr_module_prefix_condition()
class testAuditLogSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.auditLog = testAuditLog(self.browser)
#运维审计检索前置条件
self.commonSuite.audit_log_prefix_condition()
def test_audit_log_query(self):
#运维审计检索
self.auditLog.Audit_log_query_001()
def tearDown(self):
#运维审计后置条件
self.commonSuite.audit_log_post_condition()
initDriver().close_driver(self.browser)
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.alarmCase = AlarmConfig(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.alarm_strategy_module_prefix_condition()
class testSystemLogSuite(unittest.TestCase):
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.systemLog = testSystemLog(self.browser)
#配置审计前置条件
self.commonSuite.system_log_prefix_condition()
def test_system_log_query(self):
#配置审计检索
self.systemLog.system_log_query_001()
def tearDown(self):
#配置审计后置条件
self.commonSuite.system_log_post_condition()
initDriver().close_driver(self.browser)
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.userElem = UserPage(self.browser)
self.commonSuite.login_module_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.ssoMethod = testSso(self.browser)
#self.commonSuite.login_and_switch_to_common()
#单点登录前置条件
self.commonSuite.windows_sso_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.rout = RoutingConfiguration(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.routing_module_prefix_condition()
def setUp(self):
#定义驱动
self.browser = setDriver().set_driver()
self.commonSuite = CommonSuiteData(self.browser)
self.sys = SyslogService(self.browser)
self.initDriver = initDriver()
#前置条件
self.commonSuite.syslog_module_prefix_condition()
def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.comm = testCommand(self.browser) #命令规则前置条件 self.comsuit.commandrule_module_prefix_condition()
def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.timerule = testTime(self.browser) #时间规则前置条件 self.comsuit.timerule_module_prefix_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 testRetime(object):
def __init__(self, driver):
self.driver = driver
self.log = log()
self.cmf = commonFun(driver)
self.frameElem = frameElement(driver)
self.testrole = testRole(driver)
self.command = CommandRule(driver)
self.comsuit = CommonSuiteData(driver)
self.timerule = TimeRule(driver)
self.retime = RetimeRule(driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_table_data(self, sheetname):
dataFile = dataFileName()
retrulePath = dataFile.get_retime_test_data_url()
retruleData = dataFile.get_data(retrulePath, sheetname)
return retruleData
u'''添加资源时间规则'''
def add_retime_rule_001(self):
#日志开始记录
self.log.log_start("add_retime_rule")
#获取添加资源时间规则测试数据
retruleData = self.get_table_data("add_retime_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(retruleData)):
data = retruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.command.click_add_button()
if dataRow == 3:
self.retime.click_running_state()
self.timerule.start_date(data[2])
self.timerule.date_of_termination(data[4], data[5])
self.retime.set_month_start_time(data[6])
self.retime.set_month_end_time(data[7])
self.retime.set_week_start_time(data[8])
self.retime.set_week_end_time(data[9])
self.retime.set_day_start_time(data[10])
self.retime.set_day_end_time(data[11])
self.retime.select_action(data[12])
self.command.click_add_users_button()
self.command.check_all_user()
self.command.click_add_resource_button()
self.retime.check_resource(data[13])
self.retime.click_save_retime()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
self.command.click_back_command()
except Exception as e:
print("add_retime_rule fail:" + str(e))
self.log.log_end("add_retime_rule")
u'''编辑资源时间规则'''
def mod_retime_rule_002(self):
#日志开始记录
self.log.log_start("mod_retime_rule")
#获取编辑资源时间规则测试数据
retruleData = self.get_table_data("mod_retime_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(retruleData)):
data = retruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.retime.click_option_method(data[2], data[3])
self.retime.select_action(data[4])
self.retime.click_save_retime()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
self.command.click_back_command()
except Exception as e:
print("mod_retime_rule fail:" + str(e))
self.log.log_end("mod_retime_rule")
u'''资源时间规则结果'''
def add_retime_rule_result_003(self):
self.frameElem.from_frame_to_otherFrame("topFrame")
self.cmf.select_role_by_text(u"运维操作员")
#日志开始记录
self.log.log_start("add_retime_rule_result")
#获取资源时间审批测试数据
retruleData = self.get_table_data("add_retime_rule_result")
for dataRow in range(len(retruleData)):
data = retruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.retime.check_resource_time_rule(data)
except Exception as e:
print("add_retime_rule_result fail:" + str(e))
self.log.log_end("add_retime_rule_result")
u'''操作资源时间规则'''
def option_retime_rule_004(self):
self.comsuit.sys_switch_to_dep()
self.comsuit.switch_to_moudle(u"运维管理", u"规则定义")
self.command.click_left_rule(3)
#日志开始记录
self.log.log_start("option_retime_rule")
#获取操作资源时间规则测试数据
retruleData = self.get_table_data("option_retime_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(retruleData)):
data = retruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
if dataRow == 1:
self.retime.click_bulkdel_retime()
elif dataRow == 2 or dataRow == 3:
self.retime.click_option_method(data[2], data[3])
elif dataRow == 4 or dataRow == 5:
time.sleep(5)
self.retime.click_option_method(data[2], data[3])
self.command.set_row_command(data[4])
self.command.check_sure_button()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
time.sleep(3)
self.command.click_cancel_button()
continue
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
except Exception as e:
print("option_retime_rule fail:" + str(e))
self.log.log_end("option_retime_rule")
u'''校验资源时间规则'''
def check_retime_rule_005(self):
#日志开始记录
self.log.log_start("check_retime_rule")
#获取校验资源时间规则测试数据
retruleData = self.get_table_data("check_retime_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
self.command.click_add_button()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(retruleData)):
data = retruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
if 2 <= dataRow <= 4:
if dataRow != 4:
self.timerule.start_date(data[2], data[3])
else:
self.timerule.start_date(data[2])
if dataRow != 2:
self.timerule.date_of_termination(data[4], data[5])
elif 5 <= dataRow <= 11:
if dataRow == 5:
self.timerule.date_of_termination(data[4], data[5])
self.retime.set_month_start_time(data[6])
self.retime.set_month_end_time(data[7])
if dataRow == 11:
self.retime.set_day_start_time(data[8])
elif 12 <= dataRow <= 17:
self.retime.set_day_start_time(data[8])
self.retime.set_day_end_time(data[9])
elif dataRow == 18:
self.command.click_add_users_button()
self.command.check_all_user()
self.retime.click_save_retime()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
except Exception as e:
print("check_retime_rule fail:" + str(e))
self.command.click_back_command()
self.log.log_end("check_retime_rule")
u'''删除资源时间规则'''
def del_retime_rule_006(self):
#日志开始记录
self.log.log_start("del_retime_rule")
#获取删除资源时间规则测试数据
retruleData = self.get_table_data("del_retime_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(retruleData)):
data = retruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.retime.click_option_method(data[2], data[3])
self.retime.click_bulkdel_retime()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
self.cmf.click_login_msg_button()
except Exception as e:
print("del_retime_rule fail:" + str(e))
self.log.log_end("del_retime_rule")
class testLogin(object):
def __init__(self,driver):
self.driver = driver
self.log = log()
self.loginFun = loginPage(self.driver)
self.cmf = commonFun(self.driver)
self.dataFile = dataFileName()
self.userElem = UserPage(self.driver)
self.commonSuite = CommonSuiteData(self.driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_table_data(self,sheetname):
filePath = self.dataFile.get_login_test_data_url()
loginData = self.dataFile.get_data(filePath,sheetname)
return loginData
u'''登陆的div弹窗的xpath'''
def login_msg(self):
login_msg = "html/body/div[1]/div/table/tbody/tr[2]/td[2]/div/table/tbody/tr[2]/td[2]/div"
return login_msg
u'''根据访问方式类型登录测试
parameters:
sheetname : 表单名称
'''
def login_type(self,sheetname):
loginMes = self.login_msg()
loginData = self.get_table_data(sheetname)
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(loginData)):
#把单行的数据赋值给列表data
data = loginData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
time.sleep(3)
if sheetname == 'default':
if dataRow == 4:
time.sleep(2)
self.commonSuite.login_and_switch_to_sys()
self.commonSuite.switch_to_moudle(u"运维管理",u"用户")
time.sleep(2)
self.userElem.change_user_status_on("gyrlogin2")
self.commonSuite.user_quit()
self.loginFun.login(data)
# if dataRow == 1:
# loginFun.set_max_login_count()
elif sheetname == 'ad':
self.loginFun.ad_login(data)
elif sheetname == 'pwd_ad':
self.loginFun.ad_pwd_login(data)
elif sheetname == 'radius':
self.loginFun.radius_pwd_login(data)
#如果登陆成功，点击退出
if self.loginFun.is_login_success():
self.loginFun.quit()
#设定没有检查点的测试项通过
flag = True
self.cmf.test_win_check_point("xpath",loginMes,data,flag)
#清空标识状态
flag = False
except Exception as e:
print ("User login fail: ") + str(e)
#self.log.print_detail("login type error",e)
#登陆测试
def login(self):
self.log.log_start("login")
u'''可以循环设定数据测试系统登录'''
sheets_name = ['default','ad','pwd_ad','radius']#'default','ad','pwd_ad','radius'
for sheetname in sheets_name:
time.sleep(3)
self.login_type(sheetname)
self.log.log_end("login")
#if __name__ == "__main__":#internet explorer
# browser = setDriver().set_driver()
# testLogin = testLogin(browser)
# testLogin.login()
'''
lists = jsonTranscoding().set_brower()
threads = []
def execute_case(host,brower):
driver = initDriver().remote_open_driver(host,brower)
testLogin(driver).login()
initDriver().close_driver(driver)
for host,brower in lists.items():
th = Thread(target=execute_case,args=(host,brower))
th.start()
threads.append(th)
for th in threads:
th.join()
'''
class ServiceNtp():
def __init__(self,driver):
self.driver = driver
self.dataFile = dataFileName()
self.frameElem = frameElement(driver)
self.cmf = commonFun(driver)
self.log = log()
self.ntp = NtpService(driver)
self.comm = CommonSuiteData(driver)
u'''获取测试数据
Parameters:
sheetname:sheet名称
return：表格数据
'''
def get_table_data(self,sheetname):
dataFile = dataFileName()
filePath = dataFile.get_ntp_test_data_url()
fileData = dataFile.get_data(filePath,sheetname)
return fileData
u'''提示框元素路径'''
def ntp_msg(self):
ntp_msg = "html/body/div[1]/div/table/tbody/tr[2]/td[2]/div/table/tbody/tr[2]/td[2]/div"
return ntp_msg
u'''校验没有弹出框类型用例是否通过
parameters:
data : 检查点
'''
def check_without_pop_up(self,data):
content = self.ntp.get_element_content()
if content.find(data[1]) == -1:
self.log.log_detail(data[0],False)
else:
self.log.log_detail(data[0],True)
u'''编辑服务器IP与周期'''
def edit_ntp_001(self):
#日志开始记录
self.log.log_start("editNtp")
#获取编辑服务器IP与周期的数据
ntp_data = self.get_table_data("mod_ntp")
#点击保存按钮弹出框
ntp_msg = self.ntp_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(ntp_data)):
data = ntp_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.ntp.server_ip(data[2])
#自动与时间同步服务器
self.ntp.check_time_server()
self.ntp.set_cycle_date(data[3])
self.ntp.set_cycle_time(data[4])
self.ntp.save_button()
#返回上级frame
self.frameElem.switch_to_content()
#判断测试项是否通过
self.cmf.test_win_check_point("xpath", ntp_msg, data, flag)
except Exception as e:
print ("edit ntp fail: ") + str(e)
self.log.log_end("editNtp")
u'''校验服务器IP'''
def check_ntp_002(self):
#日志开始记录
self.log.log_start("checkNtp")
#获取校验服务器IP的数据
ntp_data = self.get_table_data("check_ntp")
#点击保存按钮弹出框
ntp_msg = self.ntp_msg()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(ntp_data)):
data = ntp_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.ntp.server_ip(data[2])
self.ntp.save_button()
#返回上级frame
self.frameElem.switch_to_content()
#判断测试项是否通过
self.cmf.test_win_check_point("xpath", ntp_msg, data, flag)
#清空标识状态
flag = False
except Exception as e:
print ("check ntp fail:") + str(e)
self.log.log_end("checkNtp")
u'''更新时间'''
def update_ntp_003(self):
#日志开始记录
self.log.log_start("updateNtp")
#获取更新时间的数据
ntp_data = self.get_table_data("update_ntp")
row_count = len(ntp_data)-1
for dataRow in range(len(ntp_data)):
data = ntp_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.ntp.server_ip(data[2])
if dataRow != row_count:
self.ntp.set_cycle_date(data[3])
self.ntp.set_cycle_time(data[4])
else:
#自动与时间同步服务器
self.ntp.check_time_server()
self.ntp.save_button()
#点击确定按钮
self.ntp.click_msg_button()
#更新时间
self.ntp.updata_button()
#用户退出
self.comm.user_quit()
#用户登录
self.comm.login_sysadmin()
self.cmf.select_menu(u"系统配置", u"关联服务")
#判断测试项是否通过
self.check_without_pop_up(data)
except Exception as e:
print ("update ntp fail: ") + str(e)
self.log.log_end("updateNtp")
class testRoleSuite(unittest.TestCase): def setUp(self): #调用驱动 self.browser = setDriver().set_driver() self.comsuit = CommonSuiteData(self.browser) self.cmf = commonFun(self.browser) self.testrole = testRole(self.browser) self.testmutex = testMutex(self.browser) #角色前置条件 self.comsuit.role_module_prefix_condition() def test_role(self): # u'''添加系统级角色''' self.testrole.add_sysrole_001() u'''添加部门管理员''' self.testrole.add_dptrole_002() u'''编辑系统管理员''' self.testrole.edit_role_003() u'''角色查询''' self.testrole.role_query_008() u'''切换到角色互斥定义页面''' self.cmf.select_menu(u"角色管理", u"角色互斥定义") u'''添加互斥角色''' self.testmutex.add_mutex_role_001() u'''校验添加互斥角色后用户添加角色''' self.testmutex.check_addmutex_user_addrole_002() u'''校验添加互斥角色后用户编辑中的添加角色''' self.testmutex.check_addmutex_user_editrole_003() u'''编辑互斥角色''' self.testmutex.edit_mutex_role_004() u'''校验编辑互斥角色后用户添加角色''' self.testmutex.check_editmutex_user_addrole_005() u'''校验编辑互斥角色后用户编辑中的添加角色''' self.testmutex.check_editmutex_user_editrole_006() u'''删除角色互斥''' self.testmutex.del_mutex_role_007() u'''校验角色互斥''' self.testmutex.check_mutex_role_008() u'''编辑可管理角色''' self.testrole.edit_managerole_004() u'''校验其他权限选择''' self.testrole.check_other_role() u'''编辑其他权限''' self.testrole.edit_otherrole_005() u'''校验角色名称和没有选择菜单项''' self.testrole.check_rolename() u'''检验名称简写''' self.testrole.check_shortname() u'''校验批量删除''' self.testrole.check_bulkdel() u'''删除角色''' self.testrole.del_role_006() def tearDown(self): #角色后置条件 self.comsuit.role_module_post_condition() initDriver().close_driver(self.browser)
class testSso():
def __init__(self, driver):
self.driver = driver
self.log = log()
self.cmf = commonFun(driver)
self.getElem = getElement(driver)
self.cnEnde = cnEncode()
self.ssoElem = SsoPage(self.driver)
self.tableElem = tableElement(self.driver)
self.selectElem = selectElement(driver)
self.dataFile = dataFileName()
self.frameElem = frameElement(self.driver)
self.commSuite = CommonSuiteData(self.driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_table_data(self, sheetname):
dataFile = dataFileName()
filePath = dataFile.get_sso_test_url()
ssoFileData = dataFile.get_data(filePath, sheetname)
return ssoFileData
u'''命令单点登录通用部分'''
def sso_common_func(self, data):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.ssoElem.select_account(data[2], data[3])
self.ssoElem.select_sso_icon(data[2], data[4])
if data[5] != "":
self.ssoElem.select_protocol(data[5])
#self.ssoElem.execute_chrome_key()
self.ssoElem.choice_browser(data[4], data[6], data[7], data[8])
#self.ssoElem.refresh_windows()
#判断测试项是否通过
self.log.log_detail(data[0], True)
#清空标识状态
flag = False
u'''windows资源单点登录通用部分'''
def windows_common_func(self, data):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.ssoElem.select_account(data[2], data[3])
self.ssoElem.select_sso_icon(data[2], data[4])
if data[3] == "$user" or data[3] == "$user(local)":
self.ssoElem.set_mstsc_account(data[9])
self.ssoElem.set_mstsc_pwd(data[10])
self.cmf.click_login_msg_button()
self.ssoElem.choice_browser(data[4], data[6], data[7], data[8])
#判断测试项是否通过
self.log.log_detail(data[0], True)
time.sleep(4)
u'''cisco资源单点登录'''
def cisco_sso_login_001(self):
#日志开始记录
self.log.log_start("ssoLogin")
#获取单点登录的数据
sso_data = self.get_table_data("sso")
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
#if dataRow == 2:
if 0 < dataRow <= 4:
self.sso_common_func(data)
except Exception as e:
print("Cisco SSO login fail: ") + str(e)
#self.commSuite.user_quit()
self.log.log_end("CiscossoLogin")
u'''cisco匿名单点登录'''
def cisco_niming_sso_login_002(self):
#日志开始记录
self.log.log_start("nimingssoLogin")
#获取单点登录的数据
sso_data = self.get_table_data("sso")
#self.commSuite.sso_user_login(8)
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if 4 < dataRow <= 6:
self.sso_common_func(data)
except Exception as e:
print("niming SSO login fail: ") + str(e)
#self.commSuite.user_quit()
self.log.log_end("nimingssoLogin")
u'''华为资源单点登录'''
def huawei_sso_login_003(self):
#日志开始记录
self.log.log_start("huaweissoLogin")
#self.commSuite.sso_user_login(9)
#无检查点的测试项标识，如果为True说明通过
sso_data = self.get_table_data("sso")
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if 6 < dataRow <= 10:
self.sso_common_func(data)
except Exception as e:
print("hauwei SSO login fail: ") + str(e)
#self.commSuite.user_quit()
self.log.log_end("huaweissoLogin")
u'''linux资源单点登录'''
def debian_sso_login_004(self):
#日志开始记录
self.log.log_start("debianssoLogin")
#self.commSuite.sso_user_login(10)
sso_data = self.get_table_data("sso")
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if 11 <= dataRow <= 16:
self.sso_common_func(data)
except Exception as e:
print("debian SSO login fail: ") + str(e)
#self.commSuite.user_quit()
self.log.log_end("debianssoLogin")
u'''windowsRdp单点登录'''
def windows_sso_login_005(self):
#日志开始记录
self.log.log_start("windowsssoLogin")
#self.commSuite.sso_user_login(11)
sso_data = self.get_table_data("windows_sso")
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.windows_common_func(data)
except Exception as e:
print("Windows SSO login fail: ") + str(e)
self.commSuite.user_quit()
self.log.log_end("WindowsssoLogin")
u'''domain资源单点登录'''
def domain_sso_login_006(self):
#日志开始记录
self.log.log_start("DomainssoLogin")
self.commSuite.sso_user_ad_login(42)
sso_data = self.get_table_data("domain_sso")
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.windows_common_func(data)
except Exception as e:
print("Domain SSO login fail: ") + str(e)
#self.commSuite.user_quit()
self.log.log_end("DomainssoLogin")
u'''域内资源单点登录'''
def yunei_sso_login_007(self):
#日志开始记录
self.log.log_start("yuneissoLogin")
#self.commSuite.sso_user_ad_login(13)
sso_data = self.get_table_data("yunei_sso")
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(sso_data)):
data = sso_data[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.windows_common_func(data)
except Exception as e:
print("yunei SSO login fail: ") + str(e)
#self.commSuite.user_quit()
self.log.log_end("yuneissoLogin")
#if __name__ == "__main__":
# browser = setDriver().set_local_driver()
#
# commonSuite = CommonSuiteData(browser)
#commonSuite.sso_prefix_condition()
#commonSuite.sso_post_condition()
# #commonSuite.login_and_switch_to_common()
#
# ssoTest = testSso(browser)
# ssoTest.cisco_sso_login_001()
# ssoTest.cisco_niming_sso_login_002()
# ssoTest.huawei_sso_login_003()
# #ssoTest.debian_sso_login_004()
# ssoTest.windows_sso_login_005()
#ssoTest.domain_sso_login_006()
class Backuprestore(object):
def __init__(self, driver):
self.driver = driver
self.getElem = getElement(driver)
self.selectElem = selectElement(driver)
self.frameElem = frameElement(driver)
self.cmf = commonFun(driver)
self.cnEn = cnEncode()
self.comsuit = CommonSuiteData(self.driver)
self.command = CommandRule(self.driver)
self.tableElem = tableElement(driver)
self.log = log()
self.userElem = UserPage(self.driver)
self.role = Role(driver)
u'''点击自动备份开关'''
def auto_backup_switch(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "btn_qh")
u'''勾选系统配置'''
def check_sys_config(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
values = self.check_common()
if values[0] == None:
self.getElem.find_element_wait_and_click_EC("id", "configBackUp")
if values[1] != None:
self.getElem.find_element_wait_and_click_EC("id", "databaseBackUp")
u'''勾选实体配置'''
def check_entity_config(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
values = self.check_common()
if values[0] != None:
self.getElem.find_element_wait_and_click_EC("id", "configBackUp")
if values[1] == None:
self.getElem.find_element_wait_and_click_EC("id", "databaseBackUp")
u'''勾选实体配置和系统配置'''
def check_all_config(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
values = self.check_common()
if values[0] == None:
self.getElem.find_element_wait_and_click_EC("id", "configBackUp")
if values[1] == None:
self.getElem.find_element_wait_and_click_EC("id", "databaseBackUp")
u'''勾选实体或者系统配置公共方法'''
def check_common(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
selem = self.getElem.find_element_with_wait_EC("id", "configBackUp")
value = selem.get_attribute('checked')
selemdb = self.getElem.find_element_with_wait_EC(
"id", "databaseBackUp")
valuedb = selemdb.get_attribute('checked')
list = [value, valuedb]
return list
u'''勾选实体或者系统配置
parameter:
- stauts:勾选配置信息1代表系统配置2代表实体配置，3代表系统配置和实体配置
'''
def check_config(self, stauts):
staut = self.cnEn.is_float(stauts)
if staut == '1':
self.check_sys_config()
elif staut == '2':
self.check_entity_config()
else:
self.check_all_config()
u'''选择备份方式
parameter:
- stauts:value属性值，1代表一次性执行，2代表周期性执行
'''
def select_backup_mode(self, stauts):
staut = self.cnEn.is_float(stauts)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
selem = self.getElem.find_element_with_wait_EC("id", "backUpType")
self.selectElem.select_element_by_value(selem, staut)
u'''选择执行小时
parameter:
- stauts:value属性值
'''
def select_hour(self, stauts):
staut = self.cnEn.is_float(stauts)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
selem = self.getElem.find_element_with_wait_EC("id", "startHour")
self.selectElem.select_element_by_value(selem, staut)
u'''填写分钟
parameter:
- minute:分钟
'''
def set_minute(self, minute):
minu = self.cnEn.is_float(minute)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "startMinute")
self.getElem.find_element_wait_and_sendkeys("id", "startMinute", minu)
u'''选择执行方式
parameter:
- staut:0代表按天，1代表按周，2代表按月，3代表按年
'''
def select_execu_mode(self, staut):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
if staut == 0:
self.getElem.find_element_wait_and_click_EC("id", "dayradio")
elif staut == 1:
self.getElem.find_element_wait_and_click_EC("id", "weekradio")
elif staut == 2:
self.getElem.find_element_wait_and_click_EC("id", "monthRadio")
else:
self.getElem.find_element_wait_and_click_EC("id", "yearRadio")
u'''选择存储位置
parameter:
- stauts:value属性值1代表本地备份2代表ftp备份
'''
def select_storage_location(self, stauts):
staut = self.cnEn.is_float(stauts)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
selem = self.getElem.find_element_with_wait_EC("id", "backUpLocation")
self.selectElem.select_element_by_value(selem, staut)
u'''填写远程路径
parameter:
- path:远程路径
'''
def set_remote_path(self, path):
pat = self.cnEn.is_float(path)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "path")
self.getElem.find_element_wait_and_sendkeys("id", "path", pat)
u'''填写服务器IP
parameter:
- ip:服务器IP
'''
def set_ftpip(self, ip):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "ip")
self.getElem.find_element_wait_and_sendkeys("id", "ip", ip)
u'''填写连接用户名
parameter:
- minute:连接用户名
'''
def set_name(self, name):
nam = self.cnEn.is_float(name)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "username")
self.getElem.find_element_wait_and_sendkeys("id", "username", nam)
u'''填写连接口令
parameter:
- password:连接口令
'''
def set_password(self, password):
pwd = self.cnEn.is_float(password)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "password")
self.getElem.find_element_wait_and_sendkeys("id", "password", pwd)
u'''填写确认口令
parameter:
- minute:分钟
'''
def set_password_again(self, password):
pwd = self.cnEn.is_float(password)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "passwordAgain")
self.getElem.find_element_wait_and_sendkeys("id", "passwordAgain", pwd)
u'''点击立刻备份'''
def click_backup_immediately(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "back_up_now")
u'''点击保存'''
def click_save(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "back_up_save")
u'''选择系统备份还原或者查看备份文件
parameter:
- staut:0代表系统备份还原，1代表查看备份文件
'''
def select_backup_menu(self, staut):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
if staut == 0:
self.getElem.find_element_wait_and_click_EC("id", "tit1")
elif staut == 1:
self.getElem.find_element_wait_and_click_EC("id", "tit2")
u'''点击操作列操作
Parameters:
- filename:文件名称
- value:1代表下载，2代表删除，3代表还原
'''
def click_operat_file(self, filename, value):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
row = 1
selems = self.driver.find_elements_by_name("file")
for selem in selems:
idvalue = selem.get_attribute('id')
row = row + 1
if idvalue == filename:
xpath = ".//*[@id='content_rt02']/div/table/tbody/tr[" + str(
row) + "]/td[7]/input[" + str(value) + "]"
self.getElem.find_element_wait_and_click_EC("xpath", xpath)
time.sleep(1)
u'''下载上传完成后点击操作列操作
Parameters:
- filename:文件名称
- value:1代表下载，2代表删除，3代表还原
'''
def upload_click_operat_file(self, filename, value):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
row = 1
filenames = "" + filename[:-6] + "" + filename + ""
selems = self.driver.find_elements_by_name("file")
for selem in selems:
idvalue = selem.get_attribute('id')
row = row + 1
if idvalue == filename or idvalue == filenames:
xpath = ".//*[@id='content_rt02']/div/table/tbody/tr[" + str(
row) + "]/td[7]/input[" + str(value) + "]"
self.getElem.find_element_wait_and_click_EC("xpath", xpath)
time.sleep(1)
u'''点击还原系统配置'''
def click_restore_sys_config(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "deleConfig1")
u'''点击清空数据库'''
def click_reset_database(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "resetDataBase1")
u'''点击清空数据库'''
def click_reset_audit(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "delAuditFile1")
u'''填写syslogip
parameter:
- syslogip:syslogip
'''
def set_syslogip(self, syslogip):
ip = self.cnEn.is_float(syslogip)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "host")
self.getElem.find_element_wait_and_sendkeys("id", "host", ip)
u'''填写syslog端口
parameter:
- port:syslog端口
'''
def set_port(self, port):
sysport = self.cnEn.is_float(port)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_clear_EC("id", "port")
self.getElem.find_element_wait_and_sendkeys("id", "port", sysport)
u'''点击syslog保存'''
def click_syslog_save(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "save_syslog")
u'''获取syslogip值'''
def get_syslog_port(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
selem = self.getElem.find_element_with_wait_EC("id", "port")
value = selem.get_attribute("value")
return value
u'''获取文件名称'''
def get_file_name(self):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
selem = self.getElem.find_element_with_wait_EC(
"xpath", ".//*[@id='content_rt02']/div/table/tbody/tr[2]")
value = selem.get_attribute('id')
return value
u'''编辑syslog
parameter:
- ip:syslogip
- port:端口
'''
def set_syslog(self, port, ip='no'):
self.comsuit.switch_to_moudle(u'系统配置', u'关联服务')
self.command.click_left_rule(1)
if ip != 'no':
self.set_syslogip(ip)
self.set_port(port)
self.click_syslog_save()
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
u'''检验syslog端口是否为备份之前信息
parameter:
- port:端口
- checklog:检验信息
'''
def check_syslog_content(self, port, checklog):
self.comsuit.switch_to_moudle(u'系统配置', u'关联服务')
self.command.click_left_rule(1)
elemText = self.get_syslog_port()
strdata3 = self.cnEn.is_float(port)
if elemText == strdata3:
self.log.log_detail(checklog, True)
else:
self.log.log_detail(checklog, False)
u'''校验用户或者角色信息
Parameters:
- namevalue:传入的要被查询名称
- name:表格列的name属性
- checklog:日志信息
return：定位该名称位于第几行
'''
def check_content(self, namevalue, name, checklog):
row = self.cmf.find_row_by_name(namevalue, name)
if row != 0:
self.log.log_detail(checklog, True)
else:
self.log.log_detail(checklog, False)
u'''填写用户信息
parameters:
account : 用户账号
name : 用户名称
pwd : 用户密码
agpwd : 确认密码
'''
def set_user_info(self, account, name, pwd, agpwd):
self.comsuit.switch_to_moudle(u"运维管理", u"用户")
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.userElem.add_button()
self.userElem.set_user_account(account)
self.userElem.set_user_name(name)
self.userElem.set_user_pwd(pwd)
self.userElem.set_user_enquire_pwd(agpwd)
self.userElem.save_button()
self.frameElem.switch_to_content()
self.cmf.click_login_msg_button()
u'''点击用户操作列对应的删除按钮
parameters:
- account : 用户账号
'''
def del_user_info(self, account):
self.comsuit.switch_to_moudle(u"运维管理", u"用户")
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.userElem.operate_delete(account)
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
u'''点击备份还原配置文件的删除
parameters:
- filename : 文件名称
- loginfo : 日志信息
'''
def del_backup_file(self, filename, loginfo):
self.click_operat_file(filename, 2)
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
time.sleep(1)
self.log.log_detail(loginfo, True)
u'''点击角色操作列对应的删除按钮
parameters:
- rolename : 角色名称
'''
def del_role_info(self, rolename):
self.comsuit.switch_to_moudle(u"角色管理", u"角色定义")
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.role.delete(rolename)
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
u'''执行还原操作
parameters:
- filename :执行还原的文件名称
- loginfo :日志信息
- stauts :状态1代表执行操作列按钮2代表进行上传后操作列按钮
'''
def execute_restore(self, filename, loginfo, stauts=1):
self.comsuit.switch_to_moudle(u'系统配置', u'备份还原')
self.command.click_left_rule(0)
self.select_backup_menu(1)
if stauts == 1:
self.click_operat_file(filename, 3)
elif stauts == 2:
self.upload_click_operat_file(filename, 3)
time.sleep(5)
self.frameElem.switch_to_content()
self.getElem.find_element_with_wait_EC("classname",
"aui_state_highlight")
time.sleep(3)
self.cmf.click_msg_button(1)
self.log.log_detail(loginfo, True)
u'''配置备份信息
parameters:
- data :数据文件集
- backMsg :保存成功的弹出框信息
- flag :无检查点的测试项标识，如果为True说明通过
'''
def config_backup(self, data, backMsg, flag):
self.comsuit.switch_to_moudle(u'系统配置', u'备份还原')
self.command.click_left_rule(0)
self.check_config(data[12])
self.select_backup_mode(data[4])
self.backup_time(data[5], data[6])
self.select_storage_location(data[7])
self.click_save()
time.sleep(3)
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", backMsg, data, flag)
self.click_backup_immediately()
time.sleep(2)
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
self.log.log_detail(data[9], True)
self.select_backup_menu(1)
u'''填写角色信息
Parameters:
- rolename :角色名称
- shortname :名称简写
'''
def set_role_info(self, rolename, shortname):
self.comsuit.switch_to_moudle(u"角色管理", u"角色定义")
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.role.add()
self.role.edit_rolename(rolename)
self.role.edit_shortname(shortname)
self.role.select_sysrole()
self.role.save_button()
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
u'''执行日期
Parameters:
- type :t代表今天，c代表clear，q代表确定，默认选择今天
- backuptime :执行日期设定的日期，格式为2016-9-7 11:42:42
'''
def backup_time(self, types, backuptime):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
# 时间控件的fram的xpath
fxpath = "//iframe[@hidefocus='true']"
# 日期控件table的xpath路径
txpath = "/html/body/div/div[3]/table"
status = self.cnEn.is_float('1')
type = self.cnEn.is_float(types)
# 转成datetime对象
date = datetime(*xldate_as_tuple(backuptime, 0))
end = date.strftime('%Y-%m-%d %H:%M:%S')
self.option_time("backUpTime", fxpath, status, type, txpath, end)
u'''操作时间控件
Parameters:
- wdateId：日期控件input控件的ID值
- fxpath：日期控件frame的xpath路径
- status: 日期控件是否有时分秒
- txpath：日期控件table的xpath路径
- time：设定的日期，格式为2016-9-7 11:42:42
- type：t代表今天，c代表clear，q代表确定，默认选择今天
'''
def option_time(self,
wdateId,
fxpath,
status='0',
type='t',
txpath=None,
dtime=None):
self.getElem.find_element_wait_and_click("id", wdateId)
frame = self.driver.find_element_by_xpath(fxpath)
self.driver.switch_to_frame(frame)
if type == 't':
self.getElem.find_element_wait_and_click("id", "dpTodayInput")
elif type == 'c':
self.getElem.find_element_wait_and_click("id", "dpClearInput")
elif type == 'q':
if dtime is not None:
list = dtime.split()
ymdList = list[0].split("-")
hmsList = list[1].split(":")
#年
tYear = ymdList[0]
#月
tMon = ymdList[1]
#日
tDay = ymdList[2]
#时
tHour = hmsList[0]
#分
tMin = hmsList[1]
#秒
tSen = hmsList[2]
dTitle = self.getElem.find_element_with_wait(
"id", "dpTitle").find_elements_by_tag_name("input")
#设定月
dTitle[0].clear()
dTitle[0].send_keys(tMon)
#设定年
dTitle[1].clear()
dTitle[1].send_keys(tYear)
self.frameElem.from_frame_to_otherFrame("rigthFrame")
self.getElem.find_element_wait_and_click_EC("id", "backUpTime")
self.driver.switch_to_frame(frame)
if txpath is not None:
iStatus = False
for itr in range(7):
if itr != 0:
for itd in range(7):
ct = self.tableElem.get_table_cell_text(
txpath, itr, itd)[0]
#排除第一行大于7的
if itr == 1 and int(ct) > 7:
continue
#排除倒数第二行小于15的
if itr == 5 and int(ct) < 15:
continue
#排除最后一行小于15的
if itr == 6 and int(ct) < 15:
continue
#如果跟给定的日期一致，点击日期
if int(ct) == int(tDay):
self.tableElem.get_table_cell_text(
txpath, itr, itd)[1].click()
iStatus = True
break
#找到日期后跳出循环
if iStatus:
break
#日期控件是否有时分秒
if status == '1':
dTime = self.getElem.find_element_with_wait(
"id", "dpTime").find_elements_by_tag_name("input")
#设定小时
dTime[0].clear()
dTime[0].send_keys(tHour)
#设定分钟
dTime[2].clear()
dTime[2].send_keys(tMin)
#设定秒
dTime[4].clear()
dTime[4].send_keys(tSen)
self.getElem.find_element_wait_and_click("id", "dpOkInput")
u'''上传操作
parameters:
- filename :执行还原的文件名称
- loginfo :日志信息
'''
def backup_file_upload(self, filename, loginfo):
self.frameElem.from_frame_to_otherFrame("rigthFrame")
value = "C:\Users\Administrator\Downloads\\" + filename + ""
self.getElem.find_element_wait_and_sendkeys("id", "backUpFile", value)
time.sleep(2)
self.getElem.find_element_wait_and_click_EC("id", "up_file")
self.frameElem.switch_to_content()
self.cmf.click_msg_button(1)
time.sleep(1)
self.log.log_detail(loginfo, True)
self.alarm.search_level(data[2])
self.alarm.search_button()
self.alarm.rest_button()
#清空标识状态
flag = False
self.log.log_detail(data[0], True)
except Exception as e:
print("Retrieval level error: ") + str(e)
self.log.log_end("searchByLevel")
def del_config(self):
#日志开始记录
self.log.log_start("delConfig")
flag = False
self.frameElem.from_frame_to_otherFrame("mainFrame")
if __name__ == "__main__":
browser = setDriver().set_local_driver()
commonSuite = CommonSuiteData(browser)
alarmCase = AlarmConfig(browser)
commonSuite.alarm_strategy_module_prefix_condition()
alarmCase.mod_user_mail_008()
alarmCase.command_alarm_level_config_001()
alarmCase.default_alarm_level_checkout_003()
alarmCase.default_alarm_level_config_002()
alarmCase.auth_alarm_level_config_004()
alarmCase.search_by_type_005()
alarmCase.search_by_level_006()
commonSuite.alarm_strategy_module_post_condition()
class testAddress(object):
def __init__(self, driver):
self.driver = driver
self.log = log()
self.cmf = commonFun(driver)
self.frameElem = frameElement(driver)
self.testrole = testRole(driver)
self.command = CommandRule(driver)
self.comsuit = CommonSuiteData(driver)
self.timerule = TimeRule(driver)
self.getElem = getElement(driver)
self.loginElem = loginPage(driver)
self.adrerule = AddressRule(driver)
u'''获取测试数据
Parameters:
- sheetname:sheet名称
return：表格数据
'''
def get_table_data(self, sheetname):
dataFile = dataFileName()
adrerulePath = dataFile.get_adrerule_test_data_url()
adreruleData = dataFile.get_data(adrerulePath, sheetname)
return adreruleData
u'''添加地址规则'''
def add_address_rule_001(self):
#日志开始记录
self.log.log_start("add_address_rule")
#获取添加地址规则测试数据
adreruleData = self.get_table_data("add_address_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(adreruleData)):
data = adreruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.command.click_add_button()
self.adrerule.set_rulename((data[2]))
self.timerule.select_depart(data[3])
self.timerule.set_status_type(data[4])
self.adrerule.checkbox_ip_rule(data[5])
self.adrerule.set_ip(data[6])
self.adrerule.set_ip_mask(data[7])
if dataRow != 1 and dataRow != 5:
if dataRow == 3 or dataRow == 7:
self.adrerule.click_add_ip_segment()
self.adrerule.set_ip_start(data[9])
self.adrerule.set_ip_end(data[10])
else:
self.adrerule.set_ip_test(data[8])
self.adrerule.click_test()
self.cmf.click_msg_button(1)
self.adrerule.set_description(data[11])
self.adrerule.click_save()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
self.command.click_back_command()
except Exception as e:
print("add_address_rule fail:" + str(e))
self.comsuit.user_quit()
self.log.log_end("add_address_rule")
u'''添加地址规则结果'''
def add_address_rule_result_002(self):
#日志开始记录
self.log.log_start("add_address_rule_result")
#获取添加地址规则测试数据
adreruleData = self.get_table_data("add_address_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
for dataRow in range(len(adreruleData)):
data = adreruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.comsuit.login_and_switch_to_dep()
self.comsuit.switch_to_moudle(u'运维管理', u'用户')
self.adrerule.edit_user_address_rule(data[12], data[13])
list = [data[14], data[15], data[16], data[17], data[18]]
self.comsuit.user_quit()
self.loginElem.login(list)
self.frameElem.from_frame_to_otherFrame("topFrame")
if self.getElem.is_element_exsit('id', "logout"):
self.comsuit.user_quit()
flag = True
self.cmf.test_win_check_point("xpath", comrulMsg, list,
flag)
except Exception as e:
print("add_address_rule_result fail:" + str(e))
self.comsuit.login_and_switch_to_dep()
self.comsuit.switch_to_moudle(u'运维管理', u'规则定义')
self.command.click_left_rule(2)
self.log.log_end("add_address_rule_result")
u'''编辑地址规则'''
def mod_address_rule_003(self):
#日志开始记录
self.log.log_start("mod_address_rule")
#获取编辑地址规则测试数据
adreruleData = self.get_table_data("mod_address_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(adreruleData)):
data = adreruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.adrerule.click_edit_address(data[2])
self.adrerule.set_rulename((data[3]))
self.timerule.set_status_type(data[4])
self.adrerule.checkbox_ip_rule(data[5])
self.adrerule.set_ip(data[6])
self.adrerule.set_ip_mask(data[7])
self.adrerule.set_ip_start(data[8])
self.adrerule.set_ip_end(data[9])
self.adrerule.set_description(data[10])
self.adrerule.click_save()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
self.command.click_back_command()
except Exception as e:
print("mod_address_rule fail:" + str(e))
self.log.log_end("mod_address_rule")
u'''校验地址规则'''
def check_address_rule_004(self):
#日志开始记录
self.log.log_start("check_address_rule")
#获取校验地址规则测试数据
adreruleData = self.get_table_data("check_address_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
self.command.click_add_button()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(adreruleData)):
data = adreruleData[dataRow]
try:
if dataRow != 0:
#如果不是第一行标题，则读取数据
if dataRow == 2:
self.adrerule.checkbox_ip_rule(data[3])
elif dataRow == 3 or dataRow == 4:
self.adrerule.set_ip(data[4])
elif dataRow == 5:
self.adrerule.set_ip_mask(data[5])
elif dataRow != 1:
self.adrerule.set_rulename(data[2])
self.adrerule.click_save()
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
except Exception as e:
print("check_address_rule fail:" + str(e))
self.command.click_back_command()
self.log.log_end("check_address_rule")
u'''检索地址规则'''
def query_address_rule_005(self):
#日志开始记录
self.log.log_start("query_address_rule")
#获取检索地址规则测试数据
adreruleData = self.get_table_data("query_address_rule")
for dataRow in range(len(adreruleData)):
data = adreruleData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.timerule.click_reset_time()
if dataRow != 4:
self.adrerule.set_search_addressname((data[1]))
self.adrerule.click_search_address()
self.log.log_detail(data[0], True)
except Exception as e:
print("query_address_rule fail:" + str(e))
self.log.log_end("query_address_rule")
u'''删除地址规则'''
def del_address_rule_006(self):
#日志开始记录
self.log.log_start("del_address_rule")
#获取删除地址规则测试数据
adrerulData = self.get_table_data("del_address_rule")
#保存成功的弹出框
comrulMsg = self.testrole.popup()
#无检查点的测试项标识，如果为True说明通过
flag = False
for dataRow in range(len(adrerulData)):
data = adrerulData[dataRow]
try:
#如果不是第一行标题，则读取数据
if dataRow != 0:
if dataRow == 1:
self.adrerule.click_bulkdel_address()
else:
self.adrerule.click_del_address(data[2])
self.frameElem.switch_to_content()
self.cmf.test_win_check_point("xpath", comrulMsg, data,
flag)
if dataRow != 1:
self.cmf.click_login_msg_button()
except Exception as e:
print("del_address_rule fail:" + str(e))
self.log.log_end("del_address_rule")
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:
time.sleep(2)
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:
time.sleep(2)
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:
time.sleep(2)
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:
time.sleep(2)
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()
time.sleep(2)
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()
time.sleep(2)
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:
time.sleep(2)
self.commonsuite.sys_switch_to_dep()
self.switch_to_resource_module()
time.sleep(2)
self.frameElem.from_frame_to_otherFrame("mainFrame")
self.PwdStr.resource_edit(data[2])
self.PwdStr.set_resource_strategy(data[8])
self.resource.resoure_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:
time.sleep(2)
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:
time.sleep(2)
self.commonsuite.dep_switch_to_sys()
self.switch_to_pwdStr_module()
time.sleep(2)
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()
#如果不是第一行标题，则读取数据
if dataRow != 0:
self.frameElem.from_frame_to_otherFrame("rigthFrame")
#self.appElem.operate_account_manage(data[2])
self.appElem.operate_account_del(data[3])
self.cmf.click_login_msg_button()
#判断测试项是否通过
self.check_with_pop_up(data, flag)
#清空标识状态
flag = False
except Exception as e:
print("Del account fail: ") + str(e)
self.log.log_end("Delaccount")
if __name__ == "__main__":
browser = setDriver().set_local_driver()
commonSuite = CommonSuiteData(browser)
appTest = testApp(browser)
commonSuite.login_and_switch_to_sys()
commonSuite.switch_to_moudle(u"系统配置", u"关联服务")
# appTest.add_app_001()
# appTest.edit_app_002()
# appTest.check_app_003()
# appTest.query_app_004()
# appTest.add_account_006()
# appTest.edit_account_007()
# appTest.del_account_008()
# appTest.del_app_005()
