unittest学习总结

2022-02-21 15:03:20

---

unittest --- 单元测试框架 — Python 3.9.10 文档

可以自由选择版本文档查看

一、unittest概念

unittest是Python单元测试框架，类似于JUnit框架。

unittest中有4个重要的概念：test fixture, test case, test suite, test runner

1. Testcase：一个TestCase的实例就是一个测试用例，也就是测试类，且执行顺序会按照方法名的ASCII值排序。
2. Test suite：多个测试用例集合在一起，就是TestSuite，而且TestSuite也可以嵌套TestSuite。
3. Test runner：是来执行测试用例集合的（testsuit），其中的run(test)会执行TestSuite/TestCase中的run(result)方法。
4. TestLoader：是用来加载TestCase到TestSuite中的，其中有几个loadTestsFrom__()方法，就是从各个地方寻找TestCase，创建它们的实例，然后add到TestSuite中，再返回一个TestSuite实例。
5. Test fixture：对一个测试用例环境的搭建和销毁，是一个fixture，通过覆盖 TestCase的setUp()和tearDown()方法来实现。

使用unittest编写python的单元测试代码，包括如下几个步骤：

1、定义测试类，编写一个python类，继承 unittest模块的TestCase类。unittest对测试类和测试文件的名称没有要求

2、定义测试方法，需要在测试类中定义测试方法，方法名要求以 test 开头，只有一个self参数。

3、执行 unittest.main() ，该函数会执行的功能，先实例化所有测试类，收集并运行其中所有测试方法。

class MyTest(unittest.TestCase):
 
    def test_bbb(self):
        assert True
 
    @unittest.skip
    def test_ddd(self):
        passclass AAA(unittest.TestCase):
    def test_zzz(self):
        pass
 
if __name__ == '__main__':
    loader=unittest.TestLoader()
    suit=unittest.TestSuite()
    suit.addTest(loader.discover(os.path.abspath('.')))
    # suit.addTests([MyTest('test_aaa'), MyTest('test_bbb'), MyTest('test_ccc')])
    runner=unittest.TextTestRunner()
    print(runner.run(suit))
    unittest.main()

unittest的断言方法

方法	检查
assertEqual(a, b,msg=None)	a ==b
assertNotEqual(a, b)	a !=b
assertTrue(x)	bool(x) is True
assertFalse(x)	Bool(x) is False
assertIs(a, b)	a is b
assertIsNot(a, b)	a is not b
assertIsNone(x)	x is None
assertIsNotNone(x)	x is not None
assertIn(a, b)	a in b
assertNotIn(a, b)	a not in b
assertIsInstance(a, b)	isinstance(a,b)
assertNotIsInstance(a, b)	not isinstance(a,b)

二、用例收集及执行过程函数

1、unittest.TestSuite()：生成套件，并通过套件对象调用方法加载用例

生成套件对象suite

suite=unittest.TestSuite()

加载指定用例套件中

    suit.addTests([ BBB('test_bbb'), BBB('test_ddd')])
    suit.addTest(AAA('test_zzz'))
 
    runner = unittest.TextTestRunner()
    runner.run(suit)

加载TestLoader的对象查找到的用例

suit=unittest.TestSuite()  suit.addTest(loader.discover(os.path.abspath('.'),pattern='unit*.py'))
 
runner = unittest.TextTestRunner()
runner.run(suit)

2、unittest.TestLoader()：查找用例并实例化用例

生成加载对象loader

loader=unittest.TestLoader()

loadTestsFromTestCase(self, testCaseClass)：加载指定测试类的所有用例

AAA是测试类
case=loader.loadTestsFromTestCase(AAA)
 
runner=unittest.TextTestRunner()
runner.run(case)

loadTestsFromModule(self, module, *args, pattern=None, **kws)：加载指定测试文件的所有用例

unit.py文件是测试模块
case=loader.loadTestsFromModule(unit)
 
runner=unittest.TextTestRunner()
runner.run(case)    

loadTestsFromName(self, name, module=None)：加载模块中指定名字的测试类或者测试方法，模块是必须的，name参数传str

test_zzz是测试方法，以下两种方式
# case=loader.loadTestsFromName('unit.AAA.test_zzz')
case=loader.loadTestsFromName('AAA',module=unit)
 
runner=unittest.TextTestRunner()
runner.run(case)

loadTestsFromNames(self, name, module=None)：加载模块中指定名字的测试类或者测试方法，模块是必须的，name参数传list

case=loader.loadTestsFromNames(['unit.AAA.test_zzz','unit.BBB.test_ddd'])
# case=loader.loadTestsFromNames(['AAA','BBB.test_bbb'],module=unit)
 
runner=unittest.TextTestRunner()
runner.run(case)

discover(self, start_dir, pattern='test*.py', top_level_dir=None)：加载指定路径下的所有用例

start_dir:查找用例的启动目录

pattern：匹配测试文件的表达式

top_level_dir：测试模块的顶级目录

loader=unittest.TestLoader()
case=loader.discover(os.path.abspath('.')，pattern='unit*.py')
 
runner=unittest.TextTestRunner()
runner.run(case)

3、unittest.TextTestRunner()：创建运行器

runner=unittest.TextTestRunner()
runner.run(case)

三、命令行

usage: python.exe -m unittest [-h] [-v] [-q] [--locals] [-f] [-c] [-b] [-k TESTNAMEPATTERNS] [tests ...]
 
