def test_no_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
print "bar"
self.assert_(False)
test = FooTC('test_stderr')
# this runner should not capture stdout / stderr
runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True)
result = runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "")
self.assertEqual(captured_err.strip(), "")
def test_no_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
print "bar"
self.assert_(False)
test = FooTC('test_stderr')
# this runner should not capture stdout / stderr
runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True)
result = runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "")
self.assertEqual(captured_err.strip(), "")
class ExitFirstTC(TestCase):
def setUp(self):
output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=output, exitfirst=True)
def test_failure_exit_first(self):
class FooTC(TestCase):
def test_1(self):
pass
def test_2(self):
assert False
def test_3(self):
pass
tests = [FooTC('test_1'), FooTC('test_2')]
result = self.runner.run(TestSuite(tests))
self.assertEquals(result.testsRun, 2)
self.assertEquals(len(result.failures), 1)
self.assertEquals(len(result.errors), 0)
def test_error_exit_first(self):
class FooTC(TestCase):
def test_1(self):
pass
def test_2(self):
raise ValueError()
def test_3(self):
pass
tests = [FooTC('test_1'), FooTC('test_2'), FooTC('test_3')]
result = self.runner.run(TestSuite(tests))
self.assertEquals(result.testsRun, 2)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 1)
def test_generative_exit_first(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
yield self.assert_, False
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 1)
self.assertEquals(len(result.failures), 1)
self.assertEquals(len(result.errors), 0)
class ExitFirstTC(TestCase):
def setUp(self):
output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=output, exitfirst=True)
def test_failure_exit_first(self):
class FooTC(TestCase):
def test_1(self): pass
def test_2(self): assert False
def test_3(self): pass
tests = [FooTC('test_1'), FooTC('test_2')]
result = self.runner.run(TestSuite(tests))
self.assertEqual(result.testsRun, 2)
self.assertEqual(len(result.failures), 1)
self.assertEqual(len(result.errors), 0)
def test_error_exit_first(self):
class FooTC(TestCase):
def test_1(self): pass
def test_2(self): raise ValueError()
def test_3(self): pass
tests = [FooTC('test_1'), FooTC('test_2'), FooTC('test_3')]
result = self.runner.run(TestSuite(tests))
self.assertEqual(result.testsRun, 2)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 1)
def test_generative_exit_first(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
yield self.assert_, False
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 1)
self.assertEqual(len(result.failures), 1)
self.assertEqual(len(result.errors), 0)
def setUp(self):
sys.stdout = sys.stderr = StringIO()
self.runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True, capture=True)
class OutErrCaptureTC(TestCase):
def setUp(self):
sys.stdout = sys.stderr = StringIO()
self.runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True, capture=True)
def tearDown(self):
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
def test_stdout_capture(self):
class FooTC(TestCase):
def test_stdout(self):
print "foo"
self.assert_(False)
test = FooTC('test_stdout')
result = self.runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "foo")
self.assertEqual(captured_err.strip(), "")
def test_stderr_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
self.assert_(False)
test = FooTC('test_stderr')
result = self.runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "")
self.assertEqual(captured_err.strip(), "foo")
def test_both_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
print "bar"
self.assert_(False)
test = FooTC('test_stderr')
result = self.runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "bar")
self.assertEqual(captured_err.strip(), "foo")
def test_no_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
print "bar"
self.assert_(False)
test = FooTC('test_stderr')
# this runner should not capture stdout / stderr
runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True)
result = runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "")
self.assertEqual(captured_err.strip(), "")
def test_capture_core(self):
# output = capture_stdout()
# bootstrap_print("hello", output=sys.stdout)
# self.assertEquals(output.restore(), "hello")
output = capture_stdout()
bootstrap_print("hello")
self.assertEquals(output.restore(), "hello")
def test_unicode_non_ascii_messages(self):
class FooTC(TestCase):
def test_xxx(self):
raise Exception(u'\xe9')
test = FooTC('test_xxx')
# run the test and make sure testlib doesn't raise an exception
result = self.runner.run(test)
def test_encoded_non_ascii_messages(self):
class FooTC(TestCase):
def test_xxx(self):
raise Exception('\xe9')
test = FooTC('test_xxx')
# run the test and make sure testlib doesn't raise an exception
result = self.runner.run(test)
def setUp(self):
self.loader = NonStrictTestLoader()
self.module = TestLoaderTC # mock_object(FooTC=TestLoaderTC.FooTC, BarTC=TestLoaderTC.BarTC)
self.output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=self.output)
class TestLoaderTC(TestCase):
## internal classes for test purposes ########
class FooTC(TestCase):
def test_foo1(self): pass
def test_foo2(self): pass
def test_bar1(self): pass
class BarTC(TestCase):
def test_bar2(self): pass
##############################################
def setUp(self):
self.loader = NonStrictTestLoader()
self.module = TestLoaderTC # mock_object(FooTC=TestLoaderTC.FooTC, BarTC=TestLoaderTC.BarTC)
self.output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=self.output)
def assertRunCount(self, pattern, module, expected_count, skipped=()):
if pattern:
suite = self.loader.loadTestsFromNames([pattern], module)
else:
suite = self.loader.loadTestsFromModule(module)
self.runner.test_pattern = pattern
self.runner.skipped_patterns = skipped
result = self.runner.run(suite)
self.runner.test_pattern = None
self.runner.skipped_patterns = ()
self.assertEquals(result.testsRun, expected_count)
def test_collect_everything(self):
"""make sure we don't change the default behaviour
for loadTestsFromModule() and loadTestsFromTestCase
"""
testsuite = self.loader.loadTestsFromModule(self.module)
self.assertEquals(len(testsuite._tests), 2)
suite1, suite2 = testsuite._tests
self.assertEquals(len(suite1._tests) + len(suite2._tests), 4)
def test_collect_with_classname(self):
self.assertRunCount('FooTC', self.module, 3)
self.assertRunCount('BarTC', self.module, 1)
def test_collect_with_classname_and_pattern(self):
data = [('FooTC.test_foo1', 1), ('FooTC.test_foo', 2), ('FooTC.test_fo', 2),
('FooTC.foo1', 1), ('FooTC.foo', 2), ('FooTC.whatever', 0)
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, self.module, expected_count
def test_collect_with_pattern(self):
data = [('test_foo1', 1), ('test_foo', 2), ('test_bar', 2),
('foo1', 1), ('foo', 2), ('bar', 2), ('ba', 2),
('test', 4), ('ab', 0),
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, self.module, expected_count
def test_tescase_with_custom_metaclass(self):
class mymetaclass(type): pass
class MyMod:
class MyTestCase(TestCase):
__metaclass__ = mymetaclass
def test_foo1(self): pass
def test_foo2(self): pass
def test_bar(self): pass
data = [('test_foo1', 1), ('test_foo', 2), ('test_bar', 1),
('foo1', 1), ('foo', 2), ('bar', 1), ('ba', 1),
('test', 3), ('ab', 0),
('MyTestCase.test_foo1', 1), ('MyTestCase.test_foo', 2),
('MyTestCase.test_fo', 2), ('MyTestCase.foo1', 1),
('MyTestCase.foo', 2), ('MyTestCase.whatever', 0)
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, MyMod, expected_count
def test_collect_everything_and_skipped_patterns(self):
testdata = [ (['foo1'], 3), (['foo'], 2),
(['foo', 'bar'], 0),
]
for skipped, expected_count in testdata:
yield self.assertRunCount, None, self.module, expected_count, skipped
def test_collect_specific_pattern_and_skip_some(self):
testdata = [ ('bar', ['foo1'], 2), ('bar', [], 2),
('bar', ['bar'], 0), ]
for runpattern, skipped, expected_count in testdata:
yield self.assertRunCount, runpattern, self.module, expected_count, skipped
def test_skip_classname(self):
testdata = [ (['BarTC'], 3), (['FooTC'], 1), ]
for skipped, expected_count in testdata:
yield self.assertRunCount, None, self.module, expected_count, skipped
def test_skip_classname_and_specific_collect(self):
testdata = [ ('bar', ['BarTC'], 1), ('foo', ['FooTC'], 0), ]
for runpattern, skipped, expected_count in testdata:
yield self.assertRunCount, runpattern, self.module, expected_count, skipped
def test_nonregr_dotted_path(self):
self.assertRunCount('FooTC.test_foo', self.module, 2)
def test_inner_tests_selection(self):
class MyMod:
class MyTestCase(TestCase):
def test_foo(self): pass
def test_foobar(self):
for i in xrange(5):
if i%2 == 0:
yield InnerTest('even', lambda: None)
else:
yield InnerTest('odd', lambda: None)
yield lambda: None
data = [('foo', 7), ('test_foobar', 6), ('even', 3), ('odd', 2),
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, MyMod, expected_count
def test_nonregr_class_skipped_option(self):
class MyMod:
class MyTestCase(TestCase):
def test_foo(self): pass
def test_bar(self): pass
class FooTC(TestCase):
def test_foo(self): pass
self.assertRunCount('foo', MyMod, 2)
self.assertRunCount(None, MyMod, 3)
self.loader.skipped_patterns = self.runner.skipped_patterns = ['FooTC']
self.assertRunCount('foo', MyMod, 1)
self.assertRunCount(None, MyMod, 2)
def test__classes_are_ignored(self):
class MyMod:
class _Base(TestCase):
def test_1(self): pass
class MyTestCase(_Base):
def test_2(self): pass
self.assertRunCount(None, MyMod, 2)
def setUp(self):
output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=output, exitfirst=True)
class GenerativeTestsTC(TestCase):
def setUp(self):
output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=output)
def test_generative_ok(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
yield self.assertEquals, i, i
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 10)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 0)
def test_generative_half_bad(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
yield self.assertEquals, i%2, 0
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 10)
self.assertEquals(len(result.failures), 5)
self.assertEquals(len(result.errors), 0)
def test_generative_error(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
if i == 5:
raise ValueError('STOP !')
yield self.assertEquals, i, i
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 5)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 1)
def test_generative_error2(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
if i == 5:
yield self.ouch
yield self.assertEquals, i, i
def ouch(self): raise ValueError('stop !')
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 6)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 1)
def test_generative_setup(self):
class FooTC(TestCase):
def setUp(self):
raise ValueError('STOP !')
def test_generative(self):
for i in xrange(10):
yield self.assertEquals, i, i
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 1)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 1)
def test_generative_inner_skip(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
self.innerSkip("no 5")
else:
self.assertEquals(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 10)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 0)
self.assertEquals(len(result.skipped), 1)
def test_generative_skip(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
self.skip("no 5")
else:
self.assertEquals(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 6)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 0)
self.assertEquals(len(result.skipped), 1)
def test_generative_inner_error(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
raise ValueError("no 5")
else:
self.assertEquals(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 6)
self.assertEquals(len(result.failures), 0)
self.assertEquals(len(result.errors), 1)
self.assertEquals(len(result.skipped), 0)
def test_generative_inner_failure(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
self.assertEquals(val, val+1)
else:
self.assertEquals(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEquals(result.testsRun, 10)
self.assertEquals(len(result.failures), 1)
self.assertEquals(len(result.errors), 0)
self.assertEquals(len(result.skipped), 0)
def test_tagged_class(self):
def options(tags):
class Options(object):
tags_pattern = tags
return Options()
cls = self.cls
runner = SkipAwareTextTestRunner()
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertTrue(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('one'))
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertFalse(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('two'))
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertFalse(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('three'))
self.assertFalse(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertTrue(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('two or three'))
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertTrue(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('two and three'))
self.assertFalse(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertFalse(runner.does_match_tags(cls.test_three))
def setUp(self):
sys.stdout = sys.stderr = StringIO()
self.runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True, capture=True)
class OutErrCaptureTC(TestCase):
def setUp(self):
sys.stdout = sys.stderr = StringIO()
self.runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True, capture=True)
def tearDown(self):
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
@unittest.skipIf(not sys.stdout.isatty(), "need stdout")
def test_stdout_capture(self):
class FooTC(TestCase):
def test_stdout(self):
print "foo"
self.assert_(False)
test = FooTC('test_stdout')
result = self.runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "foo")
self.assertEqual(captured_err.strip(), "")
@unittest.skipIf(not sys.stderr.isatty(), "need stderr")
def test_stderr_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
self.assert_(False)
test = FooTC('test_stderr')
result = self.runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "")
self.assertEqual(captured_err.strip(), "foo")
@unittest.skipIf(not sys.stderr.isatty(), "need stderr")
@unittest.skipIf(not sys.stdout.isatty(), "need stdout")
def test_both_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
print "bar"
self.assert_(False)
test = FooTC('test_stderr')
result = self.runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "bar")
self.assertEqual(captured_err.strip(), "foo")
@unittest.skipIf(not sys.stderr.isatty(), "need stderr")
@unittest.skipIf(not sys.stdout.isatty(), "need stdout")
def test_no_capture(self):
class FooTC(TestCase):
def test_stderr(self):
print >> sys.stderr, "foo"
print "bar"
self.assert_(False)
test = FooTC('test_stderr')
# this runner should not capture stdout / stderr
runner = SkipAwareTextTestRunner(stream=StringIO(), exitfirst=True)
result = runner.run(test)
captured_out, captured_err = test.captured_output()
self.assertEqual(captured_out.strip(), "")
self.assertEqual(captured_err.strip(), "")
@unittest.skipIf(not sys.stdout.isatty(), "need stdout")
def test_capture_core(self):
# output = capture_stdout()
# bootstrap_print("hello", output=sys.stdout)
# self.assertEqual(output.restore(), "hello")
output = capture_stdout()
bootstrap_print("hello")
self.assertEqual(output.restore(), "hello")
def test_unicode_non_ascii_messages(self):
class FooTC(TestCase):
def test_xxx(self):
raise Exception(u'\xe9')
test = FooTC('test_xxx')
# run the test and make sure testlib doesn't raise an exception
result = self.runner.run(test)
def test_encoded_non_ascii_messages(self):
class FooTC(TestCase):
def test_xxx(self):
raise Exception('\xe9')
test = FooTC('test_xxx')
# run the test and make sure testlib doesn't raise an exception
result = self.runner.run(test)
def setUp(self):
self.loader = NonStrictTestLoader()
self.module = TestLoaderTC # mock_object(FooTC=TestLoaderTC.FooTC, BarTC=TestLoaderTC.BarTC)
self.output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=self.output)
class TestLoaderTC(TestCase):
## internal classes for test purposes ########
class FooTC(TestCase):
def test_foo1(self): pass
def test_foo2(self): pass
def test_bar1(self): pass
class BarTC(TestCase):
def test_bar2(self): pass
##############################################
def setUp(self):
self.loader = NonStrictTestLoader()
self.module = TestLoaderTC # mock_object(FooTC=TestLoaderTC.FooTC, BarTC=TestLoaderTC.BarTC)
self.output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=self.output)
def assertRunCount(self, pattern, module, expected_count, skipped=()):
if pattern:
suite = self.loader.loadTestsFromNames([pattern], module)
else:
suite = self.loader.loadTestsFromModule(module)
self.runner.test_pattern = pattern
self.runner.skipped_patterns = skipped
result = self.runner.run(suite)
self.runner.test_pattern = None
self.runner.skipped_patterns = ()
self.assertEqual(result.testsRun, expected_count)
def test_collect_everything(self):
"""make sure we don't change the default behaviour
for loadTestsFromModule() and loadTestsFromTestCase
"""
testsuite = self.loader.loadTestsFromModule(self.module)
self.assertEqual(len(testsuite._tests), 2)
suite1, suite2 = testsuite._tests
self.assertEqual(len(suite1._tests) + len(suite2._tests), 4)
def test_collect_with_classname(self):
self.assertRunCount('FooTC', self.module, 3)
self.assertRunCount('BarTC', self.module, 1)
def test_collect_with_classname_and_pattern(self):
data = [('FooTC.test_foo1', 1), ('FooTC.test_foo', 2), ('FooTC.test_fo', 2),
('FooTC.foo1', 1), ('FooTC.foo', 2), ('FooTC.whatever', 0)
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, self.module, expected_count
def test_collect_with_pattern(self):
data = [('test_foo1', 1), ('test_foo', 2), ('test_bar', 2),
('foo1', 1), ('foo', 2), ('bar', 2), ('ba', 2),
('test', 4), ('ab', 0),
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, self.module, expected_count
def test_tescase_with_custom_metaclass(self):
class mymetaclass(type): pass
class MyMod:
class MyTestCase(TestCase):
__metaclass__ = mymetaclass
def test_foo1(self): pass
def test_foo2(self): pass
def test_bar(self): pass
data = [('test_foo1', 1), ('test_foo', 2), ('test_bar', 1),
('foo1', 1), ('foo', 2), ('bar', 1), ('ba', 1),
('test', 3), ('ab', 0),
('MyTestCase.test_foo1', 1), ('MyTestCase.test_foo', 2),
('MyTestCase.test_fo', 2), ('MyTestCase.foo1', 1),
('MyTestCase.foo', 2), ('MyTestCase.whatever', 0)
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, MyMod, expected_count
def test_collect_everything_and_skipped_patterns(self):
testdata = [ (['foo1'], 3), (['foo'], 2),
(['foo', 'bar'], 0),
]
for skipped, expected_count in testdata:
yield self.assertRunCount, None, self.module, expected_count, skipped
def test_collect_specific_pattern_and_skip_some(self):
testdata = [ ('bar', ['foo1'], 2), ('bar', [], 2),
('bar', ['bar'], 0), ]
for runpattern, skipped, expected_count in testdata:
yield self.assertRunCount, runpattern, self.module, expected_count, skipped
def test_skip_classname(self):
testdata = [ (['BarTC'], 3), (['FooTC'], 1), ]
for skipped, expected_count in testdata:
yield self.assertRunCount, None, self.module, expected_count, skipped
def test_skip_classname_and_specific_collect(self):
testdata = [ ('bar', ['BarTC'], 1), ('foo', ['FooTC'], 0), ]
for runpattern, skipped, expected_count in testdata:
yield self.assertRunCount, runpattern, self.module, expected_count, skipped
def test_nonregr_dotted_path(self):
self.assertRunCount('FooTC.test_foo', self.module, 2)
def test_inner_tests_selection(self):
class MyMod:
class MyTestCase(TestCase):
def test_foo(self): pass
def test_foobar(self):
for i in xrange(5):
if i%2 == 0:
yield InnerTest('even', lambda: None)
else:
yield InnerTest('odd', lambda: None)
yield lambda: None
data = [('foo', 7), ('test_foobar', 6), ('even', 3), ('odd', 2),
]
for pattern, expected_count in data:
yield self.assertRunCount, pattern, MyMod, expected_count
def test_nonregr_class_skipped_option(self):
class MyMod:
class MyTestCase(TestCase):
def test_foo(self): pass
def test_bar(self): pass
class FooTC(TestCase):
def test_foo(self): pass
self.assertRunCount('foo', MyMod, 2)
self.assertRunCount(None, MyMod, 3)
self.loader.skipped_patterns = self.runner.skipped_patterns = ['FooTC']
self.assertRunCount('foo', MyMod, 1)
self.assertRunCount(None, MyMod, 2)
def test__classes_are_ignored(self):
class MyMod:
class _Base(TestCase):
def test_1(self): pass
class MyTestCase(_Base):
def test_2(self): pass
self.assertRunCount(None, MyMod, 2)
def setUp(self):
output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=output, exitfirst=True)
def test_tagged_class(self):
def options(tags):
class Options(object):
tags_pattern = tags
return Options()
cls = self.cls
runner = SkipAwareTextTestRunner()
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertTrue(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('one'))
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertFalse(runner.does_match_tags(cls.test_two))
self.assertFalse(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('two'))
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertFalse(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('three'))
self.assertFalse(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertTrue(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('two or three'))
self.assertTrue(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertTrue(runner.does_match_tags(cls.test_three))
runner = SkipAwareTextTestRunner(options=options('two and three'))
self.assertFalse(runner.does_match_tags(cls.test_one))
self.assertTrue(runner.does_match_tags(cls.test_two))
self.assertFalse(runner.does_match_tags(cls.test_three))
class GenerativeTestsTC(TestCase):
def setUp(self):
output = StringIO()
self.runner = SkipAwareTextTestRunner(stream=output)
def test_generative_ok(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
yield self.assertEqual, i, i
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 10)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 0)
def test_generative_half_bad(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
yield self.assertEqual, i%2, 0
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 10)
self.assertEqual(len(result.failures), 5)
self.assertEqual(len(result.errors), 0)
def test_generative_error(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
if i == 5:
raise ValueError('STOP !')
yield self.assertEqual, i, i
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 5)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 1)
def test_generative_error2(self):
class FooTC(TestCase):
def test_generative(self):
for i in xrange(10):
if i == 5:
yield self.ouch
yield self.assertEqual, i, i
def ouch(self): raise ValueError('stop !')
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 6)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 1)
def test_generative_setup(self):
class FooTC(TestCase):
def setUp(self):
raise ValueError('STOP !')
def test_generative(self):
for i in xrange(10):
yield self.assertEqual, i, i
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 1)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 1)
def test_generative_inner_skip(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
self.innerSkip("no 5")
else:
self.assertEqual(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 10)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.skipped), 1)
def test_generative_skip(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
self.skipTest("no 5")
else:
self.assertEqual(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 6)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.skipped), 1)
def test_generative_inner_error(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
raise ValueError("no 5")
else:
self.assertEqual(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 6)
self.assertEqual(len(result.failures), 0)
self.assertEqual(len(result.errors), 1)
self.assertEqual(len(result.skipped), 0)
def test_generative_inner_failure(self):
class FooTC(TestCase):
def check(self, val):
if val == 5:
self.assertEqual(val, val+1)
else:
self.assertEqual(val, val)
def test_generative(self):
for i in xrange(10):
yield InnerTest("check_%s"%i, self.check, i)
result = self.runner.run(FooTC('test_generative'))
self.assertEqual(result.testsRun, 10)
self.assertEqual(len(result.failures), 1)
self.assertEqual(len(result.errors), 0)
self.assertEqual(len(result.skipped), 0)