python单元测试

单元测试的知识点：

接口测试的本质：测试类里面的函数，通过数据驱动测试
单元测试的本质：测试函数，代码级别，通过代码测试

功能测试的步骤	单元测试的步骤
1.写用例	TestCase类
2.执行用例	1:TestSUitl类：存储用例(unittest要先把用例收起来)2.TestLoader类：加载用例(也就是找用例，存到1的testSuit里 )
3.对比实际结果 期望结果 判定用例是否通过	断言Assert
4.出具测试报告	TextTestRunner

1.写用例

需要进行测试的代码(跑所有的用例)：

math_method.py

class MathMethod:
    def __init__(self,a,b):
        self.a=a
        self.b=b

    def add(self):#加法
        return self.a+self.b

    def multi(self):#乘法
        return self.a*self.b

编写单元测试的代码：

Testcase里的main会执行所有用例：

用例设计：
1 + 1
0 + 1
-1 +（-2）

case_01.py

import unittest
from python_study.test_package.math_method import MathMethod#测试的目标类
#写一个测试类 对我们自己的math_method模块里边的类进行单元测试
class TestMathMethod(unittest.TestCase):#继承了unittest里面的testcase专门用来写用例
    #编写测试用例
    def test_add_two_positive(self):#两个正数相加 1+1
        res=MathMethod(1,1).add()
        print("两个正数相加的结果是：",res)
    def test_add_two_zero(self):#两个0相加 0+0
        res=MathMethod(0,0).add()
        print("两个0相加的结果是：",res)
    def test_add_two_negative(self):#两个负数相加 -1+（-2）
        res=MathMethod(-1,-2).add()
        print("两个负数相加的结果是：",res)
        
if __name__ == '__main__':#执行所有的用例
        unittest.main()

执行结果：

一：编写测试用例的注意点：
1.一个用例就是一个函数 不能传参只有self关键字
2.所有的用例(所有的函数)都是test开头，test_
二：用例结果查看的知识点：
.表示成功…成功3个用例
E表示代码出错
F表示失败，用例未通过
三：执行用例顺序的知识点：
按照ASCII编码来执行，abcdefg谁在前谁先执行
注意：鼠标放在哪个用例的旁边就执行哪一条用例，如果跑所有的用例，在下面的代码附近点击运行
if name == ‘main’:
unittest.main()
如果想要跑单个用例用到TestSuite和TestLoader

2.执行用例

TestSuite和TestLoader执行单个用例：

TestSuite：

import unittest
from python_study.test_package.case_01 import TestMathMethod

suite=unittest.TestSuite()#存储用例
#目的：只执行一条：两个正数相加
"""unittest.TestCase里讲：A class whose instances are single cases.
 这个类的实例是一个单独的测试用例，所以使用的时候创建一个实例"""
suite.addTest(TestMathMethod('test_add_two_positive'))#继承由父类决定(创建的实例要不要传递参数，有父类有没有初始函数)
suite.addTest(TestMathMethod('test_add_two_negative'))#继承由父类决定(创建的实例要不要传递参数，有父类有没有初始函数)
#执行
runner=unittest.TextTestRunner()
runner.run(suite)

执行结果是：

TestLoader（对于执行多条用例是有帮助的）：

方法二：从测试类名加载用例：

import unittest
from python_study.test_package.case_01 import TestMathMethod#具体到类名

suite=unittest.TestSuite()#存储用例
loader=unittest.TestLoader()#创建一个加载器
suite.addTest(loader.loadTestsFromTestCase(TestMathMethod))
#执行
runner=unittest.TextTestRunner()
runner.run(suite)

方法二：从测试模块加载用例：

case_02.py

import unittest
from python_study.test_package.math_method import MathMethod#测试的目标类
class TestMathMethod(unittest.TestCase):#继承了unittest里面的testcase专门用来写用例
    #编写加法的测试用例
    def test_add_two_positive(self):#两个正数相加 1+1
        res=MathMethod(1,1).add()
        print("两个正数相加的结果是：",res)
    def test_add_two_zero(self):#两个0相加 0+0
        res=MathMethod(0,0).add()
        print("两个0相加的结果是：",res)
    def test_add_two_negative(self):#两个负数相加 -1+（-2）
        res=MathMethod(-1,-2).add()
        print("两个负数相加的结果是：",res)

class TestMulti(unittest.TestCase):#继承了unittest里面的testcase专门用来写用例
    #编写乘法的测试用例
    def test_Multi_two_positive(self):#两个正数相乘
        res=MathMethod(1,1).multi()
        print("两个正数相乘的结果是：",res)
    def test_Multi_two_zero(self):#两个0相乘
        res=MathMethod(0,0).multi()
        print("两个0相乘的结果是：",res)
    def test_Multi_two_negative(self):#两个负数相乘
        res=MathMethod(-1,-2).multi()
        print("两个负数相乘的结果是：",res)
