class ObjectMap():
def __init__(self, driver):
self.driver = driver
self.parseyaml = ParseYaml()
self.byDic = {
'id': By.ID,
'name': By.NAME,
'css': By.CSS_SELECTOR,
'link_text': By.LINK_TEXT,
'xpath': By.XPATH,
'class': By.CLASS_NAME,
'tag': By.TAG_NAME,
'link': By.PARTIAL_LINK_TEXT
}
def getElement(self, by, locator):
"""
查找单个元素对象
:param driver:
:param by:
:param locator:
:return: 元素对象
"""
try:
if by.lower() in self.byDic:
element = WebDriverWait(
self.driver,
self.parseyaml.ReadTimeWait('elementtime')).until(
EC.presence_of_element_located(
(self.byDic[by.lower()], locator)))
logger.info('通过%s定位元素%s' % (by, locator))
return element
except Exception as e:
logger.info('元素定位失败')
print(e)
def getElements(self, by, locator):
'''
查找元素组
:param driver:
:param by:
:param locator:
:return: 元素组对象
'''
try:
if by.lower() in self.byDic:
elements = WebDriverWait(
self.driver,
self.parseyaml.ReadTimeWait('elementtime')).until(
EC.presence_of_all_elements_located((by, locator)))
logger.info('通过%s定位元素组%s' % (by, locator))
return elements
except Exception as e:
logger.info('元素组定位失败')
print(e)
def __init__(self):
self.parseyaml = ParseYaml()
self.byDic = {
'id': By.ID,
'name': By.NAME,
'css': By.CSS_SELECTOR,
'link_text': By.LINK_TEXT,
'xpath': By.XPATH,
'class': By.CLASS_NAME,
'tag': By.TAG_NAME,
'link': By.PARTIAL_LINK_TEXT
}
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 __init__(self, filename):
self.filename = filename
self.parseyaml = ParseYaml()
pythoncom.CoInitialize()
self.app = win32com.client.Dispatch('Excel.Application')
# 读取excel文件
self.wb = self.app.Workbooks.Open(filename)
pythoncom.CoInitialize()
self.logger = Logger('logger').getlog()
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()
class PageAction(object):
def __init__(self):
self.parseyaml = ParseYaml()
self.byDic = {
'id': By.ID,
'name': By.NAME,
'css': By.CSS_SELECTOR,
'link_text': By.LINK_TEXT,
'xpath': By.XPATH,
'class': By.CLASS_NAME,
'tag': By.TAG_NAME,
'link': By.PARTIAL_LINK_TEXT
}
def openBrowser(self):
version = self.parseyaml.ReadParameter('Version')
# 获取浏览器类型
browser = self.parseyaml.ReadParameter('Browser')
if browser == 'Google Chrome':
logger.info("选择的浏览器为:%s浏览器" % browser)
print("选择的浏览器为:%s浏览器" % browser)
if '70' == version:
path = DRIVERS_PATH + 'chrome\\' + '70.0.3538.97\\chromedriver.exe'
elif '71' == version:
path = DRIVERS_PATH + 'chrome\\' + '71.0.3578.137\\chromedriver.exe'
elif '72' == version:
path = DRIVERS_PATH + 'chrome\\' + '72.0.3626.69\\chromedriver.exe'
elif '73' == version:
path = DRIVERS_PATH + 'chrome\\' + '73.0.3683.68\\chromedriver.exe'
elif '74' == version:
path = DRIVERS_PATH + 'chrome\\' + '74.0.3729.6\\chromedriver.exe'
elif '75' == version:
path = DRIVERS_PATH + 'chrome\\' + '75.0.3770.140\\chromedriver.exe'
elif '76' == version:
path = DRIVERS_PATH + 'chrome\\' + '76.0.3809.126\\chromedriver.exe'
elif '77' == version:
path = DRIVERS_PATH + 'chrome\\' + '77.0.3865.40\\chromedriver.exe'
elif '78' == version:
path = DRIVERS_PATH + 'chrome\\' + '78.0.3904.11\\chromedriver.exe'
elif '79' == version:
path = DRIVERS_PATH + 'chrome\\' + '79.0.3945.16\\chromedriver.exe'
elif '86' == version:
path = DRIVERS_PATH + 'chrome\\' + '86.0.4240.22\\chromedriver.exe'
else:
logger.info('浏览器版本不符合，请检查浏览器版本')
return
option = Options()
option.add_experimental_option('w3c', False)
option.add_argument('--start-maximized')
self.driver = webdriver.Chrome(executable_path=path,
options=option)
logger.info('启动谷歌浏览器')
print('启动谷歌浏览器')
elif browser == 'FireFox':
logger.info("选择的浏览器为:%s浏览器" % browser)
path = DRIVERS_PATH + 'firefox\\' + 'geckodriver.exe'
self.driver = webdriver.Firefox(executable_path=path)
self.driver.maximize_window()
logger.info('启动火狐浏览器')
print('启动火狐浏览器')
else:
# 驱动创建完成后，等待创建实例对象
WaitUnit(self.driver)
def openBrowsers(self, browser):
try:
version = self.parseyaml.ReadParameter('Version')
# 获取浏览器类型
if browser == 'Google Chrome':
logger.info("选择的浏览器为:%s浏览器" % browser)
print("选择的浏览器为:%s浏览器" % browser)
if '70' == version:
path = DRIVERS_PATH + 'chrome\\' + '70.0.3538.97\\chromedriver.exe'
elif '71' == version:
path = DRIVERS_PATH + 'chrome\\' + '71.0.3578.137\\chromedriver.exe'
elif '72' == version:
path = DRIVERS_PATH + 'chrome\\' + '72.0.3626.69\\chromedriver.exe'
elif '73' == version:
path = DRIVERS_PATH + 'chrome\\' + '73.0.3683.68\\chromedriver.exe'
elif '74' == version:
path = DRIVERS_PATH + 'chrome\\' + '74.0.3729.6\\chromedriver.exe'
elif '75' == version:
path = DRIVERS_PATH + 'chrome\\' + '75.0.3770.140\\chromedriver.exe'
elif '76' == version:
path = DRIVERS_PATH + 'chrome\\' + '76.0.3809.126\\chromedriver.exe'
elif '77' == version:
path = DRIVERS_PATH + 'chrome\\' + '77.0.3865.40\\chromedriver.exe'
elif '78' == version:
path = DRIVERS_PATH + 'chrome\\' + '78.0.3904.11\\chromedriver.exe'
elif '79' == version:
path = DRIVERS_PATH + 'chrome\\' + '79.0.3945.16\\chromedriver.exe'
elif '86' == version:
path = DRIVERS_PATH + 'chrome\\' + '86.0.4240.22\\chromedriver.exe'
else:
logger.info('浏览器版本不符合，请检查浏览器版本')
return
option = Options()
option.add_experimental_option('w3c', False)
option.add_argument('--start-maximized')
self.driver = webdriver.Chrome(executable_path=path,
options=option)
logger.info('启动谷歌浏览器')
print('启动谷歌浏览器')
elif browser == 'FireFox':
logger.info("选择的浏览器为:%s浏览器" % browser)
path = DRIVERS_PATH + 'firefox\\' + 'geckodriver.exe'
self.driver = webdriver.Firefox(executable_path=path)
self.driver.maximize_window()
logger.info('启动火狐浏览器')
print('启动火狐浏览器')
except Exception as e:
logger.info('浏览器类型不符，请选择Chrome或者Firefox')
print('浏览器类型不符，请选择Chrome或者Firefox')
print(e)
else:
# 驱动创建完成后，等待创建实例对象
WaitUnit(self.driver)
def quitBrowser(self):
logger.info('退出浏览器')
print('退出浏览器')
self.driver.quit()
def closeBrowser(self):
logger.info('关闭当前页面')
print('关闭当前页面')
self.driver.close()
def back(self):
'''
退回浏览器上一个页面
:return:
'''
# try:
if self.driver.current_url == 'data:,':
self.driver.back()
logger.info('返回到%s' % self.driver.current_url)
print('返回到%s' % self.driver.current_url)
# except Exception as e:
# logger.info('退回浏览器失败')
# print('退回浏览器失败')
# print(e)
else:
logger.info('已经是第一个页面')
print('已经是第一个页面')
return
def foword(self):
'''
前进浏览器上一个页面
:return:
'''
# try:
self.driver.forward()
logger.info('前进到%s' % self.driver.current_url)
print('前进到%s' % self.driver.current_url)
# except Exception as e:
# logger.info('前进页面失败')
# print('前进页面失败')
# print(e)
def refresh(self):
'''
刷新浏览器
:return:
'''
logger.info('刷新浏览器')
print('刷新浏览器')
self.driver.refresh()
def js_scroll_top(self):
'''滚动到顶部'''
js = "window.scrollTo(0,0)"
self.driver.execute_script(js)
def js_scroll_end(self):
'''滚动到底部'''
js = "window.scrollTo(0,document.body.scrollHeight)"
self.driver.execute_script(js)
def getUrl(self, url):
"""
加载网址
:return:
"""
# try:
logger.info('进入%s' % url)
print('进入%s' % url)
self.driver.get(url)
# except Exception as e:
# logger.info('%s进入失败' % url)
# print('%s进入失败' % url)
# print(e)
def sleep(self, sleepSeconds):
"""
强制等待时间，单位S
:param sleepSeconds:
:return:
"""
# try:
logger.info('休眠%s秒' % sleepSeconds)
print('休眠%s秒' % sleepSeconds)
time.sleep(int(sleepSeconds))
# except Exception as e:
# print(e)
def clear(self, by, locator):
"""
清空输入框
:return:
"""
# try:
logger.info('清空输入框')
print('清空输入框')
ObjectMap(self.driver).getElement(by, locator).clear()
# except Exception as e:
# logger.info('清空失败')
# print('清空失败')
# print(e)
def inputValue(self, by, locator, value):
"""
输入框输入值
:param by:
:param locator:
:param value:
:return:
"""
# try:
logger.info('输入框输入%s' % value)
print('输入框输入%s' % value)
ObjectMap(self.driver).getElement(by, locator).send_keys(value)
# except Exception as e,
# logger.info('输入框输入值错误')
# print('输入框输入值错误')
# print(e)
def clearAndInput(self, by, locator, value):
'''
清除输入框再输入值
:return:
'''
logger.info('清空输入框')
print('清空输入框')
ObjectMap(self.driver).getElement(by, locator).clear()
logger.info('输入框输入%s' % value)
print('输入框输入%s' % value)
ObjectMap(self.driver).getElement(by, locator).send_keys(value)
def uploadFile(self, by, locator, value):
'''
上传单个文件input标签 type="file"
:param by:
:param locator:
:param value:
:return:
'''
ObjectMap(self.driver).getElement(by, locator).send_keys(value)
logger.info('上传文件%s' % value)
print('上传文件%s' % value)
def uploadFiles(self, by, locator, value):
'''
上传多个文件，value为文件夹路径，input标签
:param by:
:param locator:
:param value:
:return:
'''
for root, dirs, files in os.walk(value):
for i in files:
ObjectMap(self.driver).getElement(
by, locator).send_keys(value + '\\' + i)
logger.info('上传文件%s' % i)
print('上传文件%s' % i)
def upload_file_windows(self, file_path):
'''
:param file_path:上传文件的路径,需点击打开上传按钮，弹出windows窗口再调用 chrome 可调用
:return:
'''
dialog = win32gui.FindWindow("#32770", u"打开") #窗口左上角文字
comboxex32 = win32gui.FindWindowEx(dialog, 0, "ComboBoxEx32", None)
combox = win32gui.FindWindowEx(comboxex32, 0, "ComboBox", None)
edit = win32gui.FindWindowEx(combox, 0, "Edit", None)
button = win32gui.FindWindowEx(dialog, 0, "Button", "打开(&0)")
win32gui.SendMessage(edit, win32con.WM_SETTEXT, None, file_path)
win32gui.SendMessage(dialog, win32con.WM_COMMAND, 1, button)
def assertTitle(self, titlestr):
"""
断言页面标题
:param titlestr:
:return:
"""
# try:
logger.info('"%s"标题存在' % titlestr)
print('"%s"标题存在' % titlestr)
assert titlestr in self.driver.title, '%s标题不存在' % titlestr
# except AssertionError as e:
# logger.info('"%s"标题不存在' % titlestr)
# print('"%s"标题不存在' % titlestr)
# print(e)
# except Exception as e:
# logger.info('断言失败')
# print('断言失败')
# print(e)
def assert_string_in_pageSource(self, assstring):
"""
断言字符串是否包含在源码中
:param assstring:
:return:
"""
# try:
logger.info('"%s"存在页面中' % assstring)
print('"%s"存在页面中' % assstring)
assert assstring in self.driver.page_source, "'%s'在页面中不存在" % assstring
# except AssertionError as e:
# logger.info('"%s"在页面中未找到' % assstring)
# print('"%s"在页面中未找到' % assstring)
# print(e)
# except Exception as e:
# logger.info('断言失败')
# print('断言失败')
# print(e)
def assertEqule(self, by, locator, value):
'''
检查指定元素字符串与预期结果是否相同
:return:
'''
# try:
getValue = ObjectMap(self.driver).getElement(
by, locator).get_attribute('value')
getText = ObjectMap(self.driver).getElement(by, locator).text
if getValue == getText:
assert ObjectMap(self.driver).getElement(
by, locator).get_attribute('value') == value
logger.info('%s=%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
print('%s=%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
elif getValue == '' or getValue is None:
assert ObjectMap(self.driver).getElement(by, locator).text == value
logger.info(
'%s=%s' %
(ObjectMap(self.driver).getElement(by, locator).text, value))
print('%s=%s' %
(ObjectMap(self.driver).getElement(by, locator).text, value))
elif getText == '' or getText is None:
assert ObjectMap(self.driver).getElement(
by, locator).get_attribute('value') == value
logger.info('%s=%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
print('%s=%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
else:
assert ObjectMap(self.driver).getElement(
by, locator).get_attribute('value') == value
logger.info('%s=%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
print('%s=%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
# except AssertionError:
# getValue = ObjectMap(self.driver).getElement(by, locator).get_attribute('value')
# getText = ObjectMap(self.driver).getElement(by, locator).text
# if getValue == getText:
# logger.info('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).get_attribute('value'), value))
# print('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).get_attribute('value'), value))
# elif getValue == '' or getValue is None:
# logger.info('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).text, value))
# print('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).text, value))
# elif getText == '' or getText is None:
# logger.info('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).get_attribute('value'), value))
# print('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).get_attribute('value'), value))
# else:
# logger.info('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).get_attribute('value'), value))
# print('%s!=%s' % (ObjectMap(self.driver).getElement(by, locator).get_attribute('value'), value))
# except AttributeError:
# logger.info('页面中未找到元素')
# print('页面中未找到元素')
# except TimeoutError:
# logger.info('页面中未找到元素')
# print('页面中未找到元素')
# except Exception:
# logger.info('断言失败')
# print('断言失败')
def assertLen(self, by, locator, value):
'''
检查指定元素字符串长度
:return:
'''
# try:
getValue = ObjectMap(self.driver).getElement(
by, locator).get_attribute('value')
getText = ObjectMap(self.driver).getElement(by, locator).text
if getValue == getText:
assert len(
ObjectMap(self.driver).getElement(
by, locator).get_attribute('value')) == int(value)
logger.info('"%s"长度为%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
print('"%s"长度为%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
elif getValue == '' or getValue is None:
assert len(ObjectMap(self.driver).getElement(
by, locator).text) == int(value)
logger.info(
'"%s"长度为%s' %
(ObjectMap(self.driver).getElement(by, locator).text, value))
print('"%s"长度为%s' %
(ObjectMap(self.driver).getElement(by, locator).text, value))
elif getText == '' or getText is None:
assert len(
ObjectMap(self.driver).getElement(
by, locator).get_attribute('value')) == int(value)
logger.info('"%s"长度为%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
print('"%s"长度为%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
else:
assert len(
ObjectMap(self.driver).getElement(
by, locator).get_attribute('value')) == int(value)
logger.info('"%s"长度为%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
print('"%s"长度为%s' % (ObjectMap(self.driver).getElement(
by, locator).get_attribute('value'), value))
# except AssertionError as e:
# logger.info('"%s" 在页面中未找到' % ObjectMap(self.driver).getElement(by,locator).get_attribute('value'))
# print('"%s" 在页面中未找到' % ObjectMap(self.driver).getElement(by,locator).get_attribute('value'))
# except TimeoutException:
# logger.info('页面中未找到元素')
# print('页面中未找到元素')
# except Exception as e:
# logger.info('断言失败')
# print('断言失败')
def assertElement(self, by, locator):
'''
判断元素是否存在
:return:
'''
# flag = True
# try:
assert ObjectMap(self.driver).getElement(by, locator)
# return flag
# except AssertionError as e:
# logger.info('页面中未找到元素')
# print('页面中未找到元素')
# except TimeoutException:
# logger.info('页面中未找到元素')
# print('页面中未找到元素')
# except Exception as e:
# logger.info('断言失败')
# print('断言失败')
def assertUrl(self, Url):
'''
判断当前网址是否和指定网址相同
:param Url:
:return:
'''
assert self.driver.current_url == Url
logger.info('%s==%s' % (self.driver.current_url, Url))
print('%s==%s' % (self.driver.current_url, Url))
def getTitle(self):
"""
获取页面title
:return:
"""
try:
logger.info('获取页面标题：%s' % self.driver.title)
print('获取页面标题：%s' % self.driver.title)
return self.driver.title
except Exception as e:
logger.info('获取页面标题失败')
print('获取页面标题失败')
def getPageSource(self):
"""
获取页面源码
:return:
"""
# try:
return self.driver.page_source
# except Exception as e:
# print(e)
def switchToFrame(self, by, locator):
"""
切换到frame页面内
:param by:
:param locator:
:return:
"""
# try:
self.driver.switch_to.frame(
ObjectMap(self.driver).getElement(by, locator))
# except Exception as e:
# print(e)
def switchToDefault(self):
"""
切换到默认的frame页面
:return:
"""
# try:
self.driver.switch_to.default_content()
# except Exception as e:
# print(e)
def click(self, by, locator):
"""
元素点击
:return:
"""
# try:
logger.info('点击元素：%s' % locator)
print('点击元素：%s' % locator)
ObjectMap(self.driver).getElement(by, locator).click()
# except Exception as e:
# logger.info('点击元素失败')
# print('点击元素失败')
# print(e)
def saveScreeShot(self, file, casename):
"""
屏幕截图
:return:
"""
picturename = SCREENSHOTS_PATH + file + '\\' + casename
if not os.path.exists(picturename):
os.makedirs(picturename)
picturename = picturename + '\\' + DirAndTime.getCurrentTime(
) + '.png'
else:
picturename = picturename + '\\' + DirAndTime.getCurrentTime(
) + '.png'
try:
self.driver.get_screenshot_as_file(picturename)
except Exception as e:
print(e)
else:
return picturename
def wait_find_element(self, by, locator):
'''
显性等待30S判断单个元素是否可见，可见返回元素，否则抛出异常
:param loc: 传入参数为By.xx(xx为元素定位方式),Value(为元素定位内容)
:return:
'''
# try:
if by.lower() in self.byDic:
element = WebDriverWait(self.driver, 30).until(
EC.presence_of_element_located(
(self.byDic[by.lower()], locator)))
return element
# except NoSuchElementException:
# logger.exception('找不到元素')
# print('找不到元素')
# except TimeoutException:
# logger.exception('元素查找超时')
# print('元素查找超时')
# except:
# logger.exception('查找失败')
# print('查找失败')
def not_wait_find_element(self, by, locator):
'''
显性等待60S判断单个元素是否可见，可见返回元素，否则抛出异常
:param loc: 传入参数为By.xx(xx为元素定位方式),Value(为元素定位内容)
:return:
'''
# try:
if by.lower() in self.byDic:
element = WebDriverWait(self.driver, 30).until_not(
EC.presence_of_element_located(
(self.byDic[by.lower()], locator)))
return element
# except NoSuchElementException:
# logger.exception('找不到元素')
# print('找不到元素')
# except TimeoutException:
# logger.exception('元素查找超时')
# print('元素查找超时')
# except:
# logger.exception('查找失败')
# print('查找失败')
def text_wait_find_element(self, by, locator):
'''
显性等待30S判断单个元素是否可见，可见返回元素，否则抛出异常
:param loc: 传入参数为By.xx(xx为元素定位方式),Value(为元素定位内容)
:return:
'''
# try:
if by.lower() in self.byDic:
element = WebDriverWait(self.driver, 30).until(
EC.text_to_be_present_in_element(self.byDic[by.lower()],
locator))
return element
# except NoSuchElementException:
# logger.exception('找不到元素')
# print('找不到元素')
# except TimeoutException:
# logger.exception('元素查找超时')
# print('元素查找超时')
# except:
# logger.exception('查找失败')
# print('查找失败')
def not_text_wait_find_element(self, by, locator):
'''
显性等待30S判断单个元素是否可见，可见返回元素，否则抛出异常
:param loc: 传入参数为By.xx(xx为元素定位方式),Value(为元素定位内容)
:return:
'''
# try:
if by.lower() in self.byDic:
element = WebDriverWait(self.driver, 30).until_not(
EC.text_to_be_present_in_element(self.byDic[by.lower()],
locator))
return element
# except NoSuchElementException:
# logger.exception('找不到元素')
# print('找不到元素')
# except TimeoutException:
# logger.exception('元素查找超时')
# print('元素查找超时')
# except:
# logger.exception('查找失败')
# print('查找失败')
def move_to_element(self, by, locator):
'''
:param loc:loc = (By.xx,element)
:return:
'''
# try:
element = self.driver.find_element(by, locator)
t = self.driver.find_element(by, locator).text
ActionChains(self.driver).move_to_element(element).perform()
logger.info("鼠标悬浮在%s" % t)
print("鼠标悬浮在%s" % t)
# except:
# logger.exception("未找到元素")
# print("未找到元素")
def dropDown(self, p):
"""
边框下拉滑动
:param p:
:return:
"""
js = "var q=document.documentElement.scrollTop=%s" % p
self.driver.execute_script(js)
logger.info("滑动下拉框-距离%s" % p)
print("滑动下拉框-距离%s" % p)
def scroll_top(self):
'''滚动到顶部'''
js = "var q=document.documentElement.scrollTop=0"
self.driver.execute_script(js)
def scroll_end(self):
'''滚动到底部'''
js = "window.scrollTo(0,document.body.scrollHeight)"
self.driver.execute_script(js)
def Enter(self, by, locator):
# 模拟键盘回车
ObjectMap(self.driver).getElement(by, locator).send_keys(Keys.ENTER)
def Down_end(self, count):
'''
模拟按下键盘的 下 箭头 方向键,count 为按下的次数
:return:
'''
for i in range(count):
self.driver.execute_script(
'window.scrollTo(0, document.body.scrollHeight)')
ActionChains(self.driver).key_down(Keys.DOWN).perform()
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 __init__(self, filename):
self.filename = filename
self.parseyaml = ParseYaml()
# 读取excel文件
self.wb = load_workbook(self.filename)