Rev 4784: Switch reporting of KnownFailure to be Python2.7 compatible. in http://bazaar.launchpad.net/~lifeless/bzr/subunit

[Robert Collins]

At http://bazaar.launchpad.net/~lifeless/bzr/subunit

------------------------------------------------------------
revno: 4784
revision-id: robertc at robertcollins.net-20091101054157-1pddq7pqwsn5f7f0
parent: robertc at robertcollins.net-20091101050147-sj4ltnewftl0lw98
committer: Robert Collins <robertc at robertcollins.net>
branch nick: subunit
timestamp: Sun 2009-11-01 16:41:57 +1100
message:
  Switch reporting of KnownFailure to be Python2.7 compatible.
=== modified file 'NEWS'
--- a/NEWS	2009-11-01 05:01:47 +0000
+++ b/NEWS	2009-11-01 05:41:57 +0000
@@ -36,6 +36,9 @@
 Testing
 *******
 
+* KnownFailure is now signalled to ``ExtendedTestResult`` using the same
+  method that Python 2.7 uses - ``addExpectedFailure``. (Robert Collins)
+
 * TestNotApplicable is now handled within the TestCase.run method rather
   than being looked for within ``ExtendedTestResult.addError``. This
   provides better handling with other ``TestResult`` objects, degrading to

=== modified file 'bzrlib/tests/__init__.py'
--- a/bzrlib/tests/__init__.py	2009-11-01 05:01:47 +0000
+++ b/bzrlib/tests/__init__.py	2009-11-01 05:41:57 +0000
@@ -312,16 +312,13 @@
         Called from the TestCase run() method when the test
         fails because e.g. an assert() method failed.
         """
-        if isinstance(err[1], KnownFailure):
-            return self._addKnownFailure(test, err)
-        else:
-            self._post_mortem()
-            unittest.TestResult.addFailure(self, test, err)
-            self.failure_count += 1
-            self.report_failure(test, err)
-            if self.stop_early:
-                self.stop()
-            self._cleanupLogFile(test)
+        self._post_mortem()
+        unittest.TestResult.addFailure(self, test, err)
+        self.failure_count += 1
+        self.report_failure(test, err)
+        if self.stop_early:
+            self.stop()
+        self._cleanupLogFile(test)
 
     def addSuccess(self, test):
         """Tell result that test completed successfully.
@@ -339,7 +336,7 @@
         unittest.TestResult.addSuccess(self, test)
         test._log_contents = ''
 
-    def _addKnownFailure(self, test, err):
+    def addExpectedFailure(self, test, err):
         self.known_failure_count += 1
         self.report_known_failure(test, err)
 
@@ -1573,6 +1570,14 @@
         else:
             addSkip(self, reason)
 
+    def _do_known_failure(self, result):
+        err = sys.exc_info()
+        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
+        if addExpectedFailure is not None:
+            addExpectedFailure(self, err)
+        else:
+            result.addSuccess(self)
+
     def _do_not_applicable(self, result, e):
         addNotApplicable = getattr(result, 'addNotApplicable', None)
         if addNotApplicable is not None:
@@ -1622,6 +1627,10 @@
                 except KeyboardInterrupt:
                     self._runCleanups()
                     raise
+                except KnownFailure:
+                    self._do_known_failure(result)
+                    self.tearDown()
+                    return
                 except TestNotApplicable, e:
                     self._do_not_applicable(result, e)
                     self.tearDown()
@@ -1643,6 +1652,8 @@
                 try:
                     testMethod()
                     ok = True
+                except KnownFailure:
+                    self._do_known_failure(result)
                 except self.failureException:
                     result.addFailure(self, sys.exc_info())
                 except TestNotApplicable, e:
@@ -3379,8 +3390,8 @@
     def addFailure(self, test, err):
         known = self._error_looks_like('KnownFailure: ', err)
         if known is not None:
-            self.result._addKnownFailure(test, [KnownFailure,
-                                                KnownFailure(known), None])
+            self.result.addExpectedFailure(test,
+                [KnownFailure, KnownFailure(known), None])
         else:
             self.result.addFailure(test, err)
 

=== modified file 'bzrlib/tests/test_selftest.py'
--- a/bzrlib/tests/test_selftest.py	2009-11-01 05:01:47 +0000
+++ b/bzrlib/tests/test_selftest.py	2009-11-01 05:41:57 +0000
@@ -827,9 +827,10 @@
             def report_known_failure(self, test, err):
                 self._call = test, err
         result = InstrumentedTestResult(None, None, None, None)
-        def test_function():
-            raise tests.KnownFailure('failed!')
-        test = unittest.FunctionTestCase(test_function)
+        class Test(tests.TestCase):
+            def test_function(self):
+                raise tests.KnownFailure('failed!')
+        test = Test("test_function")
         test.run(result)
         # it should invoke 'report_known_failure'.
         self.assertEqual(2, len(result._call))
@@ -952,7 +953,7 @@
                                              verbosity=1)
         test = self.get_passing_test()
         err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
-        result._addKnownFailure(test, err)
+        result.addExpectedFailure(test, err)
         self.assertFalse(result.wasStrictlySuccessful())
         self.assertEqual(None, result._extractBenchmarkTime(test))
 
@@ -1015,10 +1016,11 @@
     def test_known_failure_failed_run(self):
         # run a test that generates a known failure which should be printed in
         # the final output when real failures occur.
-        def known_failure_test():
-            raise tests.KnownFailure('failed')
+        class Test(tests.TestCase):
+            def known_failure_test(self):
+                raise tests.KnownFailure('failed')
         test = unittest.TestSuite()
-        test.addTest(unittest.FunctionTestCase(known_failure_test))
+        test.addTest(Test("known_failure_test"))
         def failing_test():
             raise AssertionError('foo')
         test.addTest(unittest.FunctionTestCase(failing_test))
@@ -1042,10 +1044,12 @@
             )
 
     def test_known_failure_ok_run(self):
-        # run a test that generates a known failure which should be printed in the final output.
-        def known_failure_test():
-            raise tests.KnownFailure('failed')
-        test = unittest.FunctionTestCase(known_failure_test)
+        # run a test that generates a known failure which should be printed in
+        # the final output.
+        class Test(tests.TestCase):
+            def known_failure_test(self):
+                raise tests.KnownFailure('failed')
+        test = Test("known_failure_test")
         stream = StringIO()
         runner = tests.TextTestRunner(stream=stream)
         result = self.run_test_runner(runner, test)