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
