http://code.google.com/p/pymox/source/detail?r=72

Modified:
  /trunk/mox.py
  /trunk/mox_test.py

=======================================
--- /trunk/mox.py       Tue Jun 28 07:27:07 2011
+++ /trunk/mox.py       Tue May  1 13:43:51 2012
@@ -224,6 +224,30 @@
      return error

+class SwallowedExceptionError(Error):
+  """Raised when Verify() is called after something already threw an  
exception.
+
+  This means that the exception that was thrown was somehow swallowed,  
allowing
+  the test to continue when it should not have.
+  """
+
+  def __init__(self, previous_exceptions):
+    """Init exception.
+
+    Args:
+      # previous_exceptions: A sequence of Error objects that were raised.
+      previous_exceptions: [Error]
+    """
+
+    Error.__init__(self)
+    self._previous_exceptions = previous_exceptions
+
+  def __str__(self):
+    exceptions = "\n".join(["%3d.  %s: %s" % (i, e.__class__.__name__, e)
+                            for i, e in  
enumerate(self._previous_exceptions)])
+    return "Previous exceptions thrown:\n%s" % (exceptions,)
+
+
  class Mox(object):
    """Mox: a factory for creating mock objects."""

@@ -426,8 +450,18 @@
          created, for debugging output purposes.
      """
      self._description = description
+    self._exceptions_thrown = []
      self._Reset()

+  def __bases__(self):
+    pass
+
+  def __members__(self):
+    pass
+
+  def __methods__(self):
+    pass
+
    def __repr__(self):
      if self._description:
        return '<MockAnything instance of %s>' % self._description
@@ -467,7 +501,8 @@
      """

      return MockMethod(method_name, self._expected_calls_queue,
-                      self._replay_mode, method_to_mock=method_to_mock,
+                      self._exceptions_thrown, self._replay_mode,
+                      method_to_mock=method_to_mock,
                        description=self._description)

    def __nonzero__(self):
@@ -498,8 +533,15 @@
      Raises:
        ExpectedMethodCallsError: if there are still more method calls in the
          expected queue.
+      any exception previously raised by this object: if _Verify was called
+      afterwards anyway.  (This detects tests passing erroneously.)
      """

+    # If any exceptions were thrown, re-raise them.  (This should only  
happen
+    # if the original exception was swallowed, in which case it's  
necessary to
+    # re-raise it so that the test will fail.  See Issue #16.)
+    if self._exceptions_thrown:
+      raise SwallowedExceptionError(self._exceptions_thrown)
      # If the list of expected calls is not empty, raise an exception
      if self._expected_calls_queue:
        # The last MultipleTimesGroup is not popped from the queue.
@@ -610,7 +652,9 @@
            name,
            method_to_mock=getattr(self._class_to_mock, name))

-    raise UnknownMethodCallError(name)
+    exception = UnknownMethodCallError(name)
+    self._exceptions_thrown.append(exception)
+    raise exception

    def __eq__(self, rhs):
      """Provide custom logic to compare objects."""
@@ -644,7 +688,7 @@
      # If we are in replay mode then simply call the mock __setitem__  
method.
      if self._replay_mode:
        return MockMethod('__setitem__', self._expected_calls_queue,
-                        self._replay_mode)(key, value)
+                        self._exceptions_thrown, self._replay_mode)(key,  
value)

      # Otherwise, create a mock method __setitem__.
@@ -673,7 +717,7 @@
      # If we are in replay mode then simply call the mock __getitem__  
method.
      if self._replay_mode:
        return MockMethod('__getitem__', self._expected_calls_queue,
-                        self._replay_mode)(key)
+                        self._exceptions_thrown, self._replay_mode)(key)

      # Otherwise, create a mock method __getitem__.
@@ -713,7 +757,7 @@
      # If we are in replay mode then simply call the mock __iter__ method.
      if self._replay_mode:
        return MockMethod('__iter__', self._expected_calls_queue,
-                        self._replay_mode)()
+                        self._exceptions_thrown, self._replay_mode)()

      # Otherwise, create a mock method __iter__.
@@ -743,7 +787,7 @@

      if self._replay_mode:
        return MockMethod('__contains__', self._expected_calls_queue,
-                        self._replay_mode)(key)
+                        self._exceptions_thrown, self._replay_mode)(key)

      return self._CreateMockMethod('__contains__')(key)

@@ -809,8 +853,10 @@

      if self._replay_mode:
        if not self._instance_queue:
-        raise UnexpectedMockCreationError(self._class_to_mock, *params,
-                                          **named_params)
+        exception = UnexpectedMockCreationError(self._class_to_mock,  
*params,
+                                                **named_params)
+        self._exceptions_thrown.append(exception)
+        raise exception

        mock_method(*params, **named_params)

@@ -967,7 +1013,7 @@
    signature) matches the expected method.
    """

