5.若依然安装报错，可采取方法二进行安装

方法二：找到pandas下载库，然后通过pip install [pandas包路径]安装 1.进入网站 www.lfd.uci.edu/~gohlke/pyt… Ctrl+F,输入pandas,找到需要的版本下载即可。

比如我要下载的是pandas-1.4.3-cp310-cp310-win_amd64.whl。 下载后保存到磁盘某一个路径下

2.打开cmd命令行，输入pip install [pandas包路径]

方法三：如果报超时的错，是因为国外的源文件在国内下载比较慢，可更换为国内的镜像。

使用清华大学的pandas镜像进行安装： pip install -i pypi.tuna.tsinghua.edu.cn/simple pandas

下载很快，且无报错。 最后执行一下python -m pip list命令查看已经安装的包，可以看到不光pandas已经装好了，还安装了numpy库。

• 执行以下代码打印出第三章接口测试用例

import pandas as pd

获取excel中的数据

sheet1_data = pd.read_excel(“…/第三章接口测试用例.xlsx”)
print(sheet1_data)
复制代码

• 显示所有的列

import pandas as pd

显示所有的列

pd .set_option(‘display.max_columns’,None)

显示所有的行

pd .set_option(‘display.max_rows’,None)

获取excel中的数据

sheet1_data = pd.read_excel(“…/第三章接口测试用例.xlsx”)
print(sheet1_data)
复制代码

2. Excel的数据访问

输入：sheet2_data = pd.read_excel("…/第三章接口测试用例.xlsx"sheet_name=“Sheet2”) 后直接报以下图

import pandas as pd

显示所有的列

pd .set_option(‘display.max_columns’,None)

显示所有的行

pd .set_option(‘display.max_rows’,None)

获取excel中的数据

sheet1_data = pd.read_excel(“…/第三章接口测试用例.xlsx”)
sheet2_data = pd.read_excel("…/第三章接口测试用例.xlsx"sheet_name=“Sheet2”)
print(sheet2_data)
复制代码

输入以下可访问到，但是也报错

import pandas as pd

显示所有的列

pd .set_option(‘display.max_columns’,None)

显示所有的行

pd .set_option(‘display.max_rows’,None)

获取excel中的数据

sheet1_data = pd.read_excel(“…/第三章接口测试用例.xlsx”)
sheet2_data = pd.read_excel("…/第三章接口测试用例.xlsx"sheet_name=“Sheet2”)

print(sheet2_data)

print(sheet1_data)

print(type(sheet1_data))
复制代码

单独访问一列的数据

import pandas as pd

显示所有的列

pd .set_option(‘display.max_columns’,None)

显示所有的行

pd .set_option(‘display.max_rows’,None)

获取excel中的数据

sheet1_data = pd.read_excel(“…/第三章接口测试用例.xlsx”)
sheet2_data = pd.read_excel("…/第三章接口测试用例.xlsx"sheet_name=“Sheet2”)

print(sheet2_data)

print(sheet1_data)

print(type(sheet1_data))

单独访问一列的数据

print(“*”*20)
print(sheet1_data[‘编号’])
复制代码

3. Python接口自动化Excel读取测试用例

导包

import xlrd
def get_exceldate(filepath,sheet_name,casename):
print(filepath)
res_list = []

获取指定的表对象

work_book = xlrd.open_workbook(filepath,formatting_info=True)

操作指定的表单

work_sheet = work_book.sheet_by_name(sheet_name)

count =0

获取第0列全部数据作为遍历对象

for one_col in work_sheet.col_values(0):

防止列中有多余数据 进行判断

if casename in one_col:
#获取每行第九列的数据
req_body = work_sheet.cell(count,9).value

#获取每行第十一列的数据
resp_exp = work_sheet.cell(count,11).value
#将数据 加入到列表中
res_list.append(req_body)
#将数据 加入到列表中
res_list.append(resp_exp)
print(one_col)
if name == ‘main’:
get_exceldate(“D:/testdata.xls”,“访问”,‘access’)
复制代码

第三章.MySQL数据库接口测试用例访问

1.MySQL存储测试用例的优劣势

1. 企业中测试团队工作场景

• 多人共同测试同一个项目
• 同事之间的工作有不同的分工和交叉

1. Excel存储测试用例的优劣势

• 优势：数据操作方便
• 劣势：团队中数据不易同步，数据复用性差

1. MySQL数据存储的优劣势

• 优势：数据同步与共享方便，数据复用性强，用例留有痕迹
• 劣势：有一定的技术门槛

2.MySQL测试用例管理思路

1. 测试用例书写

• 可以与Excel测试用例字段一致
• 但是，字段名称要是用英文，这样更符合规范

1. Excel测试用例数据导入

• 点击表，右键进入导入向导
• 进入之后可选择相应的文件（xlsx）
• 导入从磁盘寻找想要的用例表格，随后再打开
• 勾选必要用的
• 输入字段名行，第一个数据行

• 可以调整

• 选择导入模式
• 最后就是这样的

3.PyMySQL结合Pandas操作MySQL数据库

import pymysql
db_info = {
“host”:“192.168.0.108”,
“user”:“root”,
“password”:“mydb2”,
“charset”:“utf8”
}

conn = pymysql.connect(**db_info)

cursor = conn.cursor()
sql = “select * from mumu”
cursor.execute(sql)
result = cursor.fetchall()
print(result)
复制代码

• 结合pandas执行sql

import pymysql
import pandas as pd

db_info = {
“host”:“192.168.0.108”,
“user”:“root”,
“password”:“mydb2”,
“charset”:“utf8”
}

conn = pymysql.connect(**db_info)

cursor = conn.cursor()

sql = “select * from mumu”

cursor.execute(sql)

result = cursor.fetchall()

print(result)

