为 pytest 测试方法编写装饰器

Question

假设如下结构：

class SetupTestParam(object):
    def setup_method(self, method):
        self.foo = bar()

    @pytest.fixture
    def some_fixture():
        self.baz = 'foobar'

我使用SetupTestParam 作为测试类的父类。

class TestSomething(SetupTestParam):
    def test_a_lot(self, some_fixture):
        with self.baz as magic:
            with magic.fooz as more_magic:
                 blah = more_magic.much_more_magic() # repetative bleh
            ... # not repetative code here
            assert spam == 'something cool'

现在，编写测试变得重复（使用语句），我想编写一个装饰器来减少代码行数。但是pytest和函数签名有问题。

我发现 library 应该会有所帮助，但我无法让它发挥作用。

我在SetupTestParam 班级中创建了一个classmethod。

@classmethod
@decorator.decorator
def this_is_decorator(cls, f):
    def wrapper(self, *args, **kw):
        with self.baz as magic:
            with magic.fooz as more_magic:
                 blah = more_magic.much_more_magic() # repetative bleh
            return f(self, *args)
    return wrapper

装饰test_a_lot方法后，收到错误TypeError: transaction_decorator() takes exactly 1 argument (2 given)

谁能解释一下我做错了什么？ （我假设测试方法中的self 有问题？）

Answer 1

链接装饰器并不是最简单的事情。一种解决方案可能是将两个装饰器分开。保留classmethod 但将decorator.decorator 移到末尾：

@classmethod
def this_is_decorator(cls, f):
    def wrapper(self, *args, **kw):
        with self.baz as magic:
            with magic.fooz as more_magic:
                 blah = more_magic.much_more_magic() # repetative bleh
            return f(self, *args)
    return decorator.decorator(wrapper, f)

也许这对你有用。

Answer 2

经过一些调整并意识到我需要将参数传递给装饰器后，我选择将其编写为一个类：

class ThisIsDecorator(object):
    def __init__(self, param):
        self.param = param   # Parameter may vary with the function being decorated
    def __call__(self, fn):
        wraps(fn) # [1]
        def wrapper(fn, fn_self, *args): # [2] fn_self refers to original self param from function fn (test_a_lot) [2]
            with fn_self.baz as fn_self.magic: # I pass magic to fn_self to make magic accesible in function fn (test_a_lot)
                with fn_self.magic.fooz as more_magic:
                    blah = self.param.much_more_magic() # repetative bleh
            return fn(fn_self, *args)
        return decorator.decorator(wrapper, fn) 

[1] 我使用wraps 拥有原始fn __name__、__module__ 和__doc__。

[2] 传递给wrapper 的参数是self = <function test_a_lot at 0x24820c8> args = (<TestSomething object at 0x29c77d0>, None, None, None, None), kw = {}，所以我将args[0] 取出为fn_self。

原版（不传参数）：

 @classmethod
 def this_is_decorator(cls, fn):
     @wraps(fn)
     def wrapper(fn, fn_self, *args):
         with fn_self.baz as fn_self.magic:
             with fn_self.magic.fooz as more_magic:
                 blah = more_magic.much_more_magic() # repetative bleh
             return fn(fn_self, *args)
     return decorator.decorator(wrapper,fn)

感谢 Mike Muller 指出正确的方向。

Answer 3

这是定义此方法时按时间顺序发生的情况。

1. this_is_decorator 已创建（未调用）。
2. decorator.decorator(this_is_decorator) 被调用。这将返回一个新函数，该函数变为 this_is_decorator 并具有相同的用法。
3. classmethod(this_is_decorator) 被调用，其结果是一个接受(cls, f) 并返回wrapper 的类方法。
4. 稍后在运行时，对this_is_decorator 的调用将返回wrapper。

但是考虑到this_is_decorator 是一个类方法，我不清楚这就是你想要的。我猜你可能想要更多这样的东西：

from decorator import decorator
@decorator
def mydecorator(f):
  def wrapper(cls, *args, **kw):
    # ... logging, reporting, caching, whatever
    return f(*args, **kw)
  return wrapper

class MyClass(object):
  @classmethod
  @mydecorator
  def myclsmethod(a, b, c):
    # no cls or self value accepted here; this is a function not a method
    # ...

这里你的装饰器是在你的类之外定义的，因为它把一个普通的函数变成了一个classmethod（因为你可能想在其他地方使用它）。这里的执行顺序是：

1. mydecorator 已定义，未调用。
2. decorator(mydecorator) 被调用，结果变成 mydecorator。
3. 开始创建MyClass。
4. myclsmethod 已创建。它是一个普通的函数，而不是一个方法。 VM 内部存在差异，因此您不必为方法显式提供 cls 或 self 参数。
5. myclsmethod 被传递给 mydecorator（它本身已经被装饰过）并且结果 (wrapper) 仍然是一个函数而不是一个方法。
6. mydecorator 的结果被传递给classmethod，它返回绑定到MyClass.myclsmethod 的实际类方法。
7. MyClass 的定义完成。
8. 稍后当MyClass.myclsmethod(a, b, c) 被调用时，wrapper 执行，然后调用原始的myclsmethod(a, b, c) 函数（它称为f）而不提供cls 参数。

由于您还需要准确地保留参数列表，因此即使参数的名称也保留在修饰函数中，除了额外的初始参数cls，那么您可以通过这种方式实现mydecorator ：

from decorator import decorator
from inspect import getargspec

@decorator
def mydecorator(func):
  result = [None]  # necessary so exec can "return" objects
  namespace = {'f': func, 'result': result}
  source = []
  add = lambda indent, line: source.append(' ' * indent + line)  # shorthand
  arglist = ', '.join(getargspec(func).args)  # this does not cover keyword or default args
  add(0, 'def wrapper(cls, %s):' % (arglist,))
  add(2, 'return f(%s)' % (arglist,))
  add(0, 'result[0] = wrapper')  # this is how to "return" something from exec
  exec '\n'.join(source) in namespace
  return result[0]  # this is wrapper

这有点难看，但这是我知道的根据数据动态设置函数参数列表的唯一方法。如果返回 lambda 没问题，您可以使用 eval 代替 exec，这样就无需写入数组，但其他方面基本相同。