-  def __init__(self, method_name, call_queue, replay_mode,
+  def __init__(self, method_name, call_queue, exception_list, replay_mode,
                 method_to_mock=None, description=None):
      """Construct a new mock method.

@@ -975,6 +1021,8 @@
        # method_name: the name of the method
        # call_queue: deque of calls, verify this call against the head, or  
add
        #     this call to the queue.
+      # exception_list: list of exceptions; any exceptions thrown by this
+      #     instance are appended to this list.
        # replay_mode: False if we are recording, True if we are verifying  
calls
        #     against the call queue.
        # method_to_mock: The actual method being mocked, used for  
introspection.
@@ -982,6 +1030,7 @@
        #     this is equal to the descriptive name of the method's class.
        method_name: str
        call_queue: list or deque
+      exception_list: list
        replay_mode: bool
        method_to_mock: a method object
        description: str or None
@@ -992,6 +1041,7 @@
      self._call_queue = call_queue
      if not isinstance(call_queue, deque):
        self._call_queue = deque(self._call_queue)
+    self._exception_list = exception_list
      self._replay_mode = replay_mode
      self._description = description

@@ -1061,7 +1111,9 @@
      try:
        return self._call_queue.popleft()
      except IndexError:
-      raise UnexpectedMethodCallError(self, None)
+      exception = UnexpectedMethodCallError(self, None)
+      self._exception_list.append(exception)
+      raise exception

    def _VerifyMethodCall(self):
      """Verify the called method is expected.
@@ -1086,7 +1138,9 @@

      # This is a mock method, so just check equality.
      if expected != self:
-      raise UnexpectedMethodCallError(self, expected)
+      exception = UnexpectedMethodCallError(self, expected)
+      self._exception_list.append(exception)
+      raise exception

      return expected

@@ -1158,7 +1212,7 @@
        return self

      # Create a new group and add the method.
-    new_group = group_class(group_name)
+    new_group = group_class(group_name, self._exception_list)
      new_group.AddMethod(self)
      self._call_queue.append(new_group)
      return self
@@ -1831,8 +1885,18 @@
  class MethodGroup(object):
    """Base class containing common behaviour for MethodGroups."""

-  def __init__(self, group_name):
+  def __init__(self, group_name, exception_list):
+    """Construct a new method group.
+
+    Args:
+      # group_name: the name of the method group
+      # exception_list: list of exceptions; any exceptions thrown by this
+      #     instance are appended to this list.
+      group_name: str
+      exception_list: list
+    """
      self._group_name = group_name
+    self._exception_list = exception_list

    def group_name(self):
      return self._group_name
@@ -1856,8 +1920,8 @@
    over the keys of a dict.
    """

-  def __init__(self, group_name):
-    super(UnorderedGroup, self).__init__(group_name)
+  def __init__(self, group_name, exception_list):
+    super(UnorderedGroup, self).__init__(group_name, exception_list)
      self._methods = []

    def __str__(self):
@@ -1907,7 +1971,9 @@

          return self, method

-    raise UnexpectedMethodCallError(mock_method, self)
+    exception = UnexpectedMethodCallError(mock_method, self)
+    self._exception_list.append(exception)
+    raise exception

    def IsSatisfied(self):
      """Return True if there are not any methods in this group."""
@@ -1923,8 +1989,8 @@
    This is helpful, if you don't know or care how many times a method is  
called.
    """

-  def __init__(self, group_name):
-    super(MultipleTimesGroup, self).__init__(group_name)
+  def __init__(self, group_name, exception_list):
+    super(MultipleTimesGroup, self).__init__(group_name, exception_list)
      self._methods = set()
      self._methods_left = set()

@@ -1968,7 +2034,9 @@
        next_method = mock_method._PopNextMethod();
        return next_method, None
      else:
-      raise UnexpectedMethodCallError(mock_method, self)
+      exception = UnexpectedMethodCallError(mock_method, self)
+      self._exception_list.append(exception)
+      raise exception

    def IsSatisfied(self):
      """Return True if all methods in this group are called at least  
once."""
=======================================
--- /trunk/mox_test.py  Tue Jun 28 07:27:07 2011
+++ /trunk/mox_test.py  Tue May  1 13:43:51 2012
@@ -33,7 +33,7 @@
      self.assertRaises(ValueError, mox.ExpectedMethodCallsError, [])

    def testOneError(self):
-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method(1, 2).AndReturn('output')
      e = mox.ExpectedMethodCallsError([method])
      self.assertEqual(
@@ -42,13 +42,13 @@
          str(e))

    def testManyErrors(self):
-    method1 = mox.MockMethod("testMethod", [], False)
+    method1 = mox.MockMethod("testMethod", [], [], False)
      method1(1, 2).AndReturn('output')
-    method2 = mox.MockMethod("testMethod", [], False)
+    method2 = mox.MockMethod("testMethod", [], [], False)
      method2(a=1, b=2, c="only named")
-    method3 = mox.MockMethod("testMethod2", [], False)
+    method3 = mox.MockMethod("testMethod2", [], [], False)
      method3().AndReturn(44)
-    method4 = mox.MockMethod("testMethod", [], False)
+    method4 = mox.MockMethod("testMethod", [], [], False)
      method4(1, 2).AndReturn('output')
      e = mox.ExpectedMethodCallsError([method1, method2, method3, method4])
      self.assertEqual(
@@ -457,8 +457,9 @@
    """Test class to verify that the MockMethod class is working  
correctly."""

    def setUp(self):
-    self.expected_method = mox.MockMethod("testMethod", [],  
False)(['original'])
-    self.mock_method = mox.MockMethod("testMethod", [self.expected_method],
+    self.expected_method = mox.MockMethod("testMethod", [], [], False)(
+        ['original'])
+    self.mock_method = mox.MockMethod("testMethod",  
[self.expected_method], [],
                                          True)

    def testNameAttribute(self):
@@ -523,18 +524,18 @@

    def testEqualityNoParamsEqual(self):
      """Methods with the same name and without params should be equal."""
-    expected_method = mox.MockMethod("testMethod", [], False)
+    expected_method = mox.MockMethod("testMethod", [], [], False)
      self.assertEqual(self.mock_method, expected_method)

    def testEqualityNoParamsNotEqual(self):
      """Methods with different names and without params should not be  
equal."""
-    expected_method = mox.MockMethod("otherMethod", [], False)
+    expected_method = mox.MockMethod("otherMethod", [], [], False)
      self.failIfEqual(self.mock_method, expected_method)

    def testEqualityParamsEqual(self):
      """Methods with the same name and parameters should be equal."""
      params = [1, 2, 3]
-    expected_method = mox.MockMethod("testMethod", [], False)
+    expected_method = mox.MockMethod("testMethod", [], [], False)
      expected_method._params = params

      self.mock_method._params = params
@@ -542,7 +543,7 @@

    def testEqualityParamsNotEqual(self):
      """Methods with the same name and different params should not be  
equal."""
-    expected_method = mox.MockMethod("testMethod", [], False)
+    expected_method = mox.MockMethod("testMethod", [], [], False)
      expected_method._params = [1, 2, 3]

      self.mock_method._params = ['a', 'b', 'c']
@@ -551,7 +552,7 @@
    def testEqualityNamedParamsEqual(self):
      """Methods with the same name and same named params should be equal."""
      named_params = {"input1": "test", "input2": "params"}
-    expected_method = mox.MockMethod("testMethod", [], False)
+    expected_method = mox.MockMethod("testMethod", [], [], False)
      expected_method._named_params = named_params

      self.mock_method._named_params = named_params
@@ -559,7 +560,7 @@

    def testEqualityNamedParamsNotEqual(self):
      """Methods with the same name and diffnamed params should not be  
equal."""
-    expected_method = mox.MockMethod("testMethod", [], False)
+    expected_method = mox.MockMethod("testMethod", [], [], False)
      expected_method._named_params = {"input1": "test", "input2": "params"}

      self.mock_method._named_params =  
{"input1": "test2", "input2": "params2"}
@@ -575,39 +576,39 @@
      instB = TestClass();

      params = [instA, ]
-    expected_method = mox.MockMethod("testMethod", [], False)
+    expected_method = mox.MockMethod("testMethod", [], [], False)
      expected_method._params = params

      self.mock_method._params = [instB, ]
      self.assertEqual(self.mock_method, expected_method)

    def testStrConversion(self):
-    method = mox.MockMethod("f", [], False)
+    method = mox.MockMethod("f", [], [], False)
      method(1, 2, "st", n1=8, n2="st2")
      self.assertEqual(str(method), ("f(1, 2, 'st', n1=8, n2='st2') ->  
None"))

-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method(1, 2, "only positional")
      self.assertEqual(str(method), "testMethod(1, 2, 'only positional') ->  
None")

-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method(a=1, b=2, c="only named")
      self.assertEqual(str(method),
                       "testMethod(a=1, b=2, c='only named') -> None")

-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method()
      self.assertEqual(str(method), "testMethod() -> None")

-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method(x="only 1 parameter")
      self.assertEqual(str(method), "testMethod(x='only 1 parameter') ->  
None")

-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method().AndReturn('return_value')
      self.assertEqual(str(method), "testMethod() -> 'return_value'")

-    method = mox.MockMethod("testMethod", [], False)
+    method = mox.MockMethod("testMethod", [], [], False)
      method().AndReturn(('a', {1: 2}))
      self.assertEqual(str(method), "testMethod() -> ('a', {1: 2})")

@@ -746,7 +747,7 @@
    """Tests MockMethod's use of MethodChecker method."""

    def testNoParameters(self):
-    method = mox.MockMethod('NoParameters', [], False,
+    method = mox.MockMethod('NoParameters', [], [], False,
                              CheckCallTestClass.NoParameters)
      method()
      self.assertRaises(AttributeError, method, 1)
@@ -755,7 +756,7 @@
      self.assertRaises(AttributeError, method, 1, b=2)

    def testOneParameter(self):
-    method = mox.MockMethod('OneParameter', [], False,
+    method = mox.MockMethod('OneParameter', [], [], False,
                              CheckCallTestClass.OneParameter)
      self.assertRaises(AttributeError, method)
      method(1)
@@ -766,7 +767,7 @@
      self.assertRaises(AttributeError, method, 1, b=2)

    def testTwoParameters(self):
-    method = mox.MockMethod('TwoParameters', [], False,
+    method = mox.MockMethod('TwoParameters', [], [], False,
                              CheckCallTestClass.TwoParameters)
      self.assertRaises(AttributeError, method)
      self.assertRaises(AttributeError, method, 1)
@@ -783,7 +784,7 @@
      self.assertRaises(AttributeError, method, 3, a=1, b=2)

    def testOneDefaultValue(self):
-    method = mox.MockMethod('OneDefaultValue', [], False,
+    method = mox.MockMethod('OneDefaultValue', [], [], False,
                              CheckCallTestClass.OneDefaultValue)
      method()
      method(1)
@@ -794,7 +795,7 @@
      self.assertRaises(AttributeError, method, 1, b=2)

    def testTwoDefaultValues(self):
-    method = mox.MockMethod('TwoDefaultValues', [], False,
+    method = mox.MockMethod('TwoDefaultValues', [], [], False,
                              CheckCallTestClass.TwoDefaultValues)
      self.assertRaises(AttributeError, method)
      self.assertRaises(AttributeError, method, c=3)
@@ -814,7 +815,7 @@
      self.assertRaises(AttributeError, method, a=1, b=2, e=9)

    def testArgs(self):
-    method = mox.MockMethod('Args', [], False, CheckCallTestClass.Args)
+    method = mox.MockMethod('Args', [], [], False, CheckCallTestClass.Args)
      self.assertRaises(AttributeError, method)
      self.assertRaises(AttributeError, method, 1)
      method(1, 2)
@@ -825,7 +826,7 @@
      self.assertRaises(AttributeError, method, 1, 2, c=3)

    def testKwargs(self):
-    method = mox.MockMethod('Kwargs', [], False, CheckCallTestClass.Kwargs)
+    method = mox.MockMethod('Kwargs', [], [], False,  
CheckCallTestClass.Kwargs)
      self.assertRaises(AttributeError, method)
      method(1)
      method(1, 2)
@@ -840,7 +841,7 @@
      self.assertRaises(AttributeError, method, 1, 2, 3, 4)

    def testArgsAndKwargs(self):
-    method = mox.MockMethod('ArgsAndKwargs', [], False,
+    method = mox.MockMethod('ArgsAndKwargs', [], [], False,
                              CheckCallTestClass.ArgsAndKwargs)
      self.assertRaises(AttributeError, method)
      method(1)
@@ -1031,7 +1032,7 @@

      self.assertRaises(mox.UnexpectedMethodCallError, call)

-    dummy._Verify()
+    self.assertRaises(mox.SwallowedExceptionError, dummy._Verify)

    def testMockSetItem_WithSubClassOfNewStyleClass(self):
      class NewStyleTestClass(object):
@@ -1099,7 +1100,7 @@

      self.assertRaises(mox.UnexpectedMethodCallError, call)

-    dummy._Verify()
+    self.assertRaises(mox.SwallowedExceptionError, dummy._Verify)

    def testMockGetItem_WithSubClassOfNewStyleClass(self):
      class NewStyleTestClass(object):
@@ -1169,7 +1170,7 @@

      self.assertRaises(mox.UnexpectedMethodCallError, call)

-    dummy._Verify()
+    self.assertRaises(mox.SwallowedExceptionError, dummy._Verify)

    def testMockIter_ExpectedIter_NoSuccess(self):
      """Test that __iter__() gets mocked in Dummy.
@@ -1711,7 +1712,7 @@
      self.assertRaises(mox.UnexpectedMethodCallError,
                        TestClass.OtherValidCall, "wrong self")

-    self.mox.VerifyAll()
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
      self.mox.UnsetStubs()

    def testStubOutMethod_Unbound_NamedUsingPositional(self):
@@ -2001,6 +2002,118 @@
        self.assertEquals('MockMethod has no attribute "ShowMeTheMoney". '
            'Did you remember to put your mocks in replay mode?', str(e))

+  def testSwallowedUnknownMethodCall(self):
+    """Test that a swallowed UnknownMethodCallError will be re-raised."""
+    dummy = self.mox.CreateMock(TestClass)
+    dummy._Replay()
+
+    def call():
+      try:
+        dummy.InvalidCall()
+      except mox.UnknownMethodCallError:
+        pass
+
+    # UnknownMethodCallError swallowed
+    call()
+
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
+
+  def testSwallowedUnexpectedMockCreation(self):
+    """Test that a swallowed UnexpectedMockCreationError will be  
re-raised."""
+    self.mox.StubOutClassWithMocks(mox_test_helper, 'CallableClass')
+    self.mox.ReplayAll()
+
+    def call():
+      try:
+        mox_test_helper.CallableClass(1, 2)
+      except mox.UnexpectedMockCreationError:
+        pass
+
+    # UnexpectedMockCreationError swallowed
+    call()
+
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
+    self.mox.UnsetStubs()
+
+  def testSwallowedUnexpectedMethodCall_WrongMethod(self):
+    """Test that a swallowed UnexpectedMethodCallError will be re-raised.
+
+    This case is an extraneous method call."""
+    mock_obj = self.mox.CreateMockAnything()
+    mock_obj.Open()
+    self.mox.ReplayAll()
+
+    def call():
+      mock_obj.Open()
+      try:
+        mock_obj.Close()
+      except mox.UnexpectedMethodCallError:
+        pass
+
+    # UnexpectedMethodCall swallowed
+    call()
+
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
+
+  def testSwallowedUnexpectedMethodCall_WrongArguments(self):
+    """Test that a swallowed UnexpectedMethodCallError will be re-raised.
+
+    This case is an extraneous method call."""
+    mock_obj = self.mox.CreateMockAnything()
+    mock_obj.Open()
+    self.mox.ReplayAll()
+
+    def call():
+      try:
+        mock_obj.Open(1)
+      except mox.UnexpectedMethodCallError:
+        pass
+
+    # UnexpectedMethodCall swallowed
+    call()
+
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
+
+  def testSwallowedUnexpectedMethodCall_UnorderedGroup(self):
+    """Test that a swallowed UnexpectedMethodCallError will be re-raised.
+
+    This case is an extraneous method call in an unordered group."""
+    mock_obj = self.mox.CreateMockAnything()
+    mock_obj.Open().InAnyOrder()
+    mock_obj.Close().InAnyOrder()
+    self.mox.ReplayAll()
+
+    def call():
+      mock_obj.Close()
+      try:
+        mock_obj.Open(1)
+      except mox.UnexpectedMethodCallError:
+        pass
+
+    # UnexpectedMethodCall swallowed
+    call()
+
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
+
+  def testSwallowedUnexpectedMethodCall_MultipleTimesGroup(self):
+    """Test that a swallowed UnexpectedMethodCallError will be re-raised.
+
+    This case is an extraneous method call in a multiple times group."""
+    mock_obj = self.mox.CreateMockAnything()
+    mock_obj.Open().MultipleTimes()
+    self.mox.ReplayAll()
+
+    def call():
+      try:
+        mock_obj.Open(1)
+      except mox.UnexpectedMethodCallError:
+        pass
+
+    # UnexpectedMethodCall swallowed
+    call()
+
+    self.assertRaises(mox.SwallowedExceptionError, self.mox.VerifyAll)
+

  class ReplayTest(unittest.TestCase):
    """Verify Replay works properly."""