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

Question

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

Answer 1

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

所以如果你想修饰装饰器，你需要做的是：

1. 导入包含它的模块
2. 定义模拟装饰器功能
3. 设置例如 module.decorator = mymockdecorator
4. 导入使用装饰器的模块，或在您自己的模块中使用

如果包含装饰器的模块也包含使用它的函数，那么当你看到它们时它们已经被装饰了，你可能是S.O.L.

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

Answer 2

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

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

# 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的本地范围，并在使用装饰器导入单元之前启动修补程序。

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

Answer 3

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

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

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

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。你必须分别模拟每个装饰者，所以要注意你错过的那些。

Answer 4

以下对我有用：

1. 消除加载测试目标的import语句。
2. 在上面应用的测试启动时修补装饰器。
3. 在修补后立即调用importlib.import_module（）以加载测试目标。
4. 正常运行测试。

它就像一个魅力。

Answer 5

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

@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

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

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

Answer 6

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

模拟函数：

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))

将返回：

<块引用>

“你好世界”

Answer 7

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

Answer 8

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

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

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

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()...

有用的参考文献：

• Python 3 documentation for imp.reload
• Python 2.7 documentation for reload
• http://alexmarandon.com/articles/python_mock_gotchas/#patching-decorators

Answer 9

表示@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