标签：01 unittest 单元测试 测试用例 test login self def

1. unittest框架

unittest是python中一款内置的测试框架，用来测试代码的运行正确与否。他能够收集测试用例，执行测试用例，查看用例执行结果，还能够添加用例执行的前置条件和后置处理条件。

unittest中的4大核心概念：

• TestCase：测试用例，使用这类来编写测试用。它是对一类测试用例进行了封装，例如针对登录操作的测试用例，封装成一个class，针对注册 操作的测试用例，再封装成一个class；且每个class都要继承unittest.TestCase才行。每一条测试用例都是一个函数。

import unittest

class TestLogin(unittest.TestCase):
    def test_login(self):
        pass

• TestSuit：测试套件，它的本质就是一个容器，里面不存放别的东西，只存放测试用例。
• TextTestRunner：用例运行器，用来运行测试用例，并呈现出执行结果。
• Fixture：用例执行的前置和后置条件。
• TestLoader：用来收集用例。是用来加载TestCase到TestSuite中的。

2. 简单使用

1. unittest中TestCase使用规范：

1. 每一个测试类，都要继承unittest.TestCase；
2. 测试类中，每一个函数都要以test_开头，来代表一条测试用例；
3. 在编写测试用例的时候，需要遵循以下规则：
   1. 要有测试数据；
   2. 要有测试步骤，一般的，测试步骤就是来调用已经完成的功能函数；
   3. 对最后的结果进行断言：只要的最后的结果出现AssertionError的错误，那就是用例失败；
   4. 断言可以使用assert关键字跟表达式来表达，assert如果是True，则表示用例通过，否则是用例失败；
   5. 但是，在使用unittest框架，框架的内部已经为我们封装好了，我们可以直接使用进行用例断言。

一个简单的用例实例：

# 功能函数
def login_check(username=None, password=None):
    """ 登录校验的函数
    :param username: 账号
    :param password: 密码
    :return: dict type
    """
    if username != None and password != None:
        if username == 'python27' and password == 'lemonban':
            return {"code": 0, "msg": "登录成功"}
        else:
            return {"code": 1, "msg": "账号或密码不正确"}
    else:
        return {"code": 2, "msg": "所有的参数不能为空"}

import unittest
from Homework.class_unittest_study import login

# 这是一个用例类，其中的每一个函数就代表着一个测试用例。
class LoginTest(unittest.TestCase):

    # 正确用户名和密码
    def test_login_cor(self):
        res = login.login_check("python27", "lemonban")
        self.assertEqual(res, {"code": 1, "msg": "登录成功"}, msg="断言失败")

    # 用户名密码 都为空
    def test_login_no_pwdAndUsr(self):
        res = login.login_check()
        self.assertEqual(res, {"code": 2, "msg": "所有的参数不能为空"}, msg="断言成功")

    # 错误的用户名
    def test_login_wrong_usr(self):
        res = login.login_check("python30", "lemonban")
        self.assertEqual(res, {"code": 1, "msg": "账号或密码不正确"}, msg="断言成功")

    # 错误的密码
    def test_login_wrong_pws(self):
        res = login.login_check("python27", "123456")
        self.assertEqual(res, {"code": 1, "msg": "账号或密码不正确"}, msg="断言成功")

    # 密码为空
    def test_login_no_pwd(self):
        res = login.login_check(username="python27")
        self.assertEqual(res, {"code": 2, "msg": "所有的参数不能为空"}, msg="断言成功")

    # 用户名为空
    def test_login_no_usr(self):
        res = login.login_check(password="lemonban")
        self.assertEqual(res, {"code": 2, "msg": "所有的参数不能为空"}, msg="断言成功")


if __name__ == "__main__":
    unittest.main()

2. 测试用例前置处理与后置处理

注意：前置与后置的处理，是需要定义在测试用例类中的，也就是继承了unittest.TestCase的类中、。

1. setUp()前置方法

在测试用例类中，定义setUp()方法，当每条测试用例执行的时候，都会先执行setUp()方法，这个方法表示测试用例执行前的前置准备工作，例如测试用例执行的时候需要先访问数据库，或者是创建浏览器实例等等。

但是，一旦定义了setUp()方法，那么每条测试用例在执行的时候，都会进行相同的前置准备工作，不能够个性化 给每一条测试用例定义不同的前置准备。如果测试用例的前置不一样，那么需要单独重新定义一个新的测试类。

class LoginTest(unittest.TestCase):

    # 每一条测试用例执行前，都会调用这个方法，这个是测试用例执行之前的前置准备工作
    def setUp(self):
        print("测试用例开始执行....")
    
    def test_login_cor(self):
        """这是一条测试用例"""
        pass

