如何使用python mock直接模拟超类？
我正在使用python mock framework for testing (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()功能。
()如何发现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回答 2
Stack Overflow用户
发布于 2012-12-08 04:52:31
我按照kindall的建议玩弄了一下mocking super()。不幸的是，经过大量的努力，处理复杂的继承情况变得相当复杂。
经过一些工作，我意识到当通过MRO解析属性时，__dict__ ()直接访问类的属性(它不做getattr类型的调用)。解决方案是扩展一个mock.MagicMock()对象，并用一个类包装它来实现这一点。包装好的类可以放在子类的__bases__变量中。
包装对象将目标类的所有已定义属性反映到包装类的__dict__中，以便MagicMock()调用解析为内部super()中正确修补的in属性。
下面的代码是我到目前为止找到的解决方案。请注意，我实际上在上下文处理程序中实现了这一点。此外，如果从其他模块导入，则必须注意修补正确的名称空间。
这是一个简单的示例，说明了该方法：
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 == 0Stack Overflow用户
发布于 2012-06-26 04:15:07
有没有办法让我在这里插话，并以某种方式让它动态地使用mock.Mock()？
也许有更好的方法，但您始终可以编写自己的super()并将其注入到包含您正在模拟的类的模块中。让它根据调用它的内容返回它应该返回的任何内容。
您可以仅在当前名称空间中定义super() (在这种情况下，重定义仅应用于定义之后的当前模块)，也可以对__builtin__.super执行import __builtin__并将重定义应用于Python，在这种情况下，它将在Python会话中全局应用。
您可以使用默认参数捕获原始super函数(如果需要从实现中调用它)：
def super(type, obj=None, super=super):
# inside the function, super refers to the built-inhttps://stackoverflow.com/questions/11194847
复制相似问题