测试工程师社招-pytest框架
（关于测试框架，面试问的不多，比如：项目用到多少，跑出来多少问题等，不会详细问怎么写）
基础知识
一、Python+request测试接口案例
1、测试get接口
import requests
r = requests.get('https://api.github.com/events')
print(r.status_code)
print(r.json())
2、测试get param接口
import requests
params={
"shouji":"***",
"appkey":"***"
}
r = requests.get(url = 'http://api.binstd.com/shouji/query',params=params)
print(r.json())
3、测试post json接口
import requests
json_data = {
"title":"foo",
"body":"bar",
"userId":1
}
r = requests.post(url = "https://jsonplaceholder.typicode.com/posts",json = json_data)
print(r.status_code)
print(r.json())
4、测试post param接口
import requests
params ={
"shouji":"***",
"appkey":"***"
}
r = requests.post(url = "http://api.binstd.com/shouji/query",params = params)
print(r.status_code)
print(r.json())
5、测试post formdata接口
import requests
data = {
"text":"hello"
}
r = requests.post(url = "https://dict.youdao.com/keyword/key",data = data)
print(r.json())
二、pytest框架
Pytest是什么：
单元测试框架，在自动化测试或者白盒测试中针对软件的最小单元（函数、方法）进行测试
主要做什么：
发现测试用例、执行测试用例、判断测试结果、生成测试报告
插件：
pytest
pytest-html(生成html报告的插件)
pytest-xdist（多线程运行的插件）
pytest-ordering（改变用例的执行顺序的插件）
pytest-rerunfailres（失败用例重跑的插件）
allure-pytest（生成美观自定义的allure报告）
（pip insatll -r requirements.txt(去运行安装所有的插件)）
命名规则：
1、模块名必须以test_开头或者以_test结尾2、测试类必须以test开头，并且不能带有init方法3、测试用例必须以test_开头
Testcase Test test
如何执行：
1、命令行的方式执行pytest
-v 输出详细信息
-s 输出调试信息 -vs
-n 多线程运行（pytest -xdist） pytest -vs -n =2
(一个线程里面有多个进程，6秒，两个线程运行5秒--每个线程需要创建时间)
-reruns num失败重跑（插件：rerunfailres） pytest -vs --reruns=2
Raise Exception(“”)抛出异常 try except解决异常
-x 出现一个用例失败则停止测试 pytest -vs -x
-maxfail 出现几个失败才终止
-html生成html的测试报告（插件：pytest -html） pytest -vs --html ./reports/result.html
-k运行测试用例名称中包含某个字符串的测试用例 pytest -vs -k “baili or xingyao”
2、通过main方式执行
if __name__ == '__main__':
pytest.main(["-vs"])
3、通过全局配置文件pytest.ini文件执行，一般放在项目的根目录下1、可以改变默认的测试用例规则2、主函数和命令行都可以加载3、测试用例分组执行4、 -m “smoke’只执行冒烟用例 @pytest.mark.smoke
[pytest] addopts = -vs --alluredir=./temps --clean-alluredir testpaths = ./testcase python_files = test_*.py python_classes = Test* python_functions = test_*
pytest如何跳过测试用例：（）
1、无理由跳过 2、有理由跳过
import pytest
@pytest.mark.skip(reason = "无理由跳过")
def test01():
print("测试")
@pytest.mark.skipif(12>10,reason = "有理由跳过")
def test02():
print("测试01")
def test03():
print("测试03")
if __name__ == '__main__':
pytest.main(['-vs'])
Pytest测试用例的前后置，setup和teardown，不同等级，封装在一个公共包、公共类里面函数级别、类级别
模块级：setup_module/teardown_module
函数级：setup_function/teardown_function
类级：setup_class/teardown_class
类中的方法级：setup_method/teardown_method
使用fixture实现部分前后置（共享初始化、清理代码）
1、scope:作用域 @pytest.fixture(scope = “function”,autouse = True)
Function:在函数之前或者之后执行（可以手动调用，也可以自动执行），有return或者yield返回值，可以把这个值传递到测试用例当中，yield后置
Return和yield区别：1、返回某个值，返回后函数不在继续执行彻底结束2、yield生成器 返回结果后函数不结束 暂定 再次调用时暂定的地方继续执行，可执行多次
@pytest.fixture(scope = "function",autouse=True)
def func():
print("我是前置步骤")
yield
print("我是后置步骤")
Class:在类之前和类之后执行，自动执行或者手动调用(@pytest.mark.usefixtures(“exe_sql”)) @pytest.mark.usefixtures(“”)
Package、session：在整个项目会话之前和之后执行，需要结合contest.py文件使用
2、autouse:自动执行，默认是False
3、Params：实现参数化，如何把值传到fixture，通过fixture函数的参数里面加入request来接收这个参数，可以通过request.param取值
@pytest.fixture(scope ="function",autouse=False,params=read_yaml())
def exe_database_sql(request):
print(request.param)
print("执行sql查询")
yield
print("关闭数据库连接")
4、ids:不能单独使用，必须和params一起使用，作用是对参数起别名
@pytest.fixture(scope ="function",autouse=False,params=read_yaml(),ids=['z','m'])
5、name:给fixture起别名，一旦使用，只能用别名
Fixtrue结合conftest.py文件使用：
1、conftest.py专门用来存放fixtrue的配置文件
2、在conftest.py文件里面所有的方法在调用时都不需要导包
3、Conftest.py文件可以有多个，并且conftest.py文件里面的多个fixtrue可以被同一个用例调用
优先级：
fixture的session
fixture的class
Setup_class
fixture的function
Setup
pytest执行过程：
1、查找当前目录下的conftest.py文件
2、查找当前目录下的pytest.ini文件（找测试用例的位置）
3、查找用例目录下的conftest.py
4、查找py文件中是否有setup、teardown、setup_class、tear_class
5、在根据pytest.ini文件中的测试用例规则去查找用例并执行
Pytest断言：assert
Allure-pytest插件生成更美观的报告
1、安装插件
2、下载allure，解压，解压后配置环境变量
3、验证allure https://www.cnblogs.com/lirongyu-test/p/16656478.html
4、生成allure报告
a、生成临时的json报告，在pytest.ini文件里面加入以下内容
addopts = -vs --alluredir=./temps --clean-alluredir
b、生成更美观的allure报告
c、定制化
Pytest之parametrize()实现数据驱动，@pytest.mark.parametrize(args_name,args_value)，args_name：参数名称，用于将参数的值传递给函数；args_value：参数值（列表和字典列表，元祖和字典元祖），有n个值用例执行n次
#单参数单次循环
@pytest.mark.parametrize("name",['老白'])
def test_parametrize01(name):
print("测试参数化"+name)
#单参数多次循环，运行时将数组里的值分别赋值给变量，每赋值一次，运行一次
@pytest.mark.parametrize("name",['老白','老黑'])
def test_parametrize02(name):
print("测试参数化" + name)
#可以数组\可以元祖
@pytest.mark.parametrize("name,word",[['老白','123'],['老黑','456']])
def test_parametrize03(name,word):
print(f'{name}的台词是{word}')
Yaml格式测试用例读写封装
1、yaml是一种数据格式，扩展名可以使yaml.xml,#注释 ，缩进表示层级关系，区分大小写
yaml读取出来是一个字典列表 每加一次就多一个用例
2、用于做配置文件（yaml.ini）;用于编写自动化测试用例
-
name: 获取统一的鉴权码
request:
method: get
url: https://api.weixin.qq.com/cgi-bin/token
data:
grant_type: client_credential
appid: ***
secret: ***
validate: None
实战项目分享
一、requests使用
1）testcase：定义测试用例 1、导包 2、定义登录方法3、定义测试数据 4、发送post请求 5、输出结果
#1、导包
import requests
#2、定义登录方法
def login():
#3、定义测试数据
url = 'https://api.weixin.qq.com/cgi-bin/token'
params = {
"grant_type":"client_credential",
"appid":"wx71385b4e0a37259d",
"secret":"8963b6138d123eb0edf9fb5d8f453c8f"
}
#4、发送post、get请求
r = requests.get(url=url,params = params)
#5、输出结果
print(r.json())
2）utils：封装公共方法
封装get和post方法：1、创建封装get和post的方法 2、发送requests get或post请求 3、获取结果相应内容 4、内容存到相应字典 5、字典返回
#单独封装get请求
def request_get(url,params):
r = requests.get(url,params = params)
code = r.status_code
try:
body = r.json()
except Exception as e:
body = r.text
res = dict()
res['code'] = code
res['body'] = body
return res
#get方法调用
r = request_get(url,params = params)
print(r)
#单独封装post请求
def request_post(url,params,json):
r = requests.post(url,params = params,json = json)
code = r.status_code
try:
body = r.json()
except Exception as e:
body = r.text
res = dict()
res["code"] = code
res['body'] = body
return res
#post方法调用
r = request_post(url,params=params,json = json)
print(r)
get和post方法重构：1、定义一个类 2、定义判断方法：如果是get发送get方法，如果是post发送post方法 获取相应的code body 3、重构get post方法 4、在测试用例里面调用 初始化类 调用相应的get post方法
#重构：1、创建类 2、定义公共方法 3、重构get和post方法
class Request:
def request_api(self,url,data = None,params = None,json = None,cookies = None,method = "get"):
#1、增加方法的参数，根据参数来验证方法get / post请求，方法请求
if method == "get":
r = requests.get(url, params=params, json=json,cookies = cookies)
elif method == "post":
r = requests.post(url, params=params, json=json,cookies = cookies)
# 2、重复的内容，复制进来
code = r.status_code
try:
body = r.json()
except Exception as e:
body = r.text
res = dict()
res['code'] = code
res['body'] = body
return res
#get、post方法重构：1、定义方法 2、定义参数(可变参数) 3、调用公共方法
def get(self,url,**kwargs):
#url method json headers cookies
return self.request_api(url,method = "get",**kwargs)
def post(self,url,**kwargs):
return self.request_api(url,method = "post",**kwargs)
#调用：1、初始化类 2、接收get post方法 3、打印信息
request = Request()
r = request.post(url,params = params,json = json)
print(r)
二、yaml配置文件
yaml文件格式：字典和列表
字典：1、字典里的键值对“：”分隔 2、字典直接写key和value，每一个键值对占一行 3、后面要有空格
name: "test_yaml"
result: "sucess"
列表：1、一组按序排列的值（简称序列或列表）2、数组前加有“-”符号，符号与值之间需要用空格分隔
#["a","b","c"]
- "a"
- "b"
- "c"
1、字典嵌套字典
#{person1:{"name":"xiaoming","age":"18"},person2:{"name":"xiaohong","age":"20"}}
person1:
name: xiaoming
age: 18
person2:
name: xiaohong
age: 20
2、字典嵌套列表
#{person:["a","b","c"]}
person:
- "a"
- "b"
- "c"
3、列表嵌套列表
-
- "a"
- "b"
- "c"
-
- "1"
- "2"
- "3"
4、列表嵌套字典
#[{"username1":"test1",{"password1":"111","username2":"test2"}}]
- username1: "test1"
- password1: "111"
username2: "test2"
读取文件：1、读取单个文件2、读取多个文件
# 1、创建yaml格式文件
# 2、读取这个文件 (1、导入yaml包 2、打开文件 3、使用yaml读取文件) 字典格式 ：注意空格
# 3、输出这个文件
#读取单个文档
import yaml
with open("./data.yml","r",encoding="utf-8") as f:
r = yaml.safe_load(f)
print(r)
#读取多个文档
---
"用户名称1": "text123"
"密码": "123456"
---
"用户名称1": "text456"
"密码": "123456"
#1、编辑或修改data.yml 2、yaml 读物方法，all 3、循环打印
import yaml
with open("./data.yml","r",encoding="utf-8") as f:
r = yaml.safe_load_all(f)
for i in r:
print(i)
utils包-创建yamlReader类，初始化类读取yaml文件：
1、创建一个YamlReader类 2、初始化，判断文件是否存在 os.path.existd() 不存在就抛出异常 初始化文件的内容dat 3、读取单个文件 没数据返回初始化数据 有数据返回读取到的数据 4、读取多个文件 没数据返回初始化数据 有数据返回读取到的数据 （list接收）
#1、创建类 2、初始化，文件是否存在 3、yaml文件读取
import os
import yaml
class YamlReader:
#初始化，判断文件是否存在
def __init__(self,yamlIf):
if os.path.exists(yamlIf):
self.yamlIf = yamlIf
else:
raise FileNotFoundError("文件不存在")
self._data = None
self._data_all = None
#yaml读取
#单个文档读取
def data(self):
#第一次调用data，读取yaml文档，如果不是，直接返回之前保存的数据
if not self._data:
with open(self.yamlIf,"rb") as f:
self._data = yaml.safe_load(f)
return self._data
#多个文档读取
def data_all(self):
#第一次调用data，读取yaml文档，如果不是，直接返回之前保存的数据
if not self._data_all:
with open(self.yamlIf,"rb") as f:
self._data_all = list(yaml.safe_load_all(f))
return self._data_all
#yaml_demo.py文件中调用
from utils.YamlUtil import YamlReader
# res = YamlReader("./data.yml").data()
res = YamlReader("./data.yml").data_all()
print(res)
config包：1、创建yaml文件：填写url相关信息 2、创建conf.py文件1）获取conf.yaml的目录2读取conf.yaml文件
import os
from utils.YamlUtil import YamlReader
#1、获取项目基本目录
#获取当前项目的绝对路径
current = os.path.abspath(__file__)
# print(current)
BASE_DIR = os.path.dirname(os.path.dirname(current) ) #获取父级目录,获取两次
#定义config目录的路径
_config_path = BASE_DIR + os.sep + "config"
#定义conf.yml文件的路径
_config_file = _config_path + os.sep +"conf.yaml"
#变量是私有的，定义一个方法访问
def get_config_path():
return _config_path
def get_config_file():
return _config_file
#2、读取配置文件
#创建类
class ConfigYaml:
#初始yaml读取配置文件
def __init__(self):
self.config = YamlReader(get_config_file()).data()
#定义方法获取需要的信息
def get_conf_url(self):
return self.config["BASE"]["test"]["url"]
if __name__ == '__main__':
conf_read = ConfigYaml()
print(conf_read.get_conf_url())
#以上方法用来读取yaml配置文件的url，以下代码用来在测试用例中获取url
conf_y = ConfigYaml()
url_path = conf_y.get_conf_url()
url = url_path + "/tags/get"
三、日志文件
logging模块是python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径等
#log_demo.py
#1、导入logging包
import logging
#2、设置配置信息
logging.basicConfig(level=logging.INFO,format = '%(asctime)s - %(name)s-%(levelname)s-%(message)s')
#3、定义日志名称getlogger
logger = logging.getLogger("log_demo")
#4、info、debug
logger.info("info")
logger.debug("debug")
logger.warning("warning")
日志输出控制台或文件:
1、设置logger名称
2、设置log级别
3、创建hander，用于输出控制台或写入日志文件
4、设置日志级别
5、定义handler的输出格式
6、添加handler
#输出控制台
import logging
# 1、设置logger名称
logger = logging.getLogger("log_file_demo")
# 2、设置log级别
logger.setLevel(logging.INFO)
# 3、创建handler
fh_stream = logging.StreamHandler()
# 4、设置日志级别
fh_stream.setLevel(logging.INFO)
#5、定义输出格式
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname) %(message)s')
fh_stream.setFormatter(formatter)
#6、添加handler
logger.addHandler(fh_stream)
#7、运行输出
logger.info("this is a info")
logger.debug(fh_stream)
#写入文件
import logging
# 1、设置logger名称
logger = logging.getLogger("log_file_demo")
# 2、设置log级别
logger.setLevel(logging.INFO)
# 3、创建handler
fh_stream = logging.StreamHandler()
#写入文件
fh_file = logging.FileHandler("./test.log")
# 4、设置日志级别
fh_stream.setLevel(logging.INFO)
fh_file.setLevel(logging.INFO)
#5、定义输出格式
formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s')
fh_stream.setFormatter(formatter)
fh_file.setFormatter(formatter)
#6、添加handler
logger.addHandler(fh_stream)
logger.addHandler(fh_file)
#7、运行输出
logger.info("this is a info")
logger.debug("this is a debug")
四、pytest基本使用
pytest demo：步骤：1、创建普通方法 2、创建测试方法 3、pytest断言
import pytest
def func(x):
return x+1
@pytest.mark.flaky(reruns=3,reruns_delay=2) #部分失败重跑，--reruns n --reruns-delay(出错重试的时间)
def test_a():
print("---test a---")
assert func(3) == 5
def test_b():
print("---test b ---")
assert func(4) == 5
if __name__ == '__main__':
pytest.main(["-vs","pytest_demo.py"])
setup teardown:函数级别的方法，运行于测试方法的始末；
setup_class teardown_class:类级别方法，运行于测试类始末
import pytest
#1、定义类
class TestFunc:
# 3、创建setup teardown
def setup(self):
print("setup")
def teardown(self):
print("teardown")
#2、创建测试方法test开头
def test_a(self):
print("testaaa")
def test_b(self):
print("testbbb")
# 4、运行查看结果
if __name__ == '__main__':
pytest.main(["-vs","pytest_func.py"])
import pytest
class TestClass:
def setup_class(self):
print("setup")
def teardown_class(self):
print("teardown")
def test_a(self):
print("testaaa")
def test_b(self):
print("testbbb")
if __name__ == '__main__':
pytest.main(["-vs","pytest_class.py"])
parametrize参数化：1、单个参数 2、多个参数
import pytest
#传入单个参数：@pytest.mark.parametrize(argnames,argvalues)第一个参数为参数名 第二个参数为参数对应值，类型必须为可迭代类型，一般使用list
# 1、创建类和测试方法
class TestDemo:
# 2、创建测试数据
data_list = ["xiaoxiao","xixi"]
# 3、参数化
@pytest.mark.parametrize("name",data_list)
def test_a(self,name):
print("test_a")
print(name)
assert 1
if __name__ == '__main__':
pytest.main(["-vs","pytest_one.py"])
import pytest
#传入多个参数 list的每一个元素都是一个元祖，元祖里的每个元素和按参数顺序一一对应
# 1、创建类和测试方法
class TestDemo:
# 2、创建测试数据
data_list = [("xiaoxiao","123456"),("xixi","345678")]
# 3、参数化
@pytest.mark.parametrize(("name","password"),data_list)
def test_a(self,name,password):
print("test_a")
print(name,password)
assert 1
if __name__ == '__main__':
pytest.main(["-vs","pytest_two.py"])
断言：自动化最终目的，一个用例没有断言，就失去了自动化测试的意义了；assert;预期结果和实际结果做对比
常用断言
import pytest
def test_01():
a = True
assert a
def test_02():
a = True
assert not a
def test_03():
a = "hello"
b = "hello world"
assert a in b
def test_04():
a = b = "hello"
assert a==b
def test_05():
a="hello"
b = "hello world"
assert a != b
if __name__ == '__main__':
pytest.main(["pytest_assert.py"])
结果断言验证
1、断言应用接口用例：返回状态码、结果验证 返回的code、返回的body包含信息是否正确
#封装结果断言
import json
from utils.LogUtil import my_log
#1、定义封装类
class AssertUtil:
#2、初始化数据，日志
def __init__(self):
self.log = my_log("AssertUtil")
#3、code相等
def assert_code(self,code,expected_code):
try:
assert int(code) == int(expected_code)
return True
except:
self.log.error("code error,code is %s,excepted_code is %s"%(code,expected_code))
raise
#4、body相等
def assert_body(self,body,expected_body):
try:
assert body == expected_body
return True
except:
self.log.error("body error,body is %s,expected_body is %s"%(body,expected_body))
raise
#5、body包含
def assert_in_body(self,body,expected_body):
#验证返回的结果是否包含期望的结果
try:
body = json.dumps(body)
assert expected_body in body
return True
except:
self.log.error("不包含或者body是错误，body is %s,expected_body is %s"%(body,expected_body))
raise
#接口用例应用
from utils.AssertUtil import AssertUtil
code = r['code']
AssertUtil().assert_code(code,200)
# body = json.dump(r["body"])
# AssertUtil().assert_body(body,'"user_id":1,"username":"zzz"')
数据库结果断言
接口请求、返回结果验证
1、pymysql 2、工具类封装
#1、导包 2、连接database 3、获取执行sql的光标对象 4、执行sql 5、关闭对象
import pymysql
conn = pymysql.connect(
host = '',
user = '',
password='',
database='',
charset='',
port = 7090
)
cursor = conn.cursor()
sql = "select username,password from tb_users"
cursor.execute(sql)
res = cursor.fetchone()
print(res)
cursor.close()
conn.close()
1、创封装类 2、初始化数据、连接数据库、光标对象 3、创建查询、执行方法 4、关闭对象
import pymysql
from utils.LogUtil import my_log
class Mysql:
def __init__(self,host,user,password,database,charset = "utf8",port = 3306):
self.log = my_log()
self.conn = pymysql.connect(
host=host,
user=user,
password=password,
database=database,
charset=charset,
port=port
)
self.cursor = self.conn.cursor()
def fetchone(self,sql):
self.cursor.execute(sql)
return self.cursor.fetchone()
def fetchall(self,sql):
self.cursor.execute(sql)
return self.cursor.fetchall()
def exec(self):
try:
if self.conn and self.cursor:
self.cursor.execute(sql)
self.conn.commit()
except Exception as ex:
self.conn.rollback()
self.log.error("mysql执行失败")
self.log.error(ex)
return False
return True
def __del__(self):
if self.cursor is not None:
self.cursor.close()
if self.conn is not None:
self.cursor.close()
五、数据驱动
数据参数化：目的数据和代码进行分离
yaml数据驱动、excel数据驱动
1、编写yaml文件放置在data目录下 2、创建读取yaml文件的方法
列表方式：多个文档
---
"case_name": "success"
"url": "/cgi-bin/tags/create/"
"data":
tag:
name: "guangdong"
"except": '"code":200'
---
"case_name": "fail"
"url": "/cgi-bin/tags/create/"
"data":
tag:
name: ""
"except": '"code":200'
1、conf目录下conf.py添加data目录的路径 2、读取yaml文件路径、读取yaml文件内容
#获取路径
_data_path = BASE_DIR + os.sep + "data"
def get_data_path():
return _data_path
#1、获取测试用例内容：获取yaml文件路径、使用工具类读取多个文档内容
#2、参数化执行
import os
import pytest
from config import conf
from utils.YamlUtil import YamlReader
from config.conf import ConfigYaml
from utils.RequestsUtil import Request
#1、获取测试用例内容：获取testlogin.yml文件路径；使用工具类读取多个文档内容
test_file = os.path.join(conf.get_data_path(),'testlogin.yml')
# print(test_file)
data_list = YamlReader(test_file).data_all()
# print(data_list)
#2、参数化执行测试用例
@pytest.mark.parametrize("tagadd",data_list)
def test_yaml(tagadd):
url = ConfigYaml().get_conf_url()+tagadd["url"]
# print(url)
data = tagadd['data']
# print(data)
request = Request()
res = request.post(url,json = data)
print(res)
if __name__ == '__main__':
pytest.main(["-vs","test_tagadd.py"])
2、编写测试用例：读取excel数据（导入包：xlrd;创建wordbook对象；sheet对象；读取每行、读取每列、读取固定列的内容）
用例设计、excel读取、excel参数化
demo:把创建好的excel用例放在t_excel下，创建demo简单测试
#1、导包
import xlrd
#2、创建workbook对象
book = xlrd.open_workbook("testdata.xls")
#3、sheet对象
sheet = book.sheet_by_index(0)
#4、获取行数和列数
rows = sheet.nrows
cols = sheet.ncols
#5、读取每行、每列
for r in range(rows):
r_values = sheet.row_values(r)
# print(r_values)
for c in range(cols):
r_values = sheet.col_values(c)
# print(r_values)
#6、读取固定列的内容
print(sheet.cell(1,1))
excel工具类封装：
#目的：参数化,pytest, list
import os
import xlrd
class SheetTypeError:
pass
#1、验证文件是否存在，存在读取，不存在报错
class ExcelReader:
def __init__(self,excel_file,sheet_by):
if os.path.exists(excel_file):
self.excel_file = excel_file
self.sheet_by = sheet_by
self._data = list()
else:
raise FileNotFoundError("文件不存在")
#2、读取sheet名称 索引
def data(self):
#存在不读取，不存在读取
if not self._data:
wordbook = xlrd.open_workbook(self.excel_file)
if type(self.sheet_by) not in [str,int]:
raise SheetTypeError("请输入整数或字符串")
elif type(self.sheet_by) == int:
sheet = wordbook.sheet_by_index(self.sheet_by)
elif type(self.sheet_by) == str:
sheet = wordbook.sheet_by_name(self.sheet_by)
#3、读取sheet内容
#返回list 字典 [{"a":11,"b":"12"} {"a":22,"b":b2}]
#1、获取首行信息 2、遍历测试行 与首行组成dict 放在list
title = sheet.row_values(0)
for col in range(1,sheet.nrows):
col_value = sheet.row_values(col)
self._data.append(dict(zip(title,col_value)))
#4、结果返回
return self._data
if __name__ == '__main__':
reader = ExcelReader("../data/testdata.xls","Sheet1")
print(reader.data())
excel参数化运行：获取是否运行、参数化、结果断言
from utils.ExcelUtil import ExcelReader
#1、使用excel工具类，获取结果list
reader = ExcelReader("../data/testdata.xls","Sheet1")
# print(reader.data())
#2、列是否运行内容 y
run_list = list()
for line in reader.data():
if line["是否运行"] == "y":
# print(line)
#3、保存要执行结果，放到新的列表
run_list.append(line)
print(run_list)
将excel参数化 封装为方法：
#common-dataconfig:
#定义类 定义列属性
class DataConfig:
case_id = "用例ID"
case_model = "模块"
case_name = "接口名称"
url = "请求url"
pre_exec = "前置条件"
method = "请求类型"
params_type = "请求参数类型"
params = "请求参数"
expect_result = "预期结果"
actual_result = "实际结果"
is_run = "是否运行"
headers = "headers"
cookies = "cookies"
code = "status_code"
db_verify = "数据库验证"
#common-exceldata.py
from utils.ExcelUtil import ExcelReader
from common.ExcelConfig import DataConfig
class Data:
#1、使用excel工具类，获取结果list
def __init__(self,testcase_file,sheet_name):
# self.reader = ExcelReader("../data/testdata.xls", "Sheet1")
self.reader = ExcelReader(testcase_file,sheet_name)
#2、列是否运行内容 y
def get_run_data(self):
#根据是否运行列==y 获取执行测试用例
run_list = list()
for line in self.reader.data():
if str(line[DataConfig().is_run]).lower() == "y":
# print(line)
#3、保存要执行结果，放到新的列表
run_list.append(line)
print(run_list)
return run_list
#conf获取路径
def get_excel_file(self):
#获取测试用例名称
return self.config["BASE"]["test"]["testcase_file"]
def get_excel_sheet(self):
#获取测试用例名称
return self.config["BASE"]["test"]["case_sheet"]
初始化信息，执行测试用例
import json
import pytest
from config.conf import ConfigYaml
import os
from common.ExcelData import Data
from utils.LogUtil import my_log
from common import ExcelConfig
from utils.RequestsUtil import Request
#1、初始化信息
#1）初始化测试用例文件
case_file = os.path.join("../data",ConfigYaml().get_excel_file())
#2）测试用例sheet名称
sheet_name = ConfigYaml().get_excel_sheet()
#3）获取运行测试用例列表
run_list = Data(case_file,sheet_name).get_run_data()
#4）日志
log = my_log()
#2、测试用例方法，参数化运行
#一个用例的执行
#1、初始化信息 2、接口请求
class TestExcel:
#1、增加pytest 2、修改方法参数 3、重构函数内容 4、pytest.main
@pytest.mark.parametrize("case",run_list)
def test_run(self,case):
data_key = ExcelConfig.DataConfig
#run_list第一个用例 key获取values
url = ConfigYaml().get_conf_url()+case[data_key.url]
case_id = case[data_key.case_id]
case_model = case[data_key.case_model]
case_name = case[data_key.case_name]
pre_exec = case[data_key.pre_exec]
method = case[data_key.method]
params_type = case[data_key.params_type]
params = case[data_key.params]
expect_result = case[data_key.expect_result]
actual_result = case[data_key.actual_result]
is_run = case[data_key.is_run]
headers = case[data_key.headers]
cookies = case[data_key.cookies]
code = case[data_key.code]
#接口请求
request = Request()
#params转义json
if len(str(params).strip()) is not 0:
params = json.loads(params)
#method get post
if str(method).lower()=="get":
res = request.get(url,json = params)
elif str(method).lower()=="post":
res = request.post(url, json=params)
else:
log.error("错误的请求")
print(res)
if __name__ == '__main__':
pytest.main(['-s','test_excel_case.py'])
pytest.ini [pytest] addopts = -s --html=./report/report.html testpaths = testcase python_files = test_*.py python_classes = Test_* python_functions = test_*
查看15道真题和解析
