Return exception in failUnlessRaises, test it.

2 files changed, 59 insertions, 0 deletions

diff --git a/mocker.py b/mocker.py
index 3b24111..9304398 100644
--- a/mocker.py
+++ b/mocker.py
@@ -293,6 +293,27 @@ class MockerTestCase(unittest.TestCase):
                     (first.__name__, name, first_formatted,
                      second.__name__, name, second_formatted))
 
+    def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):
+        """
+        Fail unless an exception of class excClass is thrown by callableObj
+        when invoked with arguments args and keyword arguments kwargs. If a
+        different type of exception is thrown, it will not be caught, and the
+        test case will be deemed to have suffered an error, exactly as for an
+        unexpected exception. It returns the exception instance if it matches
+        the given exception class.
+        """
+        try:
+            result = callableObj(*args, **kwargs)
+        except excClass, e:
+            return e
+        else:
+            if hasattr(excClass, "__name__"):
+                excName = excClass.__name__
+            else:
+                excName = str(excClass)
+            raise self.failureException(
+                "%s not raised (%r returned)" % (excName, result))
+
 
     assertIs = failUnlessIs
     assertIsNot = failIfIs
@@ -305,6 +326,7 @@ class MockerTestCase(unittest.TestCase):
     assertApproximates = failUnlessApproximates
     assertNotApproximates = failIfApproximates
     assertMethodsMatch = failUnlessMethodsMatch
+    assertRaises = failUnlessRaises
 
     # The following are missing in Python < 2.4.
     assertTrue = unittest.TestCase.failUnless
diff --git a/test.py b/test.py
index e98acb8..d48bc11 100755
--- a/test.py
+++ b/test.py
@@ -767,6 +767,40 @@ class MockerTestCaseTest(TestCase):
         except AssertionError:
             self.fail("AssertionError shouldn't be raised")
 
+    def test_fail_unless_raises_succeeds(self):
+        class MyException(Exception):
+            pass
+        def f(*args):
+            raise MyException(*args)
+        error = self.test.failUnlessRaises(MyException, f, 1, "foo")
+        self.assertEquals(error.args, (1, "foo"))
+
+    def test_fail_unless_raises_error(self):
+        def f(*args):
+            return args
+        try:
+            self.test.failUnlessRaises(ValueError, f, 1, "foo")
+        except AssertionError, e:
+            self.assertEquals(
+                str(e),
+                "ValueError not raised ((1, 'foo') returned)")
+        else:
+            self.fail("AssertionError not raised")
+
+    def test_fail_unless_raises_other_exception(self):
+        class MyException1(Exception):
+            pass
+        class MyException2(Exception):
+            pass
+        def f(*args):
+            raise MyException2(*args)
+        try:
+            self.test.failUnlessRaises(MyException1, f, 1, "foo")
+        except MyException2:
+            pass
+        else:
+            self.fail("MyException2 not raised")
+
     def test_aliases(self):
         get_method = MockerTestCase.__dict__.get
 
@@ -803,6 +837,9 @@ class MockerTestCaseTest(TestCase):
         self.assertEquals(get_method("assertMethodsMatch"),
                           get_method("failUnlessMethodsMatch"))
 
+        self.assertEquals(get_method("assertRaises"),
+                          get_method("failUnlessRaises"))
+
     def test_twisted_trial_aliases(self):
         get_method = MockerTestCase.__dict__.get