positional arguments:
  tests                a list of any number of test modules, classes and test methods.
 
optional arguments:
  -h, --help           帮助
  -v, --verbose        详细输出
  -q, --quiet          静默输出
  --locals             报错回溯中展示变量
  -f, --failfast       遇到失败就停止程序执行
  -c, --catch          可以允许crtl+c停止执行后输出已执行用例的报告，按下后会等待一会儿生成报告
  -b, --buffer         Buffer stdout and stderr during tests
  -k TESTNAMEPATTERNS  仅运行匹配字符串的用例，注意大小写敏感
　　discover
  -s START, --start-directory START  discover -s '.'默认从当前目录下启动查找用例-p PATTERN, --pattern PATTERN   discover -p ’test*.py‘ 发现匹配的文件，默认匹配test开头的测试用例文件-t TOP, --top-level-directory TOP 最顶级目录，默认当前目录
 
Examples:
  python.exe -m unittest test_module               - 运行测试文件
  python.exe -m unittest module.TestClass          - 运行文件中的测试类
  python.exe -m unittest module.Class.test_method  - 运行指定的测试方法
  python.exe -m unittest path/to/test_file.py      - 运行指定路径的模块
 
usage: python.exe -m unittest discover [-h] [-v] [-q] [--locals] [-f] [-c] [-b] [-k TESTNAMEPATTERNS] [-s START]
                                       [-p PATTERN] [-t TOP]

四、函数

1、前后置函数

测试类前后置方法注意要加类方法装饰器

class BBB(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        print('测试类的前置')
 
    def setUp(self) -> None:
        print('测试方法的前置')
 
    def tearDown(self) -> None:
        print('测试方法的后置')
 
    @classmethod
    def tearDownClass(cls) -> None:
        print('测试类的后置')

2、跳过和期望失败

跳过测试类也是一样的写法

class BBB(unittest.TestCase):
 
    @unittest.expectedFailure
    def test_aaa(self):
        raise AssertionError
 
    @unittest.skip(reason='无条件跳过')
    def test_bbb(self):
        print('测试 bbb')
        assert True
 
    def test_ccc(self):
　　　　　if True：
        　　self.skipTest("无条件跳过")
 
    @unittest.skipIf(condition=True,reason='条件为True跳过')
    def test_ddd(self):
        print('测试 ddd')
 
    @unittest.skipUnless(condition=False,reason='条件为False跳过')
    def test_eee(self):
        pass

3、子测试迭代subTest()

class BBB(unittest.TestCase):
 
    def test_eee(self):
        for i in range(4):
            with self.subTest(param=i): #将要迭代测试的参数传给param
                self.assertEqual(i%2,0)

五、第三方库ddt做数据驱动

1、装饰器data使用unpack和*号解包的区别

*号解包：将数据包解包分开为多个用例数据，迭代传入

unpack解包：将数据包解包拆分一个用例数据，分别用不同的参数名传入测试方法中

@ddt.ddt
class CCC(unittest.TestCase):
    testdata=[{'a':1,'b':2},{'a':3,'b':4}]
 
    @ddt.data(testdata)
    def test1(self,value):
        print("第一组不解包:：value=",value)
 
    @ddt.data(testdata)
    @ddt.unpack
    def test2(self,value1,value2):
        print(f"第二组unpack解包: value1={value1} value2={value2}")
 
    @ddt.data(*testdata)
    def test3(self, value):
        print(f"第三组*号解包:：value={value}")
 
    @ddt.data(*testdata)
    @ddt.unpack
    def test4(self, a,b):
        print(f"第四组*号解包:：a={a} b={b}")
 
结果展示--------------------------------------------------
 
第一组不解包:： [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}]
.第二组unpack解包: {'a': 1, 'b': 2} {'a': 3, 'b': 4}
.第三组*号解包:： {'a': 1, 'b': 2}
.第三组*号解包:： {'a': 3, 'b': 4}
.第四组*号解包:：1 2
.第四组*号解包:：3 4
.
----------------------------------------------------------------------
Ran 6 tests in 0.002s

2、file_data(value)文件上传数据

# data.json文件数据
 
[
  {"a": 1,"b": 2},
  {"a": 3,"b": 3}
]
 
#data.yaml文件数据
 
-
  a: 1
  b: 2
-
  a: 3
  b: 4
 
代码示例：
 
@ddt.ddt
class CCC(unittest.TestCase):
    testdata = [{'a': 1, 'b': 2}, {'a': 3, 'b': 4}]
 
    @ddt.file_data(value=r'C:\Users\EDY\PycharmProjects\WEB_AUTO\data.json')
    def test1(self, **fdata):
        print("第一组json数据:：value=", fdata)
 
    @ddt.file_data(value=r'C:\Users\EDY\PycharmProjects\WEB_AUTO\data.yaml')
    def test2(self, **fdata):
        print(f"第二组yaml数据: value1={fdata}")
 
结果展示-------------------------------
 
第一组json数据:：value= {'a': 1, 'b': 2}
.第一组json数据:：value= {'a': 3, 'b': 3}
.第二组yaml数据: value1={'a': 1, 'b': 2}
.第二组yaml数据: value1={'a': 3, 'b': 4}
.
----------------------------------------------------------------------
Ran 4 tests in 0.002s

六、用execl文件或者csv做关键字驱动

待