19

我正在使用 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__ 。我希望超级认为该方法是在此时定义的，然后像往常一样使用 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
4

2 回答 2

6

有没有办法让我在这里插话并以某种方式让它即时使用 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
于 2012-06-25T20:15:06.800 回答
3

按照 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
于 2012-12-07T20:52:30.743 回答