我可以在包装函数之前修补Python装饰器吗?

时间:2011-10-05 20:50:21

标签: python unit-testing mocking decorator monkeypatching

我有一个装饰器的功能,我正在尝试借助Python Mock库进行测试。我想使用mock.patch将模拟'旁路'装饰器替换为真正的装饰器,它只调用该函数。我无法弄清楚的是如何在真正的装饰器包装函数之前应用补丁。我已经在补丁目标上尝试了一些不同的变体,并重新排序补丁和导入语句,但没有成功。有什么想法吗?

9 个答案:

答案 0 :(得分:47)

装饰器在功能定义时应用。对于大多数功能,这是在加载模块时。 (每次调用封闭函数时,在其他函数中定义的函数都会应用装饰器。)

所以如果你想修饰装饰器,你需要做的是:

  1. 导入包含它的模块
  2. 定义模拟装饰器功能
  3. 设置例如 module.decorator = mymockdecorator
  4. 导入使用装饰器的模块,或在您自己的模块中使用
  5. 如果包含装饰器的模块也包含使用它的函数,那么当你看到它们时它们已经被装饰了,你可能是S.O.L.

    编辑以反映自我最初写这篇文章以来对Python的更改:如果装饰器使用functools.wraps()并且Python的版本足够新,您可以使用__wrapped__挖出原始函数attritube并重新装饰它,但这绝不是保证,你要替换的装饰器也可能不是唯一应用的装饰器。

答案 1 :(得分:34)

应该注意的是,这里的几个答案将修补整个测试会话的装饰器而不是单个测试实例;这可能是不受欢迎的。以下是如何修补仅通过单次测试持续存在的装饰器。

我们的单位将与不受欢迎的装饰者进行测试:

# app/uut.py

from app.decorators import func_decor

@func_decor
def unit_to_be_tested():
    # Do stuff
    pass

来自装饰者模块:

# app/decorators.py

def func_decor(func):
    def inner(*args, **kwargs):
        print "Do stuff we don't want in our test"
        return func(*args, **kwargs)
    return inner

当我们的测试在测试运行期间被收集时,不需要的装饰器已经应用于我们的测试单元(因为这在导入时发生)。为了摆脱这种情况,我们需要手动替换装饰器模块中的装饰器,然后重新导入包含UUT的模块。

我们的测试模块:

#  test_uut.py

from unittest import TestCase
from app import uut  # Module with our thing to test
from app import decorators  # Module with the decorator we need to replace
import imp  # Library to help us reload our UUT module
from mock import patch


class TestUUT(TestCase):
    def setUp(self):
        # Do cleanup first so it is ready if an exception is raised
        def kill_patches():  # Create a cleanup callback that undoes our patches
            patch.stopall()  # Stops all patches started with start()
            imp.reload(uut)  # Reload our UUT module which restores the original decorator
        self.addCleanup(kill_patches)  # We want to make sure this is run so we do this in addCleanup instead of tearDown

        # Now patch the decorator where the decorator is being imported from
        patch('app.decorators.func_decor', lambda x: x).start()  # The lambda makes our decorator into a pass-thru. Also, don't forget to call start()          
        # HINT: if you're patching a decor with params use something like:
        # lambda *x, **y: lambda f: f
        imp.reload(uut)  # Reloads the uut.py module which applies our patched decorator

清理回调kill_patches恢复原始装饰器并将其重新应用到我们测试的单元。这样,我们的补丁仅通过单个测试而不是整个会话持续存在 - 这正是任何其他补丁应该如何表现的。此外,由于清理调用patch.stopall(),我们可以启动我们需要的setUp()中的任何其他补丁,它们将在一个地方得到清理。

了解此方法的重要一点是重新加载将如何影响事物。如果模块需要太长时间或者在导入时运行逻辑,那么您可能只需要耸肩并测试装饰器作为单元的一部分。 :(希望你的代码写得比那更好。对吧?

如果一个人不关心补丁是否适用于整个测试会话,最简单的方法是在测试文件的顶部:

# test_uut.py

from mock import patch
patch('app.decorators.func_decor', lambda x: x).start()  # MUST BE BEFORE THE UUT GETS IMPORTED ANYWHERE!

from app import uut

确保使用装饰器修补文件而不是UUT的本地范围,并在使用装饰器导入单元之前启动修补程序。

有趣的是,即使修补程序已停止,所有已导入的文件仍会将修补程序应用于装饰器,这与我们开始使用的情况相反。请注意,此方法将修补之后导入的测试运行中的任何其他文件 - 即使他们自己也没有声明补丁。

答案 2 :(得分:4)

当我第一次遇到这个问题时,我会使用大脑几个小时。我找到了一种更容易处理的方法。

这将完全绕过装饰者,就像目标甚至没有装饰一样。

这分为两部分。我建议阅读以下文章。

http://alexmarandon.com/articles/python_mock_gotchas/

我遇到的两件事:

1。)在导入函数/模块之前模拟Decorator。