2. tearDown()方法

该方法类似于setUp()方法，只不过这个方法是在测试用例执行完毕之后，才会调用，就相当于每条测试用例执行之后的一个后置处理程序。就比如说要关闭浏览器实例，或者是断开与数据库的链接。

class LoginTest(unittest.TestCase):

    # 每一条测试用例执行前，都会调用这个方法，这个是测试用例执行之前的前置准备工作
    def tearDown(self):
        print("测试用例开始执行....")
    
    def test_login_cor(self):
        """这是一条测试用例"""
        pass

3. setUpClass()

这个方法也是测试用例的一个前置条件，只不过有一点不同的是，它是一个类属性，只会在测试用例类开始执行的时候，调用一次，并不像setUp()方法是每条测试用例执行的时候都会调用。

不管这个测试用例类中有几个测试用例，这个方法只会执行一次。

由于这个方法是一个类属性，所以需要在方法前加装饰器@classmethod来修饰。

与其相对应的就是tearDownClass()方法。

class LoginTest(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        print("**** 测试用例类开始执行 ****")
    
    def test_login_cor(self):
        """这是一条测试用例"""
        pass
    
    def test_login_wrong(self):
        """这是一条测试用例"""
        pass

4. tearDownClass()

测试用例类的后置处理方法， 用于在整个测试用例执行完毕之后调用。

class LoginTest(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        print("**** 测试用例类开始执行 ****")
    
    @classmethod
    def tearDownClass(cls):
        print("**** 测试用例类执行结束 ****")
    
    def test_login_cor(self):
        """这是一条测试用例"""
        pass
    
    def test_login_wrong(self):
        """这是一条测试用例"""
        pass

3. 用例的收集：unittest.TestSuite()

这个类，是unittest框架中专门用来收集编写好的各种测试用例的，它可以将测试用例全部收集起来，然后统一执行。

将测试用例进行收集，这里有两种处理办法：addTest()和addTests

# 1.先将unittest框架和测试用例类引入进来
import unittest

from Homework.class_unittest_study import test_login

# 实例化一个unittest.TestSuite()套件
testSuite = unittest.TestSuite()

# 调用addTest方法 或者是addTests()方法，将测试用例添加进来。
testSuite.addTest(test_login.LoginTest("test_login_cor"))

有一点需要注意：addTest()方法一次只能添加一个测试用例，addTests()一次能够添加多个测试用例。但是，添加的方式需要注意：需要在addTest()方法或者addTests()方法中，使用类名(用例方法名)的形式将测试用例添加进来。
也就是如果你的测试用例类的名字是LoginTest，并且其中的一个用例的方法名是test_login_cor，那么就需要使用LoginTest("test_login_cor")的形式，将这个测试用例添加到测试套件中。

4. 用例的收集：unittest.TestLoader()

使用unittest.TestSuite()来收集测试用例，在实际的项目中很不方便，因为不论是addTest()还是addTests()，一旦碰上很多的测试用例，都会变得十分的繁琐，都需要去人工的一条一条的添加测试用例。

所以，通常用来收集测试用例的，使用unittest.TestLoader()来收集测试用例。

我们使用unittest.TestLoader()中的discover()来对指定项目路径下的文件，进行测试用例的收集工作。在discover()内部，为我们定义了测试用例的收集规则：

1. 默认的从以test*.py文件中，获取测试类。也就是说，文件名是以test开头的文件，就是测试类所在的文件；
2. 找到测试类所在的文件之后，再下一步就是从该文件中获取 测试用例：在测试类所在的文件中，从继承了unittest.TestCase的类中，找以test_开头的方法，认为以test_开头的方法就是测试用例。

通过上两步的查找，会找到指定的路径中的全部测试用例，并把这些测试用例添加到实例化的unittest.TestLoader()对象中。

# 1. 在discover方法中，指定搜索目录
# 2. 在指定的搜索目录中，指定搜索文件
# 3. 在指定搜索文件中，过滤测试用例：在继承了unittest.TestCase的测试类中，搜索以test_开头的方法，这就是测试用例。
testLoader = unittest.TestLoader().discover(r"G:\PythonTest\Homework\class_unittest_study")
print(type(testLoader))

5. 运行测试用例集：unittest.TextTestRunner()

这个是unittest框架自带的一个测试用例运行器，只需要调用就行了

import unittest

# 将运行结果写入文件
with open("test_res.txt", mode="w", encoding="utf-8") as f:
    # 1. 实例化unittest.TextTestRunner()
    runner = unittest.TextTestRunner(f)
    # 2. 调用run方法，执行测试用例集
    runner.run(testLoader)

但是，框架自带的这个运行测试用例的方法，它只会显示出一个txt文本格式的结果，在实际项目的时候使用的并不是很多。所以我们 使用别人开发好的一款运行测试用例并生成测试报告的类库：HTMLTestRunnerNew或者是BeautifulReport。

使用HTMLTestRunnerNew生成测试报告

这个文件需要我们去网上手动下载，下载完成之后，添加到python的安装路径中的Lib下。

这个类库生成的是一个HTML的文件，所以直接写入文件就可以了：

import unittest

from Homework.class_unittest_study import test_login

testLoader = unittest.TestLoader().discover(r"G:\PythonTest\Homework\class_unittest_study")
print(type(testLoader))

from HTMLTestRunnerNew import HTMLTestRunner
with open("reprot.html", mode="wb") as f:
    runner = HTMLTestRunner(f)
    runner.run(testLoader)

这个类库会生成一个html格式的测试报告，里面会有默认的测试报告的标题，和测试人员，如果想要修改测试报告的名字或者是测试人员的名字，可以修改源码：

DEFAULT_TITLE = 'py30单元测试报告'
DEFAULT_DESCRIPTION = ''
DEFAULT_TESTER='扈先生'

也可以在实例化HTMLTestRunner对象的时候进行传参：

runner = HTMLTestRunner(f, title="测试报告", tester="Tom")

使用BeautifulReport生成测试报告

使用pip下载包。

import unittest

from Homework.class_unittest_study import test_login

testLoader = unittest.TestLoader().discover(r"G:\PythonTest\Homework\class_unittest_study")
print(type(testLoader))

from BeautifulReport import BeautifulReport
br = BeautifulReport(testLoader)

# 需要传入测试报告的标题，如果为None，则有默认的标题，也可以传入测试报告的文件路径，同样，如果不传，也有默认的文件名
br.report("py30测试报告")

BeautifulReport生成的测试报告，默认的是不会显示用例描述的。如果想要在测试报告中显示出来用例的描述，那么需要在测试函数中添加：self.__dict__['_testMethodDoc'] = "用例描述"

并且，要把这句代码添加到测试函数中靠前的位置，最起码要在最后的断言前面，否则当永陵失败的时候，测试报告中这条失败的测试用例描述依然时空。

6. 数据驱动思想执行测试用例：ddt框架

在进行实际的自动化测试时，如果遇到单一流程，只是数据不同的测试时，单纯的使用unittest框架进行编写测试用例，再执行测试用例，这样会浪费大量的时间，严重影响效率。这个时候，就可以使用数据驱动测试的思想来实现测试工作。

数据驱动测试，这是一种思维方式，也可以理解成将测试数据进行参数化，传递给相同的一个测试流程。

在python中，使用ddt模块来实现数据驱动测试的思维。

ddt模块的使用很简单，都是一个固定的模板：

1. 首先，引入ddt框架：import ddt；
2. 之后，在测试类前，添加装饰器@ddt.ddt；
3. 在测试函数前面，添加装饰器：@ddt.data()，并将测试数据传递给这个装饰器。这里最好使用一个列表来存储测试数据，然后使用拆包的方式传递参数；
4. 并且在测试函数中，添加一个参数，来接收测试数据

import unittest
import ddt

login_info = [
    {"username": "python27", "password": "lemonban", "except": {"code": 0, "msg": "登录成功"}},
    {"username": None, "password": None, "except": {"code": 2, "msg": "所有的参数不能为空"}},
    {"username": "python30", "password": "lemonban", "except": {"code": 1, "msg": "账号或密码不正确"}}
]

@ddt.ddt
class LoginTest(unittest.TestCase):

    @ddt.data(*login_info)
    def test_login_cor(self, case):
        res = login.login_check(case["username"], case["password"])
        self.assertEqual(res, case["except"], msg="断言失败")

这样一来，ddt框架会根据你的测试数据，来自动为每一条测试数据生成一条测试用例，就上述例子来说，会直接生成3条测试用例。

ddt的使用是一个固定的模板，十分简单。

2. unittest框架中常用的断言类型

        方法                    检查
    assertEqual(a, b)           a == b      
    assertNotEqual(a, b)        a != b      
    assertTrue(x)               bool(x) is True      
    assertFalse(x)              bool(x) is False      
    assertIsNone(x)             x is None     
    assertIsNotNone(x)          x is not None   
    assertIn(a, b)              a in b    
    assertNotIn(a, b)           a not in b

标签：01,unittest,单元测试,测试用例,test,login,self,def
来源： https://www.cnblogs.com/Pilaoban/p/13173051.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。