if __name__ == '__main__':
        unittest.main()

模块的测试代码：

import unittest
#从测试类里去寻找
from python_study.test_package import case_02#具体到模块

suite=unittest.TestSuite()#存储用例
loader=unittest.TestLoader()#创建一个加载器
suite.addTest(loader.loadTestsFromModule(case_02))#从模块里去找
#执行
runner=unittest.TextTestRunner()
runner.run(suite)

3.断言

import unittest
from python_study.test_package.math_method import MathMethod#测试的目标类
class TestMathMethod(unittest.TestCase):
    def test_add_two_positive(self):#两个正数相加 1+1
        res=MathMethod(1,1).add()#实际发起请求的结果值
        print("两个正数相加的结果是：",res)
        #加一个断言，判断期望值与实际值的比对结果
        self.assertEqual(2,res)
    def test_add_two_zero(self):#两个0相加 0+0
        res=MathMethod(0,0).add()
        print("两个0相加的结果是：",res)
        self.assertEqual(0,res)
    def test_add_two_negative(self):#两个负数相加 -1+（-2）
        res=MathMethod(-1,-2).add()
        print("两个负数相加的结果是：",res)
        self.assertEqual(-3,res)
        #self.assertEqual(-3,res,"这边可以写如果出错了的提示信息")#message是断言里面用例执行失败才会打印出来

suite=unittest.TestSuite()#存储用例
loader=unittest.TestLoader()#创建一个加载器
suite.addTest(loader.loadTestsFromTestCase(TestMathMethod))
#执行
runner=unittest.TextTestRunner()
runner.run(suite)

注意：
self.xxx表示来自于父类，这边加了self关键字，但是在TestMathMethod里面没有看到，所以肯定是父类testcase里的
这个是函数之间的相互调用的知识:
1.类里面调用属性self.属性
2.类里面调用函数self.函数名

断言的语句：

4.测试报告

import unittest
from python_study.test_package.math_method import MathMethod#测试的目标类
class TestMathMethod(unittest.TestCase):
    def test_add_two_positive(self):#两个正数相加 1+1
        res=MathMethod(1,1).add()#实际发起请求的结果值
        print("两个正数相加的结果是：",res)
        #加一个断言，判断期望值与实际值的比对结果
        self.assertEqual(2,res)
    def test_add_two_zero(self):#两个0相加 0+0
        res=MathMethod(0,0).add()
        print("两个0相加的结果是：",res)
        self.assertEqual(0,res)
    def test_add_two_negative(self):#两个负数相加 -1+（-2）
        res=MathMethod(-1,-2).add()
        print("两个负数相加的结果是：",res)
        self.assertEqual(-3,res)
        # self.assertEqual(-4,res,"这边可以写如果出错了的提示信息")

suite=unittest.TestSuite()#存储用例
loader=unittest.TestLoader()#创建一个加载器
suite.addTest(loader.loadTestsFromTestCase(TestMathMethod))
#测试报告：最原始的方法
file=open('test.txt','w+',encoding="UTF-8")
runner=unittest.TextTestRunner(stream=file,descriptions=True,verbosity=2)
#执行
runner.run(suite)
file.colse()

新鲜的方法：

import  HTMLTestRunnerNew
with open("test_report.html","wb") as file:
    runner=HTMLTestRunnerNew.HTMLTestRunner(
        stream=file,verbosity=2,title='python报告'descriptions=我的报告, tester='执行者')
    runner.run(suite)

注意：
1.stream表示测试结果输出的位置
2.verbosity=1，2,0的区别是报告的详细程度不同，2更详细

上下文管理器

with open(‘test.txt’,‘w+’,encoding=“UTF-8”) as file:
runner = unittest.TextTestRunner(stream=file, descriptions=True, verbosity=1)
runner.run(suite)
print(file.close)#判断文件是否关闭的状态

异常处理

import unittest
from python_study.test_package.math_method import MathMethod#测试的目标类
class TestMathMethod(unittest.TestCase):
    def test_add_two_positive(self):#两个正数相加 1+1
        res=MathMethod(1,1).add()#实际发起请求的结果值
        print("两个正数相加的结果是：",res)
        #加一个断言，判断期望值与实际值的比对结果
        self.assertEqual(2,res)
#抛异常
    def test_Multi_two_negative(self):  # 两个负数相乘
        res = MathMethod(-1, -2).multi()
        print("两个负数相乘的结果是：", res)
        try:
            self.assertEqual(0,res)
        except AssertionError as e:
            print("出错啦，断言错误是{}".format(e))
            raise
suite=unittest.TestSuite()#存储用例
loader=unittest.TestLoader()#创建一个加载器
suite.addTest(loader.loadTestsFromTestCase(TestMathMethod))
#执行
runner=unittest.TextTestRunner()
runner.run(suite)