如何使用python模拟直接模拟超类?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (87)

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

对于这个讨论,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和使用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序列中的类中定义了哪些属性?有没有办法让我插入这里,并以某种方式让它利用模拟。模拟()在飞行中?

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
提问于
用户回答回答于

这是一个说明方法的简单例子:

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
用户回答回答于

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

可能有更好的方法,但是你可以随时编写自己的代码并将其注入到包含你正在嘲笑的类的模块中。让它根据什么叫它返回它应该的东西。

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

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

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

扫码关注云+社区

领取腾讯云代金券