Question

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

（对于那些感兴趣我已扩展 pymongo.collection.Collection 的人，我只想测试我添加的行为。我不想将mongodb作为另一个进程用于测试目的。）< / p>

在本次讨论中， 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

为名为 MockA 的 A 定义模拟类，并使用 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__并将重新定义应用于{{1在这种情况下，它将在Python会话中全局应用。

您可以使用默认参数捕获原始__builtin__.super函数（如果需要从实现中调用它）：

super

Answer 2

我按照kindall的建议嘲笑超级（）。不幸的是，经过大量的努力，处理复杂的继承案件变得非常复杂。

经过一些工作后，我意识到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

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

方法＃1

方法＃2

2 个答案: