#
# (c) Dave Kirby 2001
# dkirby@bigfoot.com
#
# Call interceptor code by Phil Dawes (pdawes@users.sourceforge.net)
'''
The Mock class emulates any other class for testing purposes.
All method calls are stored for later examination.
The class constructor takes a dictionary of method names and the values
they return. Methods that are not in the dictionary will return None.
'''
import inspect
class Mock:
def __init__(self, returnValues=None ):
self.mockCalledMethods = {}
self.mockAllCalledMethods = []
self.mockReturnValues = returnValues or {}
self.setupMethodInterceptors()
def setupMethodInterceptors(self):
if self.__class__ != Mock: # check we've been subclassed
methods = inspect.getmembers(self.__class__,inspect.ismethod)
for m in methods:
name = m[0]
self.__dict__[name] = MethodCallInterceptor(name,self)
def __getattr__( self, name ):
return MockCaller( name, self )
def getAllCalls(self):
'''return a list of MockCall objects,
representing all the methods in the order they were called'''
return self.mockAllCalledMethods
def getNamedCalls(self, methodName ):
'''return a list of MockCall objects,
representing all the calls to the named method in the order they were called'''
return self.mockCalledMethods.get(methodName, [] )
def assertNamedCall(self,methodName,*args):
# assert call was made once
assert(len(self.getNamedCalls(methodName)) == 1)
# assert args are correct
argsdict = inspect.getargvalues(inspect.currentframe())[3]
i=0
for arg in argsdict['args']:
assert(self.getNamedCalls(methodName)[0].getParam(i) == arg)
i += 1
def assertCallInOrder(self,methodName,*args):
''' Convenience method to allow client to check that calls were
made in the right order. Call once for each methodcall'''
# initialise callIndex. (n.b. __getattr__ method complicates
# this since attrs are MockCaller instances by default)
if type(self.callIndex) != type(1):
self.callIndex=0
call = self.getAllCalls()[self.callIndex]
# assert method name is correct
assert(call.getName() == methodName)
# assert args are correct
argsdict = inspect.getargvalues(inspect.currentframe())[3]
i=0
for arg in argsdict['args']:
assert(call.getParam(i) == arg)
i += 1
# assert num args are correct
assert(call.getNumParams() == i)
self.callIndex += 1
def assertNoMoreCalls(self):
assert(len(self.getAllCalls()) == self.callIndex)
class MockCall:
def __init__(self, name, params, kwparams ):
self.name = name
self.params = params
self.kwparams = kwparams
def getParam( self, n ):
if type(n) == type(1):
return self.params[n]
elif type(n) == type(''):
return self.kwparams[n]
else:
raise IndexError, 'illegal index type for getParam'
def getNumParams(self):
return len(self.params)
def getName(self):
return self.name
#pretty-print the method call
def __str__(self):
s = self.name + "("
sep = ''
for p in self.params:
s = s + sep + repr(p)
sep = ', '
for k,v in self.kwparams.items():
s = s + sep + k+ '='+repr(v)
sep = ', '
s = s + ')'
return s
def __repr__(self):
return self.__str__()
class MockCaller:
def __init__( self, name, mock):
self.name = name
self.mock = mock
def __call__(self, *params, **kwparams ):
self.recordCall(params,kwparams)
return self.mock.mockReturnValues.get(self.name)
def recordCall(self,params,kwparams):
thisCall = MockCall( self.name, params, kwparams )
calls = self.mock.mockCalledMethods.get(self.name, [] )
if calls == []:
self.mock.mockCalledMethods[self.name] = calls
calls.append(thisCall)
self.mock.mockAllCalledMethods.append(thisCall)
# intercepts the call and records it, then delegates to the real call
class MethodCallInterceptor(MockCaller):
def __call__(self, *params, **kwparams ):
self.recordCall(params,kwparams)
return self.makeCall(params)
def makeCall(self,params):
argsstr="(self.mock"
for i in range(len(params)):
argsstr += ",params["+`i`+"]"
argsstr+=")"
return eval("self.mock.__class__."+self.name+argsstr)
|