def base_compute_vcf(self,
para_id,
data_id,
cookies,
flag,
calType=1,
maxFile=0):
"""vcf协同计算 calType:1 随机查找vcf task ; 2 查找基因协同计算任务 3 GWAS 0 查找最大id+6666"""
# 获取请求url
url_compute_vcf = self.domain + Base.dh.get_path(para_id)
Log.info('compute_vcf request url : {}'.format(url_compute_vcf))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 登录态判断
if cookies is not None:
# 不存在的fileid
if maxFile:
req_para['fileId'] = self.get_max_file_id()
else:
# file文件上传获取fileId
req_para['fileId'] = self.gene_file_id(req_para['fileId'],
cookies)
# id不存在
if not calType:
req_para['taskId'] = self.get_max_task_id()
else:
req_para['taskId'] = self.get_task_id(calType)
data_source[0][5] = req_para['taskId']
data_source[0][6] = req_para['fileId']
Log.info('compute_vcf request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_compute_vcf,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('compute_vcf response data is {}'.format(res))
# 结果检查
actual = self.vcf_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_gen_start(self, para_id, data_id, cookies, isChange=0, maxFile=0):
"""gen start gen计算发起. isChange:0读取请求数据，1 请求数据重复100遍"""
# 获取请求url
url_gen_start = self.domain + Base.dh.get_path(para_id)
Log.info('gen_start request url : {}'.format(url_gen_start))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 登录态判断
if cookies is not None:
# 不存在的fileid
if maxFile:
req_para['fileList'] = self.get_max_file_id()
data_source[0][5] = req_para['fileList']
else:
# fileList 字符串转列表
req_para['fileList'] = eval(req_para['fileList'])
# fileList 文件上传，获取文件id,如果文件列表为空，则跳过上传文件操作
if len(req_para['fileList']) > 0:
req_para['fileList'] = self.gene_file_id_list(
req_para['fileList'], cookies)
data_source[0][5] = req_para['fileList']
else:
pass
# remark 内容
if isChange:
req_para['remark'] = req_para['remark'] * 100
data_source[0][7] = req_para['remark']
# top 数据转换
req_para['top'] = eval(req_para['top'])
req_para['isPrint'] = eval(req_para['isPrint'])
Log.info('gen_start request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_gen_start,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('gen_start response data is {}'.format(res))
# 结果检查
actual = self.gen_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_logout(self, para_id, data_id, cookies=None):
"""退出登录公共方法"""
Log.info('logout url is %s' % self.url)
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
Log.info('request data is %s' % req_para)
# 请求接口
res = requests.post(url=self.url, headers=Base.headers, cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('logout response data is {}'.format(res))
# 结果检查
actual = self.check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
class Test_Homepage(unittest.TestCase):
def setUp(self):
self.drive = Drive(1)
self.log = Log()
self.url = "http://www.multilotto.com/en"
self.readconfig = ElementsRead()
def test_go_to_homepage(self):
self.log.info("开始测试，进入首页")
self.drive.open_browser(self.url)
time.sleep(3)
self.log.info("点击左上角图标，刷新首页")
self.drive.find_element("首页图标").click()
def tearDown(self):
self.log.info("测试结束")
time.sleep(10)
self.drive.close_brwser()
def new_check(res, flag):
"""response对象.json对象异常捕获判定文件下载是否成功"""
try:
json_res = res.json()
if not flag:
Log.error('请求返回有误：{}'.format(json_res))
Log.info('test success')
return flag
else:
Log.error('文件下载失败，请求异常{}'.format(json_res))
return not flag
except JSONDecodeError as je:
Log.info('-content type-:{}'.format(type(res.content)))
Log.debug('-contest:{}-'.format(res.content))
Log.info('-contest is None :{}'.format(res.content is None))
return flag
except Exception as e:
Log.error('未知异常:{}'.format(e))
return not flag
def gen_check(self, res):
code = '00000'
# taskId = res['data']
# Log.debug('taskId is {}'.format(taskId))
# [data_n, data_o] = self.get_data(taskId)
# Log.info('本端数据为： {}'.format(data_n))
# Log.info('对端数据为： {}'.format(data_o))
if res['code'] == code:
taskId = res['data']
Log.debug('taskId is {}'.format(taskId))
[data_n, data_o] = self.get_data(taskId)
Log.info('本端数据为： {}'.format(data_n))
Log.info('对端数据为： {}'.format(data_o))
if self.compare(data_n, data_o):
Log.info('compare result is True ,success !')
return 1
else:
Log.error('compare result is False ,fail !')
return 0
Log.error('请求返回有误！{}'.format(res))
return 0
def base_query_update_flag(self, para_id, data_id, cookies, flag):
"""协同计算--数据更新"""
# 获取请求url
url_query_update_flag = self.domain + Base.dh.get_path(para_id)
Log.info('query_update_flag request url : {}'.format(url_query_update_flag))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
Log.info('query_update_flag request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_query_update_flag, headers=Base.headers, cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('query_update_flag response data is {}'.format(res))
# 结果检查
actual = self.query_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
class BaiduTests(unittest.TestCase):
def setUp(self):
self.log = Log("app demo test")
self.base_url = 'http://localhost:4723/wd/hub'
self.desired_caps = {}
self.desired_caps['platformName'] = 'Android'
self.desired_caps['platformVersion'] = '8'
self.desired_caps['deviceName'] = 'fc323ca3'
self.desired_caps['appPackage'] = 'com.giveu.corder'
#self.desired_caps['appActivity'] = '.SplashActivity'
self.desired_caps['appActivity'] = '.WelcomeActivity'
#.me.activity.LoginActivity}
#print(os.path.dirname(os.getcwd()))
self.driver = webdriver.Remote(self.base_url, self.desired_caps)
self.driver.implicitly_wait(15)
def test_jyb_login_demo(self):
"""即有宝登录测试用例"""
self.log.info("成功连接appium服务器")
print(self.driver.current_activity())
self.driver.find_element_by_id("com.giveu.corder:id/et_account").clear()
self.driver.find_element_by_id("com.giveu.corder:id/et_account").send_keys("865258")
self.driver.find_element_by_id("com.giveu.corder:id/et_pwd").clear()
self.driver.find_element_by_id("com.giveu.corder:id/et_pwd").send_keys("123456")
self.driver.find_element_by_id("tv_login").click()
try:
self.driver.find_element_by_id("top_tab_center_title").is_displayed()
except:
self.assertEquals(1, 2, u"登录没有成功！,请查找原因")
finally:
tt=self.driver.find_element_by_id("top_tab_center_title").text()
tl = tt.strip()
self.assertEquals(tl,u"新建订单",u"jyb登录成功")
self.log.info("jyb登录成功")
self.driver.quit()
def tearDown(self):
self.log.info("关闭并退出app。")
def base_get_server(self, para_id, data_id, cookies):
"""协同计算--查询服务器公共方法"""
# 获取请求url
url_get_server = self.domain + Base.dh.get_path(para_id)
Log.info('get_server request url : {}'.format(url_get_server))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
Log.info('get_server request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_server,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_server response data is {}'.format(res))
# 结果检查
actual = self.get_server_check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_logic_get_list(self, para_id, data_id, cookies, flag):
"""逻辑管理-查询列表"""
# 获取请求url
url_logic_get_list = self.domain + Base.dh.get_path(para_id)
Log.info('logic_get_list request url : {}'.format(url_logic_get_list))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
Log.info('logic_get_list request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_logic_get_list,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('logic_get_list response data is {}'.format(res))
# 结果检查
actual = self.get_logic_check(res, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_cancel_task(self, para_id, data_id, cookies, flag, task_modify=0, reason_modify=0):
"""协同计算--取消任务"""
# 获取请求url
url_vcf_start = self.domain + Base.dh.get_path(para_id)
Log.info('cancel_task request url : {}'.format(url_vcf_start))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
req_para['type'] = eval(req_para['type'])
# 不存在的taskId
if task_modify:
temp = {'taskId': None, 'startTaskId': None}
req_para['taskId'] = self.get_max_task_id(req_para['type'])
else:
# 获取请求参数,temp存储id,startTaskId组成的字典
temp = self.get_task_id(req_para['type'])
req_para['taskId'] = temp['id']
# reason 内容
if reason_modify:
req_para['reason'] = req_para['reason'] * 100
data_source[0][5] = req_para['taskId']
data_source[0][7] = req_para['reason']
Log.info('cancel_task request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_vcf_start, headers=Base.headers, cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('cancel_task response data is {}'.format(res))
# 结果检查
actual = self.cancel_check(res, temp, flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def base_get_list_by_condition(self, para_id, data_id, cookies):
"""获取用户列表"""
# 获取请求url
url_get_list_by_condition = self.domain + Base.dh.get_path(para_id)
Log.info('get_list_by_condition request url : {}'.format(
url_get_list_by_condition))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
Log.info('get_list_by_condition request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_list_by_condition,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info('get_list_by_condition response data is {}'.format(res))
# 结果检查
actual = self.check(res)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def cancel_check(self, res, temp, flag):
code = '00000'
if flag and res['code'] != code:
raise AssertionError('请求返回应该为成功，实际失败 {}'.format(res))
if not flag and res['code'] == code:
raise AssertionError('异常用例请求返回应该为失败，实际成功 {}'.format(res))
if not res['code'] == code:
Log.error('请求返回有误！{}'.format(res))
return 0
else:
if temp['startTaskId'] is None:
status = 4
id = temp['id']
sql_n = 'select * from t_task_history where id = %d ' % id
sql_o = 'select * from t_task_history where startTaskId = %d ' % id
else:
status = 5
id = temp['startTaskId']
sql_n = 'select * from t_task_history where startTaskId = %d ' % id
sql_o = 'select * from t_task_history where id = %d ' % id
Log.debug('本端查询sql：{}'.format(sql_n))
Log.debug('对端查询sql：{}'.format(sql_o))
data_n = self.con_n.select_dic_single(sql=sql_n)
Log.info('本端数据为： {}'.format(data_n))
time.sleep(10)
try:
data_o = self.con_o.select_dic_single(sql=sql_o)
except IndexError as e:
raise AssertionError('数据库查询为空，exception is:{}'.format(e))
Log.info('对端数据为： {}'.format(data_o))
if self.compare(data_n, data_o, status):
Log.info('compare result is True ,success !')
return 1
else:
Log.error('compare result is False ,fail !')
return 0
def base_get_Recessive_cal_result(self, para_id, data_id, cookies, flag):
"""历史记录-查询GWAS-隐性计算结果公共方法"""
# 获取请求url
url_get_Recessive_cal_result = self.domain + Base.dh.get_path(para_id)
Log.info('get_Recessive_maf_result request url : {}'.format(
url_get_Recessive_cal_result))
# 获取请求数据
data_source = self.dh.get_data(data_id)
req_para = Base.get_req_para(para_id=para_id, data_id=data_id)
# 查询数据库taskId，随机选择查询
req_para['taskId'] = self.get_Recessive_done_task_id()
req_para['pageNo'] = eval(req_para['pageNo'])
req_para['pageSize'] = eval(req_para['pageSize'])
data_source[0][5] = req_para['taskId']
# 数据库查询taskId为空处理
if req_para['taskId'] is None:
actual = not flag
Log.error('数据库查询taskId为空，该用例未执行，失败')
else:
Log.info(
'get_Recessive_cal_result request data is {}'.format(req_para))
# 请求
res = requests.post(url=url_get_Recessive_cal_result,
headers=Base.headers,
cookies=cookies,
data=Base.sign(req_para)).json()
Log.info(
'get_Recessive_cal_result response data is {}'.format(res))
# 结果检查
actual = self.get_Recessive_result_check(req_para['taskId'], res,
flag)
# 结果写入
DataHandle.set_data(data_source[0], actual)
self.dh.write_data(data_source)
# 结果检查
return self.dh.check_result(data_source)
def sendemail(subject="subject",
context="context",
image=None,
mail_file=None):
"""
自动发送邮件
:param subject:邮件主题
:param context: 邮件正文
:param image: 邮件图片
:param mail_file: 邮件附件
:return:
"""
__config = Config().email()
# 获取配置信息
smtp_server = __config["smtp_server"]
user = __config["user"]
password = __config["password"]
sender = __config["sender"]
receiver = __config["receiver"]
receiver_list = []
temp = receiver.split(",")
for t in temp:
if len(t.strip()) > 0:
receiver_list.append(t.strip())
__log = Log().log()
msg = MIMEMultipart('related')
# 主题.收发人信息
msg['Subject'] = Header(subject, 'utf-8')
msg['From'] = sender
msg['To'] = receiver
# 正文
msg.attach(MIMEText(context, 'plain', 'utf-8'))
# 添加图片
if image is not None:
msgAlternative = MIMEMultipart('alternative')
msg.attach(msgAlternative)
mail_msg = '<img src="cid:image1"><br>'
msgAlternative.attach(MIMEText(mail_msg, 'html', 'utf-8'))
# 指定图片为当前目录
with open(image, 'rb') as ff:
msgimage = MIMEImage(ff.read())
# 定义图片 ID，在 HTML 文本中引用
msgimage.add_header('Content-ID', '<image1>')
msg.attach(msgimage)
# 附件
if mail_file is not None and os.path.exists(mail_file):
with open(mail_file, 'rb') as f:
msg_file = MIMEText(f.read(), 'base64', 'utf-8')
msg_file['Content-Type'] = 'application/octet-stream'
msg_file[
'Content-Disposition'] = 'attachment; filename=test_report.html'
msg.attach(msg_file)
try:
# 发送
__log.info("sending email...")
smtp = smtplib.SMTP_SSL(smtp_server, 465)
# 1.连接邮件服务器
# smtp.connect()
# 2.登录
smtp.login(user, password)
# 3.发送邮件
__log.debug(receiver_list)
smtp.sendmail(sender, receiver_list, msg.as_string())
# 4.退出
smtp.quit()
__log.info("send email sessful")
except Exception as e:
__log.error(e)
def tearDownClass(cls):
Log.info('TestCancelTaskBB END BB端')
def tearDownClass(cls):
Log.info('TestGetListByAcceptHK END HK端')
def tearDownClass(cls):
Log.info('TestGetGenResultHK END HK端')
def tearDownClass(cls):
Log.info('TestGetListBB END BB端')
def tearDownClass(cls):
Log.info('TestUserLogin END BB端')
def test_cases(self, case):
global test_result, cookie, before_amount
url = case['Url']
method = case['Method']
param = case['Param'] # 如Param参数中，有id这个key
if param.get('id'):
param['id'] = getattr(GetData, 'loan_id') # 把loan_id替换成id的value
if param.get('mobilephone'): # 把参数中的mobilephone参数化
param['mobilephone'] = getattr(GetData, 'mobilephone')
if param.get('pwd'): # 把参数中的pwd参数化
param['pwd'] = getattr(GetData, 'pwd')
if param.get('memberId'): # 把参数中的mobilephone参数化
param['memberId'] = getattr(GetData, 'memberId')
case_id = case['CaseId']
module = case['Module']
sql = case['Sql']
if sql is not None: # 把sql中的mobilephone参数化
if sql.get('sql'):
if sql['sql'].find('mobilephone') != -1:
sql['sql'] = sql['sql'].replace(
'mobilephone', str(getattr(GetData, 'mobilephone')))
expected_result = case['ExpectedResult']
if expected_result.get('data'): #参数化excepect_result中的电话号码
if expected_result['data'].get('mobilephone'):
expected_result['data']['mobilephone'] = str(
getattr(GetData,
'mobilephone')) #expect_result中mobilephone为str
Log.info('--用例参数为{}'.format(case))
if module == 'recharge' and case_id == 2 or module == 'add_loan' and case_id == 3: # 查询投资和充值前的金额
before_amount = DoMsq().my_sql(sql['sql'], 1)
actual_result = HttpRequest().http_request(url, method, param,
cookie) # 返回 resp
Log.info('--返回结果为:{}'.format(actual_result.json()))
if actual_result.cookies:
cookie = actual_result.cookies
Log.info('---第{}条{}模块用例，返回结果{}---'.format(case_id, module,
actual_result.text))
# a=sql['sql']
try:
if module == 'add_loan' and case_id == 2: # 取出加标后的loan_id
loan_id = DoMsq().my_sql(sql['sql'], 1)
setattr(GetData, 'loan_id', loan_id[0])
if module == 'recharge' and case_id == 2: # 查询充值后的金额
after_charge = DoMsq().my_sql(
sql['sql'], 1) # sql是返回一个元组，元组中元素什么类型取决于数据库字段类型
setattr(GetData, 'after_charge',
after_charge[0]) # 赋值给after_charge是数字类型
expected_result['data']['leaveamount'] = str(
getattr(GetData, 'after_charge'))
recharge_amount = getattr(GetData, 'after_charge') - int(
before_amount[0]) # 充值金额=充值后的金额-充值前的金额
self.assertEqual(recharge_amount,
int(param['amount'])) # 判断数据库中充值后的金额是否正确
if module == 'add_loan' and case_id == 3: # 查询投资后的金额
after_invest = DoMsq().my_sql(
sql['sql'], 1) # sql是返回一个元组，元组中元素什么类型取决于数据库字段类型
setattr(GetData, 'after_invest', after_invest[0])
invest_amount = before_amount[0] - getattr(
GetData, 'after_invest') # 投资金额=投资前的金额-投资后的金额
self.assertEqual(invest_amount,
int(param['amount'])) # 判断数据库中投资后的金额是否正确
self.assertEqual(expected_result, actual_result.json())
test_result = 'Pass'
except Exception as e:
test_result = 'Fail'
Log().error(traceback.format_exc())
raise e
finally:
Log.info('开始写回测试结果{}'.format(actual_result.json()))
if module == 'recharge':
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 10, test_result)
elif module in ('register', 'login'):
DoExcel(project_path.test_cases_path).write_excel(
'Sheet1', case_id + 1, 8, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'Sheet1', case_id + 1, 9, test_result)
elif module == 'withdraw':
DoExcel(project_path.test_cases_path).write_excel(
'withdraw', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'withdraw', case_id + 1, 10, test_result)
elif module == 'add_loan':
DoExcel(project_path.test_cases_path).write_excel(
'add_loan', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'add_loan', case_id + 1, 10, test_result)
elif module in ('audit', 'invest'):
DoExcel(project_path.test_cases_path).write_excel(
'audit', case_id + 1, 9, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'audit', case_id + 1, 10, test_result)
def tearDownClass(cls):
Log.info('TestGetDetailByAcceptHK END HK端')
def tearDownClass(cls):
Log.info('TestQueryUpdateFlagBB END BB端')
class BasePage(object):
original_window = None
def __init__(self, driver):
"""
:param driver:打开浏览器驱动
:param base_url:输入测试url
:param pagetitle:输入页面title
"""
self.driver = driver
self.logger = Log()
def browser(self, browser="Chrome"):
"""
打开浏览器函数,Firefox,chrome,IE
默认Chrome浏览器
"""
try:
if browser == "Chrome" or browser == "chrome":
options = webdriver.ChromeOptions()
prefs = {
'profile.default_content_settings.popups': 0,
'download.default_directory': globalparam.download_path
}
options.add_experimental_option('prefs', prefs)
# cap=webdriver.DesiredCapabilities.CHROME()
# cap..setglobalparam.download_path
driver = webdriver.Chrome(
chrome_options=options,
executable_path=globalparam.driver_path)
return driver
elif browser == "Firefox" or browser == "firefox":
driver = webdriver.Firefox(
executable_path=globalparam.driver_path)
return driver
elif browser == "IE" or browser == "ie":
driver = webdriver.Ie(executable_path=globalparam.driver_path)
return driver
else:
logger.error("找不到驱动")
except Exception as msg:
logger.error("%s" % msg)
def getElement(self, *param, timeout=10):
'''
根据传入的查找类型查找元素
:param param[0]: 查找元素的方式
:param param[1]: 元素值
:timeout: 超时时间设置
:return: 查找到的元素
'''
if param[0] == "id":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located((By.ID, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == "class":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located((By.CLASS_NAME, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == "name":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located((By.NAME, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == "css":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located(
(By.CSS_SELECTOR, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == "linktext":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located((By.LINK_TEXT, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == "partcialtext":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located(
(By.PARTIAL_LINK_TEXT, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == "tag":
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located((By.TAG_NAME, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[0]))
elif param[0] == 'xpath':
try:
element = WebDriverWait(self.driver, timeout).until(
EC.presence_of_element_located((By.XPATH, param[1])))
return element
except:
self.logger.error("查找 %s 元素超时,类型为 %s！！" % (param[1], param[1]))
elif param[0] == 'js' or param[0] == "jquery":
return self.ExcuteJs(param[1])
else:
self.logger.error("请输入适合的查找元素方式。。。")
def clear_text(self, *param):
'''
输入文本框清空操作
:param param[0]: 查找元素的方式
:param param[1]: 元素值
'''
element = BasePage.getElement(self, param[0], param[1])
try:
element.clear()
self.logger.info('清空文本框内容')
except NameError as ne:
self.logger.error("清空文本框内容失败: %s" % ne)
self.get_screent_img()
def click_element(self, *param):
"""
点击某个元素
:param param[0]: 查找元素的方式
:param param[1]: 元素值
"""
try:
element = BasePage.getElement(self, param[0], param[1])
element.click()
self.logger.info('成功点击元素 %s: %s...' % (param[0], param[1]))
time.sleep(2)
except:
self.logger.error("无法点击元素 %s: %s..." % (param[0], param[1]))
raise
def get_text(self, *param):
'''
获取文本
:param param[0]: 查找元素的方式
:param param[1]: 元素值
'''
element = BasePage.getElement(self, param[0], param[1])
return element.text
def send_key(self, *param):
"""
文本框输入内容
:param param[0]: 查找元素的方式
:param param[1]: 元素值
:param param[3]: 输入文本的内容
"""
BasePage.getElement(self, param[0], param[1]).clear()
self.logger.info('清空%s:%s文本框内容' % (param[0], param[1]))
time.sleep(1)
self.logger.info('在 %s:%s在输入内容 %s' % (param[0], param[1], param[2]))
try:
BasePage.getElement(self, param[0], param[1]).send_keys(param[2])
time.sleep(2)
except Exception as e:
self.logger.error("在 %s：%s 中输入内容 %s 失败! " %
(param[0], param[1], param[2]))
def move_to_element(self, *param):
'''
鼠标悬停操作
:param param[0]: 查找元素的方式
:param param[1]: 元素值
Usage:
element = ("id","xxx")
driver.move_to_element(element)
'''
element = BasePage.getElement(self, param[0], param[1])
ActionChains(self.driver).move_to_element(element).perform()
def close(self):
"""
关闭浏览器
"""
try:
self.driver.close()
self.logger.info('关闭浏览器窗口')
except NameError as ne:
self.logger.error("关闭浏览器窗口失败 %s" % ne)
def quit(self):
"""
退出浏览器
"""
self.driver.quit()
def browser_back(self):
"""
浏览器后退
"""
self.driver.back()
def browser_forward(self):
"""
浏览器前进
"""
self.driver.forward(self)
def open_url(self, url):
"""
打开站点
"""
self.driver.get(url)
def get_page_title(self):
'''当前页面title'''
self.logger.info("当前页面的title为: %s" % self.driver.title)
return self.driver.title
def get_screent_img(self):
'''将页面截图下来'''
file_path = os.path.dirname(
os.path.abspath('.')) + globalparam.img_path
now = time.strftime("%Y-%m-%d_%H_%M_%S_")
screen_name = file_path + now + '.png'
try:
self.driver.get_screenshot_as_file(screen_name)
logger.info("页面已截图,截图的路径在项目: %s下" % globalparam.img_path)
except NameError as ne:
logger.error("失败截图 %s" % ne)
self.get_screent_img()
def tearDownClass(cls):
Log.info('TestComputeGenHK END HK端')
def tearDownClass(cls):
Log.info('TestUpLoadFileHK END HK端')
def tearDownClass(cls):
Log.info('TestVCFStartHK END HK端')
def tearDownClass(cls):
Log.info('TestUpLoadFileBB END BB端')
class LogEventListener(AbstractEventListener):
def __init__(self):
self.log = Log()
def before_navigate_to(self, url, driver):
self.log.info('\033[0;32m 前往新页面前URL:%s' % urllib.parse.unquote(driver.current_url, encoding="utf-8"))
def after_navigate_to(self, url, driver):
self.log.info('\033[0;32m 前往新页面后URL:%s' % urllib.parse.unquote(driver.current_url, encoding="utf-8"))
def before_navigate_back(self, driver):
pass
def after_navigate_back(self, driver):
pass
def before_navigate_forward(self, driver):
pass
def after_navigate_forward(self, driver):
pass
def before_find(self, by, value, driver):
time.sleep(5)
# self.log.info('\033[0;32m before_find:{by:%s},{value:%s},{url:%s}' % (by, value, urllib.parse.unquote(driver.current_url, encoding="utf-8")))
def after_find(self, by, value, driver):
time.sleep(5)
# self.log.info('\033[0;32m before_find:{by:%s},{value:%s},{url:%s}' % (by, value, urllib.parse.unquote(driver.current_url, encoding="utf-8")))
def before_click(self, element, driver):
self.log.info('\033[0;32m 点击元素文本:%s,跳转前页面:%s' % (
element.text, urllib.parse.unquote(driver.current_url, encoding="utf-8")))
def after_click(self, element, driver):
time.sleep(5)
self.log.info('\033[0;32m 跳转后页面:%s' % urllib.parse.unquote(driver.current_url, encoding="utf-8"))
def before_change_value_of(self, element, driver):
self.log.info('\033[0;32m 改变前元素文本:%s' % element.text)
def after_change_value_of(self, element, driver):
time.sleep(1)
self.log.info('\033[0;32m 改变后元素文本:%s' % element.text)
def before_execute_script(self, script, driver):
pass
def after_execute_script(self, script, driver):
pass
def before_close(self, driver):
pass
def after_close(self, driver):
pass
def before_quit(self, driver):
pass
def after_quit(self, driver):
pass
def on_exception(self, exception, driver):
pass
print(str(ex))
log.info(str(ex))
finally:
print("*********TEST END*********")
log.info("*********TEST END*********")
fp.close()
log.info("发送邮件开始")
Email.send_email(REPORTER_PATH)
log.info("发送邮件成功")
# pythoncom.CoInitialize()
# scheduler = BlockingScheduler()
# scheduler.add_job(AllTest().run, 'cron', day_of_week='1-5', hour=14, minute=59)
# scheduler.start()
if __name__ == '__main__':
start_time = time.time()
suit = AllTest().set_case_suite()
AllTest().run(suit)
end_time = time.time()
log.info('总时长=%.4f' % (end_time - start_time))
# tests = AllTest()
# tests.run()
'''
1、生成的测试报告有问题
2、时间没有减少太多
'''
