Selenium+Pytest⾃动化测试框架实战前⾔
selenium⾃动化+ pytest测试框架
本章你需要
⼀定的python基础——⾄少明⽩类与对象，封装继承
⼀定的selenium基础——本篇不讲selenium，不会的可以⾃⼰去看
测试框架简介
测试框架有什么优点呢：
代码复⽤率⾼，如果不使⽤框架的话，代码会很冗余
可以组装⽇志、报告、邮件等⼀些⾼级功能
提⾼元素等数据的可维护性，元素发⽣变化时，只需要更新⼀下配置⽂件
使⽤更灵活的PageObject设计模式
测试框架的整体⽬录
⽬录/⽂件说明是否为python包
common这个包中存放的是常见的通⽤的类，如读取配置⽂件是
config配置⽂件⽬录是
logs⽇志⽬录
page对selenium的⽅放进⾏深度的封装是
page_element页⾯元素存放⽬录
page_object页⾯对象POM设计模式，本⼈对这个的理解来⾃于的博客是
TestCase所有的测试⽤例集是
utils⼯具类是
script脚本⽂件
conftest.py pytest胶⽔⽂件
pytest.ini pytest配置⽂件
  这样⼀个简单的框架结构就清晰了。
知道了以上这些我们就开始吧！
我们在项⽬中先按照上⾯的框架指引，建好每⼀项⽬录。
注意：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 dt_strftime(fmt="%Y%m"):
"""
datetime格式化时间
:param fmt "%Y%m%d %H%M%S
"""
return w().strftime(fmt)
def sleep(seconds=1.0):
"""
睡眠时间
"""
time.sleep(seconds)
def running_time(func):
"""函数运⾏时间"""
@wraps(func)
def wrapper(*args, **kwargs):
start = timestamp()
res = func(*args, **kwargs)
print("校验元素done！⽤时%.3f秒！" % (timestamp() - start))
return res
return wrapper
if __name__ == '__main__':
print(dt_strftime("%Y%m%d%H%M%S"))
添加配置⽂件
配置⽂件总是项⽬中必不可少的部分！
将固定不变的信息集中在固定的⽂件中
conf.py
项⽬中都应该有⼀个⽂件对整体的⽬录进⾏管理，我也在这个python项⽬中设置了此⽂件。
在项⽬config⽬录创建conf.py⽂件，所有的⽬录配置信息写在这个⽂件⾥⾯。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import os
from selenium.webdrivermon.by import By
from utils.times import dt_strftime
class ConfigManager(object):
# 项⽬⽬录
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 页⾯元素⽬录
ELEMENT_PATH = os.path.join(BASE_DIR, 'page_element')
# 报告⽂件
REPORT_FILE = os.path.join(BASE_DIR, 'report.html')
# 元素定位的类型
LOCATE_MODE = {
'css': By.CSS_SELECTOR,
'xpath': By.XPATH,
'name': By.NAME,
'id': By.ID,
'class': By.CLASS_NAME
}
# 邮件信息
EMAIL_INFO = {
'username': '1084502012@qq',  # 切换成你⾃⼰的地址
'password': 'QQ邮箱授权码',
'smtp_host': 'smtp.qq',
'smtp_port': 465
}
# 收件⼈
ADDRESSEE = [
'1084502012@qq',
]
@property
def log_file(self):
"""⽇志⽬录"""
log_dir = os.path.join(self.BASE_DIR, 'logs')
if not ists(log_dir):
os.makedirs(log_dir)
return os.path.join(log_dir, '{}.log'.format(dt_strftime()))
@property
def ini_file(self):
"""配置⽂件"""
ini_file = os.path.join(self.BASE_DIR, 'config', 'config.ini')
if not ists(ini_file):
raise FileNotFoundError("配置⽂件%s不存在！" % ini_file)
return ini_file
cm = ConfigManager()
if __name__ == '__main__':
print(cm.BASE_DIR)
注意：QQ邮箱授权码：
这个conf⽂件我模仿了Django的settings.py⽂件的设置风格，但是⼜有些许差异。
在这个⽂件中我们可以设置⾃⼰的各个⽬录，也可以查看⾃⼰当前的⽬录。
遵循了约定：不变的常量名全部⼤写，函数名⼩写。看起来整体美观。
config.ini
在项⽬config⽬录新建⼀个config.ini⽂件，⾥⾯暂时先放⼊我们的需要测试的URL [HOST]
HOST = www.baidu
读取配置⽂件
配置⽂件创建好了，接下来我们需要读取这个配置⽂件以使⽤⾥⾯的信息。
我们在common⽬录中新建⼀个readconfig.py⽂件
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import configparser
f import cm
HOST = 'HOST'
class ReadConfig(object):
"""配置⽂件"""
def __init__(self):
def _get(self, section, option):
"""获取"""
(section, option)
def _set(self, section, option, value):
"""更新"""
with open(cm.ini_file, 'w') as 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
f import cm
class Log:
def __init__(self):
self.logger = Logger()
if not self.logger.handlers:
self.logger.setLevel(logging.DEBUG)
# 创建⼀个handle写⼊⽂件
fh = logging.FileHandler(cm.log_file, encoding='utf-8')
fh.setLevel(logging.INFO)
# 创建⼀个handle输出到控制台python怎么读取py文件
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[%(filename)s:%(lineno)d]\t%(message)s'
log = Log().logger
if __name__ == '__main__':
log.info('hello world')
在终端中运⾏该⽂件，就看到命令⾏打印出了：
INFO 2020-12-01 16:00:05,467 [logger.py:38] hello world
然后在项⽬logs⽬录下⽣成了当⽉的⽇志⽂件。
简单理解POM模型
由于下⾯要讲元素相关的，所以⾸先理解⼀下POM模型
Page Object模式具有以下⼏个优点。
该观点来⾃《Selenium⾃动化测试——基于Python语⾔》
抽象出对象可以最⼤程度地降低开发⼈员修改页⾯代码对测试的影响，所以，你仅需要对页
⾯对象进⾏调整，⽽对测试没有影响；
可以在多个测试⽤例中复⽤⼀部分测试代码；
测试代码变得更易读、灵活、可维护
Page Object模式图
basepage ——selenium的基类，对selenium的⽅法进⾏封装
pageelements——页⾯元素，把页⾯元素单独提取出来，放⼊⼀个⽂件中
searchpage ——页⾯对象类，把selenium⽅法和页⾯元素进⾏整合
testcase ——使⽤pytest对整合的searchpage进⾏测试⽤例编写
通过上图我们可以看出，通过POM模型思想，我们把：
selenium⽅法
页⾯元素
页⾯对象
测试⽤例
以上四种代码主体进⾏了拆分，虽然在⽤例很少的情况下做会增加代码，但是当⽤例多的时候意义很⼤，代码量会在⽤例增加的时候显著减少。我们维护代码变得更加直观明显，代码可读性也变得⽐⼯⼚模式强很多，代码复⽤率也极⼤的得到了提⾼。
简单学习元素定位
在⽇常的⼯作中，我见过很多在浏览器中直接在浏览器中右键Copy Xpath复制元素的同学。这样获得的元素表达式放在 webdriver 中去运⾏往往是不够稳定的，像前端的⼀些微⼩改动，都会引起元素⽆法定位的NoSuchElementException报错。
所以在实际⼯作和学习中我们应该加强⾃⼰的元素定位能⼒，尽可能的采⽤xpath和CSS selector 这种相对稳定的定位语法。由于CSS selector的语法⽣硬难懂，对新⼿很不友好，⽽且相⽐xpath缺少⼀些定位语法。所以我们选择xpath进⾏我们的元素定位语法。
xpath
语法规则
中对于 xpath 的介绍是⼀门在 XML ⽂档中查信息的语⾔。
表达式介绍备注
/根节点绝对路径
//当前节点的所有⼦节点相对路径
*所有节点元素的
@属性名的前缀@class  @id
*[1][] 下标运算符
[][ ]谓词表达式//input[@id='kw']
Following-sibling当前节点之后的同级
preceding-sibling当前节点之前的同级
parent当前节点的⽗级节点
定位⼯具
chropath
优点：这是⼀个Chrome浏览器的测试定位插件，类似于firepath，本⼈试⽤了⼀下整体感觉⾮常好。对⼩⽩的友好度很好。
缺点：安装这个插件需要FQ。
Katalon录制⼯具
录制出来的脚本⾥⾯也会有定位元素的信息
⾃⼰写——本⼈推荐这种
优点：本⼈推荐的⽅式，因为当熟练到⼀定程度的时候，写出来的会更直观简洁，并且在运⾏⾃动化测试中出现问题时，能快速定位。
缺点：需要⼀定xpath和CSS selector语法积累，不太容易上⼿。
管理页⾯元素
本教程选择的测试地址是百度⾸页，所以对应的元素也是百度⾸页的。
项⽬框架设计中有⼀个⽬录page_element就是专门来存放定位元素的⽂件的。
通过对各种配置⽂件的对⽐，我在这⾥选择的是YAML⽂件格式。其易读，交互性好。
我们在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
f import cm
class Element(object):
"""获取元素"""
def __init__(self, name):
self.file_name = '%s.yaml' % name
self.element_path = os.path.join(cm.ELEMENT_PATH, self.file_name)
if not ists(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 = (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
f import cm
from utils.times import running_time
@running_time
def inspect_element():
"""检查所有的元素是否正确
只能做⼀个简单的检查
"""
for files in os.listdir(cm.ELEMENT_PATH):
_path = os.path.join(cm.ELEMENT_PATH, files)
with open(_path, encoding='utf-8') as f:
data = yaml.safe_load(f)
for k in data.values():
try:
pattern, value = k.split('==')
except ValueError:
raise Exception("元素表达式中没有`==`")
if pattern not in cm.LOCATE_MODE:
raise Exception('%s中元素【%s】没有指定类型' % (_path, k))
elif pattern == 'xpath':
assert '//' in value,\
'%s中元素【%s】xpath类型与值不配' % (_path, k)
elif pattern == 'css':
assert '//' not in value, \
'%s中元素【%s]css类型与值不配' % (_path, k)
else:
assert value, '%s中元素【%s】类型与值不匹配' % (_path, k)
if __name__ == '__main__':
inspect_element()
执⾏该⽂件：
校验元素done！⽤时0.002秒！
可以看到，很短的时间内，我们就对所填写的YAML⽂件进⾏了审查。
现在我们基本所需要的组件已经⼤致完成了。
接下来我们将进⾏最重要的⼀环，封装selenium。
封装Selenium基类
在⼯⼚模式种我们是这样写的：
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import time
from selenium import webdriver
driver = webdriver.Chrome()
<('www.baidu')
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
ptions import TimeoutException
f import cm
from utils.times import sleep
from utils.logger import log
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:
(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.LOCATE_MODE[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 elements_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 element_text(self, locator):
"""获取当前的text"""
_text = self.find_element(locator).text
log.info("获取⽂本：{}".format(_text))
return _text
@property
def get_source(self):
"""获取页⾯源代码"""
return self.driver.page_source
def refresh(self):
"""刷新页⾯F5"""
fresh()
self.driver.implicitly_wait(30)
在⽂件中我们对主要⽤了显式等待对selenium的click，send_keys等⽅法，做了⼆次封装。提⾼了运⾏的成功率。
好了我们完成了POM模型的⼀半左右的内容。接下来我们们进⼊页⾯对象。
创建页⾯对象
在page_object⽬录下创建⼀个searchpage.py⽂件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
from page.webpage import WebPage, sleep
adelement 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['搜索按钮'])
在该⽂件中我们对，输⼊搜索关键词，点击搜索，搜索联想，进⾏了封装。
并配置了注释。
在平时中我们应该养成写注释的习惯，因为过⼀段时间后，没有注释，代码读起来很费劲。
好了我们的页⾯对象此时业已完成了。下⾯我们开始编写测试⽤例。在开始测试⽤了之前我们先熟悉⼀下pytest测试框架。简单了解Pytest
打开pytest框架的官⽹。
# content of test_sample.py
def inc(x):
return x + 1
def test_answer():
assert inc(3) == 5
官⽅教程我认为写的并不适合⼊门阅读，⽽且没有版。
推荐看⼀下。
pytest.ini
pytest项⽬中的配置⽂件，可以对pytest执⾏过程中操作做全局控制。
在项⽬根⽬录新建pytest.ini⽂件。
[pytest]
addopts = --html=report.html --self-contained-html
addopts 指定执⾏时的其他参数说明：
--html=report/report.html --self-contained-html ⽣成pytest-html带样式的报告
-s 输出我们⽤例中的调式信息
-q 安静的进⾏测试
-v 可以输出⽤例更加详细的执⾏信息，⽐如⽤例所在的⽂件及⽤例名称等
编写测试⽤例
我们将使⽤pytest编写测试⽤例。
在TestCase⽬录中创建test_search.py⽂件。
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import re
import pytest
from utils.logger import log
adconfig import ini
from page_object.searchpage import SearchPage
class TestSearch:
@pytest.fixture(scope='function', autouse=True)
def open_baidu(self, drivers):
"""打开百度"""
search = SearchPage(drivers)
<_url(ini.url)

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。