接口 测试

1.postman自动关联测试

2.postman批量运行

3.单接口测试

4.测试用例

5.断言

6.参数化（提高测试脚本复用性）

7.接口自动化测试

8.python

注释：#

多行注释：""" """

''' '''

三对引号的注释一般在文件的最开始的地方，或文档注释处

Ctrl + Alt + L 自动格式化代码格式

数据类型：

数字类型

int

float浮点型

bool

复数类型：3+4i

非数字类型

字符串 :str

列表：list [1,2,3](数组)

元组：tuple (1,2,3,4)

字典:dict {'bame':'小明'，'age;:18}

type()获取数据类型

输入 input('提示的信息')

类型转换

语法： 变量= 转换为的数据类型（原数据类型）

%格式化输出占位符号

• %d占位，填充 整数数据 digit
• %f展位，填充 浮点型数据 float
• %s 占位，填充 字符串数据string
• 补充：其实%s的占位符，可以填充任意类型的数据
• 小数%。nf n是一个整数数字，保留n位小数
• % %%

字符串.format

• 需要使用变量的地方使用{}占位
• {}，{}，{}。format（变量，变量，.....）

f-String 格式化的方式

1. 字符串的前面加上"f" 或"F"
2. 占位符统一变为{}、
3. 需要填充的变量，写在{}中

算数运算符

/ 除 得到的是浮点类型

// 求商 整数

%取余 整数

** 幂运算，指数运算 2**2=2*2*2=8

if语句

if else 结构

if 只要有一个判断成立，后继都不再判断

elif 只有条件1不成立，才会判断条件2

debug

需要加断点

if嵌套

语法：

if 判断条件1：

判断条件1，输出

if判断条件2，输出

else

判断条件2，输出

else：

判断条件1不成立，输出

随机生成随机数

import random

random.randint(a,b)

三大流程

顺序

分支

循环

循环：

语法：

1. 设置循环的初始条件（计数器）
2. 书写循环的判断条件 while 判断条件：
3. 需要重复执行的代码
4. 改变循环的初始条件（计数器）

while True:

执行语句

if 判断条件

break

breakr跳出整个循环

coutinue跳出当前循环，剩下的代码不再执行

for循环

语法：

for 变量名 in 容器（数组）:

重复执行的代码

for循环指定循环次数

语法：

for 变量 in range(循环次数):

循环体语句

range（）变形

• range(a,b) 作用是生成[a,b)之间的整数数字，不包含b

容器：

也称为数据序列，或者高级数据类型

字符串本身包含引号，在定义的时候不能使用引号

’ 的转义字符：\'-->' \"-->"

range(a,b,c) c是数组下标间隔

下标：

语法：字符串[下标]

获取字符串的长度

方法：

len(字符串)

长度-1的下标的位置是最后一个字符

切片：

切片，可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）

语法：

字符串[开始位置下标：结束位置的下标(不包含）：所取的相邻字符下标之间的差值默认是1（隔多少位）]

特殊应用：

步长为负数，开始和结束全不写，意思全变，一般不用管，只要一种使用场景

反转（逆置）字符串 字符串【： : -1】

字符串查找方法find

用法：

字符串.find(查找内容,开始位置，结束位置）

开始位置不写默认从0开始，结束位置不写默认len()

查找成功返回找到位置的下标，没有则返回-1

字符串的替换方法

replace

语法：

字符串.replace(a,b,c)

将a替换成b

a表示被替换的内容

b表示替换的内容

c表示替换的次数，一般不写，默认是全部替换，原来的字符串没有发生改变

字符串的拆分split

字符串.split(a,b)

将字符串按照a进行分割(拆分），默认空白字符（空格，换行，tab)

b, 分割次数，一般不写，全部分割，如果不写，想要指定分割次数，需要：

字符串.split(b=n) n是次数

字符串.split()按照空白进行拆分

字符串.splie(maxsplit=1)按照空白进行拆分1次

字符串的连接 join

字符串.join(列表） 括号中的内容主要是列表，可以是其他容器

作用：将字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串

• 列表中的数据是使用“ ，”隔开的
• 注意点：列表中的数据必须都是字符串，否则会报错

列表的定义：

实例化定义：

list1 = list()
print(type(list1), list1)

直接使用[]进行定义：

list2 = [1, "dss", "小米", False]
print(list2)

列表支持下标，切片，长度：

list1 = ["向澳门",132,33,"scscc",False]
print(list1[2])#下标
print(list1[1:4])#切片
print(len(list1))#长度

查询列表中数据下标的方法

在字符串中使用find方法，不存在时返回-1

列表中使用index（）方法

语法：

列表.index(数据，a,b) a 代表开始位置，b 代表结束位置，没有找到会报错

查找-判断是否存在：

判断容器中某个数据是否存在可以使用in关键字

语法：

数据 in 容器

查找-统计出现的次数

count（）方法

列表.count(数据）

list1=["da",2,23,"dfss"]
num=list1.index(2,1,4)#查询下标

print(num)
print(list1.count("2"))

添加列表的方法：

• 尾部添加：

列表.append(数据) 将数据添加到尾部

返回：返回的None(关键字，空），一般就不再使用变量来保存返回的内容，想要查看添加后的列表，需要添加列表

• 指定下标位置添加

列表.insert(下标，数据）

• 列表合并

列表1.extend（列表2） 将列表2中的所有数据逐个添加到列表1中

补充：随机生成列表

变量名 = [“啊啊啊啊”，for i in range(100)]

列表修改操作：

列表【下标】=数据

注：字符串中的字符不能使用下标修改

列表的删除

• 根据下标删除

语法：

• 列表.pop(下标)

删除指定下标位置对应的数据

下标不写，默认删除最后一个数据

返回删除后的数据

• 根据数据值删除

列表.remove(数据值）

返回None

• 清空数据

列表.clear()

lIstanbu=[2,35,64,"rege,"]
n=lIstanbu.remove(2)#直接元素删除
n=lIstanbu.pop(2)#根据下标删除
n=lIstanbu.clear()#清空
print(lIstanbu)

列表的反转（倒置）

语法：

1.字符串[::-1] 生成新列表

2.字符串.reverse() 在原列表的基础上修改

列表的复制：

1，使用切片：

变量 = 列表[ : ]

2.使用copy方法

变量 = 列表.copy()

nas = [3, 33, 546765, 7656, 543, 3, 4]
n = nas[:]  # 切片
print(n)
naaaa = nas.copy()  # copy方法
print(naaaa)

列表的的排序

对数字进行操作

列表.sort() 升序排序

列表.sort(severse=True) 降序排序

nad=[3,54,32326,6576,6757,454,43,3,346,6]
nad.sort(reverse=True)#降序排序，默认升序排序
print(nad)

列表的嵌套

列表里面可以存放列表

ss = [[23, "fdff", 4354, 654, 6564],[3423, 42, 244, 324, 2, 4242],[2435354, 42442422, 664635, 3535]]
print(len(ss))
print(ss[0])
print(ss[1][2])
print(ss[0][1][0])
ss[1].append(2222222)# 嵌套列表指定位置插入
print(ss)

元组

tuple（）

可以存放任意数量的任意类型的数据

内容不能改变，使用（）

定义：

1.1类实例化的方式

nnn = tuple()
print(type(nnn))

1.2.类型转换

元素与列表之间可以相互转换

ma = tuple([1, 24, 5, 5])
an = list(ma)
print(type(an))
na = tuple("hello")
print(type(na), na)

2.直接使用（）定义

注：只有一个数据时，数据后面必须有一个“ ，”

nnn = (1,)
print(type(nnn), nnn)

常用方法（由于数据不可修改，只能进行查询）

• 可以使用下标，切片来获取数据
• 存在index()方法
• 存在count()方法
• 可以使用in操作

na = tuple("hello")
print(type(na), na)
nnn = (1, "aaa", 24, 453, 3, 42, 234, 2422)
print(type(nnn), nnn)
print(nnn[2])
print(nnn[::-1])
print(nnn[1::2])
a=nnn.index(3)
print(a)

字典：

dict 字典中的数据是由键值对组成的

语法：

变量 = {key:value,key:value.....}

key具有唯一性，一般为字符串，不能为列表

dict不能转列表和元组

增加和修改

语法：

字典[键] = 数据值

如果键已经存在，为修改

不=不存在为添加

na = {"name": "小米", "age": "12"}
print(len(na))
na["name"] = "小d"
print(na)
na["sex"] = "男"
na["like"] = ["学习", "打游戏"]
na['like'].append("xue")
print(na)

删除：

del 字典名[键名]

清空：

字典名.clear()

删除指定字段

字典名.pop('键'）

查询：

字典中没有下标，只能通过key获取

字典[键]

字典.get[键]

# 获取
print(na["name"])
print(na.get("like")[1])

字典的遍历

• 对字典的键进行遍历
• for 变量 in 字典 ：

print（变量）#变量就是字典的key，键

for 变量 in 字典.keys()

print(变量） #kyes()可以获取所有的key的值

• 对字典的值进行遍历

for 变量 in values()：

print(变量)#字典》values()可以获取字典中所有的值

• 对字典的键值进行遍历

for 变量1，变量2 in 字典.items()#字典.items()获取键值对

print（变量1，变量2）

al = {"name": "小米", "age": "12", "sex": "男"}
# for name in al.keys():
#     print(name)
# for name in al:
#     print(name)
# for name in al.values():
#     print(name)
for name,小米 in al.items():
    print(name,小米)

总结

函数：

语法：

define 函数名（）

函数体

函数体

函数文档注释：

def log():
    """打印输出"""
    print("八云紫")
    print("八云蓝")
    print("八云橙")
log()

查看快捷键Ctrl +Q(Mac Ctrl+Q)

转到函数声明中查看Ctrl+B

函数嵌套调用：

从外层执行到里层

def a():
    print(1)

def b():
    print(2)
    a()

def c():
    print(3)
    b()
c()

遍历练习：

lis1=[]
for i in range(3):
    dict1={}
    name=input("请输入姓名")
    age=input("请输入年龄")
    dict1["name"]=name
    dict1["age"]=age
    # dict1={"name":name,"age":age}
    lis1.append(dict1)

for it in lis1:
    print(it["name"],it["age"])



01.Python-作业讲解 P89 - 22:27



列表去重：

方法1，遍历判断，放到一个新的列表

方法2，set(集合)

list(set(list))

不能保证数据在原列表中出现的顺序

for i in list:

if i not in list:

list.append(i)

print(list)

函数参数：

def main(name1, name2):
    num = name1 + name2
    print(num)


main(100, 100)
main(1, 22)

函数返回值：

def main(name1, name2):
    num = name1 + name2
    return num


re=main(100, 100)
print(main(1, 22))
print(re)

id可以获取变量的地址

可变数据类型和不可变数据类型

可变数据类型：列表list ,字典 dirt,集合 set

不可变数据类型：int float bool str tuple

1. 只要=，可以改变引用
2. 可变类型在函数内部，如果不使用=直接修改形参是引用，对形参使用的修改会同步到实参中

对于列表来说+=的本质是exctend

交换两个变量的值

a,b=b,a

组包和拆包

全局变量和局部变量

在函数内部想要修改全局变量的引用，需要添加global关键字，对变量进行声明为全局变量

函数返回多个返回值

def a(a,b):
    num1 = a + b
    num2 = a - b
    return num1,num2
# e=a(1,6)
# print(e[0],e[1])

(q,w)=a(10,44)
print((q,w))

缺省参数：

定义方式：函数定义时，给形参一个默认的值，这个形参就变为缺省参数，缺省参数的书写要放在普通参数的 后面

好处：调用的时候可以传参也可以不传参，

多值参数[可变参数/不定长参数]

不定长位置参数：

• 普通参数前面加一个*
• 数据类型时元组
• 要写在普通参数的后面
• 一般不定长位置参数的名字为args (*args)

不定长关键字参数：

• 普通参数后面加两个**，
• 数据类型为字典
• 写在所有参数的最后面
• 一般名为kwargs (**kwargs)

def aa(*args,**kwargs):
    print(type(args),args)
    print(type(kwargs),kwargs)
aa(1,2,34,)
aa(a=1,b=2,c=3)
aa(1,23,444,a=1,b=2)

匿名函数：

语法：

lambda 参数：一行代码

不需要返回值，一行代码（表达式）的结果就是返回值

# 无参无返回值
def fun():
    print("hello word")


# 匿名函数的定义
# lambda :print("hello lambda")
fun11 = lambda: print("hello lambda")  # 匿名函数的调用，一般不调用
fun22 = lambda: 10  #


# 无参有返回
def fan():
    return 10


print(fan())


# 有参无返回值
def a(a, b):
    print(a + b)


fun33 = lambda a, b: print(a + b)
a(10, 2)
fun33(10, 2)


# 有参有返回值
def aaa(a, b):
    return a + b


print(aaa(10, 22))
fun111 = lambda a, b: a + b
print(fun111(111, 334))

se=lambda a,b:a*b
print(se(1, 34))
print(se(2, 3))

fu1=lambda a:a.get("age")
fu2=lambda b:b["age"]
dict1={"name":"小米","age":"12"}
print(fu2(dict1))

列表中的字典排序：

list2 = [{"name": "ss", "age": 18}, {"name": "ss", "age": 118}, {"name": "ss", "age": 182}]
# list2.sort(key=lambda x:x["age"],reverse=False)
list2.sort(key=lambda x:x["age"],reverse=True)
print(list2)
list2 = [{"name": "ss", "age": 18}, {"name": "ss", "age": 118}, {"name": "ss", "age": 182}]
# list2.sort(key=lambda x:x["age"],reverse=False)
list2.sort(key=lambda x:x["age"],reverse=True)
print(list2)

字符串比大小：

字符比大小，是比较字符对应的ＡSCII码值

orf(字符）获取字符对应的ASCII的值

chr(字符) 获取对应的字符

字符串比大小：

对应下标位置字符的大小，直到比出大小，如果比完了还没比出大小，则相等

面向对象：

class ase:
    def aa(self):
        print("run")


list1 = [1, 2, 33, 4, 5]
(list1.sort())
print(list1)

小猫爱吃鱼

class cat:

    def eat(self):
        print("eat driner")

    def drink(self):
        print("drink water")


tnagmu = cat()
tnagmu.eat()
tnagmu.drink()

self的具体实现：

class cat:

    def eat(self):
        print({id(self)})#打印self的地址值
        print("eat driner")

    def drink(self):
        print("drink water")


tnagmu = cat()
print(id(tnagmu))#打印tnagmu的地址值，与self相同
tnagmu.eat()
tnagmu.drink()
print(tnagmu)

对象的属性操作:

添加属性：

对象名.属性名=属性值

内部类：

self.属性名=属性值

外部类：

对象.属性名=属性值

获取属性：

对象名.属性名

class cat:

    def eat(self):
        print({id(self)})#打印self的地址值
        print("eat driner")
        print(self.name)

    def drink(self):
        print("drink water")

cat.name="蓝猫"
tnagmu = cat()
print(id(tnagmu))#打印tnagmu的地址值，与self相同
tnagmu.eat()
tnagmu.drink()
print(tnagmu)
print(cat.name)

魔法方法：

• 什么情况下自动调用 创建对象之后
• 有什么用，用在哪 1. 给对象添加属性，（初始化方法，构造方法） 2.某些代码，在每次创建之后，都要执行，就可以将这些代码写在__init__方法
• 书写的注意事项 不要写错了

__init__:方法（构造方法）

class Cat:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        print("被调用了")
    def show(self):
         # print("'姓名':{self.name},'年龄':{self.age},'性别':{self.sex}")
         print("姓名",self.name,"年龄",self.age,"性别",self.sex)

blue=Cat("黑马",12,"男")#创建对象
blue.show()

__str__：方法(析构方法）

使用print(对象）打印对象的时候会进行自动调用

打印对象的时候想查看的什么信息

如果没有定义__str__方法，print（对象），默认输出对象的引用地址

必须返回一个字符串

class Cat:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        print("被调用了")

    # def show(self):
    #      # print("'姓名':{self.name},'年龄':{self.age},'性别':{self.sex}")
    #      print("姓名",self.name,"年龄",self.age,"性别",self.sex)
    def __str__(self):
        return f'名字是:{self.name},年龄是:{self.age},性别是{self.sex}'


blue = Cat("黑马", 12, "男")  # 创建对象
print(blue)
blue = Cat("黑马程序员", 1, "女")  # 创建对象
print(blue)

__del__魔法方法

对象被删除时，自动调用的（遗言）

调用场景，程序代码运行结束，所有对象都被销毁

class a:
    def __init__(self,name):
        print("我是init,我被调用了")
        self.name=name
    def __del__(self):
        print(f"{self.name}没了，我来处理后事")
a("离")
s=a("s")
d=a("d")
print("代码运行结束")

案例1

class Person:
    def __init__(self,name,weight):
        self.name=name
        self.weight=weight
    def __str__(self):
        return f'姓名：{self.name},体重：{self.weight}'
    def run(self):
        print("体重减少")
        self.weight-=0.5
    def eat(self):
        print("体重增加")
        self.weight+=1
xm = Person("小米",100)
print(xm)
xm.run()
print(xm)
xm.eat()
print(xm)

dir(对象）获取对象所有的方法

重写：扩展式

子类方法名

super().父类方法名

子类方法名

类属性是该类中 的一个全局变量

文件操作：

打开文件

open（file，mode="r",encoding=None）

file 打开的文件路径

mode: 打开方式

encoding 编码方式：

gdk 将一个汉字转换为两个字节二进制

utf-8 将一个汉字转换为一个三个字节的二进制

返回值：返回的是文件对象

读或者写文件：

前提是打开方式是w 或 a

文件对象.write()

返回值：写入文件的字符数，一般不关注

读文件：打开方式需是 r

文件对象.read(n)

n表示读取多少个字符，不写默认读取全部

返回值：读取到的内容，类型是字符串

w打开方式：文件不存在会创建，存在会覆盖

a打开方式：文件不存在会报错，存在会追加

r方式：文件不存在会报错

二进制打开方式：

rb;

wb:

ab:

with open (file,'r',encoding=utf-8) as ff

省去close 操作

with open('a.txt',encoding='utf-8')as f:
    while True:
        buf = f.readline()
        if len(buf)==0:
            break
        else:
            print(buf,end='')

按行读取文件：

f.readline()

关闭文件：

文件对象.close()

json文件的操作：

json文件的语法：

• 后缀.json
• 主要数据类型是 对象（{}类似python中的字典） 和 数组（[ ] 类似python中的列表）对象和数组可以相互嵌套
• 一个json 文件是一个对象或者数组
• json中的对象是由键值对组成的，每个数据之间使用逗号隔开，最后一个数据后面不要写逗号
• json 中 的字符串必须使用双引号
• json 中的其他数据类型
• 数字类型：int float
• String 字符串 str
• 布尔类型，true flase --->True,Flase
• null--->None

json文件的书写：

{
  "name": "小米",
  "age": 18,
  "isMan": true,
  "like": [
    "吃饭",
    "睡觉"
  ],
  "address": {
    "country": "中国",
    "city": "上海"
  }
}

读取json：

导包 import json

打开文件

读文件json.load(文件对象)

对象返回字典，数组返回列表

案例1

import json
with open("Xm.json",encoding="utf-8")as aa:
    ss=json.load(aa)
    print(type(ss))
    print(ss.get("name"))
    print(ss.get("address").get("city"))

案例2

import json
with open("Xh.json",encoding="utf-8")as f:
    abc=json.load(f)
    for aa in abc:
        print(aa.get("name"), aa.get("age"),aa.get('like'),aa.get('address').get('city'))

案例3

import json

def date():
    aa = []
    with open("Xmm.json", encoding="utf-8") as f:
        date = json.load(f)

        for i in date:
            aa.append((i.get('desc'), i.get('username'), i.get("password"), i.get("expect")))
        # print(aa)
    return aa

json 的写入：

1. import json
2. 写w方式打开文件
3. 写入

json.dump(python 中的数据类型，文件对象）

import json
with open('Xmm.json','w',encoding='utf-8')as f:
    json.dump(list,f,ensure_ascii=False,indent=4)#ensuer_ascii是否以ASCII的格式显示，indent表示缩进距离

异常捕获：

try

书写可能发生异常的代码

except 异常类型

发生了异常执行的代码

except Exception as 变量：

捕获其他异常

else:

没有发生异常执行的代码

finally：

无论有没有发生异常都会执行的代码

raise抛出异常

模块：

python源代码文件就是一个模块

imoprt

from 模块名 import 工具名

如果是函数或类需要加括号

from 模块名 import * 将模块中所有的内容都导入

对于导入的模块或工具可以使用as关键字给其起别名，原来的名字就不能用了

模块的查找顺序：

当前目录-->系统目录--->报错

注意：定义代码文件的时候，代码的名字不能和要导入 的包的名字相同

__name__的作用：

每个代码都是一个模块

在导入模块的的时候，会执行模块中的代码，

1. __name__变量
2. __name__变量 是python解释器自动维护的变量
3. __name__变量，如果代码是直接运行，值是“__main__”
4. __name__,变量，如果是导入运行的代码，值是模块名（即代码文件名）

Unit Test

• 能够组织多个用例去执行
• 能够提供丰富的断言方法（让程序代替人工自动的判断预期结果和实际结果是否相符）
• 能够生成测试报告

• TestCase（测试用例），注意这个测试用例是unit test框架的组成部分，不是手工和自动化中我们所说的用例（Test Case）

主要作用：每个TestCase（测试用例）都是一个代码文件，在这个代码文件中，来书写真正的用例代码

TestSuite

• TestSuite(测试套件)，，用来管理，组装（打包）多个TesCase（测试用例）的

TestRunner

• TestRunner（测试执行，测试运行），用来执行TestSuite（测试套件）的

TestLoader

• TestLoader（测试加载），功能是对Testuite（测试套件）功能的补充，管理，组装（打包）多个TestCase（测试用例）的

Fixture

Fixture(测试夹具），书写在TestCase（测试用例）代码中的，是一个代码结构，可以在每个方法执行前后都会执行的内容，只写一般，但每次执行用例的时候都会执行一次

TestCase

步骤：

1. 导包
2. 自定义测试类，需要继承unit test模块中的Test Case类即可
3. 书写测试方法，测试用例，即用力代码，目前没有真正的用力代码，使用print代替，书写要求：测试方法必须以test_ 开头（本质是以test开头）
4. 1，执行用例（方法）

放在哪里，执行那一块的代码

import unittest
class TestDome(unittest.TestCase):
    def test_mode1(self):
        print("用例代码1")
    def test_mode2(self):
        print("用例代码2")

TestSuite&TestTestRunner

TestSuite(测试套件）：管理 打包 组装 TestCase（测试用例）文件的

TestRunner（测试执行）：执行TestSuite（套件）

步骤:

1. 导包（unit test）
2. 实例化（创建对象）套件对象
3. 使用套件对象添加用例方法
4. 实例化运行对象
5. 使用运行对象执行套件对象

方法1：

import unittest

from Test1 import TestDome
from Test2 import TestDome2

suitt = unittest.TestSuite()
suitt.addTest(TestDome('test_mode1'))
suitt.addTest(TestDome('test_mode2'))
suitt.addTest(TestDome2('test_mode3'))
suitt.addTest(TestDome2('test_mode4'))

runner = unittest.TextTestRunner()
runner.run(suitt)

方法2：

套件添加方法

suite.addTest(unittest.makeSuite(测试类名))

import unittest

from Test1 import TestDome
from Test2 import TestDome2

suitt = unittest.TestSuite()
# suitt.addTest(TestDome('test_mode1'))
# suitt.addTest(TestDome('test_mode2'))
# suitt.addTest(TestDome2('test_mode3'))
# suitt.addTest(TestDome2('test_mode4'))
suitt.addTest(unittest.makeSuite(TestDome))
suitt.addTest(unittest.makeSuite(TestDome2))

runner = unittest.TextTestRunner()
runner.run(suitt)

unittest组成

TeastLoader（测试加载）

数据的数量较大时使用

1. 导包
2. 实例化加载对象，并添加用例discover（."/ "," "）发现
3. 实例化运行对象
4. 执行

import unittest#导包
suite= unittest.TestLoader().discover("./ca","*t*.py")#实例化加载对象，并添加用例,("用例所在路径","用例的代码文件名")
runner = unittest.TextTestRunner()#实例化运行对象
runner.run(suite)#运行

简化为三行：

import unittest#导包
suite= unittest.TestLoader().discover("./ca","*t*.py")
#实例化加载对象，并添加用例,
("用例所在路径","用例的代码文件名")


unittest.TextTestRunner().run(suite)

再次简化：

import unittest#导包

suite=unittest.defaultTestLoader.discover("case","t*.py")

unittest.TextTestRunner().run(suite)

Fixture(测试夹具)

是一种代码结构

在某些特定的情况下，会自动执行

方法级别：每个测试方法执行前后都会执行的结构

方法执行之前：

def setUp(self):

每个方法执行之前都会执行

pass

def tearDown(self):

每个方法执行之后都会执行

pass

类级别：

在整个类中，执行之前，执行之后个一次

类中所有方法之前

@class method

def setupclass(cls):

pass

类中所有方法之后

@classmethod

def teardown(cls):

pass

模块级别：

模块：代码文件

在每个代码文件执行前后执行的代码结构

模块级别的需要写在类的外边直接定义函数即可

代码文件之前

def setupModule():

pass

代码文件执行之后

def teardownModule():

pass

方法级别的和类级别的，前后的方法，不需要同时出现，根据用例代码的需要自行的选择使用

断言：

让程序代替人工自动的判断预期结果和实际结构是否相符

断言的结果：

True--->用例通过

False--->代码抛出异常，用例不通过

assertEqual：

assertEqual(预期结果，实际结果)#判断预期结果和实际结果是否相等

相等通过，不相等不通过

assertIn

assertln(预期结果，实际结果)#判断预期结果是否

包含实际结果

包含通过，不包含不通过

参数化：

unittest 框架本身不支持参数化，想要使用参数化，需要安装插件来完成

联网安装（在cmd窗口安装或者）

pip install parameterized

pip是python中包（插件）的管理工具，使用这个工具下载安装插件

验证：

pip list 查看到parmaeterized

新建一个Python代码文件，导包验证

from pa....import.....

参数化代码：

1. 导包unittest/pa
2. 定义测试类
3. 书写测试方法（用到的测试数据使用变量代替）
4. 组织测试数据并传参

跳过

代码书写在Test Case文件

@unitest.skip("跳过的原因")

根据条件判断测试函数是否跳过，判断条件成立，跳过

@unittest.skipIf("判断条件","跳过原因")

import unittest
aa=101
class TestDome(unittest.TestCase):
    @unittest.skip("我就是要跳过")
    def test_1(self):
        print("11")
    @unittest.skipIf(aa>30,"版本不服")
    def test_2(self):
        print("1122")

    def test_3(self):
        print("11333")

测试报告：

自带的测试报告：

只有单独运行TestCase得到代码，才会生成测试报告

生成第三方的测试报告：

1. 获取第三方的测试运行模块，将其放在代码 的目录中
2. 导包unittest
3. 使用套件对象，加载对象去添加用例对象
4. 实例化，第三方的运行对象并运行套件对象

9.Pytest

10.fixture