装饰器和函数是在加载模块时定义的。 如果你在导入之前没有模拟,它将忽略模拟。加载后,你必须做一个奇怪的mock.patch.object,这会让人更加沮丧。

2。)确保你正在嘲笑装饰者的正确路径。

请记住,您正在模拟的装饰器补丁是基于模块加载装饰器的方式,而不是测试加载装饰器的方式。这就是我建议始终使用完整路径进行导入的原因。这使得测试变得更加容易。

步骤:

1。)模拟功能:

from functools import wraps

def mock_decorator(*args, **kwargs):
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            return f(*args, **kwargs)
        return decorated_function
    return decorator

2。)嘲笑装饰者:

2a。)里面的路径。

with mock.patch('path.to.my.decorator', mock_decorator):
     from mymodule import myfunction

2b。)文件顶部或TestCase.setUp

中的修补程序
mock.patch('path.to.my.decorator', mock_decorator).start()

这些方法中的任何一种都允许您在TestCase或其方法/测试用例中随时导入您的函数。

from mymodule import myfunction

2。)使用单独的函数作为mock.patch的副作用。

现在,您可以对要模拟的每个装饰器使用mock_decorator。你必须分别模拟每个装饰者,所以要注意你错过的那些。

答案 3 :(得分:1)

以下对我有用:

  1. 消除加载测试目标的import语句。
  2. 在上面应用的测试启动时修补装饰器。
  3. 在修补后立即调用importlib.import_module()以加载测试目标。
  4. 正常运行测试。
  5. 它就像一个魅力。

答案 4 :(得分:1)

我们尝试模拟一个装饰器,该装饰器有时会获得另一个参数,例如字符串,有时却没有,例如:

@myDecorator('my-str')
def function()

OR

@myDecorator
def function()

由于上面的回答之一,我们编写了一个模拟函数,并使用该模拟函数修补了装饰器:

from mock import patch

def mock_decorator(f):

    def decorated_function(g):
        return g

    if callable(f): # if no other parameter, just return the decorated function
        return decorated_function(f)
    return decorated_function # if there is a parametr (eg. string), ignore it and return the decorated function

patch('path.to.myDecorator', mock_decorator).start()

from mymodule import myfunction

请注意,此示例对于不运行装饰功能的装饰器很有用,它只在实际运行之前做一些事情。 如果装饰器也运行装饰后的函数,因此需要传递该函数的参数,则模拟_装饰器函数必须有所不同。

希望这对其他人有帮助...

答案 5 :(得分:1)

我喜欢让一个技巧更简单、更容易理解。利用装饰器的功能并创建旁路。

模拟函数:

from functools import wraps

def the_call(*args, **kwargs):
    def decorator(function):
        @wraps(function)
        def wrapper(*args, **kwargs):
            if kwargs.pop("bypass", None) is True:
                return function(*args, **kwargs)
            # You will probably do something that will change the response or the arguments here below
            args = ("bar")
            kwargs = {"stuff": "bar"}
            return function(*args, **kwargs)
        return wrapper
    return decorator

您使用装饰器的功能:

@the_call()
def my_simple_function(stuff: str):
    return stuff


print(my_simple_function(stuff="Hello World"))

将返回:

<块引用>

“条”

因此在您的测试中,只需传递参数 bypass = True

print(my_simple_function(stuff="Hello World", bypass=True))

将返回:

<块引用>

“你好世界”

答案 6 :(得分:0)

也许你可以将另一个装饰器应用到所有装饰器的定义上,这些装饰器基本上检查一些配置变量以查看是否要使用测试模式。
如果是的话,它会取代正在装饰的装饰器,装饰器不会做任何事情 否则,它让这个装饰者通过。

答案 7 :(得分:0)

要修补装饰器,您需要在修补后 导入或重新加载使用该装饰器的模块,或者重新定义模块对该装饰器的引用。

在导入模块时应用装饰器。这就是为什么如果您导入了一个使用装饰器的模块,而您想在文件顶部进行修补,然后再尝试对其进行修补而不重新加载,则该修补将无效。

这是提到的第一种方法的示例-在修补使用的装饰器后重新加载模块:

import moduleA
...

  # 1. patch the decorator
  @patch('decoratorWhichIsUsedInModuleA', examplePatchValue)
  def setUp(self)
    # 2. reload the module which uses the decorator
    reload(moduleA)

  def testFunctionA(self):
    # 3. tests...
    assert(moduleA.functionA()...

有用的参考文献:

答案 8 :(得分:-2)

表示@lru_cache(max_size = 1000)


class MockedLruCache(object):

def __init__(self, maxsize=0, timeout=0):
    pass

def __call__(self, func):
    return func

cache.LruCache = MockedLruCache

如果使用没有参数的装饰器,你应该:

def __init__(self, maxsize=0, timeout=0):
    pass

def __call__(self, func):
    return func