def _test__load_tests_from_name(self, name):
loader = TestLoader()
suite = loader.loadTestsFromName(name)
result = TestResult()
suite.run(result)
self.assertEquals(result.testsRun, self.num_cases)
self.assertEquals(result.failures, [])
self.assertEquals(result.errors, [])
def test__description(self):
class MyTest(InfiTestCase):
@parameters.iterate('a', [1])
def setUp(self, a):
super(MyTest, self).setUp()
self.a = a
@parameters.iterate('b', [4])
def test(self, b):
raise NotImplementedError()
loader = TestLoader()
suite = loader.loadTestsFromTestCase(MyTest)
test = suite._tests[0]
self.assertEquals("<test__description.{0}>".format(test), repr(test))
self.assertEquals(str(test), "MyTest(a=1).test(b=4)")
def test__discovery_by_parameters(self):
run_suite_assert_success(
TestLoader().discover(
get_sample_package_root(),
filters=[
"test__python_operators:EqualityTest[a=2].test__inequality[b=None]"
]), 2)
def test__description(self):
class MyTest(InfiTestCase):
@parameters.iterate('a', [1])
def setUp(self, a):
super(MyTest, self).setUp()
self.a = a
@parameters.iterate('b', [4])
def test(self, b):
raise NotImplementedError()
loader = TestLoader()
suite = loader.loadTestsFromTestCase(MyTest)
test = suite._tests[0]
self.assertEquals("<test__description.{0}>".format(test), repr(test))
self.assertEquals(str(test), "MyTest(a=1).test(b=4)")
def test__accidental_usage(self):
class MyTest(unittest.TestCase):
@parameters.iterate('bla', [1, 2, 3])
def test_1(self):
pass
result = run_suite(TestLoader().loadTestsFromTestCase(MyTest))
self.assertEquals(result.testsRun, 1)
self.assertEquals(len(result.errors), 1)
self.assertIn("does not derive from infi.unittest.testcase", result.errors[0][1].lower())
def test__toggle(self):
expected = set((x, y) for x in [True, False] for y in [True, False])
executed = set()
class SampleTest(TestCase):
@parameters.toggle('a', 'b')
def test__parameters(self, a, b):
executed.add((a, b))
run_suite_assert_success(TestLoader().loadTestsFromTestCase(SampleTest), len(expected))
self.assertEquals(expected, executed)
def test__abstract_base_is_not_collected(self):
@abstract_base_test
class AbstractBaseTest(TestCase):
def test__a(self):
pass
def test__b(self):
pass
class DerivedTest(AbstractBaseTest):
def test__c(self):
pass
suite = TestLoader().loadTestsFromTestCase(AbstractBaseTest)
self.assertEquals(suite._tests, [])
suite = TestLoader().loadTestsFromTestCase(DerivedTest)
self.assertEquals(len(suite._tests), 3)
self.assertEqual(
set([t._testMethodName for t in suite._tests]),
set(['test__a', 'test__b', 'test__c'])
)
def test__fields(self):
from __test_pkg__.a.b.c.module import Test
[test] = TestLoader().loadTestsFromTestCase(Test)
self.assertEquals(test.get_module_base_name(), 'module')
self.assertEquals(test.get_module_full_name(), self.full_module_name)
self.assertEquals(test.get_setup_call(), Call())
self.assertEquals(test.get_method_call(), Call())
self.assertEquals(test.get_method_name(), 'test__a')
self.assertEquals(test.get_class_name(), 'Test')
def test__fields_of_parameterized_tests(self):
from __test_pkg__.a.b.c.module import ParameterizedTest
tests = TestLoader().loadTestsFromTestCase(ParameterizedTest)._tests
self.assertEquals(len(tests), 9)
test = tests[0]
self.assertEquals(test.get_setup_call(), Call(a=1))
self.assertEquals(test.get_method_call(), Call(b=1))
self.assertEquals(
test.get_filename(),
os.path.join(self.directory, *self.full_module_name.split('.')) +
'.py')
self.assertEquals(test.get_method_name(), 'test__a')
self.assertEquals(test.get_class_name(), 'ParameterizedTest')
def test__iterate_over_callable(self):
sequence = range(10)
expected = set(sequence)
executed = set()
already_called = {"value" : False}
def get_sequence():
assert not already_called['value']
already_called['value'] = True
return sequence
class SampleTest(TestCase):
@parameters.iterate('x', get_sequence)
def test__x(self, x):
executed.add(x)
self.assertFalse(already_called['value'])
run_suite_assert_success(TestLoader().loadTestsFromTestCase(SampleTest), len(expected))
self.assertEquals(executed, expected)
def test__inheritence_abstract_bases(self):
@abstract_base_test
class Base1(TestCase):
def setUp(self):
super(Base1, self).setUp()
def tearDown(self):
super(Base1, self).tearDown()
def test(self):
pass
@abstract_base_test
class Base2(Base1):
@parameters.iterate('iterator', [0, 1])
def setUp(self, iterator):
super(Base2, self).setUp()
def tearDown(self):
super(Base2, self).tearDown()
class Derived(Base2):
pass
run_suite_assert_success(TestLoader().loadTestsFromTestCase(Derived), 2)
def test__parameters(self):
values_for_setup = [10, 20, 30]
values_for_a = [1, 2, 3]
values_for_b = [4, 5, 6]
executed = set()
expected = set(itertools.product(values_for_setup, values_for_a, values_for_b))
expected.update((x, None, None) for x in values_for_setup)
class SampleTest(TestCase):
@parameters.iterate('param', values_for_setup)
def setUp(self, param):
super(SampleTest, self).setUp()
self.setup_param = param
@parameters.iterate('a', values_for_a)
@parameters.iterate('b', values_for_b)
def test_something(self, a, b):
executed.add((self.setup_param, a, b))
def test__no_params(self):
executed.add((self.setup_param, None, None))
suite = TestLoader().loadTestsFromTestCase(SampleTest)
run_suite_assert_success(suite, len(expected))
self.assertEquals(expected, executed)
def test__inheritence(self):
base_setup_args_a = range(5)
base_setup_args_b = range(7)
derived_setup_args = range(3)
expected = set(itertools.product(base_setup_args_a, base_setup_args_b, derived_setup_args))
run = set()
class Base(TestCase):
@parameters.iterate('a', base_setup_args_a)
@parameters.iterate('b', base_setup_args_b)
def setUp(self, a, b):
super(Base, self).setUp()
self.base_param_a = a
self.base_param_b = b
class Derived(Base):
@parameters.iterate('param', derived_setup_args)
def setUp(self, param):
super(Derived, self).setUp()
self.derived_param = param
def test(self):
run.add((self.base_param_a, self.base_param_b, self.derived_param))
run_suite_assert_success(TestLoader().loadTestsFromTestCase(Derived), len(expected))
self.assertEquals(run, expected)
def test__simple_discovery(self):
loader = TestLoader()
suite = loader.discover(get_sample_package_root())
result = run_suite_assert_success(suite, count_number_of_cases_in_directory(get_sample_package_root()))
def test__simple_discovery(self):
loader = TestLoader()
suite = loader.discover(get_sample_package_root())
result = run_suite_assert_success(
suite,
count_number_of_cases_in_directory(get_sample_package_root()))
def test__discovery_with_path(self):
run_suite_assert_success(
TestLoader().discover(
get_sample_package_root(),
filters=["test__python_operators:EqualityTest"]), 2 * (3 + 3))
