pytest自动化测试框架（上）
自动化测试框架是为了完成一个指定的系统的自动化测试，而封装的一整套的、完善的代码框架，主要是封装一些自动化的基础模块、自动化的管理模块、自动化的统计模块等组成一个自动化框架。pytest 是一个非常成熟的Python单元框架，比unittest 更灵活，容易上手pytest 可以和selenium，requests,appuim结合实现web自动化，接口自动化，app自动化pytest 可以实现测
目录
一、pytest 单元测试框架
单元测试是指在软件开发当中，针对软件的最小单位(函数、方法)进行正确性的检查测试
常见的单元测试框架：
java：junit 和 testng
python：unittest 和 pytest
单元测试框架主要做什么？
- 测试发现：从多个文件里面去找到我们的测试用例
- 测试执行：按照一定的顺序和规则去执行，并生成报告
- 测试判断：通过断言判断预期结果和实际结果的差异
- 测试报告：统计测试进度，耗时，通过率，生成测试报告
二、单元测试框架和自动化测试框架
2.1 什么是自动化测试框架
自动化测试框架是为了完成一个指定的系统的自动化测试，而封装的一整套的、完善的代码框架，主要是封装一些自动化的基础模块、自动化的管理模块、自动化的统计模块等组成一个自动化框架。
2.2 自动化测试框架的作用
- 提高测试效率，降低维护成本
- 减少人工干预，提高测试的准确性，增加代码的重用性
- 核心的思想是让不懂代码的人，也能够通过这个框架去实现自动化测试
2.3 单元测试框架和自动化测试框架的关系
- 单元测试框架
- pom设计模式
- 数据驱动
- 关键字驱动
- 全局配置文件的封装
- 日志监控
- selenium，request 二次封装
- 断言
- 报告邮件
- .....
单元测试框架只是自动化测试框架中的组成部分之一，就是由这些一个个部分，组成了一个完整的自动化测试框架。
三、pytest 简介
- pytest 是一个非常成熟的Python单元框架，比unittest 更灵活，容易上手
- pytest 可以和selenium，requests,appuim结合实现web自动化，接口自动化，app自动化
- pytest 可以实现测试用例的跳过以及reruns失败用例重试
- pytest 可以和allure生成非常美观的测试报告
- pytest 可以和Jenkins持续集成
- pytest 有很多非常强大的插件，并且这些插件能够实现很多的实用的操作，如：
- pytest (本身框架)
- pytest-html (生成html 格式的自动化测试报告)
- pytest-xdist (测试用例分布式执行，多CPU分发)
- pytest-ordering (用于改变测试用例的执行顺序)
- pytest-returnfailures (用例失败后重跑)
- allure-pytest (用于生成美观的测试报告)
- 插件的安装方式
- 单个安装，pip install -U pytest
- 批量安装，将需要安装的插件放入文件中，在控制台执行文件进行批量安装即可
- pip insatll -r xxx.txt
四、pytest 接口自动化框架搭建
4.1 pycharm工具安装
官方下载路径：Download PyCharm: Python IDE for Professional Developers by JetBrains
下载社区版即可满足日常的接口自动化脚本开发与维护
4.2 python安装与环境配置
官方下载路径：Download Python | Python.org
配置python的环境变量，pycharm工具配置默认运行pytest框架和运行的python环境
设置默认的python运行环境：
4.3 pycharm 安装pytest
4.4 pycharm中导入requests库
五、Pycharm常用快捷键
|
快捷键 |
作用 |
|
Tab键 |
跳制表域 |
|
Ctrl + / |
代码注释 |
|
Ctrl + F |
查找 |
|
Ctrl + R |
替换 |
|
Alt + Enter |
问题修复 |
|
Ctrl + Alt + L |
代码格式化 |
|
Ctrl + D |
复制当前光标所在行代码 |
|
Ctrl(Alt) + Shift + 上下方向键 |
上下移动光标所在行代码 |
|
Ctrl + G / Command + L |
跳转到指定行：列 |
六、命名规范
命名规范在编写代码中起到了很重要的作用，通过使用有意义的命名，可以传达变量、函数和类的用途和含义，使其他人（包括自己）更容易理解代码的意图，避免错误的变量赋值或函数调用。并且当多人合作开发或维护代码时，一致的命名约定使团队成员能够更轻松地理解和修改彼此的代码。
具体包括：
- 包名尽量短小，全小写字母，不推荐使用下划线
- 模块名尽量短小，全小写字母，可以使用下划线分隔多个字母
- 类名采用单词首字母大写形式，即 Pascal 风格。
- 常量命名时全部采用大写字母，可以使用下划线
- 变量、函数名也是全小写字母，多个字母间用下划线
_进行分隔 - 使用单下划线
_开头的模块变量或者函数是受保护的 - 使用双下划线
__开头的实例变量或方法是类私有的
七、基本语法
7.1 定义变量
在python中，变量不需要定义，直接使用：
def Test(abs1,abs2,abs3):
a = 10
b = 20
c =[1,20,40,[50,10,"where"]]
c[0] = abs1
c[1] = abs2
c[2] = abs3
print("abs1的值为：%d"%c[0])
print("abs2的值为：%d"%c[1])
print("abs3的值为：%d"%c[2])
Test(10,20,30)7.2 变量类型
7.2.1 Numbers（数字）
数字数据类型用于存储数值，他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
a = 10
b = 20也可以使用del 语句删除一些对象的引用。
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5,6,7,8 ]
print("list1[0]:",list1[0]) #输出为list1[0]: physics
print("list2[1:5]:",list2[1:5]) #输出为list2[1:5]: [2, 3, 4, 5]
del list1[2] #删除list[2]的对象的引用
print("list1:",list1) #输出为list1: ['physics', 'chemistry', 2000]7.2.2 String（字符串）
字符串或串(String)是由数字、字母、下划线组成的一串字符。
word = 'word'
sentence ="这是个句子"
paragraph = """这是一个段落
包含了多个语句"""
print(word)
print(sentence)
print(paragraph)7.2.3 List（列表）
List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
letters =['c','h','e','n','r','a','n','j','d','h','a','o']
a = letters[1:11:3]
print("letters：", a) #输出结果为letters： ['h', 'r', 'j', 'a']
letters ="chenranjdhao"
a = letters[1:11:3] #取下标为1，截止下标为11之间，每隔3个下标间距分别取值
print("letters：", a) #输出结果为letters： hrja
letters ="chenranjdhao"
a = letters[1:5] #取下标为1，截止下标小于5之间的值
print("letters：", a) #输出结果为letters： henrlist = [] #空列表
list.append('Google') #使用 append() 添加元素
list.append('Runoob')
print("更新列表数据:",list) #输出结果为 更新列表数据: ['Google', 'Runoob']7.2.4 Tuple（元组）
元组是另一个数据类型，类似于 List，用 () 进行标识，内部元素用逗号隔开。
元组不能二次赋值，相当于只读列表。
tuple = ('runoob', 786, 2.23, 'john', 70.2)
tinytuple = (123, 'john')
print(tuple) # 输出完整元组
print(tuple[0]) # 输出元组的第一个元素
print(tuple[1:3]) # 输出第二个至第四个（不包含）的元素
print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print(tup3) # 输出结果为(12, 34.56, 'abc', 'xyz')
L = ('spam', 'Spam', 'SPAM!')
print(L[1:]) # 输出结果为('Spam', 'SPAM!')
print(len(L)) # 输出结果为37.2.5 Dictionary（字典）
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
dict ={}
dict['one'] ="this is one"
dict[2]="this is two"
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print(dict['one']) #输出为：this is one
print(dict[2]) #输出为：this is two
print(tinydict) #输出为：{'name': 'runoob', 'code': 6734, 'dept': 'sales'}
print(tinydict.values()) #输出为：dict_items([('name', 'runoob'), ('code', 6734), ('dept', 'sales')])
print(tinydict.keys()) #输出为：dict_keys(['name', 'code', 'dept'])
print(tinydict.values()) #输出为：dict_values(['runoob', 6734, 'sales'])tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加
print("tinydict['School']: ", tinydict['School']) #输出结果为RUNOOB
print("tinydict['Age']: ", tinydict['Age']) #输出结果为8
del tinydict # 删除字典
print(tinydict) # 运行结果报错
tinydict.clear() # 清空字典所有条目
print(tinydict) # 运行结果为{}
7.3 运算符
7.3.1 算术运算符
7.3.2 比较运算符
7.3.3 赋值运算符
7.3.4 逻辑运算符
7.3.5 成员运算符
var1 = 'Hello \nWorld!' #字符串换行
print("e" in var1) #输出结果为 true
print('ela' not in var1) #输出结果为 true
print(var1)7.3.6 身份运算符
a = 20
b = 20
if (a is b):
print("1 - a 和 b 有相同的标识")
else:
print("1 - a 和 b 没有相同的标识")
if (a is not b):
print("2 - a 和 b 没有相同的标识")
else:
print("2 - a 和 b 有相同的标识")7.4 条件语句
var =103
if(var ==100): print("变量var的值为100")
elif(var ==101): print("值不为100")
else:print('锤子')
count = 0
while count < 5:
print (count, " is less than 5")
count = count + 1
else:
print(count, " is not less than 5")7.5 循环语句
for letter in 'chedganfgrhao':
print("当前字母：%s"% letter) #遍历字符串
fruits = ['banana','apple','mango']
for fruits in fruits:
print('当前水果: %s'% fruits) #遍历列表中的值for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print ('%d 等于 %d * %d' % (num,i,j))
break # 跳出当前循环
else: # 循环的 else 部分
print ('%d 是一个质数' % num)
for letter in 'Python':
if letter == 'h':
pass
print('这是 pass 块')
print('当前字母 :', letter)7.6 日期和时间
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
import calendar
import time
ticks =time.time()
print("当前时间戳为：",ticks) #当前时间戳为： 1691552283.167663
localtime = time.localtime(time.time())
print ("本地时间为 :", localtime) #本地时间为 : time.struct_time(tm_year=2023, tm_mon=8, tm_mday=9, tm_hour=11, tm_min=38, tm_sec=3, tm_wday=2, tm_yday=221, tm_isdst=0)
# 格式化成2022-10-17 11:45:39形式
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) #2023-08-09 11:38:03
# 格式化成Sat Mar 28 22:24:24 2022形式
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())) #Wed Aug 09 11:38:03 2023
# 将格式字符串转换为时间戳
a = "Mon Oct 28 22:24:24 2022"
print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y"))) #1666967064.0
cal = calendar.month(2023, 8)
print("以下输出2023年8月份的日历:\n",cal)7.7 print打印语句
# str + str：
print("我要打印的是字符串："+ names[0])
# str + int 解决方案：
print("我要打印的是int： %d"%lists[0])
print("我要打印的是字符串： %s"%lists[0])
print("我要打印的是数组：{}".format(names[2][0]))7.8 字符串格式化
字符串格式化是一种将变量或值插入到字符串中的过程，以创建具有动态内容的字符串。在 Python 中，我们可以使用 format() 方法和 f-string（格式化字符串字面值）来进行字符串格式化。
format() 方法，是一种传统的字符串格式化方法。它使用占位符 { } 来表示要插入的变量或值，并通过传递参数来替换这些占位符。
name = "Alice"
age = 25
message = "My name is {}, and I am {} years old.".format(name, age)
print(message)
# 输出：My name is Alice, and I am 25 years old.
name = "Alice"
age = 25
message = "My name is {0}, and I am {1} years old.".format(name, age)
print(message)
# 输出：My name is Alice, and I am 25 years old.
name = "Alice"
age = 25
message = "My name is {name}, and I am {age} years old.".format(name=name, age=age)
print(message)
# 输出：My name is Alice, and I am 25 years old.
f-string 是 Python 3.6 及更高版本引入的一种简洁且直观的字符串格式化方法。它使用前缀 f 定义字符串，并使用花括号 {} 来插入变量或值。
name = "Alice"
age = 25
greeting = f"{'Hello' if age < 30 else 'Hi'} {name.upper()}"
print(greeting)
# 输出：Hello Alice
7.9 main方法
main 方法的作用只是用于调试，模拟其他模块调用本模块的场景以及自测，main语句在其他程序调用本模块时，不执行。
7.10 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
# 函数定义的格式
def printme(str):
print(str)
return
printme("自定义函数001")
# 带参数的函数
def printinfo(name, age=35):
"打印任何传入的字符串"
print("Name: ", name)
print("Age ", age)
return
printinfo(age=50, name="Miki") # 输出结果为：Miki,50
printinfo(name="miki") # 输出结果为：Miki,35
# 不定长参数，用(*变量名)进行表示
def printinfo(arg1, *vartuple):
print("输出: \n ",arg1)
for var in vartuple:
print(var)
return
printinfo(10) # 输出结果为：10
printinfo(70, 60, 50) # 输出结果为：70 60 50
7.11 面向对象
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- 局部变量：定义在方法中的变量，只作用于当前实例的类。
- 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
- 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
- 实例化：创建一个类的实例，类的具体对象。
- 方法：类中定义的函数。
- 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
7.11.1 闭包与装饰器
7.11.1.1 简介
闭包和装饰器本质上都是 Python 中函数使用的一种特殊的变形形式，如果需要掌握闭包和装饰器，就先要理解函数。
7.11.1.2 函数引用
讲解闭包之前，需要理解一个概念，Python 中定义的函数，也可以像变量一样，将一个函数名，赋值给另一个变量名，赋值后，此变量名就可以做为该函数的一个别名使用，进行调用函数。
def show():
print("输出结果。。")
show()
a = show
a()
# 注意: 在将一个函数名（函数引用）赋值给一个变量时，函数名后不能添加括号。7.11.1.3 闭包
闭包 Closure 是指在一个嵌套的函数内部访问其外部函数中定义的变量或函数的能力。换句话说，闭包是一个函数对象，它可以记住并访问它创建时的上下文环境中的变量。
闭包通常由两个部分组成：内部函数和与其相关的环境变量。
- 内部函数是在外部函数中定义的函数，它可以访问外部函数中的局部变量和参数，以及外部函数所在的作用域中的变量。
- 环境变量是在外部函数中定义的变量或其他函数对象，它被内部函数引用并记住，即使外部函数执行完成后仍然存在。
闭包的特点包括：
- 内部函数可以访问外部函数中定义的变量和参数，即使外部函数已经执行完毕。
- 闭包可以在外部函数的作用域之外被调用和执行。
- 闭包可以访问并修改外部函数中的局部变量，使其具有持久性。
闭包的应用场景包括：
- 保护私有变量：可以使用闭包来创建私有变量和方法，通过内部函数的作用域和环境变量，可以实现对外部访问的限制。
- 延迟执行：可以使用闭包来延迟某个函数的执行，即在函数外部创建一个闭包，将需要执行的函数作为内部函数，通过调用闭包来触发函数的执行。
- 缓存数据：可以使用闭包来缓存一些昂贵的计算结果，以避免重复计算，提高程序的性能。
需要注意的是，在使用闭包时，要注意管理内存，避免产生不必要的内存泄漏问题。
nonlocal
与全局变量一样，在函数内是不能直接修改函数外的变量的，如果修改全局变量需要使用 global 在函数内部声明变量为全局变量。
闭包中要修改变量也是一样，内函数是不能直接修改外函数中定义的变量的，如果需要修改，要在内函数中使用 nonlocal 关键字声明该变量为外函数的变量。
def out_func():
out_n = 100
def inner_func():
out_n = 200 # 不使用 nonlocal 修饰
print("inner:",out_n)
print("outer1:",out_n)
inner_func()
print("outer2:",out_n)
return inner_func
if __name__ == '__main__':
of1 = out_func()
of1()
# 结果：
# outer1: 100
# inner: 200
# outer2: 100
# inner: 200
def out_func():
out_n = 100
def inner_func():
nonlocal out_n # 使用 nonlocal 修饰
out_n = 200
print("inner:",out_n)
print("outer1:",out_n)
inner_func()
print("outer2:",out_n)
return inner_func
if __name__ == '__main__':
of1 = out_func()
of1()
# 结果：
# outer1: 100
# inner: 200
# outer2: 200
# inner: 2007.11.1.4 装饰器
装饰器是 Python 提供的一种语法糖，装饰器使用 @ 符号加上装饰器名称，用于修改其他函数的行为，并且在不修改原始函数定义和调用的情况下添加额外的功能。
装饰器提供了一种简洁而优雅的方式来扩展和修改函数或类的功能。它本质上就是一个闭包函数。
装饰器的功能特点:
- 不修改已有函数的源代码
- 不修改已有函数的调用方式
- 给已有函数增加额外的功能
装饰器的使用
由于装饰器本质上就是一个闭包函数，所以在使用自定义装饰器之前，需要先定义一个用来做为装饰器的闭包。
而闭包的外部函数名，就作为装饰器名使用。
import time
def count_time(func):
def inner():
start_time = time.time()
func()
stop_time = time.time()
print(f'函数执行时间为{stop_time - start_time}秒')
return inner
@count_time
def show():
for i in range(3):
print(f"第 {i+1} 次输出")
time.sleep(1)
if __name__ == '__main__':
show()
# python解释器解释过程如下：
show = count_time(show)
show()
# 结果：
# 第 1 次输出
# 第 2 次输出
# 第 3 次输出
# 函数执行时间为3.022770404815674秒
上面代码中，使用闭包实现了一个函数执行时间统计的功能。
在 show 函数上，使用闭包函数做为装饰器为 show 统计运行时间。
通过代码可以看出，在使用 count_time 函数做为装饰器时，即没有改变show函数的内部定义，也没有改变 show 函数的调用方式，但却为 show 函数额外扩展了运行时间统计的功能，这就是装饰器的作用。
装饰器的本质
装饰器提供了一种简洁而优雅的方式 -- 语法糖 来扩展和修改函数或类的功能。其本质就是函数的使用。
语法糖： 在计算机科学中，语法糖（Syntactic sugar）是指一种语法上的扩展，它并不改变编程语言的功能，只是提供了更便捷、更易读的写法，使得代码更加简洁和可理解。
常见的语法糖:
- 推导式
- 装饰器
- 切片
- 上下文管理器
Python 解释器在遇到装饰器时，会将被装饰函数引用做为参数传递给闭包的外函数，外函数执行后，返回内函数的引用，此时，再将内函数引用赋值给被装饰器函数。
当 Python 解释器执行完装饰过程后，被装饰函数的函数名就不在保存原函数的引用，而是保存的闭包函数 inner 的引用。
而当执行被装饰函数时，实际执行的是闭包函数 inner ，由 inner 间接调用被装饰函数，完成整个调用过程。
通用装饰器
理论上，一个装饰器可以装饰任何函数，但实际前面定义的做为装饰器的 count_time 函数却只能装饰特定的无参无返回值的函数。
如果需要装饰器可以装饰任何函数，那么就需要解决被装饰函数的参数及返回值的问题。
可以通过可变参数和在内函数中返回被装饰函数执行结果的形式解决此问题。
# 做为装饰器名的外函数，使用参数接收被装饰函数的引用
def decorator(func):
# 内函数的可变参数用来接收被装饰函数使用的参数
def inner(*args, **kwargs):
# 装饰器功能代码
# 调用被装饰函数，并将接收的参数传递给被装饰函数，保存被装饰函数执行结果
result = func(*args, **kwargs)
# 返回被装饰函数执行结果
return result
# 返回内函数引用
return inner
带参数装饰器
除了普通的装饰器使用方式外，在使用装饰器时，还需要向装饰器传递一些参数，比如测试框架 pytest 实现数据驱动时，可以将测试数据以装饰器参数形式传入，此时，前面定义的做为装饰器的闭包形式就不能满足需求了。
可以在通用装饰器外，再定义一层函数，用来接收装饰器的参数。
实现代码
def decorator_args(vars, datas):
def decorator(func):
def inner(*args, **kwargs):
return func(*args, **kwargs)
return inner
return decorator
data = [(1,2,3),(4,5,6),(7,8,9)]
# 装饰器传参
@decorator_args("a,b,c", data)
def show(a,b,c):
print(a,b,c)
装饰器传参原理
装饰器传参的本质就是链式语法的多次函数调用
@decorator_args("a,b,c", data) 解析
- 先执行
decorator_args("a,b,c", data)部分 - 得到结果
decorator与@结合变成装饰器形式@decorator - 通过结果
@decorator装饰器正常装饰被装饰函数
使用装饰器传参，实现数据驱动过程(了解)
此过程只用来讲解装饰器形式如何实现数据驱动过程，并没有完整实现。
# 接收装饰器参数的函数
# 参数一：以字符串形式接收被装饰函数的参数列表，需要与被装饰函数参数名保持一致，例："a,b,c"
# 参数二：以[(),(),()] 形式传入驱动数据。
def decorator_args(vars, datas):
def decorator(func):
# 将字符串参数分割备用
v_keys = vars.split(",")
# 定义保存 [{},{},{}] 形式的数据
new_datas = []
# 遍历数据，取出一组元素数据
for item in datas:
# 定义一个新字典，用来保存 变量名与传入数据组成的字典
d_item = {}
# 使用 zip 函数，同时遍历两个元组，变量名做为key, 元素数据做为value
for k, v in zip(v_keys, item):
# 将 变量名和值对应保存到字典中
d_item[k] = v
# 将组合好的字典追加到新数据中备用
new_datas.append(d_item)
def inner(*args, **kwargs):
return func(*args, **kwargs)
# 遍历新数据，取出元素字典
for item in new_datas:
# 将字典中的数据解包传给内函数
inner(**item)
return inner
return decorator
# 数据驱动数据
data = [(1,2,3),(4,5,6),(7,8,9)]
# 装饰器传参
@decorator_args("a,b,c", data)
def show(a,b,c):
print(a,b,c)
7.11.2 面向对象的调用
7.11.3 init 函数
__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。类里面的方法都需要加上(self)，申请这是类里面自己的函数，self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的。
类以外的函数，就不需要加self，申请该函数是类外的函数方法（不受init函数的影响）。在实际编程过程中，是使用类还是函数？如果功能存在公共的模块，就使用类；没有的话，就使用函数即可。
7.11.4 类的继承
# 定义父类
class Parent:
def show(self):
print( '调用父类方法')
# 定义子类
class Child(Parent):
def myMethod(self):
print('调用子类方法')
print(12)
c= Child() # 子类实例
c.myMethod() # 子类调用子类方法
c.show() # 子类调用父类方法
class A: # 定义类 A
.....
class B: # 定义类 B
.....
class C(A, B): # 继承类 A 和 B
.....7.11.5 类的重写
class Parent: # 定义父类
def myMethod(self):
print '调用父类方法'
class Child(Parent): # 定义子类
def myMethod(self):
print '调用子类方法'
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法7.11.6 类属性与方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 报错，实例不能访问私有变量7.11.7 单下划线、双下划线、头尾双下划线说明
-
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
-
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
-
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
八、接口测试
8.1 简单的Get 请求
步骤：
- 封装一个get接口的登录函数
- requests模块
- url 入参
- res =requests.get(url)
- res接收接口返回的内容
取响应体的内容，响应体的Contest-Type存在两种方式“text/html” 和 “application/json”，通过res.text文本或res.json()方式接收接口响应的内容。
8.2 简单的POST请求
步骤：
- 封装post 接口的登录函数
- requests模块
- 传参数据
- data = {"key1":value1，"key2":value2} # 表单格式(text/html)
- json = {} # json 格式
- headers ={} 表明传参的格式
- 组装post请求数据
- res = requests.post(url=self.url,data =datas,headers=head)
常用函数:
- res.url
- res.request # 获取请求方法 get/post
- res.headers # 取值["name"]
- res.apparent_encoding #utf-8
- res.content # 转换成中文 res.content.decode("utf-8")
- res.cookies
- res.text取值
- json()取值 # json()["name"]
cookie 问题：把登录的cookie保存下来，传到下一个接口去发请求，session发起登录，通过session传递发起其他接口请求
重定向问题：禁止重定向，请求参数中传入allow_redirects=False；解决请求重定向问题，请求同一个session即可避免重定向，如 s = requests.session()；login.login(s).post_login()；
九、pytest 用例开发常见问题
9.1 脚本读取配置文件
以URL域名、登录账号与密码参数化为例：
将参数化文件整理到配置文件中(项目里新建file文件)，以xxx.ini、xxx.cfg 或 xxx.txt格式，再编写读取配置文件类，通过函数进行配置文件的调用
from configparser import ConfigParser # 读取配置文件模块
import os # 读取配置文件的本地路径
class ReadFile():
def __init__(self):
# strict=False,主要解决配置文件configparser读取重复配置项的的问题
self.conf = ConfigParser(strict=False)
# 不引用os系统内置方法，第三方模块调用时，因取不到配置文件的本地路径而报错
filepath = os.path.dirname(os.path.abspath(__file__)) + '/config.cfg'
# print(filepath)
# filepath = 'E:/work/GoodsApi/config/config.cfg'
self.conf.read(filepath,encoding="utf-8")
# 获取session字符串的URL
def getSessionHost(self):
session_host = self.conf.get('host','session_host')
return session_host
# 获取token字符串的URL
def getTokenHost(self):
token_host = self.conf.get('host','token_host')
return token_host
# 获取XX系统域名地址
def getOaperate_host(self):
oaperate_host = self.conf.get('host','oaperate_host')
return oaperate_host
# 获取用户名和密码
def getLogin(self):
username = self.conf.get('login', 'username')
password = self.conf.get('login', 'password')
return {"username":username,"password":password}
#通过main方式调试代码
if __name__ == '__main__':
session_host = ReadFile().getSessionHost()
token_host = ReadFile().getTokenHost()
oaperate_host = ReadFile().getOaperate_host()
# print(session_host)
# print(token_host)
print(oaperate_host)
# username = ReadFile().getLogin()
# print(username['username'])
# print(username['password'])
以上读取配置类代码中，主要注意两个问题：
- 获取到正确的配置文件路径
# 获取当前文件的路径 os.path.abspath(__file__)
# 获取当前文件的完整路径 os.path.dirname(os.path.abspath(__file__))
# 根据当前文件的完整路径，字符串拼接出来的路径 os.path.dirname(os.path.abspath(__file__)) + '\config.cfg'
# filepath = os.path.dirname(os.path.abspath(__file__)) + '\config.cfg'
# 获取文件的绝对路径
path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
# 通过决定路径，拼接字符串的路径
filepath = os.path.join(path,"config","config.cfg")
# print("filepath:",filepath)
self.conf.read(filepath,encoding="utf-8")- configparser读取重复配置项的处理
config配置项已经存在了，因系统读取到2个以上，会报错。如果不希望报错，直接采用新的配置项覆盖，那么需要在configparser.ConfigParser(strict=False)方法中strict参数设置未False
# 实例化ConfigParser方法时，需要在ConfigParser()方法中strict参数设置未False
self.conf = ConfigParser(strict=False)配置文件，读取配置文件，最后一步就是引用读取配置文件的函数，更便捷的维护及使用参数化的变量。
import requests
from config import readFile # 引入读取配置文件的类文件
class LoginTest():
def __init__(self):
self.s = requests.session()
self.session_host = readFile.ReadFile().getSessionHost() #实例化并赋值
self.token_host = readFile.ReadFile().getTokenHost()
self.getLogin = readFile.ReadFile().getLogin()
self.getOaperate_host = readFile.ReadFile().getOaperate_host()
# print(self.session_host)
# print(self.token_host)
def post_session(self,username,password):
session_url = self.session_host + "/saas-sso/login" # 直接使用参数化的URL
# print("session_url:",session_url)
data = {
"username": self.getLogin['username'],
"password": self.getLogin['password'],
"verification": "",
"loginFromSystemCode": "TAGGG_TKHH",
"encryptType": 1
}
res = self.s.post(url = session_url, data = data)
# print(res.json())
session = res.cookies
return session
def get_code(self):
session = LoginTest().post_session(username=self.getLogin['username'],password=self.getLogin['password'])
code_url = self.session_host + "/oauth2/authorize?client_id=TTTRG_TK&responses_type=code&redirectts_uri=" + self.getOperate_host + "/"
res = self.s.get(cookies = session,url = code_url,allow_redirects=False)
code = res.json()["data"]["code"]
# print("code:",code)
return code
if __name__ == '__main__':
# getLogin = readFile.ReadFile().getLogin()
# LoginTest().post_session(getLogin['username'],getLogin['password'])
# LoginTest().get_code()总结步骤：
- 设置xxx.cfg文件，存放配置参数
- 引入ConfigParser 内置模块
- conf.read(filepath,encoding="utf-8")
- conf.get('host','ompGuard_host')
- 封装读取配置文件模块，如类或者函数的形式
9.2 运行接口自动化用例
9.2.1 设置 pytest的测试环境
9.2.2 命名规则
用例文件名及用例中的函数或模块，以test开头或test结尾
9.2.3 接口入参
- 手写入参
- pytest装饰器参数化
9.2.4 返参检验
- 使用assert关键字进行断言判断
- 提取变量后，对变量assert
- 对返回内容text进行关键字assert
9.2.5 运行结果
import pytest
from common.LoginTest import LoginTest
from api.Label.Lable import lable
from api.Label.LableTypes import lableTypes
# 用例1：登录
def test_Login():
LoginTest().post_token()
# 用例2：添加标签类型
def test_addLableTypes():
lableTypes().add_lableTypes("自动化测试新增标签类型A")
# 用例3：添加标签
def test_addLable():
lable().add_labe("自动化测试新增标签A")
- 对单个用例运行
- 鼠标放在函数体内
- 对当前模块下所有用例运行
- 鼠标不放在任一函数体内
- main方法调用
if __name__ == '__main__':
pytest(['-s','testLogin.py'])9.3 pytest参数化
单个变量参数化(全量测试)：
@pytest.mark.parametrize("username",("18688276555","","1868827"))
@pytest.mark.parametrize("username",("18688276555","","1868827"))
# 对 username 进行全量测试
def test_session(username):
res =LoginTest().post_session(username,password = readFile.ReadFile().getLogin()['password'])
print(res)
assert res.json()["code"] == "200"
组合交叉参数化：
多个变量参数化(入参、预期结果参数化)：
# 用例：对入参username、password、出参code，进行参数化
@pytest.mark.parametrize("username,password,code",
[("18688276555","A","200"),
("","B","100"),
("1868827","C","100"),
])
def test_session2(username,password,code):
res =LoginTest().post_session(username = username,password = password)
assert code == res['code']9.4 文件读写
config目录下，新建desc.txt 文件，在公共目录下读取、写入、追加 desc.txt 文件
import os
path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
file =os.path.join(path,"config","desc.txt")
print(file)
# 读取desc.txt 文件（'r' 也可以写成'rb'，即二进制文件读取，则可不申明utf-8）
with open(file,'r',encoding = 'utf-8')as f:
text = f.readline(7)
text2 = f.read()
print(text)
print(text2)
# 完全覆盖重写desc.txt 文件（'w' 也可以写成'wb'，即二进制文件写入，则可不申明utf-8）
with open(file,'w',encoding = 'utf-8')as f:
f.write("abcdefg")
print(text)
print(text2)
# 追加写入desc.txt 文件
with open(file,'a',encoding = 'utf-8')as f:
f.write("abcdefg")
print(text)
print(text2)
9.5 上传图片与视频
def upload(self):
path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
file = os.path.join(path, "config", "123.jpg")
login.Login(self).post_login()
url = "https://xxxx.com"
filename = file
file = {"uploadFiles":open(filename,"rb")}
res = self.post(url,files = file)
print(res.txt)
# 通过二进制流的方式进行文件的读取
open(file,"rb")9.6 数据库参数化
- 数据库配置文件
[mysql]
host = rm.mysql.aliyuncs.com
port = 13308
user = qa
password = Oc0Nqir76yBWxo12311ba
# 数据库配置文件，多种类型存储数据
[dbinfo]
dbinfo ={
"host":"rm.mysql.aliyuncs.com",
"user":"qa",
"password":"Oc0Nqir76yBWxo12311ba",
"port":13308
}
- 安装pymysql
- 连接数据库
- 封装查询/修改SQL
- 关闭释放连接
- 返回数据
封装数据库连接，封装SQL语句运行处理：
class ReadFile():
def __init__(self):
self.conf = ConfigParser(strict=False)
path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
filepath = os.path.join(path,"config","config.cfg")
self.conf.read(filepath,encoding="utf-8")
# 封装读取config配置文件中的数据
def getValue(self,section='hostname',option = 'host'):
value = self.conf.get(section,option)
return value
# 获取MYSQL数据库
def getMysql(self):
host = self.getValue('mysql','host')
username = self.getValue('mysql','username')
password = self.getValue('mysql','password')
port = self.getValue('mysql','port')
return {"host":host,"username":username,"password":password,"port":(int)port}
# 获取MYSQL数据库(读配置二)
def getMysql1(self):
dbinfo = self.getValue('dbinfo','dbinfo')
return dbinfo
class Connect():
def __init__(self,database = 'tx_product'):
dbinfo = ReadFile().getMysql()
# 使用配置二的函数方法
# dbinfo = eval(ReadFile().getMysql1())
# print(type(dbinfo))
self.con = pymysql.Connect(database=database,
cursorclass=pymysql.cursors.DictCursor,
**dbinfo)
self.curos = self.con.cursor()
# 封装SQL查询
def select_sql(self,sql):
self.curos.execute(sql)
# res = self.curos.fetchall() # 获取所有的值
res = self.curos.fetchone() # 获取第一行的值
# res = self.curos.fetchmany(size) # 自定义返回数量
print(res)
self.con.close() # 关闭SQL连接函数
return res
# 封装SQL更新
def update_sql(self,sql):
try:
self.curos.execute(sql)
self.con.commit() # 执行更新语句，并提交
except:
self.con.rollback() # 执行更新语句报错，则回滚
self.con.close()
if __name__ == '__main__':
con =Connect()
s_sql = "select product_id from product"
res = con.select_sql(s_sql)
print(res[0]['product_id']) # list列表取某组数据中具体值)
GitCode 天启AI是一款由 GitCode 团队打造的智能助手，基于先进的LLM（大语言模型）与多智能体 Agent 技术构建，致力于为用户提供高效、智能、多模态的创作与开发支持。它不仅支持自然语言对话，还具备处理文件、生成 PPT、撰写分析报告、开发 Web 应用等多项能力，真正做到“一句话，让 Al帮你完成复杂任务”。
更多推荐
2
0- 0
已为社区贡献1条内容
所有评论(0)