print(type(result)

结合pandas执行sql

sql = “select * from mumu”
result = pd read_sql(sql,conn)
print(result)
复制代码

第四章.PyTest自动化测试框架

1. PyTest介绍与安装

1. PyTest介绍

• PyTest是python的一个第三方的单元测试库
• 自动识别测试模块和测试函数
• 支持非常丰富的断言（assert）语句

1. PyTest中的使用约束

• 测试文件的文件名必须以"test_“或”_test"结尾
• 测试类必须以“Test”开头
• 测试的函数名必须以"_test"开头
• 测试类里面不能使用"init"方法

1. PyTest安装命令

pip install pytest

cd到这个文件

• 输入1时打印结果为：

import pytest

def test_demo():
assert 1 == 1

if name ==“main”:
pytest.main([‘test_pytest1.py’])
复制代码

• 输入2时打印结果为：

import pytest

def test_demo():
assert 1 == 1

if name ==“main”:
pytest.main([‘test_pytest1.py’])
复制代码

2. PyTest中的断言

• 执行代码打开自己的文件

import pytest

def add(a,b):
return a + b

def test_dengyu():
assert 3 == add(1,2)

if name == “main”:
pytest.main([‘test_pytest2.py’])
复制代码

• 执行以下代码：

import pytest

def add(a,b):
return a + b

def test_dengyu():
assert 3 == add(1,2)

def test_budengyu():
assert 5 != add(1,3)

def test_dayu():
assert 5 > add(1,3)

def test_dayudengyu():
assert 5 >= add(1,3)

def test_xiaoyu():
assert 1 < add(1,2)

def test_xiaoyudengyu():
assert 1 <= add(1,3)

def test_baohan():
assert 1 in [1,2,3]

def test_bubaohan():
assert 1 not in [1,2,3]

def test_iftrue():
assert 1 is True

def test_iffalse():
assert 0 is False

if name == “main”:
pytest.main([‘test_pytest2.py’])
复制代码

• 打印结果为三个失败，七个通过

D:\python\python.exe “D:/PyCharm Community Edition 2022.3.2/plugins/python-ce/helpers/pycharm/_jb_pytest_runner.py” --path C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5\test_pytest2.py
Testing started at 18:45 …
Launching pytest with arguments C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5\test_pytest2.py --no-header --no-summary -q in C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5

============================= test session starts =============================
collecting … collected 10 items

test_pytest2.py::test_dengyu PASSED [ 10%]
test_pytest2.py::test_budengyu PASSED [ 20%]
test_pytest2.py::test_dayu PASSED [ 30%]
test_pytest2.py::test_dayudengyu PASSED [ 40%]
test_pytest2.py::test_xiaoyu PASSED [ 50%]
test_pytest2.py::test_xiaoyudengyu PASSED [ 60%]
test_pytest2.py::test_baohan PASSED [ 70%]
test_pytest2.py::test_bubaohan FAILED [ 80%]
test_pytest2.py:26 (test_bubaohan)
1 != [1, 2, 3]

Expected :[1, 2, 3]
Actual :1

def test_bubaohan():

  assert 1 not in [1,2,3]

E assert 1 not in [1, 2, 3]

test_pytest2.py:28: AssertionError

test_pytest2.py::test_iftrue FAILED [ 90%]
test_pytest2.py:29 (test_iftrue)
1 != True

Expected :True
Actual :1

def test_iftrue():

  assert 1 is True

E assert 1 is True

test_pytest2.py:31: AssertionError

test_pytest2.py::test_iffalse FAILED [100%]
test_pytest2.py:32 (test_iffalse)
0 != False

Expected :False
Actual :0

def test_iffalse():

  assert 0 is False

E assert 0 is False

test_pytest2.py:34: AssertionError

========================= 3 failed, 7 passed in 0.21s =========================

Process finished with exit code 1
复制代码

3. PyTest中的参数化

• 执行以下代码三个通过，三个失败：

参数化

import pytest

def add(a,b):
return a + b
#第一种实现参数化的写法
@pytest.mark.parametrize([‘x’,‘y’],[(1,2),(0,3),(1,4)])
def test_add1():
assert 3 == add(x,y)

第二种参数化的写法

xy = [(-1,3),(-1,4),(1,-4)]
@pytest.mark.parametrize([‘x’,‘y’],xy)
def test_add2(x,y):
assert 3 == add(x,y)

if name == “main”:
pytest.main([‘test_pytest3.py’])
复制代码

参数化

import pytest

def add(a,b):
return a + b
#第一种实现参数化的写法
@pytest.mark.parametrize([‘x’,‘y’],[(1,2),(0,3),(1,4)])
def test_add1():
assert 3 == add(x,y)

第二种参数化的写法

xy = [(-1,3),(-1,4),(1,-4)]
@pytest.mark.parametrize([‘x’,‘y’],xy)
def test_add2(x,y):
assert 3 == add(x,y)

把存储在mysql当中的测试用例参数发出来

import pymysql
db_info={
“host”:“192.168.0.108”,
“user”:“root”,
“database”:“db2”
“charset”:“utf8”
}
conn pytest.connect(**db_info)
cursor = conn.cursor()
sql = “select * from mumu”
cursor.execute(sql)
result = cursor.fetchall()

@pytest.mark.parametrize([‘id’,
‘case_id’,
‘interface_type’,
‘uri’,
‘method’,
‘if_login’,
‘input_data’,
‘data_type’,
‘expect’],result)
def test_mysql_parm(id,case_id,interface_type,uri,method,
if_login, input_data,data_type,
expect):
print(title)

if name == “main”:
pytest.main([‘test_pytest3.py’])
复制代码

4. PyTest中的组织管理

• 执行以下打印结果为9个都通过

测试用例的组织管理

import pytest

def test_01():
print(1)

def test_02():
print(2)

def test_03():
print(3)

def test_04():
print(4)

class TestLogin():
def test_05(self):
print(5)
def test_06(self):
print(6)
def test_07(self):
print(7)
def test_08(self):
print(8)
def test_09(self):
print(9)

if name == “main”:
pytest.main([‘test_pytest4.py’])
复制代码

D:\python\python.exe “D:/PyCharm Community Edition 2022.3.2/plugins/python-ce/helpers/pycharm/_jb_pytest_runner.py” --path C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5\test_pytest4.py
Testing started at 19:25 …
Launching pytest with arguments C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5\test_pytest4.py --no-header --no-summary -q in C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5

============================= test session starts =============================
collecting … collected 9 items

test_pytest4.py::test_01 PASSED [ 11%]1

test_pytest4.py::test_02 PASSED [ 22%]2

test_pytest4.py::test_03 PASSED [ 33%]3

test_pytest4.py::test_04 PASSED [ 44%]4

test_pytest4.py::TestLogin::test_05 PASSED [ 55%]5

test_pytest4.py::TestLogin::test_06 PASSED [ 66%]6

test_pytest4.py::TestLogin::test_07 PASSED [ 77%]7

test_pytest4.py::TestLogin::test_08 PASSED [ 88%]8

test_pytest4.py::TestLogin::test_09 PASSED [100%]9

============================== 9 passed in 0.06s ==============================

Process finished with exit code 0
复制代码

测试用例的组织管理

import pytest

def test_01():
print(1)

def test_02():
print(2)

def test_03():
print(3)
@pytest.mark.run(order=1)
def test_04():
print(4)

class TestLogin():
def test_05(self):
print(5)
def test_06(self):
print(6)
def test_07(self):
print(7)
def test_08(self):
print(8)
def test_09(self):
print(9)

if name == “main”:
pytest.main([‘test_pytest4.py’])

“”"
在pytest当中，测试方法执行的顺序，默认是从上到下
我们使用pytest.mark.run进行测试函数执行顺序的标记时
需要先安装pip inst pytest_ordering
“”"
复制代码

D:\python\python.exe “D:/PyCharm Community Edition 2022.3.2/plugins/python-ce/helpers/pycharm/_jb_pytest_runner.py” --path C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5\test_pytest4.py
Testing started at 19:33 …
Launching pytest with arguments C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5\test_pytest4.py --no-header --no-summary -q in C:\Users\Administrator\PycharmProjects\pythonProject\part2\chapter5

============================= test session starts =============================
collecting … collected 9 items

test_pytest4.py::test_04 PASSED [ 11%]4

test_pytest4.py::test_01 PASSED [ 22%]1

test_pytest4.py::test_02 PASSED [ 33%]2

test_pytest4.py::test_03 PASSED [ 44%]3

test_pytest4.py::TestLogin::test_05 PASSED [ 55%]5

test_pytest4.py::TestLogin::test_06 PASSED [ 66%]6

test_pytest4.py::TestLogin::test_07 PASSED [ 77%]7

test_pytest4.py::TestLogin::test_08 PASSED [ 88%]8

test_pytest4.py::TestLogin::test_09 PASSED [100%]9

============================== 9 passed in 0.06s ==============================

Process finished with exit code 0
复制代码

5. PyTest框架简介

pytest，rf（学关键字语法，报告漂亮），unitest 　　pytest是python的第三方单元测试框架，可以做系统测试，比unitest更简洁和高效，执行315种以上的插件，

同时兼容unittest框架，在unittest框架迁移到pytest框架的代码不需要重写代码 　　unittest框架迁移到pytest框架的时候不需要重写代码 　　纯python代码的自动化测试框架

1：Pytest框架简介： 　　接口测试方案：python

一：工具类：纯手工测试，用工具来做（postman jemeter soapui）–入门简单，不好扩展（后面很多框架定制化） 　　　　二：代码类：现成的python框架：unitest(单元测试比较多，最原始的解释器自带的，不需要安装，不支持定制化，分布式) pytest（高级，效率高，支持定制化） nose 　　　　　　rf（报告篇评论，需要学会–封装关键字） 　　　　　　pytest和nose都是unitest扩展的更高级的一个库，框架，基于unitest 　　　　三：测试平台：现成平台，公司自己定制开发的，不对外 （融合jmeter，）　　综合平台 　　　　　　前端 　　　　　　后端 　　　　　　执行机制----框架pytest（一般融合了禅道，框架，邮件各种功能）

pytest是python的第三方单元测试框架，可以做系统测试，比unitest更简洁和高效，支持315种以上的插件，

同时兼容unittest框架，在unittest框架迁移到pytest框架的代码不需要重写代码 　　unittest框架迁移到pytest框架的时候不需要重写代码 　　纯python代码的自动化测试框架

pytest对比unitest框架的优势：高级，效率高，支持定制化，支持分布式，支持315种以上的丰富插件，还能向下兼容unitest

pytest灵活：

1：定制化（定制化用例执行，定制化报告）

2：环境清除也灵活 　　以及各方面做的都比unittest更加灵活

pytest更加灵活，便捷，效率更高，　　还支持分布式（分布式是其他框架做不了）

分布式：1000个接口用例怎么跑，一条条跑很费劲，时间长，找几个同时分担执行测试用例（pytets独有的性质）

2：pytest框架环境搭建： 　　pip pytest 　　　　　　　　　　　　　　 安装pytest 　　pip install pytest-html 　　　　　　 　　 安装原生态报告模板–自带的（有点垃圾） 　　Required-by: pytest-xdist(分布式测试), pytest-metadata, pytest-html, pytest-forked, allure-pytest 　　100个接口用例，正常是一个个用例跑，时间很长， 　　分布式-多个业务用例多条线来跑，提高效率（分布式设计用例—分布式逻辑设计，不要出现耦合，关联性太强的东西，否则会等待的）

3:pytets执行测试用例 　　设计测试用例时候注意点（必须遵循的规则，否则不识别）：

1：.py测试文件必须以test（test_xxx）开头（或者以_test结尾） 　　　　2：测试类必须以Test开头，并且不能有init方法-----测试类Test开头 　　　　3：测试方法必须以test_开头 　　　　4：断言必须使用assert

4：一般做项目是新建package包的　 　　项目文件 　　　　lib库文件　　　　（登录接口源代码，其他接口公共的类,封装的库，登录的，订单的）（包） 　　　　data文件　　　　（参数化数据，excel文件，yaml文件，csv文件—测试文件，用例，文档）(可以是普通文件夹) 　　　　test_case文件　　（放测试用例的 ）（包） 　　　　　　test_func01.py（测试用例，写的最好见名知意） 　　　　report文件　　　　（存放测试报告的普通文件夹） 　　　　config　　　　　　（配置文件）

5：pytest函数级别 　　函数级别的测试用例必须test_开头：如下test_tc01，test_tc02两个测试用例

import pytest
def test_tc01():　　　　#定义函数类型测试用例　　
assert 1+12 　　#断言
def test_tc02():
assert 1+13 　　#断言

if name == ‘main’:
pytest.main([“test_func01.py”]) #我主动运行我的pytest框架(自动调用所有的test测试函数，按照顺序依次运行，test开头的用例自动识别）
复制代码

6：pytest类级别（工作一般以类位单元，一个模块一个类，登录类，订单类，购物类） 　　类级别的测试l类必须以Test开头，并且类李不能有init方法，类里面的函数都是test_开头

封装好函数和类就行，其他的交给框架，设置好，框架帮你自动组织怎么运行

封装为了分层，后面更好维护，代码结构整洁

import pytest

class Test_login(): 　　　　　　　　　　　　#登录模块的测试类
def test_login01(self):
print(“—test_login01----”)
assert 1 + 1 == 2
def test_login02(self):
print(“—test_login02----”)
assert 1 + 1 == 3
if name == ‘main’:
pytest.main([“test_func01.py”,“-s”]) #框架自己调用函数　　需要打印对应的信息，需要在列表里面加-s
复制代码

7：自动化测试里面的环境初始化与清除 　　环境初始化目的：

清空测试环境的垃圾数据，前置条件

需不需要分层：需要

比如：课程模块：课程模块的初始化需要

1：删除所有的课程

2：新增我们的一些课程（这个给修改/查询/删除接口使用）　　模块级别的（大的课程模块第一件事就是删除以前的课程）

干掉数据后假如需要删除课程，这个接口需要单独的fixture的初始化，增加课程才能删除，其他的接口不需要这个fixture初始化，）

分层：模块层次的初始化，某个接口也需要初始化----框架的分层

条件初始化要和接口挂钩，接口该怎么就要怎么设计

环境初始化和清除，

一头一尾，两个不同概念，（环境的初始化也可以是清除数据） 　　　　一个接口可以多个级别的fixture，可以

分布式：1：并行执行 2：分布式

优化运行时间：分布式，（搭建环境麻烦）

什么是环境初始化：

做这个用例之前想要做个操作，初始化动作，比如登录，首先需要连上这个项目(要先能ping通)，

环境初始化–比如课程新增需要数据全部清空，也是环境初始化

功能测试：保证测试环境数据和跑什么系统的，或者后台有什么进程执行，或者项目里面测试这功能，功能里面有没有垃圾数据要清除　　做个初始化

unittest：最基础的框架，python自带（环境初始化和数据清除用setup和teardown）

jemeter：也有环境清除和初始化

不管做什么测试比如（功能，自动化，性能）都要对当前测试环境初始化，做完后要垃圾数据进行回收（特别是自动化，不然很多用例明明是对的会失败）

每次做一个场景，模块的时候，看看模块有没有需要前置的或者环境清除的步骤（基本操作流程）

pytest是unittest的升级版，对环境清除操作非常灵活（分层分级）

pytest：fixture操作类进行环境初始化 @fixture这样的一个装饰器

pytest的fixture操作

环境初始化与清除

pytest提供的fixture实现unitest中的setup/teardown功能，可以在每次执行case之前初始化数据

不同的是，fixture可以只在执行某几个特定case前运行，只需要在运行case前调用即可，比setup/teardown使用灵活

pytest的初始化和清除可以类里面写个setup_class方法做，以类为单元，模块，包，方法为单元都可以，也可以用fixture来做

8：pytest前置和后置条件（环境初始化与清除）　　 　　环境初始化

1：清除以前的数据

2：测试的时候不是每个接口都要执行，可以定制化执行，固定执行某些接口，先执行删除用例，

但是数据已经被清除了，无法删除，修改–需要新增一批测试数据，所以这时候需要环境初始化和清除的想法

setup_class：类里面类级别的初始化，teardown

pytest初始化和前置条件,很多接口用例本身需要初始化,初始化分为很多层，

可以在整个外面做，也可以在里面做，测试类的初始化可以在类里面定义

import pytest
class Test_login(): 　　　　　　　　　　#登录模块的测试类
#该测试类—有个前置的操作（初始化）
def setup_class(self):　　　　　　#类级别的初始化–可选项
#一个项目，先登录，再购物，登录就是购物类的前置条件，可以放在setup_class里面
print(“执行测试类之前，我需要执行操作”)

def test_login01(self):
print(“—test_login01----”)
assert 1 + 1 == 2
def test_login02(self):
print(“—test_login02----”)
assert 1 + 1 == 3

def teardown(self):　　　　　　　　　　　　#看业务本身需不需要初始化和清除环境，–可选项
print(“------该测试类的环境清除-----”)

if name == ‘main’:
pytest.main([“test_func01.py”,“-s”])
复制代码

9：pyets种有四种级别的setup和teardown 　　1：setup_module和teardown_module,在整个测试用例所在的文件中所在的文件中所有的方法运行前和运行后运行，只运行一次—模块的 　　2：setup_class和teardown_class,在整个测试文件中的一个class中所有的用例的签后运行 ----class类 　　3：setup_method和teardown_method,在class内的每个方法运行前后运行 ---------方法的 　　4：setup_function和teardown_function,在非class下属的每个测试方法的前后运行 ----函数的 　　　　分层分级（不同级别有不同方法）

10：pytest里面的数据初始化装饰器fixture参数说明 fixture_function: Optional[_FixtureFunction] = None, *, scope: “Union[_Scope, Callable[[str, Config], _Scope]]” = “function”, --scope参数:级别 params: Optional[Iterable[object]] = None,------------------------------- params:参数 autouse: bool = False,---------------------------------------------------- autouse：是否自动化执行 ids: Optional[ Union[ Iterable[Union[None, str, float, int, bool]], Callable[[Any], Optional[object]], ] ] = None, name: Optional[str] = None 　@pytest.fixture(scope=xxx,params=xxx,autouse=xxx)

fiixture装饰器可以传单三个参数

1：scope参数：初始化清除定义级别

2：params:参数

3：autouse：是否自动化执行

11：fixture 函数级别的初始化，环境初始化

import pytest

#函数级别的@pytest.fixture()初始化操作

@pytest.fixture() 　　　　#标记函数是个初始化操作，标记后需要传给每个函数statr_func这个函数名才会执行初始化操作（函数级别的）

def statr1_func():

#这不是测试函数，一个普通函数,pytest执行用例只能识别test开头的方法和函数，所以pytest.main不会执行(不参加pytest用例)

print(“------初始化操作1------”)

@pytest.fixture()

def statr2_func():

print(“------初始化操作2------”)

#fixture:有哪些操作（可以多个初始化可以一起调，需要两个初始化，需要连接，需要登录）

#这种写法很方便，函数需要statr_func1函数做一个初始化操作可以调用statr_func1这个函数，—def test_001(statr1_func):

需要其他初始化方法可以选择性调用其他初始化函数，传递函数名就行（灵活选择）----def test_002(statr2_func):

#函数初始化操作需要传递几个函数也可以多个函数名传递–def test_003(statr2_func,statr1_func):

#方便灵活

def test_001(statr1_func):

print(“-----test01------”)

def test_002(statr2_func):

print(“-----test02 ------”)

def test_003(statr2_func,statr1_func):

print(“-----test03 ------”

if name == ‘main’:

pytest.main([“test_pytest.py”,“-s”])
复制代码

**　聪明的小伙伴就发现了，欸出bug了， print("-----test03 ------"这里明显少了个括号嘿嘿嘿，写代码还是要细心一点。记得加上【）】 **

12：类级别的初始化class，可以使用setup做初始化，也可以使用fixture做初始化

import pytest

@pytest.fixture(scope=“class”) 　　　　　　　　#类级别的初始化函数 scope=“class” 就是把这个初始化定义成类级别的
def statr1_func():
print(“------初始化操作1------”)

class Test_00:　　　　　　　　　　　　　　　　　　#需要执行 Test_00测试类，需要做初始化(可以setup_class)

def setup_class(self):

print(“类内部的初始化,”) 　　　　 #只对类有用,类级别的，类里只做一次(几个类的初始化操作一样这种不适合，需要重复写)

#fixture初始化类就是避免重复代码
def test_001(self,statr1_func):
print(“-----test01------”)

def test_002(self,statr1_func):
print(“-----test02 ------”)

if name == ‘main’:
pytest.main([“test_pytest01.py”,“-s”])
复制代码

类级别初始化fixture，虽然test_001和test_002都调用了statr1_func这个类级别的初始化函数，但是执行类测试用例的时候只执行statr1_func初始函数一次 　　 　　多个类都可以调用statr1_func这个类级别的初始化方法,调用的时候最好放在类里的第一个函数，后面的函数可以不传(因为对应的是类级别的初始化)

import pytest
@pytest.fixture(scope=“class”) 　　　　　　#类级别的初始化函数
def statr1_func():
print(“------初始化操作1------”)
#一个模块里面有函数用例也有类的用例怎么做：（class级别的初始化只对类有用，对函数没用）
def test_003(statr1_func): #测试函数,
print(“-----test03------”)

class Test_00: #需要执行test00测试类，需要做初始化(可以setup_class)
def test_001(self,statr1_func):
print(“-----test01------”)

def test_002(self,statr1_func):
print(“-----test02 ------”)

if name == ‘main’:
pytest.main([“test_pytest01.py”,“-s”])
复制代码

初始化方法statr1_func定义成class类级别的，函数级别的测试测试用例test__003调用初始化函数会执行一次， 　　class类级别的测试用例Test_00调用初始化函数会执行一次（一共执行两次） 　　看级别的，整个模块的级别的化最好用module，否则有问题，fixture可以做return，会有返回值的，对应级别来做， 执行结果： 　　　　test_pytest01.py 　　　　------初始化操作1------ 　　　　-----test03------ 　　　　.------初始化操作1------ 　　　　-----test01------ 　　　　.-----test02 ------

13：类级别初始化实际代码：初始化操作是登录操作

#课程模块的测试类
import pytest
from lib.api_lib.lesson import Lesson
from lib.api_lib.lesson import Login
from tools.execlMethod import get_excelData
import json
import os

@pytest.fixture(scope=“class”) 　　　　　　　　#类级别的初始化函数
def start_func():
global sessionid
sessionid = Login().login(‘{“username”:“auto”,“password”:“sdfsdfsdf”}’)

class Test_lesson:
#1:课程新增接口,前置条件登录(封装完一个方法后想办法做数据驱动)，课程增加需要通过excel表用例来做
@pytest.mark.parametrize(“inData,repsData”, get_excelData(‘2-课程模块’, 2, 26))
def test_lesson_add(self,start_func,inData,repsData):
reps=Lesson(sessionid).lesson_add(inData)
print(reps)
assert reps[“retcode”]==json.loads(repsData)[“retcode”]

if name == ‘main’:
pytest.main([“test_lesson01.py”, “-s”, “–alluredir”, “…/report/tmp”])
os.system(“allure serve …/report/tmp”)

复制代码

14：模块级别的初始化mudule，不管是类还是方法　　　　@pytest.fixture(scope=“module”) 　　　　模块（module）级别的初始化，（整个模块所有的类所有的东西要做一步操作，可以使用module这个模式）

只在模块运行前面只做一次，后面不做了，哪怕多调用也没用，一个模块里面有test_003函数测试用例，

也有classTest_00类级别的测试用例，定义一个模块级别的初始化函数statr1_func

函数里面调用初始化方法def test_003(statr1_func):和类里面的方法调用初始化方法test_001(self,statr1_func):，test_001(self,statr1_func):

整个模块执行的时候初始化函数都只执行一次（不管你这个模块里面调用多少次）

import pytest
@pytest.fixture(scope=“module”) 　　　　　　#模块级别的初始化函数
def statr1_func():
print(“------初始化操作1------”)

#一个模块里面有函数用例也有类的用例怎么做：（class级别的初始化只对类有用，对函数没用）
def test_003(statr1_func): 　　　　　　　　 #测试函数,
print(“-----test03------”)

class Test_00: 　　#需要执行test00测试类，需要做初始化(可以setup_class)

def setup_class(self):

print(“类内部的初始化,”) 　　　　#只对类有用,类级别的，类里只做一次(几个类的初始化操作一样这种不适合，需要重复写)

#fixture初始化类就是避免重复代码

def test_001(self,statr1_func):
print(“-----test01------”)

def test_001(self,statr1_func):
print(“-----test02 ------”)

if name == ‘main’:
pytest.main([“test_pytest01.py”,“-s”])
复制代码

执行结果：test_pytest01.py 　　　　　　　　　　------初始化操作1------ 　　　　　　　　　　-----test03------ 　　　　　　　　　　.-----test01------ 　　　　　　　　　　.-----test02 ------

在这个模块下面所有的都会调用（包级别的，包里面运行前做个环境清除）

需要在testcase文件夹里面创建一个conftest.py模块，这个

固定名称，pytest自动识别这个名称

testcase里面：新增课程前面需要登录，增加课程前面需要清除数据，需要2个级别的初始化，1：登录 2：整个环境的清除

test_case（测试用例文件夹）创建一个：conftest.py文件　　里面写包级别的初始化

conftest.py文件里也能写类级别和模块级别的初始化，而且不需要调用，这个conftest.py模块是pytest自动识别导入的

test_case　　　　　　　　　　　　　　　　#文件夹
conftest.py
import pytest
#包级别的初始化，在运行整个包之前做个初始化，包里面不同作用域，每个包里面都可以放一个，每个包里面的操作都可以不一样
@pytest.fixture(scope=“session”,autouse=True) 　　　　　　　　#session级别的处于时候autouse=True默认自动执行
def start_demo(request): #包的开始
print(“我是整个包的初始化”)
def fin(): 　　　　　　　　　　　　　　　　　　　　　　　　　　 #尾部这是包级别的，整个包做完后做个环境数据的清除 包的结束
print(‘—测试完成，包的数据清除—’)

request.addfinalizer(fin)　　　　　　　　　　　　　　　　　　 #回调，当我整个包运行完了后回调fin这个方法

#fixture的参数autouse: bool = False,—自动执行参数
复制代码

#session的级别，包里面有很多模块，很多模块需要对整个包进行初始化在conftest.py里面做模块的数据初始化和清除（conftest.py只对当前包有用）

15：两种调用初始化和清除函数的方式+初始化清除函数的返回值的使用

import pytest
@pytest.fixture()
def befor_func():
print(‘xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx’)
yield 10
print(‘zzzzzzzzzzzzzzzzzz测试用例的清除zzzzzzzzzzzzzz’)

def test_001(befor_func):　　　　　　　　　　　　　　　　#调用初始化和清除方式一：直接在测试用例里传递初始化清除函数的函数名来调用
print(“测试用例001”)
res=befor_func　　　　　　　　　　　　　　　　　　　　#如果初始化清除函数有返回值，可以直接这样接收参数来使用
print(res)

@pytest.mark.usefixtures(‘befor_func’)　　　　　　　　#调用初始化和清除方式二：使用usefixtures放在测试用例前面直接调用初始化清除函数
def test_002():
print(“测试用例002”)

if name == ‘main’:
pytest.main([“test1.py”,‘-s’])
复制代码

七：pytest前置条件+后置条件的两种写法

1：使用yield关键字来是实现　　推荐使用这种，因为yield关键字能返回函数的值

import pytest
@pytest.fixture()
def befor_func():
print(‘xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx’)
yield 10　　　　　　　　　　　　　　　　　　　　　　　　　　　　#yield后面跟的是测试用例的后置条件，支持用例执行后就执行yield里的内容
print(‘zzzzzzzzzzzzzzzzzz测试用例的清除zzzzzzzzzzzzzz’)

def test_001(befor_func):
print(“测试用例001”)
res=befor_func
print(res)

if name == ‘main’:
pytest.main([“test1.py”,‘-s’])
复制代码

2：使用finc()函数来实现　　　　这种就不能返回返回值了

import pytest
@pytest.fixture()
def befor_func(request):
print(‘xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx’)
def fin():　　　　　　　　　　　　　　　　　　　　　　　　#尾部这是后置条件，测试用例执行后就会调用这个函数　　　　　　
print(‘zzzzzzzzzzzz测试用例的清除zzzzzzzzzzz’)

request.addfinalizer(fin)　　　　　　　　　　　　　　　#回调，当我整个包运行完了后回调fin这个方法　　　　　　　　　　
def test_001(befor_func):
print(“测试用例001”)

if name == ‘main’:
pytest.main([“test1.py”,‘-s’])
复制代码

16：pytest数据驱动（参数化）　 　　pytest数据驱动的意义：

参数化（登录用例4条，每一个账号密码都不同，使用框架把4个用例全部执行完，不需要for循环遍历执行，采用数据驱动方案来做）

pytest内置装饰器@pytest.mark.parametrize可以让测试数据参数化，把测试数据单独管理，类似ddt数据驱动的作用，方便代码和测试数据分离

@pytest.mark.parametrize(“a”,[1,2,3])：　　　　　　　　参数化传一组参数

@pytest.mark.parametrize(“a,b”, [(1,2),(3,4),(5,6)]) 　　 参数化传多组参数

登录账户密码（name和psw不同的用例组合，一个接口几十个用例怎么做----几十组数据----传的参数不同（什么请求方式和各种都一样）

可以把name和psw分别采取多组数据进行参数化，数据分离，一个接口跑4次，每次用不同的参数）

import pytest
#[(1,2),(3,4),(5,6)] [1,2,3]
class Test_login():
def setup_class(self):
print(“执行测试类之前，我需要执行操作”)

@pytest.mark.parametrize(“a”,[1,2,3]) #(“变量名”,[1,2,3]),数据需要封装成一个列表，多个数据需要封装成列表嵌套元组 ----数据驱动
def test_login01(self,a): #数据驱动，一定要把变量名a引入引来，不然无法参数化
复制代码

print(“—test_login01----”)
assert 1 + 1 == a

@pytest.mark.parametrize(“a,b”, [(1,2),(3,4),(5,6)]) #数据驱动传多组参数
def test_login02(self,a,b):
print(“—test_login02----”)
assert a + 1 == b

def teardown_class(self):
print(“------该测试类的环境清除-----”)

if name == ‘main’:
pytest.main([“test_func01.py”,“-s”])
复制代码

17：pytest结合allure报告操作　　 　　一：pytest自带的报告框架 pytest-html

二：allure环境搭建（allure是报告库不是python专属的，很全面的框架）-allure报告漂亮

1：下载allure.zip（压缩包） 　　　　2：解压allure.zip到一个文件目录 　　　　3：将allure-2.13.3\bin路径添加到环境变量path 　　　　4：pip install allure-pytest -------allure报告本身不是很漂亮，通过allure-pytest这个库可以定制化报告，让报告变得很漂亮 　　　　5：验证（cmd输入allure）

三：allure和pytest联合执行生成报告：运行两条语句

1：执行pytest单元测试，生成的allure报告需要的数据存在/tmp目录

pytest -sq --alluredir=…/report/tmp　　　#pytest把allure报告的生成的中间文件放到一个临时文件里面（pytets生成报告，需要数据，所以先把数据存起来）

#所有的报告需要数据支持的，数据来源pytest框架本身，结果数据存到一个文件，存在…/report/tmp文件夹

#tmp临时文件，一般json格式

2：执行命令，生成测试报告

allure generate …/report/tmp -o …/report/report -clean 　　　　　　#allure指令生成对应报告

18：allure模拟代码

import pytest
import os
class Test_login():
def setup_class(self):
print(“执行测试类之前，我需要执行操作”)

@pytest.mark.parametrize(“a”,[1,2,3])
def test_login01(self,a):
print(“—test_login01----”)
assert 1 + 1 == a

@pytest.mark.parametrize(“a,b”, [(1,2),(3,4),(5,6)])
def test_login02(self,a,b):
print(“—test_login02----”)
assert a + 1 == b

def teardown_class(self):
print(“------该测试类的环境清除-----”)

if name == ‘main’:
#需要打印对应的信息，需要在列表里面加-s
#1:–alluredir —生成临时文件，测试用例的结果数据放到目录 --alluredir 存放目录
pytest.main([“test_func01.py”,“-s”,“–alluredir”,“…/report/tmp”]) #框架自己调用函数
#通过–alluredir把allure需要的数据存到…/report/tmp这个路径下面
#…/–所在路径的父级别目录是test_case的目录隔壁邻居report文件下tmp，专门放alluer报告生成的需要的数据源

2:临时数据没有报告的，allure generate allure才会生成报告 -----allure生成器生成allure报告–generate allure生成器,cmd指令

#需要os模块os.system()调用指令可以在local的cmd里面敲
os.system(“allure generate …/report/tmp -o …/report/report --clean”)
#os.system(“allure generate 报告需要的数据 -o 报告存放目录 --clean”)
#-o生成
#allure generate生成报告指令，把…/report/tmp 的文件-o生成报告out out一下，生成的报告放在…/report/report
#–clean把上次报告清除一下用–clean
#allure报告生成的是一个服务，（本地服务）和jinkins结合，放在整个里面去集成，放到公共服务器里面
复制代码

19：allure报告的优化

import pytest
import os
import allure
@allure.feature(“登录模块”) #一级标题，大模块标题（类标签）
class Test_login():
def setup_class(self):
print(“执行测试类之前，我需要执行操作”)

@allure.story(“登录login01”) # 二级标签（每个接口的标签）
@allure.title(“login01”) # 标题，每个用例带个标题（报告体现在每个测试用例）(一个接口有几个用例，title用例的标签)
@pytest.mark.parametrize(“a”,[1,2,3])
def test_login01(self,a):
print(“—test_login01----”)
assert 1 + 1 == a

@allure.story(“登录login02”) # 二级标签，定制allure报告层级
@allure.title(“login02”) #标题，每个用例带个标题（报告体现在每个测试用例）
@pytest.mark.parametrize(“a,b”, [(1,2),(3,4),(5,6)])
def test_login02(self,a,b):
print(“—test_login02----”)
assert a + 1 == b

def teardown_class(self):
print(“------该测试类的环境清除-----”)

@allure.feature(“购物模块”)
class Test_Shopping():
@allure.story(“shopping”)
@allure.title(“shopping01”)
@pytest.mark.parametrize(“a,b”, [(1, 2), (3, 4), (5, 6)])
def test_shopping(self, a, b):
print(“—test_login02----”)
assert a + 1 == b
if name == ‘main’:
pytest.main([“test_func01.py”,“-s”,“–alluredir”,“…/report/tmp”])
os.system(“allure generate …/report/tmp -o …/report/report --clean”)
#allure报告生成的是一个服务，（本地服务）和jinkins结合，放在整个里面去集成，放到公共服务器里面

复制代码

20：其他知识点 　　　　测试用例一般写在excel表格文件里面，数据分离（维护好excel就行）

pytest–从头到尾到报告执行发邮件

字典是一种存储类型，json是一种格式（完全不同）

21：pytest参数解析

pytest.main([‘test_boss.py’,‘-s’,‘-k test_modify_psw’,‘–alluredir=tmp/my_allure_results’])

test_boss.py 　　　　　　　　指定测试用例文件，
-s 　　　　　　　　　　　　 显示print语句
-k test_modify_psw 　　　　 指定某个测试用例

-n 　　　　　　　　　　　　表示用两个进程启动测试脚本

生成报告缓存文件　　--alluredir=tmp/my_allure_results

os.system(‘allure serve tmp/my_allure_results’)　　　　打开测试报告，命令行需要python 的os模块调用
复制代码

22：pytest的初始化和清除：

import pytest
#假设启动被测app的时候需要去填写配置项信息，每个的端口号不同，多终端需要两个appim server
#这时候setup_module和teardown_module不能传参，搞不定，需要换一种方法做测试用例的初始化和清除，

#setup_module以模块为作用域，不写module以测试用例（测试函数）为作用域

def setup_module(): 　　 #测试用例之前执行，原始的setup和teardown有个缺陷，里面不能传参数，

#默认test级别，每个测试用例执行的时候都会执行一次，希望当前某个模块执行的时候只执行一次（不管里面用例执行多少次）

#setup初始化和tear_down升个级，升级成module模块级别的

print(“启动被测app”)

print(‘连接appium服务’)

def teardown_module():

print(‘关闭被测app’)

print(‘断开appium服务’)

#定义个函数，名字随便取　　使用@pytest.fixture装饰器把这个函数装饰成初始化清除函数
@pytest.fixture(scope=‘module’) #作用域默认test，初始化，加装饰器，初始化清除函数,autouse=True（自动执行）这种方法不建议使用 #
def before_test(): #初始化函数升级作用域到module模块级别
print(“启动被测app”)
print(‘连接appium服务’)
yield #后面写清除动作，
after_test()

#清除函数，清除函数并不会直接被初始化函数使用，我们必须放在初始化函数yiled后面才能回被调用
def after_test():
print(‘关闭被测app’)
print(‘断开appium服务’)
#目前一共有两个port，需要测试两个手机，两个多终端,before_test需要装饰器标记

#测试用例的参数化
@pytest.mark.usefixtures(‘before_test’) #这表示调用某个自定义的初始化函数，括号里面的字符串写被调用函数的名字
@pytest.mark.parametrize(‘psw’,[‘boss123’,‘boss456’])
def test_app(psw): #测试用例，可能涉及到其他参数,比如需要一些配置信息,测试用例涉及到参数，
#多组参数需要使用装饰器pytest.mark.parametrize(数据驱动)，psw传参和形参名字对应的
print(‘测试boss app’)
print(f’登录测试账号{psw}')

if name == ‘main’:
pytest.main([‘pytest_ywt.py’,‘-s’])
复制代码

23：pytest之：不只是测试函数test_app能参数化，初始化函数before_test也能参数化 　　重点：测试用例的参数化+初始化清除函数的参数化　　初始化清除函数的参数化能够实现appium的多终端测试

初始化清除函数的参数化，方法很多种：

before_test初始化函数注入参数，因为print(f’连接appium服务{port}')里面port需要变化的，

@pytest.fixture(scope=‘module’,params=[(4723,),(4727,)])　　：初始化清除函数的参数化

始化函数装饰器里面加params参数传参，port=request.param[0] 来调用params里的参数

#初始化清除函数的参数化：只传单个参数 import pytest @pytest.fixture(scope=‘module’,params=[(4723,),(4727,)]) #初始化清除函数的参数化params def before_test(request):
port=request.param[0] 　　　　　　　　　　　　　　#param[0]，假如注入多个参数一个port和一个data–需要params传元组， #params=[(4723,100),(4727,200)],一个参数的话不需要写成列表嵌套元素， 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#params[0]代表获取元组第一个 print(“启动被测app”) print(f’连接appium服务{port}') yield #后面写清除动作， after_test() 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#request是pytest的对象，我们在用对象里面的方法的时候pycham不会自动帮我们取显示名字， 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#它也不知道request里面到底什么内容

def after_test():
print(‘关闭被测app’)
print(‘断开appium服务’)

@pytest.mark.usefixtures(‘before_test’)
@pytest.mark.parametrize(‘psw’,[‘boss123’,‘boss456’])
def test_app(psw):
print(‘测试boss app’)
print(f’登录测试账号{psw}')

if name == ‘main’:
pytest.main([‘pytest_ywt.py’,‘-s’]) 　　
#初始化清除函数的参数化：传多个参数　　　　　　　　　　　　　　
import pytest
@pytest.fixture(scope=‘module’,params=[(4723,‘xiaomi’),(4727,‘meizu’)])
def before_testquest):
port=request.param[0] 　　　　　　#param[0]，假如注入多个参数一个port和一个data，需要params传元组，params=[(4723,100),(4727,200)],
#一个参数的话不需要写成列表嵌套元素，request.params[0]代表获取元组第一个
device=request.param[1] 　　　　#request.param[1]对应元素里面第二个参数，
print(f"在{device}启动被测app")
print(f’连接appium服务{port}')
yield #后面写清除动作，
after_test()

#request是pytest的对象，(固定写法：request.param)
#我们在用对象里面的方法的时候pycham不会自动帮我们去显示名字，它也不知道request里面到底什么内容

def after_test():
print(‘关闭被测app’)
print(‘断开appium服务’)

@pytest.mark.usefixtures(‘before_test’)
@pytest.mark.parametrize(‘psw’,[‘boss123’,‘boss456’])
def test_app(psw):

print(‘测试boss app’)
print(f’登录测试账号{psw}')

if name == ‘main’:
pytest.main([‘pytest_ywt.py’,‘-s’])
复制代码

24：pytest框架执行代码也能在cmd里面直接输入命令执行 　　　　xxx\test_case> pytest -s 　　在test_case这个目录执行会运行test_case文件里面所有的测试文件（test开头的测试用例）

25：分布式 　　设置用例每个模块独立，有什么前置做到模块里面，比如测试10个模块，用相关联来做，不能做分布式(并发执行)

每个模块独立还能定制执行那个模块，关联性太强做不到

最好做到每个接口都独立化（前置条件做好）不要做太大关联性的接口

每一层都能做环境清除和定制化（包，模块。类，函数）分层，为后面mark（定点执行哪些用例）和分布式打基础

分布式：必须做到用例的隔离（低耦合，高内聚），用例走串行风险很大，很难维护

3000个请求，全部独立化，然后分布式来做（效率提高几倍–几十倍）

26：分布式的实现 　　分布式的核心点：封装设计：相互独立，登录和课程相互独立，至少模块为单元要相互独立，封装相互独立，接口用例之间最好也相互独立　　才能进行分布式

一：pytest分布式环境搭建和理论介绍：

第一步：安装一个库 pip install pytest-xdist 　　分布式运行插件,可以做分布式（这个库有两种运行方式）

运行方式：

1：串行，顺序运行，串行运行，从头到尾

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数软件测试工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上软件测试开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注软件测试）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

test.mark.usefixtures(‘before_test’)
@pytest.mark.parametrize(‘psw’,[‘boss123’,‘boss456’])
def test_app(psw):

print(‘测试boss app’)
print(f’登录测试账号{psw}')

if name == ‘main’:
pytest.main([‘pytest_ywt.py’,‘-s’])
复制代码

24：pytest框架执行代码也能在cmd里面直接输入命令执行 　　　　xxx\test_case> pytest -s 　　在test_case这个目录执行会运行test_case文件里面所有的测试文件（test开头的测试用例）

25：分布式 　　设置用例每个模块独立，有什么前置做到模块里面，比如测试10个模块，用相关联来做，不能做分布式(并发执行)

每个模块独立还能定制执行那个模块，关联性太强做不到

最好做到每个接口都独立化（前置条件做好）不要做太大关联性的接口

每一层都能做环境清除和定制化（包，模块。类，函数）分层，为后面mark（定点执行哪些用例）和分布式打基础

分布式：必须做到用例的隔离（低耦合，高内聚），用例走串行风险很大，很难维护

3000个请求，全部独立化，然后分布式来做（效率提高几倍–几十倍）

26：分布式的实现 　　分布式的核心点：封装设计：相互独立，登录和课程相互独立，至少模块为单元要相互独立，封装相互独立，接口用例之间最好也相互独立　　才能进行分布式

一：pytest分布式环境搭建和理论介绍：

第一步：安装一个库 pip install pytest-xdist 　　分布式运行插件,可以做分布式（这个库有两种运行方式）

运行方式：

1：串行，顺序运行，串行运行，从头到尾

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数软件测试工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-KITAe4tp-1712854842076)]
[外链图片转存中…(img-loE1rBBG-1712854842077)]
[外链图片转存中…(img-Dp3y4rXk-1712854842077)]
[外链图片转存中…(img-LsevOzL5-1712854842078)]
[外链图片转存中…(img-fEdrQIbq-1712854842078)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上软件测试开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注软件测试）
[外链图片转存中…(img-UWiQMjQD-1712854842079)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！