From 8be1bd09e650fa33564bfd03f555c8088f164563 Mon Sep 17 00:00:00 2001
From: jmalonzo <jmalonzo@141a2093-ea25-0410-9ad2-d44d734a8f13>
Date: Tue, 24 Jul 2007 09:31:10 +0000
Subject: [PATCH] added nose config and mock objects library as well as summary
 items test

git-svn-id: svn+ssh://svn.gnome.org/svn/straw/trunk@307 141a2093-ea25-0410-9ad2-d44d734a8f13
---
 nose.cfg           |   2 +
 test/mock.py       | 465 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 test/test_items.py |  37 +++++
 3 files changed, 504 insertions(+)
 create mode 100644 nose.cfg
 create mode 100644 test/mock.py
 create mode 100644 test/test_items.py

diff --git a/nose.cfg b/nose.cfg
new file mode 100644
index 0000000..61fd903
--- /dev/null
+++ b/nose.cfg
@@ -0,0 +1,2 @@
+[nosetests]
+verbose=3
diff --git a/test/mock.py b/test/mock.py
new file mode 100644
index 0000000..7c20056
--- /dev/null
+++ b/test/mock.py
@@ -0,0 +1,465 @@
+#
+# (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
+# 
+#     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:
+    """
+    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.realClassMethods = None
+        if realClass:
+            self.realClassMethods = dict(inspect.getmembers(realClass, inspect.isroutine))
+            for retMethod in self.mockReturnValues.keys():
+                if not self.realClassMethods.has_key(retMethod):
+                    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.__class__,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 == None:
+            return
+        if not self.realClassMethods.has_key(name):
+            raise MockInterfaceError("Calling mock method '%s' that was not found in the original class" % name)
+
+        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 posSeen.has_key(kwp):
+            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 = self.kwparams.items()
+        items.sort()
+        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.__class__, 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 cl.__dict__.has_key(name):
+        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) != 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/test_items.py b/test/test_items.py
new file mode 100644
index 0000000..41c20dc
--- /dev/null
+++ b/test/test_items.py
@@ -0,0 +1,37 @@
+
+import pygtk
+import gobject
+from mock import Mock
+import nose
+from SummaryItem import SummaryItem
+
+
+class TestSummaryItem:
+    def setUp(self):
+        mock = Mock( {
+                'add_refer': None,
+                '__nonzero__' : 1
+                })
+        self.summaryItem = SummaryItem(mock)
+
+    def tearDown(self):
+        self.summaryItem = None
+        mock = None
+
+    def test_seen(self):
+        def _cb(*args): assert True
+        self.summaryItem.connect('read', _cb)
+        self.summaryItem.seen = True
+        assert self.summaryItem.seen is True
+
+    def test_sticky(self):
+        def _cb(*args): assert True
+        self.summaryItem.connect('sticky', _cb)
+        self.summaryItem.sticky = True
+        assert self.summaryItem.sticky is True
+        self.summaryItem.sticky = False
+        assert self.summaryItem.sticky is False
+
+    def test_id(self):
+        self.summaryItem.id = 1
+        assert summaryItem.id is 1
-- 
2.11.4.GIT