def test__with_skip(self): def _if2(): test_skip() clear() test(_if2) start(listener=Listener(0)) self.assertEqual(0, len(TestSuite.get_instance().broken())) self.assertEqual(0, len(TestSuite.get_instance().success())) self.assertEqual(0, len(TestSuite.get_instance().failed())) self.assertEqual(1, len(TestSuite.get_instance().ignored())) self.assertEqual(1, TestSuite.get_instance().tests_count())
def test_three_success_one_failed_when_data(self): def _(): return [0, 1, 2, 3] clear() provider(name='four')(_) test(data_provider='four')(_fn) start(listener=Listener(0)) self.assertEqual(0, len(TestSuite.get_instance().broken())) self.assertEqual(3, len(TestSuite.get_instance().success())) self.assertEqual(1, len(TestSuite.get_instance().failed())) self.assertEqual(4, TestSuite.get_instance().tests_count())
def test_provider_with_brake(self): def _if2(it): if it == 2: test_break() clear() CONTAINER([1, 2, 3, 4], name='three') test(data_provider="three")(_if2) start(listener=Listener(0)) self.assertEqual(1, len(TestSuite.get_instance().broken())) self.assertEqual(3, len(TestSuite.get_instance().success())) self.assertEqual(0, len(TestSuite.get_instance().failed())) self.assertEqual(4, TestSuite.get_instance().tests_count())
def test_ignored_on_sys_exit(self): clear() def exit_(): import sys sys.exit(1) test(exit_) start(listener=Listener(0)) self.assertEqual(0, len(TestSuite.get_instance().broken())) self.assertEqual(0, len(TestSuite.get_instance().success())) self.assertEqual(0, len(TestSuite.get_instance().failed())) self.assertEqual(1, len(TestSuite.get_instance().ignored())) self.assertEqual(1, TestSuite.get_instance().tests_count())
def test_provider_cached(self): count = 0 def ca_(): nonlocal count count += 1 return [0, 1] clear() provider(cached=True)(ca_) test(data_provider="ca_")(_fn) test(data_provider="ca_", name='teo')(_fn) start(listener=Listener(0)) self.assertEqual(1, count) self.assertEqual(0, len(TestSuite.get_instance().broken())) self.assertEqual(4, len(TestSuite.get_instance().success())) self.assertEqual(0, len(TestSuite.get_instance().failed())) self.assertEqual(4, TestSuite.get_instance().tests_count())
def _run(func): clear() test(func) start(listener=Listener(3))
from unittest import main, TestCase import checking.runner as runner from checking.annotations import * from checking.classes.listeners.basic import Listener from tests.fixture_behaviour_test import clear a_list = [] _listener = Listener(0) _listener.on_failed = lambda t, e: a_list.append(e) class AssertTest(TestCase): def setUp(self) -> None: clear() a_list.clear() def test_assert_equal(self): def _(): assert 1 == 2 test(_) runner.start(listener=_listener) self.assertTrue(type(a_list[0]) is AssertionError) self.assertEqual(a_list[0].args[0], 'Objects are not equal (1 != 2)') def test_assert_not_equal(self): def _(): assert 1 != 1 test(_)
def test_get_test_arg_short_without_new_line_returns_empty(self): test_ = Test('name', print) test_.argument = 1 self.assertEqual('', Listener._get_test_arg_short_without_new_line(test_))
def test_get_test_arg_short_without_new_line_returns_none(self): test_ = Test('name', print) test_.provider = '1' self.assertEqual('[None]', Listener._get_test_arg_short_without_new_line(test_))
class TestBeforeAndAfter(TestCase): _listener = Listener(0) def test_no_fixture_when_simple_test(self): clear() test(fn) start(listener=self._listener) self.assertEqual('test', common_str) def test_before_suite_default(self): clear() test(fn) before_suite(b_suite) start(listener=self._listener) self.assertEqual('bs_test', common_str) def test_after_suite_default(self): clear() test(fn) after_suite(a_suite) start(listener=self._listener) self.assertEqual('test_as', common_str) def test_before_group_default(self): clear() test(fn) before_group(b_group) start(listener=self._listener) self.assertEqual('bg_test', common_str) def test_after_group_default(self): clear() test(fn) after_group(a_group) start(listener=self._listener) self.assertEqual('test_ag', common_str) def test_before_test_default(self): clear() test(fn) before(b_test) start(listener=self._listener) self.assertEqual('bt_test', common_str) def test_after_test_default(self): clear() test(fn) after(a_test) start(listener=self._listener) self.assertEqual('test_at', common_str) def test_all_fixtures_default(self): clear() test(fn) after_group(a_group) before_group(b_group) before(b_test) after(a_test) before_suite(b_suite) after_suite(a_suite) start(listener=self._listener) self.assertEqual('bs_bg_bt_test_at_ag_as', common_str) def test_all_fixtures_default_with_two_tests(self): clear() test(fn) test(fn) after_group(a_group) before_group(b_group) before(b_test) after(a_test) before_suite(b_suite) after_suite(a_suite) start(listener=self._listener) self.assertEqual('bs_bg_bt_test_atbt_test_at_ag_as', common_str) def test_run_after_suite_if_before_failed_and_flag_true(self): clear() after_suite(always_run=True)(a_suite) test(fn) TestSuite.get_instance().is_before_failed = True start(listener=self._listener) self.assertEqual('_as', common_str) def test_not_run_after_suite_if_before_failed(self): clear() after_suite(a_suite) test(fn) TestSuite.get_instance().is_before_failed = True start(listener=self._listener) self.assertEqual('', common_str) def test_run_after_group_if_before_failed_and_flag_true(self): clear() after_group(always_run=True)(a_group) test(fn) list(TestSuite.get_instance().groups.values() )[0].is_before_failed = True start(listener=self._listener) self.assertEqual('_ag', common_str) def test_not_run_after_group_if_before_failed(self): clear() after_group(a_group) test(fn) list(TestSuite.get_instance().groups.values() )[0].is_before_failed = True start(listener=self._listener) self.assertEqual('', common_str) def test_no_after_test_if_before_failed(self): clear() test(fn) after_group(a_group) before_group(b_group) before(b_test) after(a_test) before_suite(b_suite) after_suite(a_suite) list(TestSuite.get_instance().groups.values() )[0].tests[0].is_before_failed = True start(listener=self._listener) self.assertEqual('bs_bg_bt__ag_as', common_str) def test_all_fixtures_default_with_two_tests_and_different_groups(self): clear() test(fn) test(groups=['api'])(fn) after_group(a_group) before_group(b_group) before(b_test) after(a_test) after_group(name='api')(a_group_2) before_group(name='api')(b_group_2) before(group_name='api')(b_test_2) after(group_name='api')(a_test_2) before_suite(b_suite) after_suite(a_suite) start(listener=self._listener) self.assertEqual('bs_bg_bt_test_at_agBG_BT_test_AT_AG_as', common_str) def test_retries_if_not_fails(self): clear() test(retries=3)(fn) start(listener=self._listener) self.assertEqual(1, len(TestSuite.get_instance().success())) self.assertEqual(1, TestSuite.get_instance().tests_count()) def test_retries_if_fails(self): clear() test(retries=3)(failed) start(listener=self._listener) self.assertEqual(0, len(TestSuite.get_instance().success())) self.assertEqual(3, len(TestSuite.get_instance().failed())) self.assertEqual(3, TestSuite.get_instance().tests_count()) def test_priorities(self): clear() test(priority=3)(b_suite) test(priority=2)(a_suite) test(priority=1)(b_group) test(fn) start(listener=self._listener) self.assertEqual('testbg__asbs_', common_str) def test_common_params(self): clear() test(par_1) test(par_2) start(listener=self._listener) self.assertEqual(runner.common.as_dict(), {'1': 1}) def test_no_tests_if_filter_not_existed_group(self): clear() test(par_1) test(groups=['a'])(par_2) start(listener=self._listener, groups=['b']) self.assertFalse(TestSuite.tests_count()) def test_one_test_if_filter_existed_group(self): clear() test(par_1) test(groups=['a'])(par_2) start(listener=self._listener, groups=['a']) self.assertEqual(1, TestSuite.tests_count()) def test_no_params_on_default(self): clear() test(fn) start(listener=self._listener) self.assertFalse(runner.common) def test_params_if_exists(self): clear() test(fn) start(listener=self._listener, params={'test': 'test'}) self.assertTrue(runner.common) self.assertEqual(runner.common.as_dict(), {'test': 'test'}) def test_params_if_exists_and_use_in_test(self): clear() test(par_1) start(listener=self._listener, params={'test': 'test'}) self.assertTrue(runner.common) self.assertEqual('test', runner.common['test']) self.assertEqual(1, runner.common['1']) def test_common_function_works(self): def name(): pass clear() common_function(name) test(failed) start(listener=self._listener) self.assertTrue(runner.common) self.assertEqual(name, runner.common.name) self.assertEqual(name, runner.common['name']) def test_common_function_works_with_params(self): def name(): pass clear() common_function(name) test(failed) start(listener=self._listener, params={'test': 'test'}) self.assertTrue(runner.common) self.assertEqual(name, runner.common.name) self.assertEqual('test', runner.common.test) self.assertEqual(2, len(runner.common.as_dict())) def test_common_function_raises_on_second_use_of_name(self): def name(): pass clear() common_function(name) with self.assertRaises(WrongDecoratedObject) as e: common_function(name) self.assertEqual(e.exception.args[0], 'Name "name" is already used at common object')
class TestAnnotations(TestCase): _listener = Listener(0) def test_valid_func_works(self): clear() initial_count = TestSuite.get_instance().tests_count() test(valid) self.assertEqual(initial_count + 1, TestSuite.get_instance().tests_count()) def test_not_add_if_disabled(self): clear() initial_count = TestSuite.get_instance().tests_count() test(enabled=False)(valid) self.assertEqual(initial_count, TestSuite.get_instance().tests_count()) def test_not_add_if_enabled(self): clear() initial_count = TestSuite.get_instance().tests_count() test(enabled=True)(valid) self.assertEqual(initial_count + 1, TestSuite.get_instance().tests_count()) def test_raises_when_func_for_provider_has_no_arg(self): with self.assertRaises(WrongDecoratedObject) as e: test(data_provider="good")(valid) self.assertEqual( "Test named 'valid' uses a data provider, but takes no arguments.", e.exception.args[0]) def test_raises_when_no_provider(self): clear() test(data_provider="missing")(valid_for_provider) with self.assertRaises(UnknownProviderName) as e: start(TestSuite.get_instance(), listener=Listener(0)) self.assertTrue("Could not find provider(s) named ['missing']" in e.exception.args[0]) def test_ignore_all_if_test_disabled(self): test(enabled=False, data_provider="wrong")(valid) def test_raises_when_using_test_with_class(self): with self.assertRaises(WrongDecoratedObject) as ex: test(T) self.assertTrue('test' in ex.exception.args[0]) def test_raises_when_using_function_with_arg(self): with self.assertRaises(WrongDecoratedObject) as ex: test(valid_for_provider) self.assertTrue('test' in ex.exception.args[0]) def test_raises_when_using_test_with_class_methods(self): with self.assertRaises(WrongDecoratedObject) as ex: t = T() test(t.m) self.assertTrue('test' in ex.exception.args[0]) def test_name_param_works(self): clear() test(name='new_name')(valid) self.assertTrue('new_name' in [ t.name for t in list(TestSuite.get_instance().groups.values())[0].tests ]) def test_raises_if_only_is_not_callable(self): clear() with self.assertRaises(ValueError): test(only_if=False)(valid) def test_data_works(self): clear() provider(name="any_name")(valid_for_data) self.assertTrue('any_name' in TestSuite.get_instance().providers) def test_data_raises_when_duplicate_name(self): with self.assertRaises(DuplicateProviderNameException) as e: provider(valid_for_data) provider(valid_for_data) self.assertEqual( "Provider named 'valid_for_data' already exists. Provider names must be unique.", e.exception.args[0]) def test_data_raises_when_two_args(self): def _(): return [1, 2] with self.assertRaises(WrongDecoratedObject) as e: provider(name='another2')(_) test(data_provider='another2')(non_valid_for_provider) self.assertEqual( "Test named 'non_valid_for_provider' uses a data provider, but takes more than one argument.", e.exception.args[0]) def test_data_name_works(self): clear() provider(name="another")(valid_for_data) self.assertTrue('another' in TestSuite.get_instance().providers) def test_data_ignore_if_disabled(self): clear() provider(enabled=False, name="no")(valid) self.assertFalse('no' in TestSuite.get_instance().providers) def test_before_all_when_before_first(self): clear() before_ = valid before(before_) t = Test('first', print) list(TestSuite.get_instance().groups.values())[0].add_test(t) self.assertTrue(t.before) self.assertEqual(before_, t.before[0]) def test_before_all_when_before_last(self): clear() t = Test('second', print) TestSuite.get_instance().get_or_create("new").add_test(t) bef = lambda: None before(group_name='new')(bef) self.assertTrue(bef in t.before) def test_no_timeout_default(self): clear() test(valid) self.assertEqual( 0, list(TestSuite.get_instance().groups.values())[0].tests[0].timeout) def test_timeout_same(self): clear() test(timeout=10)(valid) self.assertEqual( 10, list(TestSuite.get_instance().groups.values())[0].tests[0].timeout) def test_timeout_same_float(self): clear() test(timeout=10.02)(valid) self.assertEqual( 10, list(TestSuite.get_instance().groups.values())[0].tests[0].timeout) def test_timeout_same_negative(self): clear() test(timeout=-1)(valid) self.assertEqual( 0, list(TestSuite.get_instance().groups.values())[0].tests[0].timeout) def test_description_empty(self): clear() test(valid) self.assertIsNone( list(TestSuite.get_instance().groups.values()) [0].tests[0].description) self.assertEqual( 'annotations_test.valid', str(list(TestSuite.get_instance().groups.values())[0].tests[0])) def test_description_from_param(self): clear() test(description='test')(valid) self.assertEqual( list(TestSuite.get_instance().groups.values()) [0].tests[0].description, 'test') self.assertEqual( "annotations_test.valid ('test')", str(list(TestSuite.get_instance().groups.values())[0].tests[0])) def test_description_from_docs(self): clear() test(f) self.assertEqual( list(TestSuite.get_instance().groups.values()) [0].tests[0].description, 'Test') self.assertEqual( "annotations_test.f ('Test')", str(list(TestSuite.get_instance().groups.values())[0].tests[0])) def test_description_from_param_wins_docs(self): clear() test(description='test')(f) self.assertEqual( list(TestSuite.get_instance().groups.values()) [0].tests[0].description, 'test') self.assertEqual( "annotations_test.f ('test')", str(list(TestSuite.get_instance().groups.values())[0].tests[0])) def test_data_file(self): clear() DATA_FILE('test_data.txt', name='new') test(data_provider='new')(valid_for_provider) self.assertTrue('new' in TestSuite.get_instance().providers) def test_data_file_has_three_tests(self): clear() DATA_FILE('test_data.txt', name='new') test(data_provider='new')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_data_file_has_three_tests_with_long_path(self): clear() DATA_FILE('files/test_data.txt', name='new') test(data_provider='new')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_data_file_when_no_name(self): clear() DATA_FILE('files/test_data.txt') test(data_provider='files/test_data.txt')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_container_has_three_tests_default(self): clear() CONTAINER([_ for _ in range(3)]) test(data_provider='container')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_container_has_three_tests_generator(self): clear() CONTAINER((_ for _ in range(3))) test(data_provider='container')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_container_has_three_tests_str(self): clear() CONTAINER('123') test(data_provider='container')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_container_has_three_tests_with_name(self): clear() CONTAINER('123', name='text') test(data_provider='text')(valid_for_provider) start(listener=self._listener) self.assertEqual(3, TestSuite.tests_count()) def test_data_function_must_have_return_fail(self): def fail(): pass clear() with self.assertRaises(WrongDecoratedObject): provider(name='text')(fail)