ddt

DDT(Data Driver Test)数据驱动测试,是由测试数据来驱动测试用例的执行;DDT可以实现用例的重复执行以及代码的重复使用,减少工作量。数据代码分离为主流设计思路,在常见的测试体系中可以使用xml文件、excel文件、json文件来管理测试数据;通过代码自动读取,来驱动用例的执行,ddt测试框架基于这种设计思路上,实现了方便使用,简单易懂的效果。

下载

pip install ddt
pip install -i https://pypi.doubanio.com/simple ddt

ddt模块包含了一个类的装饰器ddt和两个方法的装饰器

1、类装饰器:ddt
2、方法装饰器:data:包含多个你想要传给测试用例的参数
            unpack:通常data中包含的每一个值都会作为一个单独的参数传给测试方法,
            如果这些值是用元组或者列表传进来的,可以用unpack方法将其自动分解成多个参数

 

 

在unittest中的应用

示例一

import unittest
from ddt import ddt,data,unpack
#通过ddt模块中的ddt类装饰器的方法对当前类进行装饰
@ddt
class MyTestCase1(unittest.TestCase):
    @data(1,2,3)
    def test_normal(self,value):
        print(value)

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

示例二

import unittest
import ddt
import requests

data_list = [
    {"url": "https://cnodejs.org/api/v1/topics", "method": "get"},
    {"url": "https://cnodejs.org/api/v1/topic/5433d5e4e737cbe96dcef312", "method": "get"},
    {"url": "https://cnodejs.org/api/v1/topic_collect/collect", "method": "post"},
    {"url": "https://cnodejs.org/api/v1/topic_collect/de_collect", "method": "post"},
    {"url": "https://cnodejs.org/api/v1/user/alsotang", "method": "get"},
    {"url": "https://cnodejs.org/api/v1/message/mark_all", "method": "post"},
]


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

    def get_response(self, item):
        return requests.request(method=item['method'], url=item['url'])

    @ddt.data(*data_list)
    def test_case_01(self, item):
        response = self.get_response(item)
        self.assertEqual(response.status_code, 200)


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

如上示例,我们从Excel或者其他文本中获取到的数据是data_list类型,那么在做数据驱动的时候,就可以通过如上示例的操作来完成数据驱动测试。

 

2、传入元组、字典、列表等复杂结构数据,@data 装饰器结合 @unpack装饰器使用

import unittest
from ddt import ddt, data, unpack


@ddt
class MyTestCase2(unittest.TestCase):
    # 元组
    @data((1, 2), (2, 3))
    @unpack
    def test_tuple(self, value1, value2):
        print('test_tuple', value1, value2)

    # 列表
    @data([1, 2], [2, 3])
    @unpack
    def test_list(self, value1, value2):
        print('test_list', value1, value2)

    # 字典
    @data({'value1': 1, 'value2': 2}, {'value1': 2, 'value2': 3})
    @unpack
    def test_dict(self, value1, value2):
        print('test_dict', value1, value2)


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

 

在了解了 ddt 的使用后,你是否有过如下疑问:

  • ddt 是如何把你的测试数据转换传给你的测试用例?

  • 当你的一组数据有多个参数时,ddt 是如何 unpack 的?

  • 当你有多组数据时,ddt 拆分测试用例是如何命名的?

探索 ddt 实现数据驱动的秘密。

  通过阅读ddt 源码,我们不难发现其实 ddt 的实现核心就是@ddt(cls)这个装饰器,而这个装饰器的核心代码是 wrapper这个类函数,下面我直接把 wrapper 的源码贴上来,大家一起看看:

def wrapper(cls):
    # 先遍历被装饰类的name, 和func
    # 对于func,先看被装饰的是DATA_ATTR还是FILE_ATTR
    for name, func in list(cls.__dict__.items()):
        # 如果被装饰的是DATA_ATTR
        if hasattr(func, DATA_ATTR):
            #获取@data提供数据的index和内容并且遍历它们
            for i, v in enumerate(getattr(func, DATA_ATTR)):
                # 重新生成新的测试函数名,这个函数名会展示在测试报告中
                test_name = mk_test_name(
                    name,
                    getattr(v, "__name__", v),
                    i,
                    fmt_test_name
                )
                test_data_docstring = _get_test_data_docstring(func, v)
                # 如果类函数被@unpack装饰
                if hasattr(func, UNPACK_ATTR):
                    # 如果提供的数据是tuple或者list
                    if isinstance(v, tuple) or isinstance(v, list):
                        # 则添加一个case到测试类中
                        # list或tuple传不定数目的值, 用*v即可。
                        add_test(
                            cls,
                            test_name,
                            test_data_docstring,
                            func,
                            *v
                        )
                    else:
                        # unpack dictionary
                        # 添加一个case到测试类中
                        # dict中传不定数目的值,用**v
                        add_test(
                            cls,
                            test_name,
                            test_data_docstring,
                            func,
                            **v
                        )
                else:
                    # 如不需要unpack,则直接添加一个case到测试类
                    add_test(cls, test_name, test_data_docstring, func, v)
            # 删除原来的测试类
            delattr(cls, name)
        # 如果被装饰的是file_data
        elif hasattr(func, FILE_ATTR):
            # 获取file的名称
            file_attr = getattr(func, FILE_ATTR)
            # 根据process_file_data解析这个文件
            # 在解析的最后,会调用mk_test_name生成多个测试用例
            process_file_data(cls, name, func, file_attr)
            # 测试用例生成后,会删除原来的测试用例
            delattr(cls, name)
    return cls

   来分析下这段代码, 对于每一个被 @ddt 装饰的测试类,ddt 首先去遍历测试类的自有属性,从而得出这个测试类有哪些测试方法,这部分主要靠这条语句

