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 格式化的方式
- 字符串的前面加上"f" 或"F"
- 占位符统一变为{}、
- 需要填充的变量,写在{}中
算数运算符
/ 除 得到的是浮点类型
// 求商 整数
%取余 整数
** 幂运算,指数运算 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)
三大流程
顺序
分支
循环
循环:
语法:
- 设置循环的初始条件(计数器)
- 书写循环的判断条件 while 判断条件:
- 需要重复执行的代码
- 改变循环的初始条件(计数器)
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
- 只要=,可以改变引用
- 可变类型在函数内部,如果不使用=直接修改形参是引用,对形参使用的修改会同步到实参中
对于列表来说+=的本质是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)
字符串比大小:
字符比大小,是比较字符对应的ASCII码值
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 的写入:
- import json
- 写w方式打开文件
- 写入
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__的作用:
每个代码都是一个模块
在导入模块的的时候,会执行模块中的代码,
- __name__变量
- __name__变量 是python解释器自动维护的变量
- __name__变量,如果代码是直接运行,值是“__main__”
- __name__,变量,如果是导入运行的代码,值是模块名(即代码文件名)
Unit Test
- 能够组织多个用例去执行
- 能够提供丰富的断言方法(让程序代替人工自动的判断预期结果和实际结果是否相符)
- 能够生成测试报告
- TestCase(测试用例),注意这个测试用例是unit test框架的组成部分,不是手工和自动化中我们所说的用例(Test Case)
主要作用:每个TestCase(测试用例)都是一个代码文件,在这个代码文件中,来书写真正的用例代码
TestSuite
- TestSuite(测试套件),,用来管理,组装(打包)多个TesCase(测试用例)的
TestRunner
- TestRunner(测试执行,测试运行),用来执行TestSuite(测试套件)的
TestLoader
- TestLoader(测试加载),功能是对Testuite(测试套件)功能的补充,管理,组装(打包)多个TestCase(测试用例)的
Fixture
Fixture(测试夹具),书写在TestCase(测试用例)代码中的,是一个代码结构,可以在每个方法执行前后都会执行的内容,只写一般,但每次执行用例的时候都会执行一次
TestCase
步骤:
- 导包
- 自定义测试类,需要继承unit test模块中的Test Case类即可
- 书写测试方法,测试用例,即用力代码,目前没有真正的用力代码,使用print代替,书写要求:测试方法必须以test_ 开头(本质是以test开头)
- 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(套件)
步骤:
- 导包(unit test)
- 实例化(创建对象)套件对象
- 使用套件对象添加用例方法
- 实例化运行对象
- 使用运行对象执行套件对象
方法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(测试加载)
数据的数量较大时使用
- 导包
- 实例化加载对象,并添加用例discover(."/ "," ")发现
- 实例化运行对象
- 执行
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.....
参数化代码:
- 导包unittest/pa
- 定义测试类
- 书写测试方法(用到的测试数据使用变量代替)
- 组织测试数据并传参
跳过
代码书写在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得到代码,才会生成测试报告
生成第三方的测试报告:
- 获取第三方的测试运行模块,将其放在代码 的目录中
- 导包unittest
- 使用套件对象,加载对象去添加用例对象
- 实例化,第三方的运行对象并运行套件对象