5 fixture

可以看作case的前置条件、后置条件

5.1 fixture的用例执行顺序

fixture分为

• 方法级别
• 类级别
• 模块级别

5.1.1方法级fixture

1. 每个测试用例之前要调用setUp
2. 每个测试用例执行后要调用tearDown
3. testCase中有多少测试用例,那么setUp和tearDown就被调用多少次

def add(a, b):
    return a + b

class TestAdd(unittest.TestCase):
    def setUp(self):  # 每运行一个用例执行的
        print("连接数据库")

    # 后置条件
    def tearDown(self):
        print("断开数据库")

    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertNotEqual(add(0, 1), 0)

    def test_add_negative(self):
        self.assertEqual(add(-1, -2), -3)
        self.assertNotEqual(add(-1, -1), 0)

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

通过结果可以看出，每个测试用例执行前会调用setUp方法，每个用例执行结束的时候也会调用tearDown方法，无论有多少用例，每次都会调用setUp、tearDown。

5.1.2 类级fixture

1. 一个类不管有多少个方法, 在方法执行前,执行一次setUpClass
2. 一个类不管有多少个方法,在方法执行后,执行一次tearDownClass
3. 因为setUpClass和tearDownClass都是类级别的方法，所以需要在方法前面加@classmethod修饰

class TestAdd(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("一个测试类只执行一次的前置")

    @classmethod
    def tearDownClass(cls):
        print("一个测试类只执行一次的后置")

    def setUp(self):  # 每运行一个用例执行的
        print("连接数据库")

    # 后置条件
    def tearDown(self):
        print("断开数据库")

    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertNotEqual(add(0, 1), 0)

    def test_add_negative(self):
        self.assertEqual(add(-1, -2), -3)
        self.assertNotEqual(add(-1, -1), 0)

 在结果可以看出setUpClass、tearDownClass仅运行一次

5.1.3 模块级fixture

1. 在python中模块就是py文件, 一个py文件就是一个模块
2. 在一个模块中不管有多少类,多少测试用例, 所有测试用例执行前,执行一次setUpModule
3. 在一个模块中不管有多少类,多少测试用例, 所有测试用例执行后,执行一次tearDownModule

def setUpModule():
    print("setUpModule被调用了")
def tearDownModule():
    print("tearDownModule被调用了")

class TestAdd(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("一个测试类只执行一次的前置")

    @classmethod
    def tearDownClass(cls):
        print("一个测试类只执行一次的后置")

    def setUp(self):  # 每运行一个用例执行的
        print("连接数据库")

    # 后置条件
    def tearDown(self):
        print("断开数据库")

    def test_add(self):
        self.assertEqual(add(1, 2), 3)
        self.assertNotEqual(add(0, 1), 0)

    def test_add_negative(self):
        self.assertEqual(add(-1, -2), -3)
        self.assertNotEqual(add(-1, -1), 0)

class TestAdd2(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("Add2一个测试类只执行一次的前置")

    @classmethod
    def tearDownClass(cls):
        print("Add2一个测试类只执行一次的后置")

    def setUp(self):  # 每运行一个用例执行的
        print("Add2连接数据库")

    # 后置条件
    def tearDown(self):
        print("Add2断开数据库")

    def test_add2(self):
        self.assertEqual(add(1, 2), 3)

    def test_add2_negative(self):
        self.assertEqual(add(-1, -2), -3)

调试结果 

============================= test session starts =============================
collecting ... collected 4 items

test_fixture.py::TestAdd::test_add 
test_fixture.py::TestAdd::test_add_negative 
test_fixture.py::TestAdd2::test_add2 setUpModule被调用了
一个测试类只执行一次的前置
PASSED                                [ 25%]连接数据库
断开数据库
PASSED                       [ 50%]连接数据库
断开数据库
一个测试类只执行一次的后置

test_fixture.py::TestAdd2::test_add2_negative 

============================== 4 passed in 0.25s ==============================
Add2一个测试类只执行一次的前置
PASSED                              [ 75%]Add2连接数据库
Add2断开数据库
PASSED                     [100%]Add2连接数据库
Add2断开数据库
Add2一个测试类只执行一次的后置
tearDownModule被调用了

6 TestCase + fixture

继承unittest里面的TestCase类、继承这个类，可以将每个case都要引入fixture，做一些准备以及结束的工作

1. 编写用例步骤如下
2. 导入unittest模块，被测文件或者其中的类
3. 创建一个测试类，并继承unittest.TestCase
4. 重写setup和tearDown方法（如果有初始化条件和结束条件）
5. 定义测试函数，函数名以test_开头，测试用例
6. 调用unittest.main()方法运行测试用例

class LoginCheckTest(unittest.TestCase)
    def setUp(self):
        print("每条用例开始执行")
        
    def test_loin(self):
        
    def test_password_error(self):
        
    def test_user_error(self):
    
    def test_password6(self):
        
    def testpassword18(self):
        
    def tearDown(self):
        print("每条用例执行之后")