如何使用python mock直接模拟超类？

Question

我正在使用python模拟框架进行测试(http://www.voidspace.org.uk/python/mock/),我想模拟一个超类,并专注于测试子类的添加行为.

(对于那些感兴趣的人,我已经扩展了pymongo.collection.Collection,我想只测试我添加的行为.我不想将mongodb作为另一个进程进行测试.)

对于此讨论,A是超类,B是子类.此外,我定义了直接和间接超类调用,如下所示:

class A(object):
    def method(self):
        ...

    def another_method(self):
        ...

class B(A):
    def direct_superclass_call(self):
        ...
        A.method(self)

    def indirect_superclass_call(self):
        ...
        super(A, self).another_method()

方法#1

为A调用一个名为MockA的模拟类,并使用mock.patch将其替换为运行时的测试.这会处理直接的超类调用.然后操纵B .__ bases__来处理间接超类调用.(见下文)

出现的问题是我必须编写MockA,在某些情况下(如pymongo.collection.Collection的情况),这可能涉及大量工作来解开所有内部调用模拟.

方法#2

所需的方法是以某种方式使用mock.Mock()类来及时处理模拟上的调用,以及在测试中定义的return_value或side_effect.通过这种方式,我不得不通过避免MockA的定义来做更少的工作.

我遇到的问题是我无法弄清楚如何改变B .__ bases__以便mock.Mock()的实例可以作为超类放置到位(我必须以某种方式在这里做一些直接绑定).到目前为止,我已经确定,super()检查MRO,然后调用定义相关方法的第一个类.我无法弄清楚如何让一个超类来处理它的检查,如果它遇到一个模拟类,就会成功.在这种情况下似乎没有使用__getattr__.我希望super认为此方法已定义,然后像往常一样使用mock.Mock()功能.

super()如何发现MRO序列中类中定义的属性？有没有办法让我插入这里并以某种方式让它在飞行中使用mock.Mock()？

import mock

class A(object):
    def __init__(self, value):
        self.value = value      

    def get_value_direct(self):
        return self.value

    def get_value_indirect(self):
        return self.value   

class B(A):
    def __init__(self, value):
        A.__init__(self, value)

    def get_value_direct(self):
        return A.get_value_direct(self)

    def get_value_indirect(self):
        return super(B, self).get_value_indirect()


# approach 1 - use a defined MockA
class MockA(object):
    def __init__(self, value):
        pass

    def get_value_direct(self):
        return 0

    def get_value_indirect(self):
        return 0

B.__bases__ = (MockA, )  # - mock superclass 
with mock.patch('__main__.A', MockA):  
    b2 = B(7)
    print '\nApproach 1'
    print 'expected result = 0'
    print 'direct =', b2.get_value_direct()
    print 'indirect =', b2.get_value_indirect()
B.__bases__ = (A, )  # - original superclass 


# approach 2 - use mock module to mock out superclass

# what does XXX need to be below to use mock.Mock()?
#B.__bases__ = (XXX, )
with mock.patch('__main__.A') as mymock:  
    b3 = B(7)
    mymock.get_value_direct.return_value = 0
    mymock.get_value_indirect.return_value = 0
    print '\nApproach 2'
    print 'expected result = 0'
    print 'direct =', b3.get_value_direct()
    print 'indirect =', b3.get_value_indirect() # FAILS HERE as the old superclass is called
#B.__bases__ = (A, )  # - original superclass

Answer 1

有没有办法让我插入这里并以某种方式让它在飞行中使用mock.Mock()？

可能有更好的方法,但您可以随时编写自己的方法super()并将其注入包含您正在模拟的类的模块中.让它根据所谓的内容返回任何内容.

您可以只super()在当前命名空间中定义(在这种情况下,重定义仅适用于定义后的当前模块),或者您可以import __builtin__应用重定义__builtin__.super,在这种情况下,它将全局应用于Python会话.

您可以super使用默认参数捕获原始函数(如果需要从实现中调用它):

def super(type, obj=None, super=super):  
    # inside the function, super refers to the built-in

Answer 2

我按照 kindall 的建议尝试了模拟 super() 。不幸的是，经过大量的努力，处理复杂的继承情况变得相当复杂。

经过一番工作后，我意识到 super() 在通过 MRO 解析属性时直接访问类的 __dict__ （它不执行 getattr 类型的调用）。解决方案是扩展一个 mock.MagicMock() 对象并用一个类包装它来完成此任务。然后可以将包装的类放置在子类的 __bases__ 变量中。

包装对象将目标类的所有已定义属性反映到包装类的 __dict__ 中，以便 super() 调用解析为内部 MagicMock() 内属性中正确修补的内容。

以下代码是迄今为止我发现可行的解决方案。请注意，我实际上是在上下文处理程序中实现的。此外，如果从其他模块导入，则必须注意修补适当的名称空间。

这是一个说明该方法的简单示例：

from mock import MagicMock
import inspect 


class _WrappedMagicMock(MagicMock):
    def __init__(self, *args, **kwds):
        object.__setattr__(self, '_mockclass_wrapper', None)
        super(_WrappedMagicMock, self).__init__(*args, **kwds)

    def wrap(self, cls):
        # get defined attribtues of spec class that need to be preset
        base_attrs = dir(type('Dummy', (object,), {}))
        attrs = inspect.getmembers(self._spec_class)
        new_attrs = [a[0] for a in attrs if a[0] not in base_attrs]

        # pre set mocks for attributes in the target mock class
        for name in new_attrs:
            setattr(cls, name, getattr(self, name))

        # eat up any attempts to initialize the target mock class
        setattr(cls, '__init__', lambda *args, **kwds: None)

        object.__setattr__(self, '_mockclass_wrapper', cls)

    def unwrap(self):
        object.__setattr__(self, '_mockclass_wrapper', None)

    def __setattr__(self, name, value):
        super(_WrappedMagicMock, self).__setattr__(name, value)

        # be sure to reflect to changes wrapper class if activated
        if self._mockclass_wrapper is not None:
            setattr(self._mockclass_wrapper, name, value)

    def _get_child_mock(self, **kwds):
        # when created children mocks need only be MagicMocks
        return MagicMock(**kwds)


class A(object):
    x = 1

    def __init__(self, value):
        self.value = value

    def get_value_direct(self):
        return self.value

    def get_value_indirect(self):
        return self.value


class B(A):
    def __init__(self, value):
        super(B, self).__init__(value)

    def f(self):
        return 2

    def get_value_direct(self):
        return A.get_value_direct(self)

    def get_value_indirect(self):
        return super(B, self).get_value_indirect()

# nominal behavior
b = B(3)
assert b.get_value_direct() == 3
assert b.get_value_indirect() == 3
assert b.f() == 2
assert b.x == 1

# using mock class
MockClass = type('MockClassWrapper', (), {})
mock = _WrappedMagicMock(A)
mock.wrap(MockClass)

# patch the mock in
B.__bases__ = (MockClass, )
A = MockClass

# set values within the mock
mock.x = 0
mock.get_value_direct.return_value = 0
mock.get_value_indirect.return_value = 0

# mocked behavior
b = B(7)
assert b.get_value_direct() == 0
assert b.get_value_indirect() == 0
assert b.f() == 2
assert b.x == 0