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 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=()):
self.loader.test_pattern = pattern
self.loader.skipped_patterns = skipped
if pattern:
suite = self.loader.loadTestsFromNames([pattern], module)
else:
suite = self.loader.loadTestsFromModule(module)
result = self.runner.run(suite)
self.loader.test_pattern = None
self.loader.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_testcase_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
# FIXME InnerTest masked by pattern usage
# data = [('foo', 7), ('test_foobar', 6), ('even', 3), ('odd', 2), ]
data = [('foo', 7), ('test_foobar', 6), ('even', 0), ('odd', 0), ]
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.assertRunCount('foo', MyMod, 1, ['FooTC'])
self.assertRunCount(None, MyMod, 2, ['FooTC'])
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)
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=()):
self.loader.test_pattern = pattern
self.loader.skipped_patterns = skipped
if pattern:
suite = self.loader.loadTestsFromNames([pattern], module)
else:
suite = self.loader.loadTestsFromModule(module)
result = self.runner.run(suite)
self.loader.test_pattern = None
self.loader.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_testcase_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
# FIXME InnerTest masked by pattern usage
# data = [('foo', 7), ('test_foobar', 6), ('even', 3), ('odd', 2), ]
data = [
('foo', 7),
('test_foobar', 6),
('even', 0),
('odd', 0),
]
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.assertRunCount('foo', MyMod, 1, ['FooTC'])
self.assertRunCount(None, MyMod, 2, ['FooTC'])
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)
