def test_decorator_with_suite_inheritance(): @lcc.suite("My Suite 1") @lcc.link("http://www.example1.com") @lcc.tags("tag1", "tag2") @lcc.prop("key1", "value1") class MySuite1: pass @lcc.suite("My Suite 2") @lcc.link("http://www.example2.com") @lcc.tags("tag3") @lcc.prop("key2", "value2") class MySuite2(MySuite1): pass suite1 = load_suite_from_class(MySuite1) suite2 = load_suite_from_class(MySuite2) assert len(suite1.links) == 1 assert suite1.links[0] == ("http://www.example1.com", None) assert suite1.tags == ["tag1", "tag2"] assert len(suite1.properties) == 1 assert suite1.properties["key1"] == "value1" assert len(suite2.links) == 2 assert suite2.links[0] == ("http://www.example1.com", None) assert suite2.links[1] == ("http://www.example2.com", None) assert suite2.tags == ["tag1", "tag2", "tag3"] assert len(suite2.properties) == 2 assert suite2.properties["key1"] == "value1" assert suite2.properties["key2"] == "value2"
def test_duplicated_test_name(): @lcc.suite("My Suite") class MySuite: def __init__(self): add_test_into_suite( lcc.Test("mytest", "First test", dummy_test_callback()), self) add_test_into_suite( lcc.Test("mytest", "Second test", dummy_test_callback()), self) with pytest.raises(ProgrammingError): load_suite_from_class(MySuite)
def test_duplicated_test_description(): @lcc.suite("My Suite") class MySuite: @lcc.test("somedesc") def foo(self): pass @lcc.test("somedesc") def bar(self): pass with pytest.raises(InvalidMetadataError): load_suite_from_class(MySuite)
def test_duplicated_suite_description(): @lcc.suite("My Suite") class MySuite: @lcc.suite("somedesc") class SubSuite1: pass @lcc.suite("somedesc") class SubSuite2: pass with pytest.raises(InvalidMetadataError) as excinfo: load_suite_from_class(MySuite)
def test_allowed_properties_and_tags(): @lcc.prop("foo", 1) @lcc.tags("tag1") @lcc.suite("MySuite") class MySuite: @lcc.prop("foo", 2) @lcc.tags("tag2") @lcc.test("Some test") def sometest(self): pass suite = load_suite_from_class(MySuite) # passing case policy = MetadataPolicy() policy.add_property_rule("foo", on_test=True, on_suite=True) policy.add_tag_rule(["tag1", "tag2"], on_test=True, on_suite=True) policy.disallow_unknown_properties() policy.disallow_unknown_tags() policy.check_test_compliance(suite.get_tests()[0]) policy.check_suite_compliance(suite) # non-passing case policy = MetadataPolicy() policy.add_property_rule("bar", on_test=True, on_suite=True) policy.add_tag_rule(["tag3"], on_test=True, on_suite=True) policy.disallow_unknown_properties() policy.disallow_unknown_tags() with pytest.raises(InvalidMetadataError): policy.check_test_compliance(suite.get_tests()[0]) with pytest.raises(InvalidMetadataError): policy.check_suite_compliance(suite)
def test_suite_rank_forced(): @lcc.suite("My Suite") class MySuite1: @lcc.suite("A", rank=2) class A: @lcc.test("test") def test(self): pass @lcc.suite("B", rank=3) class B: @lcc.test("test") def test(self): pass @lcc.suite("C", rank=1) class C: @lcc.test("test") def test(self): pass @lcc.suite("D", rank=4) class D: @lcc.test("test") def test(self): pass suite = load_suite_from_class(MySuite1) assert suite.get_suites()[0].name == "C" assert suite.get_suites()[1].name == "A" assert suite.get_suites()[2].name == "B" assert suite.get_suites()[3].name == "D"
def test_different_test_and_suite_tag_configurations(): @lcc.tags("tag1") @lcc.suite("MySuite") class MySuite: @lcc.tags("tag2") @lcc.test("Some test") def sometest(self): pass suite = load_suite_from_class(MySuite) # passing case policy = MetadataPolicy() policy.add_tag_rule("tag1", on_suite=True) policy.add_tag_rule("tag2", on_test=True) policy.check_test_compliance(suite.get_tests()[0]) policy.check_suite_compliance(suite) # non-passing case policy = MetadataPolicy() policy.add_tag_rule("tag1", on_test=True) policy.add_tag_rule("tag2", on_suite=True) with pytest.raises(InvalidMetadataError): policy.check_test_compliance(suite.get_tests()[0]) with pytest.raises(InvalidMetadataError): policy.check_suite_compliance(suite)
def test_is_empty_on_suite_without_test(): @lcc.suite("My suite 1") class mysuite1: pass suite = load_suite_from_class(mysuite1) assert suite.is_empty()
def assert_report_from_suites(report, suite_classes): assert report.start_time is not None assert report.end_time is not None assert report.report_generation_time is not None assert len(report.get_suites()) == len(suite_classes) for suite_data, suite_class in zip(report.get_suites(), suite_classes): suite = load_suite_from_class(suite_class) assert_suite_data_from_suite(suite_data, suite)
def test_get_fixtures(): @lcc.suite("My Suite") class MySuite: def setup_suite(self, foo): pass suite = load_suite_from_class(MySuite) assert suite.get_fixtures() == ["foo"]
def test_is_empty_on_suite_with_test(): @lcc.suite("My suite 1") class mysuite1: @lcc.test("My test") def mytest(self): pass suite = load_suite_from_class(mysuite1) assert not suite.is_empty()
def test_add_test_into_suite_multiple(): @lcc.suite("My Suite") class MySuite: def __init__(self): for i in 1, 2, 3: add_test_into_suite( lcc.Test("mytest_%d" % i, "My Test %d" % i, dummy_test_callback()), self) suite = load_suite_from_class(MySuite) assert len(suite.get_tests()) == 3
def test_add_test_into_suite_with_method_and_fixture(): @lcc.suite("My Suite") class MySuite: def __init__(self): add_test_into_suite(lcc.Test("mytest", "My Test", self.func), self) def func(self, fixt): pass suite = load_suite_from_class(MySuite) assert suite.get_tests()[0].get_fixtures() == ["fixt"]
def test_hierarchy_depth(): @lcc.suite("My suite") class mysuite: @lcc.test("My test") def mytest(self): pass suite = load_suite_from_class(mysuite) test = suite.get_tests()[0] assert test.hierarchy_depth == 1
def test_decorator_test(): @lcc.suite("My Suite") class MySuite: @lcc.test("test_desc") def mytest(self): pass suite = load_suite_from_class(MySuite) test = suite.get_tests()[0] assert test.name == "mytest" assert test.description == "test_desc"
def test_path(): @lcc.suite("My suite") class mysuite: @lcc.test("My test") def mytest(self): pass suite = load_suite_from_class(mysuite) test = suite.get_tests()[0] assert test.path == "mysuite.mytest"
def test_add_test_into_suite_disabled(): @lcc.suite("My Suite") class MySuite: def __init__(self): test = lcc.Test("mytest", "My Test", dummy_test_callback()) test.disabled = True add_test_into_suite(test, self) suite = load_suite_from_class(MySuite) test = suite.get_tests()[0] assert test.is_disabled()
def test_add_test_into_suite_with_method(): @lcc.suite("My Suite") class MySuite: def __init__(self): add_test_into_suite(lcc.Test("mytest", "My Test", self.func), self) def func(self): pass suite = load_suite_from_class(MySuite) assert len(suite.get_tests()) == 1
def test_depends_on_test(): @lcc.suite("suite") class suite: @lcc.test("My Test") @lcc.depends_on("another.test") def test(self): pass suite = load_suite_from_class(suite) test = suite.get_tests()[0] assert test.dependencies == ["another.test"]
def test_check_fixtures_in_suites_ok(): @lcc.suite("MySuite") class MySuite: @lcc.suite("MySubSuite") class MySubSuite: @lcc.test("test") def sometest(self, fix1): pass suite = load_suite_from_class(MySuite) registry = build_registry() registry.check_fixtures_in_suites([suite])
def test_decorator_tags(): @lcc.suite("My Suite") @lcc.tags("tag3") class MySuite: @lcc.test("test_desc") @lcc.tags("tag1", "tag2") def mytest(self): pass suite = load_suite_from_class(MySuite) assert suite.tags == ["tag3"] test = suite.get_tests()[0] assert test.tags == ["tag1", "tag2"]
def test_add_test_into_suite_with_callable_and_fixture(): class SomeTest(object): def __call__(self, fixt): pass @lcc.suite("My Suite") class MySuite: def __init__(self): add_test_into_suite(lcc.Test("mytest", "My Test", SomeTest()), self) suite = load_suite_from_class(MySuite) assert suite.get_tests()[0].get_fixtures() == ["fixt"]
def test_add_test_into_suite_with_callable(): class SomeTest(object): def __call__(self): pass @lcc.suite("My Suite") class MySuite: def __init__(self): add_test_into_suite(lcc.Test("mytest", "My Test", SomeTest()), self) suite = load_suite_from_class(MySuite) assert len(suite.get_tests()) == 1
def test_check_fixtures_in_suites_incompatible_fixture_in_inject(): @lcc.suite("MySuite") class MySuite: fix3 = lcc.inject_fixture() @lcc.test("test") def sometest(self): pass suite = load_suite_from_class(MySuite) registry = build_registry() with pytest.raises(exceptions.FixtureError): registry.check_fixtures_in_suites([suite])
def test_hierarchy(): @lcc.suite("My suite") class mysuite: @lcc.test("My test") def mytest(self): pass suite = load_suite_from_class(mysuite) test = suite.get_tests()[0] path = test.hierarchy assert next(path).name == "mysuite" assert next(path).name == "mytest"
def test_decorator_link(): @lcc.suite("My Suite") @lcc.link("http://www.example.com", "example") class MySuite: @lcc.test("test_desc") @lcc.link("http://www.example.com") def mytest(self): pass suite = load_suite_from_class(MySuite) assert suite.links[0] == ("http://www.example.com", "example") test = suite.get_tests()[0] assert test.links[0] == ("http://www.example.com", None)
def test_check_fixtures_in_suites_unknown_fixture_in_test(): @lcc.suite("MySuite") class MySuite: @lcc.suite("MySubSuite") class MySubSuite: @lcc.test("test") def sometest(self, unknown_fix): pass suite = load_suite_from_class(MySuite) registry = build_registry() with pytest.raises(exceptions.FixtureError): registry.check_fixtures_in_suites([suite])
def test_decorator_prop(): @lcc.suite("My Suite") @lcc.prop("key1", "val1") class MySuite: @lcc.test("test_desc") @lcc.prop("key2", "val2") def mytest(self): pass suite = load_suite_from_class(MySuite) assert suite.properties["key1"] == "val1" test = suite.get_tests()[0] assert test.properties["key2"] == "val2"
def test_hierarchy_paths(): @lcc.suite("MySuite") class MySuite: @lcc.suite("MySubSuite") class MySubSuite: @lcc.test("Test 2") def test(self): pass suite = load_suite_from_class(MySuite) assert list(suite.get_suites()[0].get_tests()[0].hierarchy_paths) == [ "MySuite", "MySuite.MySubSuite", "MySuite.MySubSuite.test" ]
def test_pull_test_node(): @lcc.suite("My suite 1") class mysuite1: @lcc.test("My test") def mytest(self): pass suite = load_suite_from_class(mysuite1) test = suite.get_tests()[0] pulled_test = test.pull_node() assert pulled_test.parent_suite is None assert test.parent_suite is not None