def __init__(self):
self.parseExcel = ParseExcel()
self.log = Log()
self.select = SelectTheSorting()
self.pa = PageAction()
self.pj = ParseJson()
self.rm = RequestMethod()
def setUp(self):
self.parseyaml = ParseYaml()
self.testdata_path = self.parseyaml.ReadParameter('ImportAddress')
self.parseexcel = ParseExcel(self.testdata_path)
self.pageaction = PageAction()
self.sheetnames = self.parseexcel.wb.sheetnames
self.parameter = CONFIG_PATH + 'Parameter.yaml'
self.CaseNum = 0
# 创建六个字典，分别储存步骤测试结果，用例测试结果，用例测试时间，错误信息，截图信息，步骤测试时间
self.time_dic = {}
self.result_dic = {}
self.error_dic = {}
self.picture_dic = {}
self.caseResult_dic = {}
self.caseTime_dic = {}
self.font = Font(color=None)
class Login(object):
# 构造函数
def __init__(self):
self.pa = PageAction()
self.pc = ParseConfig()
self.log = Log()
# 登录方法
def loginMethod(self):
# 打开浏览器
self.pa.openBrowser(self.pc.getValue("addres", "url"))
self.log.info("打开浏览器")
# 输入用户名
self.pa.pageMotion(motion="input", locatorExpression="//input[@placeholder='请输入账号']",
value=self.pc.getValue("login", "username"))
self.log.info("输入用户名")
# 输入密码
self.pa.pageMotion(motion="input", locatorExpression="//input[@placeholder='请输入密码']",
value=self.pc.getValue("login", "password"))
self.log.info("输入密码")
# 点击登录
self.pa.pageMotion(motion="click", locatorExpression="//button[@type='button']")
self.log.info("点击登录")
def __init__(self):
self.login = Login()
self.pa = PageAction()
self.pj = ParseJson()
self.log = Log()
class SelectTheSorting(object):
# 构造函数
def __init__(self):
self.login = Login()
self.pa = PageAction()
self.pj = ParseJson()
self.log = Log()
def selectSort(self, area, branch):
# 登录
self.login.loginMethod()
# 选择区域
# if area == "北京区域":
# 选择区域
self.pa.pageMotion(motion='click', locatorExpression="//input[@placeholder='请选择二级组织']")
self.pa.pageMotion(motion='click', locatorExpression="//span[contains(text()," + "'" + area + "' " + ")]")
self.log.info("选择" + area)
if branch != None:
self.pa.pageMotion(motion='click', locatorExpression="//input[@placeholder='请选择三级组织']")
self.pa.pageMotion(motion='click', locatorExpression="//span[contains(text()," + "'" + branch + "' " + ")]")
self.log.info("选择" + branch)
else:
pass
# print("//span[contains(text(),"+"'"+area+"' " +")]")
# 选择角色
self.pa.pageMotion(motion='click', locatorExpression="//input[@placeholder='请选择角色']")
self.pa.pageMotion(motion='click', locatorExpression="//span[contains(text(), '分院IT')]")
self.log.info("选择分院IT角色")
self.pa.pageMotion(motion='click_sleep', locatorExpression="//button[@type='button']")
self.log.info("点击进入")
def role(self):
# print(self.pj.getRoleData("area"))
# print()
self.pa.pageMotion(motion='click', locatorExpression="//input[@placeholder='请选择二级组织']")
self.pa.pageMotion(motion='click', locatorExpression="//span[contains(text()," + "'" + self.pj.getRoleData(
"area") + "' " + ")]")
self.pa.pageMotion(motion='click', locatorExpression="//input[@placeholder='请选择三级组织']")
self.pa.pageMotion(motion='click', locatorExpression="//span[contains(text()," + "'" + self.pj.getRoleData(
"branch") + "' " + ")]")
class TestCase(object):
# 构造函数
def __init__(self):
self.parseExcel = ParseExcel()
self.log = Log()
self.select = SelectTheSorting()
self.pa = PageAction()
self.pj = ParseJson()
self.rm = RequestMethod()
# 加载测试用例
# @app.task
def ruCase(self, area, branch):
'''
:return: 运行测试用例
'''
# select = SelectTheSorting()
self.select.selectSort(area, branch)
startTime, excel_id, excel_step, excel_motion, excel_locatorExpression, \
excel_hoverLocator, excel_value, excel_expect, excel_getText, \
excel_locatorExpressionResult, excel_runResult = self.parseExcel.getCaseData()
self.log.info("用例开始时间:" + startTime)
# print(excel_id)
# print(excel_step)
# print(excel_motion)
# print(len(excel_id))
# print(excel_getText)
caseNum = len(excel_id) - 1
pass_count = []
fail_count = []
exception = []
for i in range(len(excel_id)):
# print(i)
id = str(excel_id[i])
step = excel_step[i]
motion = excel_motion[i]
# print(motion)
locatorExpression = excel_locatorExpression[i]
hoverLocator = excel_hoverLocator[i]
value = excel_value[i]
getText = excel_getText[i]
# print(getText)
expect = excel_expect[i]
locatorExpressionResult = excel_locatorExpressionResult[i]
# print(locatorExpressionResult)
if motion == "click":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "click_bottom":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "click_top":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "input":
if value == 'number':
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression,
value=self.pj.getJsonData(value))
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if self.pj.getJsonData(value) in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
else:
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression, value=value)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
if isinstance(expect, int):
expect = str(expect)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
else:
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "hover":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "double_click":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "double_click_esc":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "enter":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "top":
self.pa.pageMotion(motion=motion)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "click_esc":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "click_role":
self.select.role()
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "步" + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "click_sleep":
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "click_await":
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
self.pa.pageMotion(motion=motion, locatorExpression=locatorExpression)
result = self.pa.pageMotion(motion=getText, locatorExpression=locatorExpressionResult)
try:
if expect in result:
self.parseExcel.writeCell(i + 2, 10, "pass")
self.log.info("第" + id + "步：" + step + "-----pass")
pass_count.append(i)
else:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----fail")
fail_count.append(i)
self.pa.pageMotion(motion='quit')
break
except:
self.parseExcel.writeCell(i + 2, 10, "fail")
self.log.info("第" + id + "步：" + step + "-----exception")
exception.append(i)
self.pa.pageMotion(motion='quit')
break
self.rm.runMethod(caseCount=caseNum, startTime=startTime, casePresent=id)
elif motion == "quit":
self.parseExcel.writeCell(i + 2, 10, "pass")
self.pa.pageMotion(motion=motion)
excelstartTime, excelid, excelstep, excelmotion, excellocatorExpression, \
excelhoverLocator, excelvalue, excelexpect, excelgetText, \
excellocatorExpressionResult, runResult = self.parseExcel.getCaseData()
# endTime = datetime.datetime.now()
endTime = time.strftime('%Y-%m-%d %H:%M:%S')
self.log.info("用例结束时间:" + endTime)
# sumCase = len(pass_count) + len(fail_count)
pr = len(pass_count) / caseNum
# passingRate = '{:.0%}'.format(pr)
passingRate = "%.2f" % pr
fr = len(fail_count) / caseNum
# failureRate = '{:.0%}'.format(fr)
failureRate = "%.2f" % fr
print(failureRate)
self.log.info("用例通过条数" + str(len(pass_count)))
self.log.info("用例失败条数：" + str(len(fail_count)))
self.log.info("xpath定位失败：" + str(len(exception)))
message = None
if len(pass_count) == caseNum:
message = 1 # 1代表成功
if len(fail_count) > 0:
message = 2 # 2代表失败
if len(exception) > 0:
message = 3 # 3代表未找到定位元素
# print(message)
return startTime, endTime, caseNum, len(pass_count), len(fail_count), passingRate, failureRate, \
excel_id, excel_step, excel_motion, excel_locatorExpression, excel_value, excel_expect, excel_getText, \
excel_locatorExpressionResult, runResult, message
def __init__(self):
self.pa = PageAction()
self.pc = ParseConfig()
self.log = Log()
class RunnerTestCase(unittest.TestCase):
def setUp(self):
self.parseyaml = ParseYaml()
self.testdata_path = self.parseyaml.ReadParameter('ImportAddress')
self.parseexcel = ParseExcel(self.testdata_path)
self.pageaction = PageAction()
self.sheetnames = self.parseexcel.wb.sheetnames
self.parameter = CONFIG_PATH + 'Parameter.yaml'
self.CaseNum = 0
# 创建六个字典，分别储存步骤测试结果，用例测试结果，用例测试时间，错误信息，截图信息，步骤测试时间
self.time_dic = {}
self.result_dic = {}
self.error_dic = {}
self.picture_dic = {}
self.caseResult_dic = {}
self.caseTime_dic = {}
self.font = Font(color=None)
def test_Case(self):
try:
# self.setUp()
# 获取循环次数
loop = int(self.parseyaml.ReadParameter('loop'))
# 获取模块名
moudle = self.parseyaml.ReadParameter('Moudle')
# 清除用例旧数据
self.parseexcel.clearCaseColumnValue(self.sheetnames[0])
# 清除步骤旧数据
for i, v in enumerate(self.sheetnames):
if i == 0:
continue
else:
self.parseexcel.clearStepColumnValue(v)
for l in range(loop):
# 用例运行数
try:
# 获取'是否执行'列
isimplement = self.parseexcel.getColumnValue(self.sheetnames[0], testCase_Isimplement)
# 循环'是否执行'列
# 如果执行，且模块名符合，则获取用例编号，并切换到对应的工作表，执行用例
for index, value in enumerate(isimplement):
if moudle == '全部':
pd = "value.lower() == 'y'"
else:
pd = 'value.lower() == "y" and moudle ' \
'== self.parseexcel.getCellValue(self.sheetnames[0], index + 2, testCase_Sheet)'
try:
# 如果是否执行为空则跳过执行
if value is None or value == '':
continue
elif eval(pd):
# 根据'是否执行'；列索引获取对应的工作表名
sheetname = self.parseexcel.getCellValue(self.sheetnames[0], index + 2, testCase_Sheet)
# 根据'是否执行'列索引获取对应的用例编号
testcasenum = self.parseexcel.getCellValue(self.sheetnames[0], index + 2, testCase_Num)
# 切换到用例对应的工作表
# sheetnames = self.parseexcel.wb[sheetname]
'''
根据用例编号(testcasenum)获取预置条件编号
'''
# 获取用例步骤的用例编号类，并执行对应用例编号的用例步骤（增加表内是否有合并单元格的判断）
if self.parseexcel.ismerge(sheetname):
teststepnum = self.parseexcel.getMergeColumnValue(sheetname, testStep_Num)
else:
teststepnum = self.parseexcel.getColumnValue(sheetname, testStep_Num)
# 循环用例步骤编号，根据索引获取预置条件编号
testPrenum = ''
for i, v in enumerate(teststepnum):
if v == testcasenum:
# 用例前置条件编号
testPrenum = self.parseexcel.getCellValue(sheetname, i + 2, testStep_Preset)
break
# 循环用例步骤编号，找到与预置条件编号相同的用例步骤编号
# 循环所有的步骤编号
# 获取对应用例编号的步骤编号的关键字，定位方式，表达式，操作值
url = ParseYaml().ReadParameter('IP')
while re.match(r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$", url) is None and re.match(r'[^\s]*[.com|.cn]', url) is None:
url = ParseYaml().ReadParameter('IP') # 从输入框获取浏览器地址
# 先打开浏览器，进入指定IP地址
time.sleep(1)
self.pageaction.openBrowser()
self.pageaction.getUrl('http://%s' % url)
# 执行预置条件
for t, v in enumerate(teststepnum):
if v == testPrenum:
# 用例执行步骤
pre_stepname = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Describe)
# 获取预置条件关键字
pre_keyword = self.parseexcel.getCellValue(sheetname, t + 2, testStep_KeyWord)
# 去除前后空格
if pre_keyword is not None:
pre_keyword = pre_keyword.strip()
# 获取定位方式
pre_location = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Location)
# 去除前后空格
if pre_location is not None:
pre_location = pre_location.strip()
# 获取定位表达式
pre_locator = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Locator)
if type(pre_locator) is int:
pre_locator = str(self.parseexcel.getCellValue(sheetname, t + 2, testStep_Locator))
# 获取输入值
pre_testvalue = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Value)
# 如果输入值为 int 类型，则强转为 str 类型，用于字符串拼接
if type(pre_testvalue) is int:
pre_testvalue = str(self.parseexcel.getCellValue(sheetname, t + 2, testStep_Value))
# 总共有四种情况可以正常执行，其他情况则会将用例判断为运行失败
# 1.关键字，定位方式，表达式，输入值全部不为空的情况 例：send_keys
# 2.关键字，输入值不为空，定位方式，表达式为空的情况 例：assert（断言）
# 3.关键字，定位方式，表达式不为空，输入值为空的情况 例：click
# 4.关键字不为空，定位方式，表达式，输入值为空的情况 例 getTitle
if pre_keyword and pre_location and pre_locator and pre_testvalue:
pre_fun = 'self.pageaction' + '.' + pre_keyword + '(' + '"' + pre_location + '"' + ', ' + '"' + pre_locator + '"' + ', ' + '"' + \
pre_testvalue + '"' + ')'
elif pre_keyword and pre_testvalue and pre_location is None or pre_location == '' \
and pre_locator is None or pre_location == '':
pre_fun = 'self.pageaction' + '.' + pre_keyword + '(' + '"' + pre_testvalue + '"' + ')'
elif pre_keyword and pre_location and pre_locator and pre_testvalue is None or pre_testvalue == '':
pre_fun = 'self.pageaction' + '.' + pre_keyword + '(' + '"' + pre_location + '"' + ', ' + '"' + pre_locator + '"' + ')'
elif pre_keyword and pre_location is None or pre_location == '' and pre_locator is None \
or pre_locator == '' and pre_testvalue is None or pre_testvalue == '':
pre_fun = 'self.pageaction' + '.' + pre_keyword + '(' + ')'
elif pre_keyword is None or pre_keyword == '' and pre_location is None or pre_location == '' \
and pre_locator is None or pre_locator == '' and pre_testvalue is None or pre_testvalue == '':
continue
else:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t+2] = '关键字对应参数错误'
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '关键字对应参数错误')
logger.info('关键字对应参数错误')
print('关键字对应参数错误')
continue
# 执行用例
try:
# eval 将字符串转换为可执行的python语句
eval(pre_fun)
# 抛出异常的情况，将失败结果写入excel表格中
except TypeError:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t+2] = '关键字参数个数错误，请检查参数'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '关键字参数个数错误，请检查参数')
logger.info('步骤"{}"执行失败'.format(pre_stepname))
logger.info('关键字参数个数错误，请检查参数')
print('步骤"{}"执行失败'.format(pre_stepname))
print('关键字参数个数错误，请检查参数')
except TimeoutException:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t+2] = '元素定位超时，' \
'请检查上一步是否执行成功，或元素定位方式'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '元素定位超时，'
# '请检查上一步是否执行成功，或元素定位方式')
logger.info('步骤"{}"执行失败'.format(pre_stepname))
logger.info('元素定位超时，请检查上一步是否执行成功，或元素定位方式')
print('步骤"{}"执行失败'.format(pre_stepname))
print('元素定位超时，请检查上一步是否执行成功，或元素定位方式')
except TimeoutError as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Failed'
self.error_dic.setdefault(sheetname, {})[t + 2] = '断言失败'
logger.info('步骤"{}"执行失败'.format(pre_stepname))
print('步骤"{}"执行失败'.format(pre_stepname))
logger.info(e)
except AttributeError as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = '元素定位超时，请检查元素定位'
logger.info('步骤"{}"执行失败'.format(pre_stepname))
print('步骤"{}"执行失败'.format(pre_stepname))
logger.info(e)
except AssertionError:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Failed'
self.error_dic.setdefault(sheetname, {})[t+2] = '断言失败'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Failed')
# self.parseexcel.writeCellValues(sheetname, t + 2, '断言失败')
logger.info('步骤"{}"执行失败'.format(pre_stepname))
print('步骤"{}"执行失败'.format(pre_stepname))
except WebDriverException:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t+2] = '浏览器异常，' \
'请检查浏览器驱动或运行过程中是否被强制关闭'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '浏览器异常，'
# '请检查浏览器驱动或运行过程中是否被强制关闭')
logger.info('步骤"{}"执行失败'.format(pre_stepname))
logger.info('浏览器异常，请检查浏览器驱动或运行过程中是否被强制关闭')
print('步骤"{}"执行失败'.format(pre_stepname))
print('浏览器异常，请检查浏览器驱动或运行过程中是否被强制关闭')
except Exception:
error_info = traceback.format_exc()
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t+2] = error_info
# # 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, error_info)
logger.info('步骤"{}"执行失败'.format(pre_stepname))
print('步骤"{}"执行失败'.format(pre_stepname))
else:
# 写入测试结果
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t+2] = 'Pass'
# self.parseexcel.writeCellValue(sheetname, t + 2, testStep_Result+l, 'Pass')
logger.info('步骤"{}"执行成功'.format(pre_stepname))
print('步骤"{}"执行成功'.format(pre_stepname))
finally:
# 截图
bf.add_test_img()
pic = self.pageaction.saveScreeShot(sheetname, testcasenum)
# 将截图信息以及测试时间存入字典中
Time = datetime.now()
Time.strftime('%Y:%m:%d %H:%M:%S')
self.picture_dic.setdefault(sheetname, {})[t+2] = pic
self.time_dic.setdefault(sheetname, {})[t + 2] = Time
# self.parseexcel.writeCellValue(sheetname, t + 2, testStep_Picture, pic)
# self.parseexcel.writeCellTime(sheetname, t + 2, testStep_EndTime)
else:
continue
# 将用例步骤工作表内的用例编号以字典的方式循环
for t, v in enumerate(teststepnum):
# 用例步骤（用例编号） 与 用例列表（用例编号）相同的
if v == testcasenum:
# 用例执行步骤
stepname = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Describe)
# 获取关键字
keyword = self.parseexcel.getCellValue(sheetname, t + 2, testStep_KeyWord)
# 去除前后空格
if keyword is not None:
keyword = keyword.strip()
# 获取定位方式
location = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Location)
# 去除前后空格
if location is not None:
location = location.strip()
# 获取定位表达式
locator = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Locator)
if type(locator) is int:
locator = str(self.parseexcel.getCellValue(sheetname, t + 2, testStep_Locator))
# 获取输入值
testvalue = self.parseexcel.getCellValue(sheetname, t + 2, testStep_Value)
# 如果输入值为 int 类型，则强转为 str 类型，用于字符串拼接
if testvalue is not None and type(testvalue) is not str:
testvalue = str(self.parseexcel.getCellValue(sheetname, t + 2, testStep_Value))
# if testvalue.lower() == 'none':
# testvalue = ''
# 进行关键字拼接
# 总共有四种情况可以正常执行，其他情况则会将用例判断为运行失败
# 1.关键字，定位方式，表达式，输入值全部不为空的情况 例：send_keys
# 2.关键字，输入值不为空，定位方式，表达式为空的情况 例：assert（断言）
# 3.关键字，定位方式，表达式不为空，输入值为空的情况 例：click
# 4.关键字不为空，定位方式，表达式，输入值为空的情况 例 getTitle
if keyword and location and locator and testvalue:
fun = 'self.pageaction' + '.' + keyword + '(' + '"' + location + '"' + ', ' + '"' + locator + '"' + ', ' + '"' + \
testvalue + '"' + ')'
elif keyword and testvalue and location is None or location == '' \
and locator is None or location == '':
fun = 'self.pageaction' + '.' + keyword + '(' + '"' + testvalue + '"' + ')'
elif keyword and location and locator and testvalue is None or testvalue == '':
fun = 'self.pageaction' + '.' + keyword + '(' + '"' + location + '"' + ', ' + '"' + locator + '"' + ')'
elif keyword and location is None or location == '' and locator is None \
or locator == '' and testvalue is None or testvalue == '':
fun = 'self.pageaction' + '.' + keyword + '(' + ')'
elif keyword is None or keyword == '' and location is None or location == '' \
and locator is None or locator == '' and testvalue is None or testvalue == '':
continue
else:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = '关键字对应参数错误'
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '关键字对应参数错误')
logger.info('关键字对应参数错误')
print('关键字对应参数错误')
continue
# 执行用例
try:
# eval 将字符串转换为可执行的python语句
eval(fun)
# 抛出异常的情况，将失败结果写入excel表格中
except TypeError as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = '关键字参数个数错误，请检查参数'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '关键字参数个数错误，请检查参数')
logger.info('步骤"{}"执行失败'.format(stepname))
logger.info('关键字参数个数错误，请检查参数')
print('步骤"{}"执行失败'.format(stepname))
print('关键字参数个数错误，请检查参数')
logger.info(e)
except TimeoutException as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = '元素定位超时，' \
'请检查上一步是否执行成功，或元素定位方式'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '元素定位超时，'
# '请检查上一步是否执行成功，或元素定位方式')
logger.info('步骤"{}"执行失败'.format(stepname))
logger.info('元素定位超时，请检查上一步是否执行成功，或元素定位方式')
print('步骤"{}"执行失败'.format(stepname))
print('元素定位超时，请检查上一步是否执行成功，或元素定位方式')
logger.info(e)
except TimeoutError as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Failed'
self.error_dic.setdefault(sheetname, {})[t + 2] = '断言失败'
logger.info('步骤"{}"执行失败'.format(stepname))
print('步骤"{}"执行失败'.format(stepname))
logger.info(e)
except AttributeError as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = '元素定位超时，请检查元素定位'
logger.info('步骤"{}"执行失败'.format(stepname))
print('步骤"{}"执行失败'.format(stepname))
logger.info(e)
except AssertionError as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Failed'
self.error_dic.setdefault(sheetname, {})[t + 2] = '断言失败'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Failed')
# self.parseexcel.writeCellValues(sheetname, t + 2, '断言失败')
logger.info('步骤"{}"执行失败'.format(stepname))
print('步骤"{}"执行失败'.format(stepname))
logger.info(e)
except WebDriverException as e:
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = '浏览器异常，' \
'请检查浏览器驱动或运行过程中是否被强制关闭'
# 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, '浏览器异常，'
# '请检查浏览器驱动或运行过程中是否被强制关闭')
logger.info('步骤"{}"执行失败'.format(stepname))
logger.info('浏览器异常，请检查浏览器驱动或运行过程中是否被强制关闭')
print('步骤"{}"执行失败'.format(stepname))
print('浏览器异常，请检查浏览器驱动或运行过程中是否被强制关闭')
logger.info(e)
except Exception:
error_info = traceback.format_exc()
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Skip'
self.error_dic.setdefault(sheetname, {})[t + 2] = error_info
# # 写入测试时间，测试结果，错误信息，错误截图
# self.parseexcel.writeCellValue(sheetname, t+2, testStep_Result+l, 'Skip')
# self.parseexcel.writeCellValues(sheetname, t + 2, error_info)
logger.info('步骤"{}"执行失败'.format(stepname))
print('步骤"{}"执行失败'.format(stepname))
else:
# 写入测试结果
# 将结果以及错误信息存入字典
self.result_dic.setdefault(sheetname, {})[t + 2] = 'Pass'
# self.parseexcel.writeCellValue(sheetname, t + 2, testStep_Result+l, 'Pass')
logger.info('步骤"{}"执行成功'.format(stepname))
print('步骤"{}"执行成功'.format(stepname))
finally:
# 截图
bf.add_test_img()
pic = self.pageaction.saveScreeShot(sheetname, testcasenum)
# 将截图信息以及测试时间存入字典中
Time = datetime.now()
Time.strftime('%Y:%m:%d %H:%M:%S')
self.picture_dic.setdefault(sheetname, {})[t + 2] = pic
self.time_dic.setdefault(sheetname, {})[t + 2] = Time
# self.parseexcel.writeCellValue(sheetname, t + 2, testStep_Picture, pic)
# self.parseexcel.writeCellTime(sheetname, t + 2, testStep_EndTime)
else:
continue
self.CaseNum += 1
YamlWrite().Write_Yaml_Updata(self.parameter, 'CaseNum', self.CaseNum)
self.pageaction.quitBrowser()
# 写入测试结果
for r, v in self.result_dic.items():
for a, b in v.items():
if b == 'Pass':
self.parseexcel.wb[r].cell(int(a), testStep_Result + l).font = Font(color='33ff33')
self.parseexcel.wb[r].cell(int(a), testStep_Result + l, b)
elif b == 'Failed':
self.parseexcel.wb[r].cell(int(a), testStep_Result + l).font = Font(color='cc0000')
self.parseexcel.wb[r].cell(int(a), testStep_Result + l, b)
elif b == 'Skip':
self.parseexcel.wb[r].cell(int(a), testStep_Result + l).font = Font(color='D1D1D1')
self.parseexcel.wb[r].cell(int(a), testStep_Result + l, b)
else:
continue
# 通过循环对应 用例编号的步骤的结果，全部为pass的则写入用例Pass，有一条失败的则写入Failed
for s, b in enumerate(teststepnum):
# 获取测试结果
if b == testcasenum:
if self.parseexcel.getCellValue(sheetname, s+2, testStep_Result) is None \
or self.parseexcel.getCellValue(sheetname, s+2, testStep_Result) == '':
continue
elif self.parseexcel.getCellValue(sheetname, s+2, testStep_Result) == 'Pass':
# 将用例测试结果存入字典
self.caseResult_dic.setdefault(self.sheetnames[0], {})[index+2] = 'Pass'
# self.parseexcel.writeCellValue(self.sheetnames[0], index+2, testCase_Result+l, 'Pass')
elif self.parseexcel.getCellValue(sheetname, s+2, testStep_Result) == 'Skip':
self.caseResult_dic.setdefault(self.sheetnames[0], {})[index+2] = 'Failed'
break
# self.parseexcel.writeCellValue(self.sheetnames[0], index + 2, testCase_Result+l,
# 'Failed')
else:
self.caseResult_dic.setdefault(self.sheetnames[0], {})[index+2] = 'Failed'
break
# self.parseexcel.writeCellValue(self.sheetnames[0], index + 2, testCase_Result+l,
# 'Failed')
Time = datetime.now()
Time.strftime('%Y:%m:%d %H:%M:%S')
# 增加时间写入，以及已运行数量统计
self.caseTime_dic.setdefault(self.sheetnames[0], {})[index+2] = Time
# self.parseexcel.writeCellTime(self.sheetnames[0], index + 2, testCase_EndTime)
# 增加用例时间运行间隔，默认1秒（通过配置文件进行修改）
time.sleep(self.parseyaml.ReadTimeWait('casetime'))
else:
continue
except Exception as e:
Time = datetime.now()
Time.strftime('%Y:%m:%d %H:%M:%S')
self.caseResult_dic.setdefault(self.sheetnames[0], {})[index + 2] = 'Failed'
self.caseTime_dic.setdefault(self.sheetnames[0], {})[index + 2] = Time
# self.parseexcel.writeCellTime(self.sheetnames[0], index + 2, testCase_EndTime)
# self.parseexcel.writeCellValue(self.sheetnames[0], index + 2, testCase_Result+l,
# 'Failed')
self.CaseNum += 1
YamlWrite().Write_Yaml_Updata(self.parameter, 'CaseNum', self.CaseNum)
logger.info(e)
logger.info('正在写入测试结果，请勿关闭界面...')
# 读取所有字典，将结果写入excel中
for t, v in self.time_dic.items():
for a, b in v.items():
self.parseexcel.wb[t].cell(int(a), testStep_EndTime, b)
for e, v in self.error_dic.items():
for a, b in v.items():
self.parseexcel.wb[e].cell(int(a), testStep_Error, b)
for p, v in self.picture_dic.items():
for a, b in v.items():
self.parseexcel.wb[p].cell(int(a), testStep_Picture).value = '=HYPERLINK("{}", "{}")'.format(b, b)
for ct, v in self.caseTime_dic.items():
for a, b in v.items():
self.parseexcel.wb[ct].cell(int(a), testCase_EndTime, b)
for cr, v in self.caseResult_dic.items():
for a, b in v.items():
if b == 'Pass':
self.parseexcel.wb[cr].cell(int(a), testCase_Result + l).font = Font(color='33ff33')
self.parseexcel.wb[cr].cell(int(a), testCase_Result + l, b)
elif b == 'Failed':
self.parseexcel.wb[cr].cell(int(a), testCase_Result + l).font = Font(color='cc0000')
self.parseexcel.wb[cr].cell(int(a), testCase_Result + l, b)
else:
continue
# 获取excel中'用例工作表'列的不为None的总行数
total_case = list(filter(None, self.parseexcel.getColumnValue(self.sheetnames[0], testCase_Sheet)))
# 写入excel表的总用例数单元格中
self.parseexcel.writeCellValue(self.sheetnames[0], 1, 2, len(total_case)-1)
# 循环执行结果列中为pass的列
pass_case = []
faild_case = []
for pi in list(filter(None, self.parseexcel.getColumnValue(self.sheetnames[0], testCase_Result))):
if pi.lower() == 'pass':
pass_case.append(pi)
elif pi.lower() == 'failed':
faild_case.append(pi)
else:
continue
# 写入excel表中的通过用例数单元格中
self.parseexcel.writeCellValue(self.sheetnames[0], 1, 4, len(pass_case))
# 写入excel表中的失败用例数单元格中
self.parseexcel.writeCellValue(self.sheetnames[0], 1, 6, len(faild_case))
# 循环是否执行列的中n的数量
n_case = []
for ni in list(filter(None, self.parseexcel.getColumnValue(self.sheetnames[0], testCase_Isimplement))):
if ni.lower() == 'n':
n_case.append(ni)
# 写入excel表中的未测试用例的单元格中
self.parseexcel.writeCellValue(self.sheetnames[0], 1, 8, len(n_case))
except Exception as e:
logger.info(e)
self.pageaction.quitBrowser()
finally:
self.parseexcel.wb.save(self.testdata_path)
logger.info('用例测试结束')
print('用例测试结束')
except Exception as e:
print(e)
# 异常结束时，关闭文件流
self.parseexcel.wb.close()
def RunReport(self):
report_path = ParseYaml().ReadParameter('ReportAddress') # 报告存放位置
timestr = time.strftime('%Y%m%d%H%M%S', time.localtime(time.time()))
filename = report_path+'\\'+timestr+'.html'
fp = open(filename, 'wb')
# suites = unittest.defaultTestLoader.discover(TESTCASE_PATH, pattern='test*.py', top_level_dir=TESTCASE_PATH)
suites = unittest.TestSuite()
suites.addTest(RunnerTestCase('test_Case'))
runner = HTMLTestRunner(
title='自动化测试报告',
description='',
stream=fp,
verbosity=2,
)
runner.run(suites)
fp.close()
def RunnerBeautifulReport(self):
suite = unittest.TestLoader().loadTestsFromTestCase(RunnerTestCase)
runner = bf(suite)
report_path = REPORT_PATH# 报告存放位置
timestr = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
filename = report_path+'\\'+timestr+'.html'
runner.report(filename = '\\'+'测试报告'+timestr+'.html', description=u"测试报告",report_dir=report_path,theme="theme_cyan")
# if __name__ == '__main__':
# RunnerTestCase().RunnerBeautifulReport()