本文深入介绍了Python的unittest框架，包括如何创建单元测试类，使用setUp()、tearDown()、setUpClass()和tearDownClass()进行资源管理。此外，讲解了TestSuite和TestLoader如何组织及运行测试用例，以及TextTestRunner生成测试报告。最后，重点阐述了unittest的各种断言方法，如assertEqual、assertTrue等，确保测试用例的正确性。
文章目录
unittest.TestSuite()
""""
使用unittest框架设计mypath的单元测试用例（讲述unittest的特性）
1、导包，不需要安装
2、建一个单元测试类
3、
setUp()、test_xxx()、tearDown()，不管怎么调整顺序执行顺序不变
setUp():准备条件，资源初始化
test_xxx()：测试用例，把测试步骤写在这里
tearDown()：测试用例的资源释放
@classmethodz注解方法是类方法，不用创建对象他也能用，他在对象进内存之前就已经存在的方法，随着类一起进的内存
setUpClass:给当前单元测试类所有的用例进行初始化
tearDownClass：给当前单元测试类所有的用例进行资源释放
setUpClass和setUp()区别
setUp()不需要@classmethod注解；setUpClass方法需要@classmethod注解
setUp()实例方法：需要创建对象再调用；setUpClass方法：不需要创建对象也可以调用
setUp()在每一个测试用例执行之前执行一次；setUpClass方法在测试执行之前只执行一次
setUp()是对一条测试用例进行初始化；setUpClass方法给当前单元测试类所有的用例进行初始化
4、创建测试用例:
test开头的方法
5、测试用例执行：
main():把所有的测试用例都执行了一遍，控制不了执行顺序，按照测试用例名（方法名）的字母顺序来排序执行的
如何解决：
使用测试集合的概念，testsuite
分类，我要把加法的测试用例加到测试集合testsuite中，只运行测试集合即可
testsuite：
1、testsuite创建对象
2、调用testsuite方法将addTest、addTests将测试用例加入测试集合
3、testsuite的run（）方法运行测试集合
注意：run方法参数是testresult的对象：re =unittest.TestResult()
testresult中存储测试执行的结果
print(re.__dict__)
"""
import unittest
# 创建一个单元测试类
class unitmypath(unittest.TestCase):
#一种注解，在python，java语言中使用给方法特定的含义
@classmethod
def setUpClass(cls) -> None:
print("我是setupclass方法")
# 3个用例，其中第一个需要a条件，其中第二个需要b条件，其中第三个需要c条件，三个都需要d条件
# abc，可以放在test开头的方法中的，d条件都需要放在setUp()中（建议这么做）, setUpClass也可以
@classmethod
def tearDownClass(cls) -> None:
print("我是teardownclass方法")
# 方法名不能改，self参数不能少,写test中公用的代码
def setUp(self) -> None:
print("我是setUp方法")
self.mm =mymath()
# 必须是test开头的方法，self参数不能少
def test_add_1(self):
print("我是第一条测试用例")
actuallval = self.mm.jia(10,12)
exceptval = 22
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_add_2(self):
print("我是第二条测试用例")
actuallval = self.mm.jia("abc","123")
exceptval = "abc123"
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_chengfa_3(self):
print("我是第三条测试用例")
actuallval = self.mm.chengfa(12,2)
exceptval = 24
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
# 方法名不能改，self参数不能少
def tearDown(self) -> None:
print("我是tearDown")
# 用这句话注销对象，释放资源
self.mm = None
# 创建一个加减法运算
class mymath():
def jia(self,a,b):
return a+b
def jian(self,a,b):
return a-b
def chengfa(self,a,b):
return a*b
if __name__ == '__main__':
# 调用单元测试类
# 这个方法可以执行单元测试用例，执行全部的测试用例
# 如果我只想执行加法的测试用例，main()方法不太行了
# unittest.main()
suitt = unittest.TestSuite()
# 测试集合对象中的一个方法，addTest---》追加单个测试用例到测试集合
# 格式，类名(用例名)
# 要求掌握
# suitt.addTest(unitmypath("test_chengfa_3"))
# suitt.addTest(unitmypath("test_add_2"))
# suitt.addTest(unitmypath("test_add_1"))
# 测试集合对象中的另一个方法，addTests---》追加多个测试用例到测试集合
# 了解即可
suitt.addTests(map(unitmypath,["test_add_2","test_add_1"]))
# 测试集合中有run方法直接运行即可
re =unittest.TestResult()
suitt.run(re)
print(re.__dict__)
unittest.TestSuite()不起作用
unittest.defaultTestLoader
""""
使用unittest框架设计mypath的单元测试用例（讲述unittest的特性）
1、导包，不需要安装
2、建一个单元测试类
3、
setUp()、test_xxx()、tearDown()，不管怎么调整顺序执行顺序不变
setUp():准备条件，资源初始化
test_xxx()：测试用例，把测试步骤写在这里
tearDown()：测试用例的资源释放
@classmethodz注解方法是类方法，不用创建对象他也能用，他在对象进内存之前就已经存在的方法，随着类一起进的内存
setUpClass:给当前单元测试类所有的用例进行初始化
tearDownClass：给当前单元测试类所有的用例进行资源释放
setUpClass和setUp()区别
setUp()不需要@classmethod注解；setUpClass方法需要@classmethod注解
setUp()实例方法：需要创建对象再调用；setUpClass方法：不需要创建对象也可以调用
setUp()在每一个测试用例执行之前执行一次；setUpClass方法在测试执行之前只执行一次
setUp()是对一条测试用例进行初始化；setUpClass方法给当前单元测试类所有的用例进行初始化
4、创建测试用例:
test开头的方法
5、测试用例执行：
main():把所有的测试用例都执行了一遍，控制不了执行顺序，按照测试用例名（方法名）的字母顺序来排序执行的
如何解决：
使用测试集合的概念，testsuite
分类，我要把加法的测试用例加到测试集合testsuite中，只运行测试集合即可
testsuite：
1、testsuite创建对象
2、调用testsuite方法将addTest、addTests将测试用例加入测试集合
3、testsuite的run（）方法运行测试集合
注意：run方法参数是testresult的对象：re =unittest.TestResult()
testresult中存储测试执行的结果
print(re.__dict__)
TestLoader：
1、创建TestLoader对象 loader = unittest.TestLoader()
2、将loader的方法loadTestsFromName()指定测试用例加载到测试集合，并返回一个测试集合对象
loadTestsFromName()的参数比较灵活(理解会用即可,必须掌握）
1、可以是模块名 ： 2
2、可以是模块中的类名 ： 2.unitmypath
3、可以是模块中类中的某一个测试用例 ： 2.unitmypath.test_add_1
3、使用loader中的discover方法（必须掌握），将指定的文件（模块）中的测试用例一次性加载完
suitt = unittest.defaultTestLoader.discover(r"./",pattern="unit*.py")
path：指定测试用例目录即可（单元测试用例，使用unittest写的测试用例
pattern：指定匹配规则：unit_reg_*.py
unit_login_*.py
"""
import unittest
# 创建一个单元测试类
class unitmypath(unittest.TestCase):
#一种注解，在python，java语言中使用给方法特定的含义
@classmethod
def setUpClass(cls) -> None:
print("我是setupclass方法")
# 3个用例，其中第一个需要a条件，其中第二个需要b条件，其中第三个需要c条件，三个都需要d条件
# abc，可以放在test开头的方法中的，d条件都需要放在setUp()中（建议这么做）, setUpClass也可以
@classmethod
def tearDownClass(cls) -> None:
print("我是teardownclass方法")
# 方法名不能改，self参数不能少,写test中公用的代码
def setUp(self) -> None:
print("我是setUp方法")
self.mm =mymath()
# 必须是test开头的方法，self参数不能少
def test_add_1(self):
print("我是第一条测试用例")
actuallval = self.mm.jia(10,12)
exceptval = 22
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_add_2(self):
print("我是第二条测试用例")
actuallval = self.mm.jia("abc","123")
exceptval = "abc123"
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_chengfa_3(self):
print("我是第三条测试用例")
actuallval = self.mm.chengfa(12,2)
exceptval = 24
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
# 方法名不能改，self参数不能少
def tearDown(self) -> None:
print("我是tearDown")
# 用这句话注销对象，释放资源
self.mm = None
# 创建一个加减法运算
class mymath():
def jia(self,a,b):
return a+b
def jian(self,a,b):
return a-b
def chengfa(self,a,b):
return a*b
if __name__ == '__main__':
# 调用单元测试类
# 这个方法可以执行单元测试用例，执行全部的测试用例
# 如果我只想执行加法的测试用例，main()方法不太行了
# unittest.main()
suitt = unittest.TestSuite()
# 测试集合对象中的一个方法，addTest---》追加单个测试用例到测试集合
# 格式，类名(用例名)
# suitt.addTest(unitmypath("test_chengfa_3"))
# suitt.addTest(unitmypath("test_add_2"))
# suitt.addTest(unitmypath("test_add_1"))
# 测试集合对象中的另一个方法，addTests---》追加多个测试用例到测试集合
# suitt.addTests(map(unitmypath,["test_add_2","test_add_1"]))
# 如果测试用例大，testsuite自带的方法加测试用例到集合很麻烦
# 可以用unittest提供的testloader模块，提供了把测试用例加载到测试集合的方法
# 创建testloader对象
loader =unittest.TestLoader()
# loadTestsFromName():通过添加一个模块名、类名、测试用例名，将其中的用例添加到测试集合
# suitt = loader.loadTestsFromName("2")
# suitt = loader.loadTestsFromName("2.unitmypath")
# 第一个2是模块名，第二个test_add_2是类名，最后一个才是测试用例名
# suitt = loader.loadTestsFromName("2.unitmypath.test_add_2")
# 使用TestLoader对象的discover方法加载用例,是将指定路径下所有符合匹配规则（pattern）的文件中的单元测试用例一次性加载
# 第一个参数是一个目录，这个目录下可以有单元测试用例的文件(.py)
# unit*.py表示以unit开头，以.py结尾的文件
# 因为文件verydow*.py是线性脚本，直接运行
# 加载测试集合并运行测试用例有几条，0条
# unittest.defaultTestLoader.discover调用的文件一定是写了test_等类似本代码的函数，否则会加载不进来
suitt = unittest.defaultTestLoader.discover(r"./",pattern="unit*.py")
print(suitt.countTestCases())
# 测试集合中有run方法直接运行即可
# 测试结果
re =unittest.TestResult()
suitt.run(re)
print(re.__dict__)
unittest.TextTestRunner
""""
使用unittest框架设计mypath的单元测试用例（讲述unittest的特性）
1、导包，不需要安装
2、建一个单元测试类
3、
setUp()、test_xxx()、tearDown()，不管怎么调整顺序执行顺序不变
setUp():准备条件，资源初始化
test_xxx()：测试用例，把测试步骤写在这里
tearDown()：测试用例的资源释放
@classmethodz注解方法是类方法，不用创建对象他也能用，他在对象进内存之前就已经存在的方法，随着类一起进的内存
setUpClass:给当前单元测试类所有的用例进行初始化
tearDownClass：给当前单元测试类所有的用例进行资源释放
setUpClass和setUp()区别
setUp()不需要@classmethod注解；setUpClass方法需要@classmethod注解
setUp()实例方法：需要创建对象再调用；setUpClass方法：不需要创建对象也可以调用
setUp()在每一个测试用例执行之前执行一次；setUpClass方法在测试执行之前只执行一次
setUp()是对一条测试用例进行初始化；setUpClass方法给当前单元测试类所有的用例进行初始化
4、创建测试用例:
test开头的方法
5、测试用例执行：
main():把所有的测试用例都执行了一遍，控制不了执行顺序，按照测试用例名（方法名）的字母顺序来排序执行的
如何解决：
使用测试集合的概念，testsuite
分类，我要把加法的测试用例加到测试集合testsuite中，只运行测试集合即可
testsuite：
1、testsuite创建对象
2、调用testsuite方法将addTest、addTests将测试用例加入测试集合
3、testsuite的run（）方法运行测试集合
注意：run方法参数是testresult的对象：re =unittest.TestResult()
testresult中存储测试执行的结果
print(re.__dict__)
TestLoader：
1、创建TestLoader对象 loader = unittest.TestLoader()
2、将loader的方法loadTestsFromName()指定测试用例加载到测试集合，并返回一个测试集合对象
loadTestsFromName()的参数比较灵活(理解会用即可）
1、可以是模块名 ： 2
2、可以是模块中的类名 ： 2.unitmypath
3、可以是模块中类中的某一个测试用例 ： 2.unitmypath.test_add_1
3、使用loader中的discover方法（必须掌握），将指定的文件（模块）中的测试用例一次性加载完
suitt = unittest.defaultTestLoader.discover(r"./",pattern="unit*.py")
path：指定测试用例目录即可（单元测试用例，使用unittest写的测试用例
pattern：指定匹配规则：unit_reg_*.py
unit_login_*.py
TestRunner:
在测试用例、测试集合执行时都用的testsuite（）中的run（）方法，但是发现不具有可观性suitt.run(result)
TexTestRunner--->将结果以text的形式展示的运行器
"""
import unittest
# 创建一个单元测试类
class unitmypath(unittest.TestCase):
#一种注解，在python，java语言中使用给方法特定的含义
@classmethod
def setUpClass(cls) -> None:
print("我是setupclass方法")
# 3个用例，其中第一个需要a条件，其中第二个需要b条件，其中第三个需要c条件，三个都需要d条件
# abc，可以放在test开头的方法中的，d条件都需要放在setUp()中（建议这么做）, setUpClass也可以
@classmethod
def tearDownClass(cls) -> None:
print("我是teardownclass方法")
# 方法名不能改，self参数不能少,写test中公用的代码
def setUp(self) -> None:
print("我是setUp方法")
self.mm =mymath()
# 必须是test开头的方法，self参数不能少
def test_add_1(self):
print("我是第一条测试用例")
actuallval = self.mm.jia(10,12)
exceptval = 22
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_add_2(self):
print("我是第二条测试用例")
actuallval = self.mm.jia("abc","123")
exceptval = "abc123"
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_chengfa_3(self):
print("我是第三条测试用例")
actuallval = self.mm.chengfa(12,2)
exceptval = 24
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
# 方法名不能改，self参数不能少
def tearDown(self) -> None:
print("我是tearDown")
# 用这句话注销对象，释放资源
self.mm = None
# 创建一个加减法运算
class mymath():
def jia(self,a,b):
return a+b
def jian(self,a,b):
return a-b
def chengfa(self,a,b):
return a*b
if __name__ == '__main__':
# 创建测试集合
suitt = unittest.TestSuite()
# 使用TestLoader中的discover方法返回测试集合
suitt =unittest.defaultTestLoader.discover(r"./" , pattern="unit*.py")
# 调用测试集合的run()方法运行测试用例
# 创建一个TestResult的对象
# re = unittest.TestResult()
# suitt.run(result=re)
# 查看运行结果
# print(re.__dict__)
# 使用TextTestRunner()运行器提供的run()方法运行测试集合
# 如何产生文件流对象，如何打开一个文本文件，往里面写数据
# 报告是以TextTestResult的形式展示的
# TextTestRunner是TestRunner的子类
# TextTestResult是TestResult的子类
with open(r'./re.txt',"w",encoding="utf-8") as f:
runner = unittest.TextTestRunner(f,descriptions="单元测试报告执行", verbosity=2)
runner.run(suitt)
unittest.TextTestRunner不能使用的问题
断言
""""
使用unittest框架设计mypath的单元测试用例（讲述unittest的特性）
1、导包，不需要安装
2、建一个单元测试类
3、
setUp()、test_xxx()、tearDown()，不管怎么调整顺序执行顺序不变
setUp():准备条件，资源初始化
test_xxx()：测试用例，把测试步骤写在这里
tearDown()：测试用例的资源释放
@classmethodz注解方法是类方法，不用创建对象他也能用，他在对象进内存之前就已经存在的方法，随着类一起进的内存
setUpClass:给当前单元测试类所有的用例进行初始化
tearDownClass：给当前单元测试类所有的用例进行资源释放
setUpClass和setUp()区别
setUp()不需要@classmethod注解；setUpClass方法需要@classmethod注解
setUp()实例方法：需要创建对象再调用；setUpClass方法：不需要创建对象也可以调用
setUp()在每一个测试用例执行之前执行一次；setUpClass方法在测试执行之前只执行一次
setUp()是对一条测试用例进行初始化；setUpClass方法给当前单元测试类所有的用例进行初始化
4、创建测试用例:
test开头的方法
5、测试用例执行：
main():把所有的测试用例都执行了一遍，控制不了执行顺序，按照测试用例名（方法名）的字母顺序来排序执行的
如何解决：
使用测试集合的概念，testsuite
分类，我要把加法的测试用例加到测试集合testsuite中，只运行测试集合即可
testsuite：
1、testsuite创建对象
2、调用testsuite方法将addTest、addTests将测试用例加入测试集合
3、testsuite的run（）方法运行测试集合
注意：run方法参数是testresult的对象：re =unittest.TestResult()
testresult中存储测试执行的结果
print(re.__dict__)
TestLoader：
1、创建TestLoader对象 loader = unittest.TestLoader()
2、将loader的方法loadTestsFromName()指定测试用例加载到测试集合，并返回一个测试集合对象
loadTestsFromName()的参数比较灵活(理解会用即可）
1、可以是模块名 ： 2
2、可以是模块中的类名 ： 2.unitmypath
3、可以是模块中类中的某一个测试用例 ： 2.unitmypath.test_add_1
3、使用loader中的discover方法（必须掌握），将指定的文件（模块）中的测试用例一次性加载完
suitt = unittest.defaultTestLoader.discover(r"./",pattern="unit*.py")
path：指定测试用例目录即可（单元测试用例，使用unittest写的测试用例
pattern：指定匹配规则：unit_reg_*.py
unit_login_*.py
TestRunner:
在测试用例、测试集合执行时都用的testsuite（）中的run（）方法，但是发现不具有可观性suitt.run(result)
TexTestRunner--->将结果以text的形式展示的运行器
断言：一个测试用例两部分，一个是测试步骤，一个是测试断言，缺一不可
unittest提供的断言方法：
asssertEqual(a,b,msg=" ")：判断a和b是否相等，如果相等则断言成功，如果不相等，则断言失败，并且输出msg消息
asssertNotEqual(a,b,msg=" "):判断和b是否不相等
asssertTrue(a):判断a是否为True这个bool值
asssertIs(a,b,msg=" "):断言a和b的内存地址是否一致
asssertIsNot(a,b,msg=" "):断言a和b的内存地址是否不相等
asssertIsNone(a)：判断对象a是不是空指针，如果是断言成功
asssertIsNotNone(a)：判断对象a是不是空指针，如果是空指针，断言失败
asssertIn(a,b)：判断对象a是不是b的成员，如果是则断言成功
asssertNotIn(a,b)：判断对象a是不是b的成员，如果不是则断言成功
asssertIsInstance(a,b)：判断对象a是不是b的一个实例对象，a是对象，b是类
asssertIsNotInstance(a,b)：判断对象a不是b的一个实例对象，a是对象，b是类
"""
import unittest
# 创建一个单元测试类
class unitmypath(unittest.TestCase):
#一种注解，在python，java语言中使用给方法特定的含义
@classmethod
def setUpClass(cls) -> None:
print("我是setupclass方法")
# 3个用例，其中第一个需要a条件，其中第二个需要b条件，其中第三个需要c条件，三个都需要d条件
# abc，可以放在test开头的方法中的，d条件都需要放在setUp()中（建议这么做）, setUpClass也可以
@classmethod
def tearDownClass(cls) -> None:
print("我是teardownclass方法")
# 方法名不能改，self参数不能少,写test中公用的代码
def setUp(self) -> None:
print("我是setUp方法")
self.mm =mymath()
# 必须是test开头的方法，self参数不能少
def test_add_1(self):
print("我是第一条测试用例")
actuallval = self.mm.jia(10,12)
exceptval = 22
# 判断给定的两个参数是否相等
# self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
# self.assertNotEqual(12,12)
# self.assertTrue(not False)
# a="12"
# b="13"
# self.assertIs(a,b,"身份不相同")# 判断身份是否相同
# a =None
# self.assertIsNone(a)
# self.assertIsNotNone(self.mm)
# 这种方法a如果是0或者false的话，断言失败
# 如果a是非0或者True，则断言成功
# a = 0
# self.assertTrue(a)
# self.assertIn("a","anc")
# self.assertIsInstance(self.mm,mymath)
self.assertIsInstance("a",str)
def test_add_2(self):
print("我是第二条测试用例")
actuallval = self.mm.jia("abc","123")
exceptval = "abc123"
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
def test_chengfa_3(self):
print("我是第三条测试用例")
actuallval = self.mm.chengfa(12,2)
exceptval = 22
# 判断给定的两个参数是否相等
self.assertEqual(actuallval,exceptval,"预期结果和实际不相等")
# 方法名不能改，self参数不能少
def tearDown(self) -> None:
print("我是tearDown")
# 用这句话注销对象，释放资源
self.mm = None
# 创建一个加减法运算
class mymath():
def jia(self,a,b):
return a+b
def jian(self,a,b):
return a-b
def chengfa(self,a,b):
return a*b
if __name__ == '__main__':
# 创建测试集合
suitt = unittest.TestSuite()
test_dir = './'
# 定义测试目录为当前目录
suitt = unittest.defaultTestLoader.discover(test_dir, pattern='test*.py')
# # 使用TestLoader中的discover方法返回测试集合
# suitt =unittest.defaultTestLoader.discover(r"E:\python code\jiekou\qianfengtest\untiet" , pattern="test3.py")
# loader = unittest.TestLoader()
# suitt =loader.loadTestsFromName("3.unitmypath")
# 调用测试集合的run()方法运行测试用例
# 创建一个TestResult的对象
# re = unittest.TestResult()
# suitt.run(result=re)
# 查看运行结果
# print(re.__dict__)
# 使用TextTestRunner()运行器提供的run()方法运行测试集合
# 如何产生文件流对象，如何打开一个文本文件，往里面写数据
# 报告是以TextTestResult的形式展示的
# TextTestRunner是TestRunner的子类
# TextTestResult是TestResult的子类
with open(r'./re.txt',"w",encoding="utf-8") as f:
runner = unittest.TextTestRunner(f,descriptions="单元测试报告执行", verbosity=3)
runner.run(suitt)
扫一扫
511
到【灌水乐园】发言
