def test_exclude_skips(self):
filtered_result = pysubunit.TestResultStats(None)
result_filter = test_results.TestResultFilter(filtered_result,
filter_skip=True)
self.run_tests(result_filter)
self.assertEqual(0, filtered_result.skipped_tests)
self.assertEqual(2, filtered_result.failed_tests)
self.assertEqual(3, filtered_result.testsRun)
def test_exclude_failure(self):
filtered_result = unittest.TestResult()
result_filter = test_results.TestResultFilter(filtered_result,
filter_failure=True)
self.run_tests(result_filter)
self.assertEqual(['error'],
[error[0].id() for error in filtered_result.errors])
self.assertEqual(
[], [failure[0].id() for failure in filtered_result.failures])
self.assertEqual(3, filtered_result.testsRun)
def test_fixup_expected_errors(self):
filtered_result = unittest.TestResult()
result_filter = test_results.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_skip_preserved(self):
subunit_stream = compat._b('\n'.join(["test: foo", "skip: foo", ""]))
result = doubles.ExtendedTestResult()
result_filter = test_results.TestResultFilter(result)
self.run_tests(result_filter, subunit_stream)
foo = pysubunit.RemotedTestCase('foo')
self.assertEqual([
('startTest', foo),
('addSkip', foo, {}),
('stopTest', foo),
], result._events)
def test_fixup_unexpected_success(self):
filtered_result = unittest.TestResult()
result_filter = test_results.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_errors(self):
filtered_result = unittest.TestResult()
result_filter = test_results.TestResultFilter(filtered_result,
filter_error=True)
self.run_tests(result_filter)
# skips are seen as errors by default python TestResult.
self.assertEqual([], filtered_result.errors)
self.assertEqual(
['failed'],
[failure[0].id() for failure in filtered_result.failures])
self.assertEqual(3, filtered_result.testsRun)
def test_default(self):
"""The default is to exclude success and include everything else."""
filtered_result = unittest.TestResult()
result_filter = test_results.TestResultFilter(filtered_result)
self.run_tests(result_filter)
# skips are seen as success by default python TestResult.
self.assertEqual(['error'],
[error[0].id() for error in filtered_result.errors])
self.assertEqual(
['failed'],
[failure[0].id() for failure in filtered_result.failures])
self.assertEqual(4, filtered_result.testsRun)
def test_filter_predicate_with_tags(self):
"""You can filter by predicate callbacks that accept tags"""
filtered_result = unittest.TestResult()
def filter_cb(test, outcome, err, details, tags):
return outcome == 'success'
result_filter = test_results.TestResultFilter(
filtered_result, filter_predicate=filter_cb, filter_success=False)
self.run_tests(result_filter)
# Only success should pass
self.assertEqual(1, filtered_result.testsRun)
def test_include_success(self):
"""Successes can be included if requested."""
filtered_result = unittest.TestResult()
result_filter = test_results.TestResultFilter(filtered_result,
filter_success=False)
self.run_tests(result_filter)
self.assertEqual(['error'],
[error[0].id() for error in filtered_result.errors])
self.assertEqual(
['failed'],
[failure[0].id() for failure in filtered_result.failures])
self.assertEqual(5, filtered_result.testsRun)
def test_tag_filter(self):
tag_filter = test_results.make_tag_filter(['global'], ['local'])
result = doubles.ExtendedTestResult()
result_filter = test_results.TestResultFilter(
result, filter_success=False, filter_predicate=tag_filter)
self.run_tests(result_filter)
tests_included = [
event[1] for event in result._events if event[0] == 'startTest'
]
tests_expected = list(
map(pysubunit.RemotedTestCase,
['passed', 'error', 'skipped', 'todo']))
self.assertEqual(tests_expected, tests_included)
def test_filter_predicate(self):
"""You can filter by predicate callbacks"""
# 0.0.7 and earlier did not support the 'tags' parameter, so we need
# to test that we still support behaviour without it.
filtered_result = unittest.TestResult()
def filter_cb(test, outcome, err, details):
return outcome == 'success'
result_filter = test_results.TestResultFilter(
filtered_result, filter_predicate=filter_cb, filter_success=False)
self.run_tests(result_filter)
# Only success should pass
self.assertEqual(1, filtered_result.testsRun)
def _make_result(output, options, predicate):
"""Make the result that we'll send the test outcomes to."""
fixup_expected_failures = set()
for path in options.fixup_expected_failures or ():
fixup_expected_failures.update(pysubunit.read_test_list(path))
return testtools.StreamToExtendedDecorator(
test_results.TestResultFilter(
testtools.ExtendedToStreamDecorator(
v2.StreamResultToBytes(output)),
filter_error=options.error,
filter_failure=options.failure,
filter_success=options.success,
filter_skip=options.skip,
filter_xfail=options.xfail,
filter_predicate=predicate,
fixup_expected_failures=fixup_expected_failures))
def test_time_passes_through_filtered_tests(self):
# Passing a subunit stream through TestResultFilter preserves 'time'
# directives even if a specific test is filtered out.
date_a = datetime(year=2000, month=1, day=1, tzinfo=iso8601.UTC)
date_b = datetime(year=2000, month=1, day=2, tzinfo=iso8601.UTC)
date_c = datetime(year=2000, month=1, day=3, tzinfo=iso8601.UTC)
subunit_stream = compat._b('\n'.join([
"time: %s", "test: foo", "time: %s", "success: foo", "time: %s", ""
]) % (date_a, date_b, date_c))
result = doubles.ExtendedTestResult()
result_filter = test_results.TestResultFilter(result)
result_filter.startTestRun()
self.run_tests(result_filter, subunit_stream)
result_filter.stopTestRun()
self.maxDiff = None
self.assertEqual([('startTestRun', ), ('time', date_a),
('time', date_c), ('stopTestRun', )], result._events)
def test_tags_tracked_correctly(self):
tag_filter = test_results.make_tag_filter(['a'], [])
result = doubles.ExtendedTestResult()
result_filter = test_results.TestResultFilter(
result, filter_success=False, filter_predicate=tag_filter)
input_stream = compat._b("test: foo\n"
"tags: a\n"
"successful: foo\n"
"test: bar\n"
"successful: bar\n")
self.run_tests(result_filter, input_stream)
foo = pysubunit.RemotedTestCase('foo')
self.assertEqual([
('startTest', foo),
('tags', set(['a']), set()),
('addSuccess', foo),
('stopTest', foo),
], result._events)
def test_time_ordering_preserved(self):
# Passing a subunit stream through TestResultFilter preserves the
# relative ordering of 'time' directives and any other subunit
# directives that are still included.
date_a = datetime(year=2000, month=1, day=1, tzinfo=iso8601.UTC)
date_b = datetime(year=2000, month=1, day=2, tzinfo=iso8601.UTC)
date_c = datetime(year=2000, month=1, day=3, tzinfo=iso8601.UTC)
subunit_stream = compat._b('\n'.join([
"time: %s", "test: foo", "time: %s", "error: foo", "time: %s", ""
]) % (date_a, date_b, date_c))
result = doubles.ExtendedTestResult()
result_filter = test_results.TestResultFilter(result)
self.run_tests(result_filter, subunit_stream)
foo = pysubunit.RemotedTestCase('foo')
self.maxDiff = None
self.assertEqual([('time', date_a), ('time', date_b),
('startTest', foo), ('addError', foo, {}),
('stopTest', foo), ('time', date_c)], result._events)