# wrapper源码第4行
for name, func in list(cls.__dict__.items()):

 然后,ddt 去判断所有的 func(即类函数)里,有没有装饰器 @data 或者 @file_data,主要靠这两条语句:

# 被@data装饰, wrapper源码第6行
if hasattr(func, DATA_ATTR):
# 被file_data 装饰,wrapper源码第47行
elif hasattr(func, FILE_ATTR):

接着程序会进入两条分支:被 @data 装饰,即由 ddt 直接提供数据;被 @file_data 装饰,即数据由外部文件提供。

1.被 @data 装饰,即由 ddt 直接提供数据
  如果数据是直接通过 @data 提供的,那么为每一组数据新生成一个测试用例名称。

# 在本例中, i, v的第一次循环,值为 
# i:0 v:['Testing', 'Testing']
# wrapper源码第8行
for i, v in enumerate(getattr(func, DATA_ATTR)):
    test_name = mk_test_name(
        name,
        getattr(v, "__name__", v),
        i,
        fmt_test_name
    )

test_name 生成使用的是函数 mk_test_name。

  注意:ddt 在此时实现了把你的测试数据转换传给你的测试用例。其实不是通过传递,而是通过把测试数据拆分,并且生成新测试用例的方式来达成的。

  而在函数 mk_test_name 里,ddt 更是把原来的测试函数通过特定的规则,拆分成不同的测试函数。

test_name = mk_test_name(name,getattr(v, "__name__", v),i,fmt_test_name)

mk_test_name 的参数里:

  • name 是原测试函数的名字

  • v 是我们的一组测试数据

  • i 是这组数据的 index

fmt_test_name 指定新的 test 函数的名字的格式,这个格式是按照原来测试函数名 index 第一个测试数据_第二个测试数据这样的格式。

 

例如,我们的测试数据 ['Testing','Testing'] 会被转换成test_baidu_search_1_['Testing', 'Testing']',但是由于符号 '[' 和 '' 以及 ',' 是不合法的字符,故会被 '_' 替换,故最终新生成的测试用例名是test_baidu_search_1___Testing____Testing__ 这块的逻辑在函数 mk_test_name 的最后两行:

# ddt内容函数mk_test_name,test_name处理逻辑如下
test_name = "{0}_{1}_{2}".format(name, index, value)
return re.sub(r'\W|^(?=\d)', '_', test_name)

 紧接着,ddt 又去查找你的测试类函数,看它有没有被 @unpack 装饰。如果有,就意味着我们的测试类函数有多个参数,这个时候就需要把我们的测试数据 unpack,这样我们的测试类函数的各个参数才能接收到传入的值。

这样,ddt 把上一步生成的 test_name 和刚刚 unpack 的值(数据是 list、tuple,还是 dictionary,决定了 unpack 采用 *v 还是 **v),通过 add_test 来新生成一个测试用例,注册到我们的测试类下面,所有这些动作是在下面这段代码里完成的。

# wrapper源码里的18行到43行
if hasattr(func, UNPACK_ATTR):
    if isinstance(v, tuple) or isinstance(v, list):
        add_test(
            cls,
            test_name,
            test_data_docstring,
            func,
            *v
        )
    else:
        # unpack dictionary
        add_test(
            cls,
            test_name,
            test_data_docstring,
            func,
            **v
        )
else:
    add_test(cls, test_name, test_data_docstring, func, v)

注意:
  这个时候测试类中是多了测试函数的,多了多少个,要取决于 ddt 提供的测试数据的组数,有几组就生成几个测试用例,并且都注册到原测试类中去;

  unpack 其实就是为了把一个测试用例的多个测试数据全部传入新生成的测试函数中去,这些测试数据和测试函数的参数一一对应。

  最后,ddt 会把最初的那个原始测试类方法给删除(因为原测试函数已经根据各组数据变成了新的测试函数)。

# wrapper源码45行
delattr(cls, name)

  通过这样的方式,ddt 根据测试数据的组数,通过函数 mk_test_name 生成多组测试用例,并通过 add_test 函数注册到 unittest的TestSuite 里去。

 

2.被 @file_data 装饰,即数据由外部文件提供
  如果测试函数被 @file_data 装饰,ddt 则会先获取 file_data 里的数据文件名称,然后通过函数 process_file_data 里进行下一步处理。

# wrapper源码的第49到52行
file_attr = getattr(func, FILE_ATTR)
process_file_data(cls, name, func, file_attr)

起来只有短短的两行,其实 ddt 在函数 process_file_data 内部做了很多操作。

  首先 ddt 会先拿到我们提供的数据文件的绝对地址,并通过后缀名判断它是 yaml 文件还是 json 文件,然后分别调用 yaml 或者 json 的 load 方法拿到文件里提供的数据。

  拿到数据后,最终也是通过 mk_test_name 函数和 add_test 函数,生成多条测试用例,并且注册到 unittest 的 TestSuite 里去。

最后一样是删除原来的测试函数:

# wrapper源码54行
delattr(cls, name)

这就是 ddt 的整个实现逻辑了。

posted @ 2021-06-20 17:51  断浪狂刀忆年少  阅读(549)  评论(0编辑  收藏  举报