def test_teardown_test_session_after_test_failure_and_test_success(): marker = [] @lcc.fixture(scope="session") def fixt(): marker.append("test_session_setup") yield 1 marker.append("test_session_teardown") @lcc.suite("MySuite") class MySuite: @lcc.test("Test 1") def test_1(self, fixt): marker.append("test_1") 1 / 0 @lcc.test("Test 2") def test_2(self): marker.append("test_2") run_suite_class(MySuite, fixtures=[fixt]) assert marker == [ "test_session_setup", "test_1", "test_2", "test_session_teardown" ]
def test_run_with_fixtures_dependencies_in_test_scope(): # in this test, fixture dependency is set on fixture alphabetical inverse # order to highlight a bad dependency check implementation that use set data type marker = [] @lcc.fixture(names=["fixt_3"], scope="test") def fixt3(): return 2 @lcc.fixture(names=["fixt_2"], scope="test") def fixt2(fixt_3): return fixt_3 * 3 @lcc.fixture(names=["fixt_1"], scope="test") def fixt1(fixt_2): return fixt_2 * 4 @lcc.suite("MySuite") class MySuite: @lcc.test("Test") def test(self, fixt_1): marker.append(fixt_1) run_suite_class(MySuite, fixtures=[fixt1, fixt2, fixt3]) assert marker == [24]
def test_fixture_name_scopes(): fixts = [] @lcc.fixture(scope="session") def fixt_session_prerun(fixture_name): fixts.append(fixture_name) @lcc.fixture(scope="session") def fixt_session(fixture_name, fixt_session_prerun): fixts.append(fixture_name) @lcc.fixture(scope="suite") def fixt_suite(fixture_name, fixt_session): fixts.append(fixture_name) @lcc.fixture(scope="test") def fixt_test(fixture_name, fixt_suite): fixts.append(fixture_name) @lcc.suite("suite") class suite: @lcc.test("test") def test(self, fixt_test): pass run_suite_class( suite, fixtures=[fixt_session_prerun, fixt_session, fixt_suite, fixt_test]) assert fixts == [ "fixt_session_prerun", "fixt_session", "fixt_suite", "fixt_test" ]
def test_run_with_suite_fixture_used_in_subsuite(): marker = [] @lcc.fixture(scope="suite") def fixt1(): yield 1 marker.append(2) @lcc.suite("MySuiteA") class MySuiteA: @lcc.test("Test") def test(self, fixt1): marker.append(fixt1) @lcc.suite("MySuiteB") class MySuiteB: @lcc.test("Test") def test(self, fixt1): marker.append(fixt1) @lcc.suite("MySuiteC") class MySuiteC: @lcc.test("Test") def test(self, fixt1): marker.append(fixt1) run_suite_class(MySuiteA, fixtures=[fixt1]) assert marker == [1, 2, 1, 2, 1, 2]
def test_report_detailed_with_filter(tmpdir, cmdout): run_suite_class(mysuite, tmpdir=tmpdir, backends=[JsonBackend()]) assert main(["report", tmpdir.strpath, "--failed"]) == 0 cmdout.dump() cmdout.assert_substrs_in_line(0, ["My Test 1"]) cmdout.assert_substrs_in_line(1, ["mysuite.mytest1"]) cmdout.assert_substrs_in_line(3, ["My Test 1"]) cmdout.assert_substrs_in_line(5, ["ERROR", "failure"]) cmdout.assert_lines_nb(9)
def test_report_detailed_with_arguments(tmpdir, cmdout): run_suite_class(mysuite, tmpdir=tmpdir, backends=[JsonBackend()]) assert main(["report", tmpdir.strpath, "--explicit", "--max-width=80"]) == 0 cmdout.dump() cmdout.assert_substrs_in_line(0, ["FAILED: My Test 1"]) cmdout.assert_substrs_in_line(1, ["mysuite.mytest1"]) cmdout.assert_substrs_in_line(3, ["My Test 1"]) cmdout.assert_substrs_in_line(5, ["ERROR", "failure"]) cmdout.assert_substrs_in_line(8, ["My Test 2"]) cmdout.assert_substrs_in_line(9, ["mysuite.mytest2"]) cmdout.assert_substrs_in_line(10, ["n/a"]) cmdout.assert_lines_nb(13)
def test_setup_suite(): marker = [] @lcc.suite("MySuite") class MySuite: def setup_suite(self): marker.append("ok") @lcc.test("Some test") def sometest(self): pass run_suite_class(MySuite) assert marker
def test_teardown_suite_after_test_failure(): marker = [] @lcc.suite("MySuite") class MySuite: def teardown_suite(self): marker.append("ok") @lcc.test("Some test") def sometest(self): 1 / 0 run_suite_class(MySuite) assert marker
def test_get_fixture_unknown(): marker = [] @lcc.suite("mysuite") class mysuite: @lcc.test("mytest") def mytest(self): try: lcc.get_fixture("fixt") except ProgrammingError: marker.append("exception") run_suite_class(mysuite) assert marker == ["exception"]
def test_setup_test(): marker = [] @lcc.suite("MySuite") class MySuite: def setup_test(self, test): marker.append(test.name) @lcc.test("Some test") def sometest(self): pass run_suite_class(MySuite) assert marker == ["sometest"]
def test_teardown_test_after_test_failure(): marker = [] @lcc.suite("MySuite") class MySuite: def teardown_test(self, test, status): marker.append((test.name, status)) @lcc.test("Some test") def sometest(self): 1 / 0 run_suite_class(MySuite) assert marker[0] == ("sometest", "failed")
def test_get_fixture(): marker = [] @lcc.fixture(scope="session_prerun") def fixt(): return 42 @lcc.suite("mysuite") class mysuite: @lcc.test("mytest") def mytest(self, fixt): marker.append(lcc.get_fixture("fixt")) run_suite_class(mysuite, fixtures=[fixt]) assert marker == [42]
def test_fixture_name_multiple_names(): fixts = [] @lcc.fixture(scope="test", names=["fixt1", "fixt2"]) def fixt(fixture_name): fixts.append(fixture_name) @lcc.suite("suite") class suite: @lcc.test("test") def test(self, fixt1, fixt2): pass run_suite_class(suite, fixtures=[fixt]) assert sorted(fixts) == ["fixt1", "fixt2"]
def test_all_types_of_logs(): @lcc.suite("MySuite") class mysuite: @lcc.test("Test 1") def test_1(self): lcc.log_debug("some debug message") lcc.log_info("some info message") lcc.log_warn("some warning message") @lcc.test("Test 2") def test_2(self): lcc.log_error("some error message") report = run_suite_class(mysuite) test = report.get_test("mysuite.test_1") assert test.status == "passed" step = test.steps[0] assert step.entries[0].level == "debug" assert step.entries[0].message == "some debug message" assert step.entries[1].level == "info" assert step.entries[1].message == "some info message" assert step.entries[2].level == "warn" test = report.get_test("mysuite.test_2") assert test.status == "failed" step = test.steps[0] assert step.entries[0].message == "some error message" assert step.entries[0].level == "error"
def test_run_with_fixture_with_logs(): marker = [] @lcc.fixture() def test_fixture(): lcc.log_info("setup") yield 1 lcc.log_info("teardown") @lcc.suite("MySuite") class MySuite: @lcc.test("Test") def test(self, test_fixture): lcc.set_step("Doing some test") lcc.log_info("some log") marker.append(test_fixture) report = run_suite_class(MySuite, fixtures=[test_fixture]) assert marker == [1] steps = report.get_suites()[0].get_tests()[0].steps assert len(steps) == 3 assert steps[0].description == "Setup test" assert steps[1].description == "Doing some test" assert steps[2].description == "Teardown test"
def test_exception_abortsuite(): @lcc.suite("MySuite") class MySuite: @lcc.suite("MyFirstSuite") class MyFirstSuite: @lcc.test("Some test") def sometest(self): raise lcc.AbortSuite("test error") @lcc.test("Some other test") def someothertest(self): pass @lcc.suite("MySecondSuite") class MySecondSuite: @lcc.test("Another test") def anothertest(self): pass assert_test_statuses( run_suite_class(MySuite), failed=["MySuite.MyFirstSuite.sometest"], skipped=["MySuite.MyFirstSuite.someothertest"], passed=["MySuite.MySecondSuite.anothertest"], )
def test_setup_suite_error_because_of_fixture(): marker = [] @lcc.fixture(scope="suite") def fix(): 1 / 0 @lcc.suite("MySuite") class MySuite: @lcc.test("Some test") def sometest(self, fix): pass @lcc.test("Some other test") def sometest_bis(self): pass def teardown_suite(self): marker.append("must_not_be_executed") report = run_suite_class(MySuite, fixtures=[fix]) assert_test_statuses(report, skipped=["MySuite.sometest", "MySuite.sometest_bis"]) assert not marker
def test_run_with_fixture_using_test_method(): marker = [] @lcc.fixture() def test_fixture(): return 1 @lcc.suite("MySuite") class MySuite: @lcc.test("Test") def test(self, test_fixture): marker.append(test_fixture) run_suite_class(MySuite, fixtures=[test_fixture]) assert marker == [1]
def test_multiple_steps_on_different_threads(): def thread_func(i): lcc.set_step(str(i), detached=True) time.sleep(0.001) lcc.log_info(str(i)) lcc.end_step(str(i)) @lcc.suite("MySuite") class mysuite: @lcc.test("Some test") def sometest(self): threads = [ lcc.Thread(target=thread_func, args=(i, )) for i in range(3) ] for thread in threads: thread.start() for thread in threads: thread.join() report = run_suite_class(mysuite) test = get_last_test(report) remainings = list(range(3)) for step in test.steps: remainings.remove(int(step.description)) assert len(step.entries) == 1 assert step.entries[0].message == step.description assert len(remainings) == 0
def test_teardown_test_session_after_test_failure(): marker = [] @lcc.fixture(scope="session") def fixt(): yield 1 marker.append(1) @lcc.suite("MySuite") class MySuite: @lcc.test("Some test") def sometest(self, fixt): 1 / 0 run_suite_class(MySuite, fixtures=[fixt]) assert marker
def test_test_failure(): @lcc.suite("MySuite") class MySuite: @lcc.test("Some test") def sometest(self): lcc.check_that("val", 1, lcc.equal_to(2)) assert_test_failed(run_suite_class(MySuite))
def test_test_success(): @lcc.suite("MySuite") class MySuite: @lcc.test("Some test") def sometest(self): pass assert_test_passed(run_suite_class(MySuite))
def test_run_with_fixture_used_in_setup_suite(): marker = [] @lcc.fixture(scope="suite") def fixt1(): return 1 @lcc.suite("MySuiteA") class MySuite: def setup_suite(self, fixt1): marker.append(fixt1) @lcc.test("sometest") def sometest(self): pass run_suite_class(MySuite, fixtures=[fixt1]) assert marker == [1]
def test_simple_test(): @lcc.suite("MySuite") class mysuite: @lcc.test("Some test") def sometest(self): pass report = run_suite_class(mysuite) assert_report_from_suite(report, mysuite)
def test_add_report_info(): @lcc.suite("Some suite") class mysuite: @lcc.test("Some test") def sometest(self): lcc.add_report_info("some info", "some data") report = run_suite_class(mysuite) assert report.info[-1] == ["some info", "some data"]
def test_get_fixture_bad_scope(): marker = [] @lcc.fixture(scope="test") def fixt(): return 42 @lcc.suite("mysuite") class mysuite: @lcc.test("mytest") def mytest(self, fixt): try: lcc.get_fixture("fixt") except ProgrammingError: marker.append("exception") run_suite_class(mysuite, fixtures=[fixt]) assert marker == ["exception"]
def test_get_fixture_not_executed(): marker = [] @lcc.fixture(scope="session_prerun") def fixt(): return 42 @lcc.suite("mysuite") class mysuite: @lcc.test("mytest") def mytest(self): try: lcc.get_fixture("fixt") except ProgrammingError: marker.append("exception") run_suite_class(mysuite) assert marker == ["exception"]
def test_sub_suite_inline(): @lcc.suite("MyParentSuite") class MyParentSuite: @lcc.suite("MyChildSuite") class MyChildSuite: @lcc.test("Some test") def sometest(self): pass assert_test_passed(run_suite_class(MyParentSuite))
def test_teardown_test_error(): @lcc.suite("MySuite") class MySuite: def teardown_test(self, test, status): 1 / 0 @lcc.test("Some test") def sometest(self): pass assert_test_failed(run_suite_class(MySuite))
def test_teardown_suite_after_test_failure_and_test_success(): marker = [] @lcc.suite("MySuite") class MySuite: def teardown_suite(self): marker.append("teardown_suite") @lcc.test("Test 1") def test_1(self): marker.append("test_1") 1 / 0 @lcc.test("Test 2") def test_2(self): marker.append("test_2") run_suite_class(MySuite) assert marker == ["test_1", "test_2", "teardown_suite"]