Selenium+Unittest自动化测试框架实战
前言
selenium自动化+unittest测试框架
- 本章你需要
-
一定的python基础——至少明白类与对象，封装继承
-
一定的selenium基础——不讲selenium，不会的自己去看selenium中文翻译网
-
项目框架
开始之前先简单介绍一下框架体系吧：
| 目录/文件 | 说明 | 是否为python包 |
|---|---|---|
| common | 常见的通用类。如：读取config文件，元素文件 | 是 |
| config | 配置文件目录 | 是 |
| logs | 日志文件目录 | |
| page | selenium基类 | 是 |
| page_element | 页面元素 | |
| page_object | 页面对象POM设计模式，本人对这个的理解来自于苦叶子的博客 | 是 |
| report | 报告目录 | |
| TestCase | 测试用例 | 是 |
| utils | 工具类。如：邮箱、日志 | 是 |
| run_case.py | 总执行文件 | |
| script | 常用脚本目录 |
- 框架有什么优点呢？
- 代码复用率高，如果不使用框架的话，代码会很冗余
- 可以组装日志、报告、邮件等一些高级功能
- 提高元素等数据的可维护性，元素发生变化时，只需要更新一下配置文件
- 使用更灵活的PageObject设计模式
知道了以上这些我们就开始吧！
我们在项目中先按照上面的框架指引，建好每一项目录。
注意：python包为是的，都需要添加一个__init__.py文件以标识此目录为一个python包。
首先管理时间
首先呢，因为用到时间的地方可能会比较多，所以我们也单独把时间封装成一个模块。让其他模块来调用即可。
在utils目录中新建times.py文件。填入以下内容。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import time
import datetime
from functools import wraps
def timestamp():
"""时间戳"""
return time.time()
def datetime_strftime(fmt="%Y%m"):
"""datetime格式化时间"""
return datetime.datetime.now().strftime(fmt)
def sleep(seconds=1.0):
"""
睡眠时间
"""
time.sleep(seconds)
def run_time(func):
"""运行时长"""
@wraps(func)
def wrapper(*args, **kwargs):
start_time = timestamp()
res = func(*args, **kwargs)
print("Done！用时%.3f秒！" % (timestamp() - start_time))
return res
return wrapper
if __name__ == '__main__':
print(timestamp())
配置文件
配置文件总是一个项目的重要组成部分！
在项目中我们创建config文件目录，里面存放我们本次项目所需要的配置文件。包括我们常用的目录管理和一些设置。
conf.py
在项目config目录创建conf.py文件，所有的目录配置或者基本不变的配置信息写在这个文件里面。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os
from selenium.webdriver.common.by import By
from utils.times import datetime_strftime
class ConfigManager(object):
# 项目目录
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 配置文件
INI_PATH = os.path.join(BASE_DIR, 'config', 'config.ini')
# 页面元素目录
ELEMENT_PATH = os.path.join(BASE_DIR, 'page_element')
# 报告目录
REPORT_PATH = os.path.join(BASE_DIR, 'report')
# 测试用例
TEST_SUITES = os.path.join(BASE_DIR, "TestCase")
# 元素定位的类型
LOCATE_MODE = {
'css': By.CSS_SELECTOR,
'xpath': By.XPATH,
'name': By.NAME,
'id': By.ID,
'class': By.CLASS_NAME
}
# 邮件信息
EMAIL_INFO = {
'username': '1084502012@qq.com', # 切换成你自己的地址
'password': 'QQ邮箱授权码',
'smtp_host': 'smtp.qq.com',
'smtp_port': 465
}
# 收件人
ADDRESSEE = ['1084502012@qq.com', ]
@property
def log_path(self):
# 日志目录
log_path = os.path.join(self.BASE_DIR, 'logs')
if not os.path.exists(log_path):
os.makedirs(log_path)
return os.path.join(log_path, '{}.log'.format(datetime_strftime()))
@property
def report_path(self):
"""报告文件"""
_path = self.REPORT_PATH
if not os.path.exists(_path):
os.makedirs(_path)
return os.path.join(_path, '{}.html'.format(datetime_strftime("%Y%m%d_%H%M%S")))
@property
def get_new_report(self):
"""获取最新的报告"""
_path = self.REPORT_PATH
report_path = os.listdir(_path)
report_new_path = sorted(report_path,
key=lambda x: os.path.getmtime(os.path.join(_path, x)))
report_new_file = os.path.join(_path, report_new_path[-1])
with open(report_new_file, encoding='utf-8') as f:
return f.read()
cm = ConfigManager()
if __name__ == '__main__':
print(cm.BASE_DIR)
注意：QQ邮箱授权码：点击查看生成教程
这个conf文件我模仿了Django的settings.py文件风格。
在这个文件中我们可以设置自己的各个目录，也可以查看自己当前的目录。
遵循了约定：不变的常量名全部大写，变量名称小写的规范。看起来整体美观。
config.ini
然后在config目录中新建一个config.ini文件，里面暂时先放入我们的需要测试的URL
[HOST]
HOST = https://www.baidu.com
配置文件创建好了，接下来我们需要读取这个配置文件以使用里面的信息。
读取配置文件
在common目录新建一个readconfig.py文件。这个文件就是我们用来读取config.ini文件里面的配置信息的。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os
import configparser
from config.conf import cm
HOST = 'HOST'
class ReadConfig:
"""配置文件"""
def __init__(self):
self.path = cm.INI_PATH
if not os.path.exists(self.path):
raise FileNotFoundError("配置文件%s不存在！" % self.path)
self.config = configparser.RawConfigParser() # 当有%的符号时请使用Raw读取
self.config.read(self.path, encoding='utf-8')
def _get(self, section, option):
"""获取"""
return self.config.get(section, option)
def _set(self, section, option, value):
"""更新"""
self.config.set(section, option, value)
with open(self.path, 'w') as f:
self.config.write(f)
@property
def url(self):
return self._get(HOST, HOST)
ini = ReadConfig()
if __name__ == '__main__':
print(ini.url)
可以看到我们用python内置的configparser模块对config.ini文件进行了读取。
对于url值的提取，我使用了高阶语法@property将方法改写为属性值，调用更简单。
记录操作日志
日志，大家应该都很熟悉这个名词，就是记录代码中的动作。
在utils目录中新建logger.py文件。
这个文件就是我们用来在自动化测试过程中记录一些操作步骤的。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import logging
from config.conf import cm
class Logger:
def __init__(self, name=None):
self.logger = logging.getLogger(name)
if not self.logger.handlers:
self.logger.setLevel(logging.DEBUG)
# 创建一个handle写入文件
fh = logging.FileHandler(cm.log_path, encoding='utf-8')
fh.setLevel(logging.INFO)
# 创建一个handle输出到控制台
ch = logging.StreamHandler()
ch.setLevel(logging.INFO)
# 定义输出的格式
formatter = logging.Formatter(self.fmt)
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# 添加到handle
self.logger.addHandler(fh)
self.logger.addHandler(ch)
@property
def fmt(self):
return '%(levelname)s\t%(asctime)s\t%(name)s:%(lineno)d\t%(message)s'
if __name__ == '__main__':
log = Logger(__name__).logger
log.info('hello world')
在终端中运行该文件，就看到命令行打印出了：
INFO 2020-1-16 20:37:19,726 __main__:37 hello world
然后在项目logs目录下生成了当月的日志文件。
话不多说，进入正题！
简单理解POM模型
由于下面要讲元素相关的，所以首先理解一下POM模型
Page Object模式具有以下几个优点。
该观点来自 《Selenium自动化测试——基于Python语言》
- 抽象出对象可以最大程度地降低开发人员修改页面代码对测试的影响， 所以， 你仅需要对页
面对象进行调整， 而对测试没有影响； - 可以在多个测试用例中复用一部分测试代码；
- 测试代码变得更易读、 灵活、 可维护
Page Object模式图
- basepage ——selenium的基类，对selenium的方法进行封装
- pageelements——页面元素，把页面元素单独提取出来，放入一个文件中
- searchpage ——页面对象类，把selenium方法和页面元素进行整合
- testcase ——使用pytest对整合的searchpage进行测试用例编写
通过上图我们可以看出，通过POM模型思想，我们把：
-
selenium方法
-
页面元素
-
页面对象
-
测试用例
以上四种代码主体进行了拆分，虽然在用例很少的情况下做会增加代码，但是当用例多的时候意义很大，代码量会在用例增加的时候显著减少。我们维护代码变得更加直观明显，代码可读性也变得比工厂模式强很多，代码复用率也极大的得到了提高。
管理页面元素
本教程选择的测试地址是百度首页，所以对应的元素也是百度首页的。
项目框架设计中有一个目录page_element就是专门来存放定位元素的文件的。
通过对各种配置文件的对比，我在这里选择的是YAML文件格式。其支持与python数据类型堪称无缝对接，且易读，交互性好。
我们在page_element目录中新建一个search.yaml文件。
搜索框: "id==kw"
候选: "css==.bdsug-overflow"
搜索候选: "css==#form div li"
搜索按钮: "id==su"
元素定位文件创建好了，下来我们需要读取这个文件。
在common中创建readelement.py文件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os
import yaml
from config.conf import cm
class Element:
"""获取元素"""
def __init__(self, name):
self.file_name = '%s.yaml' % name
self.element_path = os.path.join(cm.ELEMENT_PATH, self.file_name)
if not os.path.exists(self.element_path):
raise FileNotFoundError("%s 文件不存在！" % self.element_path)
with open(self.element_path, encoding='utf-8') as f:
self.data = yaml.safe_load(f)
def __getitem__(self, item):
"""获取属性"""
data = self.data.get(item)
if data:
name, value = data.split('==')
return name, value
raise ArithmeticError("{}中不存在关键字：{}".format(self.file_name, item))
if __name__ == '__main__':
search = Element('search')
print(search['搜索框'])
通过特殊方法__getitem__实现调用任意属性，读取yaml中的值。
这样我们就实现了定位元素的存储和调用。
但是还有一个问题，我们怎么样才能确保我们写的每一项元素不出错，人为的错误是不可避免的，但是我们可以通过代码来运行对文件的审查。但是也不能检查出所有的问题，所以还是要细心。
所以我们编写一个文件，在script目录中创建inspect.py文件，对所有的元素yaml文件进行一次大概的审查。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os
import yaml
from utils.times import run_time
from config.conf import cm
@run_time
def inspect_element():
"""审查所有的元素是否正确"""
for i in os.listdir(cm.ELEMENT_PATH):
_path = os.path.join(cm.ELEMENT_PATH, i)
if os.path.isfile(_path):
with open(_path, encoding='utf-8') as f:
data = yaml.safe_load(f)
for k in data.values():
pattern, value = k.split('==')
if pattern not in cm.LOCATE_MODE:
raise AttributeError('【%s】路径中【%s]元素没有指定类型' % (i, k))
if pattern == 'xpath':
assert '//' in value, '【%s】路径中【%s]元素xpath类型与值不配' % (
i, k)
if pattern == 'css':
assert '//' not in value, '【%s】路径中【%s]元素css类型与值不配' % (
i, k)
if pattern in ('id', 'name', 'class'):
assert value, '【%s】路径中【%s]元素类型与值不匹配' % (i, k)
if __name__ == '__main__':
inspect_element()
执行该文件：
Done！用时0.015秒！
可以看到，很短的时间内，我们就对所填写的YAML文件进行了审查。
封装Selenium基类
在工厂模式种我们是这样写的：
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import time
from selenium import webdriver
driver = webdriver.Chrome()
driver.get('https://www.baidu.com')
driver.find_element_by_xpath("//input[@id='kw']").send_keys('selenium')
driver.find_element_by_xpath("//input[@id='su']").click()
time.sleep(5)
driver.quit()
很直白，简单，又明了。
创建driver对象，打开百度网页，搜索selenium，点击搜索，然后停留5秒，查看结果，最后关闭浏览器。
那我们为什么要封装selenium的方法呢。首先我们上述这种较为原始的方法，基本不适用于平时做UI自动化测试的，因为在UI界面实际运行情况远远比较复杂，可能因为网络原因，或者控件原因，我们元素还没有显示出来，就进行点击或者输入。所以我们需要封装selenium方法，通过内置的显式等待或一定的条件语句，才能构建一个稳定的方法。而且把selenium方法封装起来，有利于平时的代码维护。
我们在page目录创建webpage.py文件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
"""
selenium基类
本文件存放了selenium基类的封装方法
"""
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from config.conf import cm
from utils.times import sleep
from utils.logger import Logger
log = Logger(__name__).logger
class WebPage(object):
"""selenium基类"""
def __init__(self, driver):
# self.driver = webdriver.Chrome()
self.driver = driver
self.timeout = 20 # 查找元素的超时时间
self.wait = WebDriverWait(self.driver, self.timeout)
def get_url(self, url):
"""打开网址并验证"""
self.driver.maximize_window()
self.driver.set_page_load_timeout(60)
try:
self.driver.get(url)
self.driver.implicitly_wait(10)
log.info("打开网页：%s" % url)
except TimeoutException:
raise TimeoutException("打开%s超时请检查网络或网址服务器" % url)
@staticmethod
def element_locator(func, locator):
"""元素定位器"""
name, value = locator
return func(cm.ELEMENT_PATH[name], value)
def find_element(self, locator):
"""寻找单个元素"""
return WebPage.element_locator(lambda *args: self.wait.until(
EC.presence_of_element_located(args)), locator)
def find_elements(self, locator):
"""查找多个相同的元素"""
return WebPage.element_locator(lambda *args: self.wait.until(
EC.presence_of_all_elements_located(args)), locator)
def ele_num(self, locator): # 获取相同元素的个数
"""获取相同元素的个数"""
number = len(self.find_elements(locator))
log.info("相同元素：{}".format((locator, number)))
return number
def input_text(self, locator, txt):
"""输入(输入前先清空)"""
sleep(0.5)
ele = self.find_element(locator)
ele.clear()
ele.send_keys(txt)
log.info("输入文本：{}".format(txt))
def is_click(self, locator):
"""点击"""
self.find_element(locator).click()
sleep()
log.info("点击元素：{}".format(locator))
def get_text(self, locator):
"""获取当前的text"""
ele_text = self.find_element(locator).text
log.info("获取文本：{}".format(ele_text))
return ele_text
@property
def get_source(self):
"""获取页面源代码"""
return self.driver.page_source
def shot_file(self, path):
"""文件截图"""
return self.driver.save_screenshot(path)
def refresh(self):
"""刷新页面F5"""
self.driver.refresh()
self.driver.implicitly_wait(30)
if __name__ == "__main__":
pass
在文件中我们对主要用了显式等待对selenium的click，send_keys等方法，做了二次封装。提高了运行的成功率。
好了我们完成了POM模型的一半工作了。接下来我们们进入页面对象。
创建页面对象
我们开始创建searchpage页面对象类。
在page_object目录下创建一个searchpage.py文件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
from page.webpage import WebPage, sleep
from common.readelement import Element
search = Element('search')
class SearchPage(WebPage):
"""搜索类"""
def input_search(self, content):
"""输入搜索"""
self.input_text(search['搜索框'], txt=content)
sleep()
@property
def imagine(self):
"""搜索联想"""
return [x.text for x in self.find_elements(search['候选'])]
def click_search(self):
"""点击搜索"""
self.is_click(search['搜索按钮'])
if __name__ == '__main__':
pass
在该文件中我们对，输入搜索关键词，点击搜索，搜索联想，进行了封装。
并配置了注释。
在平时中我们应该养成写注释的习惯，因为过一段时间后，没有注释，代码读起来很费劲。
好了我们的页面对象此时业已完成了。
下面我们开始编写测试用例。
熟悉unittest测试框架
unittest是python标准库中自带的测试框架。
学习unittest最好的教程应该是python官方文档了。
官方文档：https://docs.python.org/zh-cn/3.7/library/unittest.html
不细说了，自己去看吧。
编写测试用例
我们将使用unittest编写测试用例。
在TestCase目录中创建test_search.py文件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import re
import unittest
from selenium import webdriver
from utils.logger import Logger
from common.readconfig import ini
from page_object.searchpage import SearchPage
from chromedriver_py import binary_path
log = Logger(__name__).logger
class TestSearch(unittest.TestCase):
"""搜索测试"""
@classmethod
def setUpClass(cls) -> None:
cls.driver = webdriver.Chrome(executable_path=binary_path)
cls.search = SearchPage(cls.driver)
cls.search.get_url(ini.url)
@classmethod
def tearDownClass(cls) -> None:
cls.driver.quit()
def setUp(self) -> None:
self.imgs = [] # 注意：添加此行用于报告中失败截图
def test_001(self):
"""搜索"""
self.search.input_search("selenium")
self.search.click_search()
result = re.search(r'selenium', self.search.get_source)
log.info(result)
assert result
def test_002(self):
"""测试搜索候选"""
self.search.input_search("selenium")
log.info(list(self.search.imagine))
assert all(["selenium" in i for i in self.search.imagine])
if __name__ == '__main__':
unittest.main(verbosity=2)
我们测试用例就编写好了。
- 第一个测试用例：
- 我们实现了在百度selenium关键字，并点击搜索按钮，并在搜索结果中，用正则查找结果页源代码，返回数量大于10我们就认为通过。
- 第二个测试用例：
- 我们实现了，搜索selenium，然后断言搜索候选中的所有结果有没有selenium关键字。
执行用例
以上我们已经编写完成了整个框架和测试用例。
我们进入到当前项目的主目录执行文件：
DevTools listening on ws://127.0.0.1:7341/devtools/browser/09ec4049-0745-4048-8fe2-ece53457d8c0
INFO 2020-06-10 16:21:20,021 [webpage.py:37] 打开网页：https://www.baidu.com
test_001 (__main__.TestSearch)
搜索 ... INFO 2020-06-10 16:21:20,667 [webpage.py:69] 输入文本：selenium
INFO 2020-06-10 16:21:22,738 [webpage.py:75] 点击元素：('id', 'su')
INFO 2020-06-10 16:21:22,785 [test_search.py:43] <re.Match object; span=(326, 334), match='selenium'>
ok
test_002 (__main__.TestSearch)
测试搜索候选 ... INFO 2020-06-10 16:21:23,407 [webpage.py:69] 输入文本：selenium
INFO 2020-06-10 16:21:24,466 [test_search.py:49] ['selenium', 'selenium python', 'selenium面试题', 'selenium中文文档']
ok
----------------------------------------------------------------------
Ran 2 tests in 12.531s
OK
可以看到两条用例已经执行成功了。
生成测试报告
unittest无法像pytest一样直接添加命令行参数就可以生成报告。
但是可以通过第三方模块HTMLTestRunner_cn去生成报告。我们需要下载该模块去生成报告。
生成的报告结果图：
这个模块我已保存在群文件中。左上角加群。
然后将下载的HTMLTestRunner_cn.py文件放在项目的tools目录。
执行并生成报告
我们在项目根目录下创建run_case.py文件作为项目的运行文件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import unittest
from config.conf import cm
from utils.send_mail import send_report_mail
from utils.HTMLTestRunner_cn import HTMLTestRunner
discover = unittest.defaultTestLoader.discover(cm.TEST_SUITES, pattern="test*.py")
def main():
"""主函数"""
try:
with open(cm.report_path, 'wb+') as fp:
runner = HTMLTestRunner(stream=fp,
title="测试结果",
description="用例执行情况",
verbosity=2,
retry=1,
save_last_try=True)
result = runner.run(discover)
except Exception as e:
print("用例执行失败:{}".format(e))
else:
if result.failure_count or result.error_count:
# 如果测试有错误，就发送邮件
send_report_mail()
if __name__ == "__main__":
main()
发送结果邮件
当项目执行完成之后，需要发送到自己或者其他人邮箱里查看结果。
我们编写发送邮件的模块。
在tools目录中新建send_mail.py文件
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import smtplib
from email.header import Header
from email.mime.text import MIMEText
from email.utils import parseaddr, formataddr
from email.mime.multipart import MIMEMultipart
from config.conf import cm
def _format_addr(s):
"""格式化邮件地址"""
name, addr = parseaddr(s)
return formataddr((Header(name, 'utf-8').encode(), addr))
def send_report_mail():
"""发送最新的测试报告"""
# email地址和口令：
email_info = cm.EMAIL_INFO
user = email_info['username']
pwd = email_info['password']
# 收件人地址
to_addr = cm.ADDRESSEE
# SMTP服务器地址
smtp_server = email_info['smtp_host']
smtp_port = email_info['smtp_port']
try:
# 初始化邮件对象
msg = MIMEMultipart()
msg['From'] = _format_addr("selenium爱好者<%s>" % user)
msg['To'] = _format_addr('管理员 <%s>' % ','.join(to_addr))
msg['Subject'] = Header("unittest演示测试最新的测试报告", 'utf-8').encode()
# 发送HTML文件
msg.attach(MIMEText(cm.get_new_report, 'html', 'utf-8'))
# 发件人邮箱中的SMTP服务器，端口
with smtplib.SMTP_SSL(smtp_server, smtp_port) as server:
# 括号中对应的是发件人邮箱账号、邮箱密码
server.login(user, pwd)
# 括号中对应的是发件人邮箱账号、收件人邮箱账号、发送邮件
server.sendmail(user, to_addr, msg.as_string())
print("测试结果邮件发送成功！")
except smtplib.SMTPException as e:
print(u"Error: 无法发送邮件", format(e))
if __name__ == '__main__':
send_report_mail()
执行该文件：
测试邮件发送成功！
可以看到测试报告邮件已经发送成功了。
打开邮箱。
成功收到了邮件，只是样式丢失了。
这个unittest框架的selenium—demo项目就算是整体完工了。
开源地址
为了方便学习交流，本次的示例项目已经开源在码云：
https://gitee.com/wxhou/web-unittest
参考文献
| 随风挥手 ——土木狗的IT生涯 | 群: 299524235 |
