Merge addition of --fixup-expected-failures argument to filter-subunit.

4 files changed, 70 insertions, 8 deletions

diff --git a/python/subunit/__init__.py b/python/subunit/__init__.py
index 9dc849a..368d3b2 100644
--- a/python/subunit/__init__.py
+++ b/python/subunit/__init__.py
@@ -1132,6 +1132,19 @@ def get_default_formatter():
         return sys.stdout
 
 
+def read_test_list(path):
+    """Read a list of test ids from a file on disk.
+
+    :param path: Path to the file
+    :return: Sequence of test ids
+    """
+    f = open(path, 'rb')
+    try:
+        return [l.rstrip("\n") for l in f.readlines()]
+    finally:
+        f.close()
+
+
 def _make_stream_binary(stream):
     """Ensure that a stream will be binary safe. See _make_binary_on_windows."""
     if getattr(stream, 'fileno', None) is not None:
diff --git a/python/subunit/test_results.py b/python/subunit/test_results.py
index e7f9171..fe5b8d1 100644
--- a/python/subunit/test_results.py
+++ b/python/subunit/test_results.py
@@ -294,7 +294,7 @@ class TestResultFilter(TestResultDecorator):
 
     def __init__(self, result, filter_error=False, filter_failure=False,
         filter_success=True, filter_skip=False,
-        filter_predicate=None):
+        filter_predicate=None, fixup_expected_failures=None):
         """Create a FilterResult object filtering to result.
 
         :param filter_error: Filter out errors.
@@ -306,6 +306,8 @@ class TestResultFilter(TestResultDecorator):
             through.  err and details may be none if no error or extra
             metadata is available. outcome is the name of the outcome such
             as 'success' or 'failure'.
+        :param fixup_expected_failures: Set of test ids to consider known
+            failing.
         """
         super(TestResultFilter, self).__init__(result)
         self.decorated = TimeCollapsingDecorator(
@@ -330,18 +332,30 @@ class TestResultFilter(TestResultDecorator):
         self._current_test_filtered = None
         # Calls to this result that we don't know whether to forward on yet.
         self._buffered_calls = []
+        if fixup_expected_failures is None:
+            self._fixup_expected_failures = frozenset()
+        else:
+            self._fixup_expected_failures = fixup_expected_failures
 
     def addError(self, test, err=None, details=None):
         if (self.filter_predicate(test, 'error', err, details)):
-            self._buffered_calls.append(
-                ('addError', [test, err], {'details': details}))
+            if self._failure_expected(test):
+                self._buffered_calls.append(
+                    ('addExpectedFailure', [test, err], {'details': details}))
+            else:
+                self._buffered_calls.append(
+                    ('addError', [test, err], {'details': details}))
         else:
             self._filtered()
 
     def addFailure(self, test, err=None, details=None):
         if (self.filter_predicate(test, 'failure', err, details)):
-            self._buffered_calls.append(
-                ('addFailure', [test, err], {'details': details}))
+            if self._failure_expected(test):
+                self._buffered_calls.append(
+                    ('addExpectedFailure', [test, err], {'details': details}))
+            else:
+                self._buffered_calls.append(
+                    ('addFailure', [test, err], {'details': details}))
         else:
             self._filtered()
 
@@ -354,8 +368,12 @@ class TestResultFilter(TestResultDecorator):
 
     def addSuccess(self, test, details=None):
         if (self.filter_predicate(test, 'success', None, details)):
-            self._buffered_calls.append(
-                ('addSuccess', [test], {'details': details}))
+            if self._failure_expected(test):
+                self._buffered_calls.append(
+                    ('addUnexpectedSuccess', [test], {'details': details}))
+            else:
+                self._buffered_calls.append(
+                    ('addSuccess', [test], {'details': details}))
         else:
             self._filtered()
 
@@ -373,6 +391,9 @@ class TestResultFilter(TestResultDecorator):
     def _filtered(self):
         self._current_test_filtered = True
 
+    def _failure_expected(self, test):
+        return (test.id() in self._fixup_expected_failures)
+
     def startTest(self, test):
         """Start a test.
 
diff --git a/python/subunit/tests/test_details.py b/python/subunit/tests/test_details.py
index 41c3212..2fd1a66 100644
--- a/python/subunit/tests/test_details.py
+++ b/python/subunit/tests/test_details.py
@@ -14,7 +14,6 @@
 #  limitations under that license.
 #
 
-from cStringIO import StringIO
 import unittest
 
 import subunit.tests
diff --git a/python/subunit/tests/test_subunit_filter.py b/python/subunit/tests/test_subunit_filter.py
index cf6c2b6..f8db05b 100644
--- a/python/subunit/tests/test_subunit_filter.py
+++ b/python/subunit/tests/test_subunit_filter.py
@@ -88,6 +88,35 @@ xfail todo
             filtered_result.failures])
         self.assertEqual(3, filtered_result.testsRun)
 
+    def test_fixup_expected_failures(self):
+        filtered_result = unittest.TestResult()
+        result_filter = TestResultFilter(filtered_result,
+            fixup_expected_failures=set(["failed"]))
+        self.run_tests(result_filter)
+        self.assertEqual(['failed', 'todo'],
+            [failure[0].id() for failure in filtered_result.expectedFailures])
+        self.assertEqual([], filtered_result.failures)
+        self.assertEqual(4, filtered_result.testsRun)
+
+    def test_fixup_expected_errors(self):
+        filtered_result = unittest.TestResult()
+        result_filter = TestResultFilter(filtered_result,
+            fixup_expected_failures=set(["error"]))
+        self.run_tests(result_filter)
+        self.assertEqual(['error', 'todo'],
+            [failure[0].id() for failure in filtered_result.expectedFailures])
+        self.assertEqual([], filtered_result.errors)
+        self.assertEqual(4, filtered_result.testsRun)
+
+    def test_fixup_unexpected_success(self):
+        filtered_result = unittest.TestResult()
+        result_filter = TestResultFilter(filtered_result, filter_success=False,
+            fixup_expected_failures=set(["passed"]))
+        self.run_tests(result_filter)
+        self.assertEqual(['passed'],
+            [passed.id() for passed in filtered_result.unexpectedSuccesses])
+        self.assertEqual(5, filtered_result.testsRun)
+
     def test_exclude_failure(self):
         filtered_result = unittest.TestResult()
         result_filter = TestResultFilter(filtered_result, filter_failure=True)