Merge lp:~jml/testtools/assert-raises-lambda into lp:~testtools-committers/testtools/trunk

[Jonathan Lange]

When assertRaises currently fails, it doesn't mention the callable that it was invoked with. Instead it mentions a lambda that we make up in order to be able to re-use the Raises matcher.

This patch addresses this problem by using a wrapper object instead of a lambda. The wrapper object is a nullary callable and has a custom __repr__ method that forwards to the callable that assertRaises was invoked with.

[lp:~jml/testtools/assert-raises-lambda]

239. By Jonathan Lange on 2012-01-28

NEWS update

240. By Jonathan Lange on 2012-01-28

Format properly

[Jonathan Lange (jml)]

Note that this is the sort of thing that's likely to trip up with cross-Python compatibility – I've only tested on Python 2.7.

We need to make sure that trunk passes on all supported Pythons before releasing.

[Robert Collins (lifeless)]

This will certainly work. Its a bit sad that folk using lambda's directly won't get the benefit. Perhaps the wrapper should be a public helper? [short of introspecting lambdas...

review: Approve

[lp:~jml/testtools/assert-raises-lambda]

241. By Jonathan Lange on 2012-01-29

Extract Nullary and move it into helpers.

242. By Jonathan Lange on 2012-01-29

Move to testcase so it doesn't appear in stack traces.

243. By Jonathan Lange on 2012-01-29

In the NEWS

244. By Jonathan Lange on 2012-01-29

Document

=== modified file 'NEWS'
--- NEWS	2012-01-10 17:59:27 +0000
+++ NEWS	2012-01-29 14:12:23 +0000
@@ -21,6 +21,9 @@
   previous release promised clean stack, but now we actually provide it.
   (Jonathan Lange, #854769)
 
+* ``assertRaises`` now includes the ``repr`` of the callable that failed to raise
+  properly. (Jonathan Lange, #881052)
+
 * Failed equality assertions now line up. (Jonathan Lange, #879339)
 
 * ``MatchesAll`` and ``MatchesListwise`` both take a ``first_only`` keyword
@@ -28,6 +31,9 @@
   and not continue looking for other possible mismatches.
   (Jonathan Lange)
 
+* New helper, ``Nullary`` that turns callables with arguments into ones that
+  don't take arguments.  (Jonathan Lange)
+
 * New matchers:
 
   * ``DirContains`` matches the contents of a directory.

=== modified file 'doc/for-test-authors.rst'
--- doc/for-test-authors.rst	2011-12-07 11:32:45 +0000
+++ doc/for-test-authors.rst	2012-01-29 14:12:23 +0000
@@ -1322,6 +1322,27 @@
 particular attribute.
 
 
+Nullary callables
+-----------------
+
+Sometimes you want to be able to pass around a function with the arguments
+already specified.  The normal way of doing this in Python is::
+
+  nullary = lambda: f(*args, **kwargs)
+  nullary()
+
+Which is mostly good enough, but loses a bit of debugging information.  If you
+take the ``repr()`` of ``nullary``, you're only told that it's a lambda, and
+you get none of the juicy meaning that you'd get from the ``repr()`` of ``f``.
+
+The solution is to use ``Nullary`` instead::
+
+  nullary = Nullary(f, *args, **kwargs)
+  nullary()
+
+Here, ``repr(nullary)`` will be the same as ``repr(f)``.
+
+
 .. _testrepository: https://launchpad.net/testrepository
 .. _Trial: http://twistedmatrix.com/documents/current/core/howto/testing.html
 .. _nose: http://somethingaboutorange.com/mrl/projects/nose/

=== modified file 'testtools/testcase.py'
--- testtools/testcase.py	2011-12-05 15:21:33 +0000
+++ testtools/testcase.py	2012-01-29 14:12:23 +0000
@@ -384,8 +384,8 @@
         capture = CaptureMatchee()
         matcher = Raises(MatchesAll(ReRaiseOtherTypes(),
                 MatchesException(excClass), capture))
-
-        self.assertThat(lambda: callableObj(*args, **kwargs), matcher)
+        our_callable = Nullary(callableObj, *args, **kwargs)
+        self.assertThat(our_callable, matcher)
         return capture.matchee
     failUnlessRaises = assertRaises
 
@@ -777,6 +777,25 @@
         return True
 
 
+class Nullary(object):
+    """Turn a callable into a nullary callable.
+
+    The advantage of this over ``lambda: f(*args, **kwargs)`` is that it
+    preserves the ``repr()`` of ``f``.
+    """
+
+    def __init__(self, callable_object, *args, **kwargs):
+        self._callable_object = callable_object
+        self._args = args
+        self._kwargs = kwargs
+
+    def __call__(self):
+        return self._callable_object(*self._args, **self._kwargs)
+
+    def __repr__(self):
+        return repr(self._callable_object)
+
+
 # Signal that this is part of the testing framework, and that code from this
 # should not normally appear in tracebacks.
 __unittest = True

=== modified file 'testtools/tests/test_testcase.py'
--- testtools/tests/test_testcase.py	2011-10-30 16:27:05 +0000
+++ testtools/tests/test_testcase.py	2012-01-29 14:12:23 +0000
@@ -25,11 +25,13 @@
     )
 from testtools.matchers import (
     Annotate,
+    Contains,
     DocTestMatches,
     Equals,
     MatchesException,
     Raises,
     )
+from testtools.testcase import Nullary
 from testtools.testresult.doubles import (
     Python26TestResult,
     Python27TestResult,
@@ -309,6 +311,17 @@
         self.assertFails('<function <lambda> at ...> returned None',
             self.assertRaises, expectedExceptions, lambda: None)
 
+    def test_assertRaises_function_repr_in_exception(self):
+        # When assertRaises fails, it includes the repr of the invoked
+        # function in the error message, so it's easy to locate the problem.
+        def foo():
+            """An arbitrary function."""
+            pass
+        self.assertThat(
+            lambda: self.assertRaises(Exception, foo),
+            Raises(
+                MatchesException(self.failureException, '.*%r.*' % (foo,))))
+
     def assertFails(self, message, function, *args, **kwargs):
         """Assert that function raises a failure with the given message."""
         failure = self.assertRaises(
@@ -1283,6 +1296,38 @@
         self.assertTrue(test.teardown_called)
 
 
+class TestNullary(TestCase):
+
+    def test_repr(self):
+        # The repr() of nullary is the same as the repr() of the wrapped
+        # function.
+        def foo():
+            pass
+        wrapped = Nullary(foo)
+        self.assertEqual(repr(wrapped), repr(foo))
+
+    def test_called_with_arguments(self):
+        # The function is called with the arguments given to Nullary's
+        # constructor.
+        l = []
+        def foo(*args, **kwargs):
+            l.append((args, kwargs))
+        wrapped = Nullary(foo, 1, 2, a="b")
+        wrapped()
+        self.assertEqual(l, [((1, 2), {'a': 'b'})])
+
+    def test_returns_wrapped(self):
+        # Calling Nullary returns whatever the function returns.
+        ret = object()
+        wrapped = Nullary(lambda: ret)
+        self.assertIs(ret, wrapped())
+
+    def test_raises(self):
+        # If the function raises, so does Nullary when called.
+        wrapped = Nullary(lambda: 1/0)
+        self.assertRaises(ZeroDivisionError, wrapped)
+
+
 def test_suite():
     from unittest import TestLoader
     return TestLoader().loadTestsFromName(__name__)