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__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))