diff options
author | André Apitzsch <git@apitzsch.eu> | 2018-11-25 14:31:08 +0300 |
---|---|---|
committer | André Apitzsch <git@apitzsch.eu> | 2018-11-25 16:16:55 +0300 |
commit | fabdaa4e15498aadb08dcacc2339893ae7e1e378 (patch) | |
tree | 3a45e8ee02bebec1818572bdbc851fdeae69d871 /test | |
parent | 633e0dd25ec69f63924d6d508ad882cde4eacc9a (diff) |
Test: Use Mock from standard library
Diffstat (limited to 'test')
-rw-r--r-- | test/broken/test_xmpp_smacks.py | 1 | ||||
-rw-r--r-- | test/lib/mock.py | 463 | ||||
-rw-r--r-- | test/lib/xmpp_mocks.py | 2 | ||||
-rw-r--r-- | test/unit/test_xmpp_client_nb.py | 5 | ||||
-rw-r--r-- | test/unit/test_xmpp_dispatcher_nb.py | 1 |
5 files changed, 4 insertions, 468 deletions
diff --git a/test/broken/test_xmpp_smacks.py b/test/broken/test_xmpp_smacks.py index d56bb64..fa66065 100644 --- a/test/broken/test_xmpp_smacks.py +++ b/test/broken/test_xmpp_smacks.py @@ -18,7 +18,6 @@ class TestDispatcherNB(unittest.TestCase): # Setup mock client self.client = Mock() - self.client._caller = Mock() self.client.defaultNamespace = protocol.NS_CLIENT self.client.Connection = Mock() # mock transport self.con = self.client.Connection diff --git a/test/lib/mock.py b/test/lib/mock.py deleted file mode 100644 index e2a2b6c..0000000 --- a/test/lib/mock.py +++ /dev/null @@ -1,463 +0,0 @@ -# -# (c) Dave Kirby 2001 - 2005 -# mock@thedeveloperscoach.com -# -# Original call interceptor and call assertion code by Phil Dawes (pdawes@users.sourceforge.net) -# Call interceptor code enhanced by Bruce Cropley (cropleyb@yahoo.com.au) -# -# This Python module and associated files are released under the FreeBSD -# license. Essentially, you can do what you like with it except pretend you wrote -# it yourself. -# -# -# Copyright (c) 2005, Dave Kirby -# Copyright (c) 2009, Yann Leboulanger -# -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * Neither the name of this library nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# -# mock@thedeveloperscoach.com - - -""" -Mock object library for Python. Mock objects can be used when unit testing -to remove a dependency on another production class. They are typically used -when the dependency would either pull in lots of other classes, or -significantly slow down the execution of the test. -They are also used to create exceptional conditions that cannot otherwise -be easily triggered in the class under test. -""" - -__version__ = "0.1.0" - -# Added in Python 2.1 -import inspect -import re - -class MockInterfaceError(Exception): - pass - -class Mock(object): - """ - The Mock class emulates any other class for testing purposes. - All method calls are stored for later examination. - """ - - def __init__(self, returnValues=None, realClass=None): - """ - The Mock class constructor takes a dictionary of method names and - the values they return. Methods that are not in the returnValues - dictionary will return None. - You may also supply a class whose interface is being mocked. - All calls will be checked to see if they appear in the original - interface. Any calls to methods not appearing in the real class - will raise a MockInterfaceError. Any calls that would fail due to - non-matching parameter lists will also raise a MockInterfaceError. - Both of these help to prevent the Mock class getting out of sync - with the class it is Mocking. - """ - self.mockCalledMethods = {} - self.mockAllCalledMethods = [] - self.mockReturnValues = returnValues or {} - self.mockExpectations = {} - self.realClass = realClass - self.realClassMethods = None - if realClass: - self.realClassMethods = dict(inspect.getmembers(realClass, inspect.isroutine)) - for retMethod in self.mockReturnValues.keys(): - if retMethod not in self.realClassMethods: - raise MockInterfaceError("Return value supplied for method '%s' that was not in the original class" % retMethod) - self._setupSubclassMethodInterceptors() - - def _setupSubclassMethodInterceptors(self): - methods = inspect.getmembers(self.realClass, inspect.isroutine) - baseMethods = dict(inspect.getmembers(Mock, inspect.ismethod)) - for m in methods: - name = m[0] - # Don't record calls to methods of Mock base class. - if not name in baseMethods: - self.__dict__[name] = MockCallable(name, self, handcrafted=True) - - def __getattr__(self, name): - return MockCallable(name, self) - - def mockAddReturnValues(self, **methodReturnValues ): - self.mockReturnValues.update(methodReturnValues) - - def mockSetExpectation(self, name, testFn, after=0, until=0): - self.mockExpectations.setdefault(name, []).append((testFn, after, until)) - - def _checkInterfaceCall(self, name, callParams, callKwParams): - """ - Check that a call to a method of the given name to the original - class with the given parameters would not fail. If it would fail, - raise a MockInterfaceError. - Based on the Python 2.3.3 Reference Manual section 5.3.4: Calls. - """ - if self.realClassMethods is None: - return - if name not in self.realClassMethods: - return - - func = self.realClassMethods[name] - try: - args, varargs, varkw, defaults = inspect.getargspec(func) - except TypeError: - # func is not a Python function. It is probably a builtin, - # such as __repr__ or __coerce__. TODO: Checking? - # For now assume params are OK. - return - - # callParams doesn't include self; args does include self. - numPosCallParams = 1 + len(callParams) - - if numPosCallParams > len(args) and not varargs: - raise MockInterfaceError("Original %s() takes at most %s arguments (%s given)" % - (name, len(args), numPosCallParams)) - - # Get the number of positional arguments that appear in the call, - # also check for duplicate parameters and unknown parameters - numPosSeen = _getNumPosSeenAndCheck(numPosCallParams, callKwParams, args, varkw) - - lenArgsNoDefaults = len(args) - len(defaults or []) - if numPosSeen < lenArgsNoDefaults: - raise MockInterfaceError("Original %s() takes at least %s arguments (%s given)" % (name, lenArgsNoDefaults, numPosSeen)) - - def mockGetAllCalls(self): - """ - Return a list of MockCall objects, - representing all the methods in the order they were called. - """ - return self.mockAllCalledMethods - getAllCalls = mockGetAllCalls # deprecated - kept for backward compatibility - - def mockGetNamedCalls(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, []) - getNamedCalls = mockGetNamedCalls # deprecated - kept for backward compatibility - - def mockCheckCall(self, index, name, *args, **kwargs): - '''test that the index-th call had the specified name and parameters''' - call = self.mockAllCalledMethods[index] - assert name == call.getName(), "%r != %r" % (name, call.getName()) - call.checkArgs(*args, **kwargs) - - -def _getNumPosSeenAndCheck(numPosCallParams, callKwParams, args, varkw): - """ - Positional arguments can appear as call parameters either named as - a named (keyword) parameter, or just as a value to be matched by - position. Count the positional arguments that are given by either - keyword or position, and check for duplicate specifications. - Also check for arguments specified by keyword that do not appear - in the method's parameter list. - """ - posSeen = {} - for arg in args[:numPosCallParams]: - posSeen[arg] = True - for kwp in callKwParams: - if kwp in posSeen: - raise MockInterfaceError("%s appears as both a positional and named parameter." % kwp) - if kwp in args: - posSeen[kwp] = True - elif not varkw: - raise MockInterfaceError("Original method does not have a parameter '%s'" % kwp) - return len(posSeen) - -class MockCall: - """ - MockCall records the name and parameters of a call to an instance - of a Mock class. Instances of MockCall are created by the Mock class, - but can be inspected later as part of the test. - """ - def __init__(self, name, params, kwparams ): - self.name = name - self.params = params - self.kwparams = kwparams - - def checkArgs(self, *args, **kwargs): - assert args == self.params, "%r != %r" % (args, self.params) - assert kwargs == self.kwparams, "%r != %r" % (kwargs, self.kwparams) - - def getParam( self, n ): - if isinstance(n, int): - return self.params[n] - elif isinstance(n, str): - return self.kwparams[n] - else: - raise IndexError('illegal index type for getParam') - - def getNumParams(self): - return len(self.params) - - def getNumKwParams(self): - return len(self.kwparams) - - 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 = ', ' - items = sorted(self.kwparams.items()) - for k, v in items: - s = s + sep + k + '=' + repr(v) - sep = ', ' - s = s + ')' - return s - def __repr__(self): - return self.__str__() - -class MockCallable: - """ - Intercepts the call and records it, then delegates to either the mock's - dictionary of mock return values that was passed in to the constructor, - or a handcrafted method of a Mock subclass. - """ - def __init__(self, name, mock, handcrafted=False): - self.name = name - self.mock = mock - self.handcrafted = handcrafted - - def __call__(self, *params, **kwparams): - self.mock._checkInterfaceCall(self.name, params, kwparams) - thisCall = self.recordCall(params, kwparams) - self.checkExpectations(thisCall, params, kwparams) - return self.makeCall(params, kwparams) - - def recordCall(self, params, kwparams): - """ - Record the MockCall in an ordered list of all calls, and an ordered - list of calls for that method name. - """ - thisCall = MockCall(self.name, params, kwparams) - calls = self.mock.mockCalledMethods.setdefault(self.name, []) - calls.append(thisCall) - self.mock.mockAllCalledMethods.append(thisCall) - return thisCall - - def makeCall(self, params, kwparams): - if self.handcrafted: - allPosParams = (self.mock,) + params - func = _findFunc(self.mock.realClass, self.name) - if not func: - raise NotImplementedError - return func(*allPosParams, **kwparams) - else: - returnVal = self.mock.mockReturnValues.get(self.name) - if isinstance(returnVal, ReturnValuesBase): - returnVal = returnVal.next() - return returnVal - - def checkExpectations(self, thisCall, params, kwparams): - if self.name in self.mock.mockExpectations: - callsMade = len(self.mock.mockCalledMethods[self.name]) - for (expectation, after, until) in self.mock.mockExpectations[self.name]: - if callsMade > after and (until==0 or callsMade < until): - assert expectation(self.mock, thisCall, len(self.mock.mockAllCalledMethods)-1), 'Expectation failed: '+str(thisCall) - - -def _findFunc(cl, name): - """ Depth first search for a method with a given name. """ - if name in cl.__dict__: - return cl.__dict__[name] - for base in cl.__bases__: - func = _findFunc(base, name) - if func: - return func - return None - - - -class ReturnValuesBase: - def next(self): - try: - return self.iter.next() - except StopIteration: - raise AssertionError("No more return values") - def __iter__(self): - return self - -class ReturnValues(ReturnValuesBase): - def __init__(self, *values): - self.iter = iter(values) - - -class ReturnIterator(ReturnValuesBase): - def __init__(self, iterator): - self.iter = iter(iterator) - - -def expectParams(*params, **keywords): - '''check that the callObj is called with specified params and keywords - ''' - def fn(mockObj, callObj, idx): - return callObj.params == params and callObj.kwparams == keywords - return fn - - -def expectAfter(*methods): - '''check that the function is only called after all the functions in 'methods' - ''' - def fn(mockObj, callObj, idx): - calledMethods = [method.getName() for method in mockObj.mockGetAllCalls()] - #skip last entry, since that is the current call - calledMethods = calledMethods[:-1] - for method in methods: - if method not in calledMethods: - return False - return True - return fn - -def expectException(exception, *args, **kwargs): - ''' raise an exception when the method is called - ''' - def fn(mockObj, callObj, idx): - raise exception(*args, **kwargs) - return fn - - -def expectParam(paramIdx, cond): - '''check that the callObj is called with parameter specified by paramIdx (a position index or keyword) - fulfills the condition specified by cond. - cond is a function that takes a single argument, the value to test. - ''' - def fn(mockObj, callObj, idx): - param = callObj.getParam(paramIdx) - return cond(param) - return fn - -def EQ(value): - def testFn(param): - return param == value - return testFn - -def NE(value): - def testFn(param): - return param != value - return testFn - -def GT(value): - def testFn(param): - return param > value - return testFn - -def LT(value): - def testFn(param): - return param < value - return testFn - -def GE(value): - def testFn(param): - return param >= value - return testFn - -def LE(value): - def testFn(param): - return param <= value - return testFn - -def AND(*condlist): - def testFn(param): - for cond in condlist: - if not cond(param): - return False - return True - return testFn - -def OR(*condlist): - def testFn(param): - for cond in condlist: - if cond(param): - return True - return False - return testFn - -def NOT(cond): - def testFn(param): - return not cond(param) - return testFn - -def MATCHES(regex, *args, **kwargs): - compiled_regex = re.compile(regex, *args, **kwargs) - def testFn(param): - return compiled_regex.match(param) is not None - return testFn - -def SEQ(*sequence): - iterator = iter(sequence) - def testFn(param): - try: - cond = iterator.next() - except StopIteration: - raise AssertionError('SEQ exhausted') - return cond(param) - return testFn - -def IS(instance): - def testFn(param): - return param is instance - return testFn - -def ISINSTANCE(class_): - def testFn(param): - return isinstance(param, class_) - return testFn - -def ISSUBCLASS(class_): - def testFn(param): - return issubclass(param, class_) - return testFn - -def CONTAINS(val): - def testFn(param): - return val in param - return testFn - -def IN(container): - def testFn(param): - return param in container - return testFn - -def HASATTR(attr): - def testFn(param): - return hasattr(param, attr) - return testFn - -def HASMETHOD(method): - def testFn(param): - return hasattr(param, method) and callable(getattr(param, method)) - return testFn - -CALLABLE = callable diff --git a/test/lib/xmpp_mocks.py b/test/lib/xmpp_mocks.py index e461d10..0e97313 100644 --- a/test/lib/xmpp_mocks.py +++ b/test/lib/xmpp_mocks.py @@ -4,7 +4,7 @@ Module with dummy classes for unit testing of XMPP and related code. import threading, time -from test.lib.mock import Mock +from unittest.mock import Mock from nbxmpp import idlequeue diff --git a/test/unit/test_xmpp_client_nb.py b/test/unit/test_xmpp_client_nb.py index 478cf07..8a8cb7b 100644 --- a/test/unit/test_xmpp_client_nb.py +++ b/test/unit/test_xmpp_client_nb.py @@ -5,9 +5,10 @@ It actually connects to a xmpp server. ''' import unittest +from unittest.mock import Mock from test.lib.xmpp_mocks import MockConnection, IdleQueueThread -from test.lib.mock import Mock + from nbxmpp import client_nb # (XMPP server hostname, c2s port). Script will connect to the machine. @@ -56,7 +57,7 @@ class TestNonBlockingClient(unittest.TestCase): self.client = client_nb.NonBlockingClient( domain=server_port[0], idlequeue=self.idlequeue_thread.iq, - caller=Mock(realClass=TempConnection)) + caller=Mock(spec=TempConnection)) self.client.connect( hostname=server_port[0], diff --git a/test/unit/test_xmpp_dispatcher_nb.py b/test/unit/test_xmpp_dispatcher_nb.py index 2156781..dfd0b52 100644 --- a/test/unit/test_xmpp_dispatcher_nb.py +++ b/test/unit/test_xmpp_dispatcher_nb.py @@ -19,7 +19,6 @@ class TestDispatcherNB(unittest.TestCase): # Setup mock client self.client = Mock() - self.client._caller = Mock() self.client.defaultNamespace = protocol.NS_CLIENT self.client.Connection = Mock() # mock transport self.con = self.client.Connection |