def make_multitest(name, part_tuple=None, suites=None):
# a test target shall only return 1 runnable object
test = MultiTest(
name=name, suites=[cls() for cls in suites], part=part_tuple
)
return test
def main(plan):
plan.add(MultiTest(name='Assertions Test', suites=[SampleSuite()]))
def make_multitest():
return MultiTest(name='MyMultitest', suites=[MySuite()])
def main(plan):
multi_test = MultiTest(name="Sample", suites=[Alpha(), Beta(), Gamma()])
plan.add(multi_test)
def main(plan):
plan.add(
MultiTest(name="AssertionsSummaryTest", suites=[AssertionsSummary()]))
def get_mtest():
return MultiTest(name='MTest3', suites=[MySuite()])
def schedule_tests_to_pool(plan, pool, **pool_cfg):
pool_name = pool.__name__
pool = pool(name=pool_name, **pool_cfg)
plan.add_resource(pool)
uids = []
dirname = os.path.dirname(os.path.abspath(__file__))
mtest1 = MultiTest(name="MTest1", suites=[MySuite()])
mtest2 = MultiTest(name="MTest2", suites=[MySuite()])
uids.append(plan.schedule(target=mtest1, weight=1, resource=pool_name))
uids.append(
plan.schedule(Task(target=mtest2, weight=2), resource=pool_name)
)
task3 = Task(target=get_mtest, path=dirname, kwargs=dict(name=3), weight=3)
uids.append(plan.schedule(task=task3, resource=pool_name))
# Task schedule shortcut
uids.append(
plan.schedule(
target="get_mtest",
module="func_pool_base_tasks",
path=dirname,
kwargs=dict(name=4),
weight=4,
resource=pool_name,
)
)
uids.append(
plan.schedule(
Task(
target="get_mtest",
module="func_pool_base_tasks",
path=dirname,
kwargs=dict(name=5),
weight=5,
),
resource=pool_name,
)
)
from .func_pool_base_tasks import get_mtest_imported
uids.append(
plan.schedule(
Task(target=get_mtest_imported, kwargs=dict(name=6), weight=6),
resource=pool_name,
)
)
uids.append(
plan.schedule(
Task(target=get_mtest(name=7), weight=7), resource=pool_name
)
)
assert plan.run().run is True
assert plan.report.passed is True
assert plan.report.counter == {"passed": 7, "total": 7, "failed": 0}
names = ["MTest{}".format(x) for x in range(1, 8)]
assert [entry.name for entry in plan.report.entries] == names
assert isinstance(plan.report.serialize(), dict)
assert [plan.result.test_results[uid].report.name for uid in uids] == names
assert list(pool._executed_tests) == uids[::-1]
def main(plan):
multi_test_1 = MultiTest(name='Primary', suites=[AlphaSuite()])
multi_test_2 = MultiTest(name='Secondary', suites=[BetaSuite()])
plan.add(multi_test_1)
plan.add(multi_test_2)
def multitest_kill_one_worker(name, parent_pid, size):
"""Test that kills one worker."""
return MultiTest(name='MTest{}'.format(name),
suites=[SuiteKillingWorker(parent_pid, size)])
def get_mtest(name):
return MultiTest(name="MTest{}".format(name), suites=[MySuite()])
def get_mtest_imported(name):
"""TODO."""
return MultiTest(name='MTest{}'.format(name), suites=[MySuite()])
pass
@testcase(tags={'speed': 'fast'})
def test_two(self, env, result):
pass
@testcase(tags={'color': 'green'})
def test_three(self, env, result):
pass
@testcase(tags={'color': ('blue', 'red')})
def test_four(self, env, result):
pass
multitest_A = MultiTest(name='AAA', suites=[Alpha()])
multitest_B = MultiTest(name='BBB', suites=[Beta()])
multitest_C = MultiTest(name='CCC', suites=[Gamma()])
multitest_D = MultiTest(name='DDD', suites=[Alpha(), Beta()])
multitest_E = MultiTest(name='EEE', suites=[Beta(), Gamma()])
multitest_F = MultiTest(name='FFF', suites=[Alpha(), Beta(), Gamma()])
class TestTags(object):
@pytest.mark.parametrize(
'tags, multitest, expected',
(
('foo', multitest_A, True),
(('foo', 'something', 'else'), multitest_A, True),
('bar', multitest_A, False),
def main(plan):
plan.add(
MultiTest(name="MultiTest",
suites=[Suite()],
testcase_report_target=False))
def test_xml_exporter(tmpdir):
"""
XMLExporter should create a JUnit compatible xml file for each
multitest in the plan.
"""
xml_dir = tmpdir.mkdir('xml')
with log_propagation_disabled(TESTPLAN_LOGGER):
plan = Testplan(
name='plan', parse_cmdline=False,
exporters=XMLExporter(xml_dir=xml_dir.strpath)
)
multitest_1 = MultiTest(name='Primary', suites=[Alpha()])
multitest_2 = MultiTest(name='Secondary', suites=[Beta()])
plan.add(multitest_1)
plan.add(multitest_2)
plan.run()
xml_primary = xml_dir.join('primary.xml').strpath
xml_secondary = xml_dir.join('secondary.xml').strpath
xml_primary_comparison = XC(
tag='testsuites',
children=[
XC(
tag='testsuite',
tests="2", errors="0", name="Alpha",
package="Primary:Alpha",
hostname=re.compile(".+"),
failures="0", id="0",
children=[
XC(
tag='testcase',
classname='Primary:Alpha:test_comparison',
name='test_comparison',
time=re.compile('\d+\.?\d*')
),
XC(
tag='testcase',
classname='Primary:Alpha:test_membership',
name='test_membership',
time=re.compile('\d+\.?\d*')
),
XC(tag='system-out'),
XC(tag='system-err')
]
),
]
)
xml_secondary_comparison = XC(
tag='testsuites',
children=[
XC(
tag='testsuite',
tests="2", errors="1", name="Beta",
package="Secondary:Beta",
hostname=re.compile(".+"),
failures="1", id="0",
children=[
XC(
tag='testcase',
classname='Secondary:Beta:test_failure',
name='test_failure',
time=re.compile('\d+\.?\d*'),
children=[
XC(
tag='failure',
message='failing assertion', type='assertion'),
XC(
tag='failure',
message='Equal', type='assertion'),
],
),
XC(
tag='testcase',
classname='Secondary:Beta:test_error',
name='test_error',
time=re.compile('\d+\.?\d*'),
children=[
XC(
tag='error',
message=re.compile(
'Traceback(.|\s)+Exception:\sfoo'
)
)
]
),
XC(tag='system-out'),
XC(tag='system-err')
]
)
]
)
test_ctx = (
(xml_primary, xml_primary_comparison),
(xml_secondary, xml_secondary_comparison)
)
for file_path, xml_comparison in test_ctx:
with open(file_path) as xml_file:
xml_comparison.compare(xml_file.read())
def make_multitest(part_tuple=None):
test = MultiTest(name='MultitestParts',
suites=[Suite1(), Suite2()],
part=part_tuple)
return test
def test_three(self, env, result):
pass
@testcase(tags={"color": ("blue", "red")})
def test_four(self, env, result):
pass
@testsuite
class Delta(object):
@testcase(parameters=[1, 2, 3])
def parametrized(self, env, result, val):
pass
multitest_A = MultiTest(name="AAA", suites=[Alpha()])
multitest_B = MultiTest(name="BBB", suites=[Beta()])
multitest_C = MultiTest(name="CCC", suites=[Gamma()])
multitest_D = MultiTest(name="DDD", suites=[Alpha(), Beta()])
multitest_E = MultiTest(name="EEE", suites=[Beta(), Gamma()])
multitest_F = MultiTest(name="FFF", suites=[Alpha(), Beta(), Gamma()])
class TestTags(object):
@pytest.mark.parametrize(
"tags, multitest, expected",
(
("foo", multitest_A, True),
(("foo", "something", "else"), multitest_A, True),
("bar", multitest_A, False),
({"color": "blue"}, multitest_A, True),
def main(plan):
test = MultiTest(name="MultiplyTest", suites=[Alpha()])
plan.add(test)
def main(plan):
plan.add(MultiTest(
name="Hooks",
suites=[SimpleTest()],
))
def get_mtest():
test = MultiTest(
name="MTest", suites=[Suite1(), Suite2()], thread_pool_size=2
)
return test
def test_parametrization_tagging():
"""
Parametrization report group should include tags
generated by `tag_func` and native suite tags in `tag_index` attribute.
"""
@testsuite(tags='foo')
class DummySuite(object):
@testcase(parameters=('red', 'blue', 'green'),
tags='alpha',
tag_func=lambda kwargs: {'color': kwargs['color']})
def dummy_test(self, env, result, color):
pass
all_tags_index = {
'simple': frozenset({'foo', 'alpha'}),
'color': frozenset({'red', 'blue', 'green'})
}
parametrization_group = TestGroupReport(
name='dummy_test',
category=Categories.PARAMETRIZATION,
tags={
'simple': frozenset({'alpha'}),
},
tags_index=all_tags_index,
entries=[
TestCaseReport(name='dummy_test__color_red',
tags={
'simple': frozenset({'alpha'}),
'color': frozenset({'red'})
},
tags_index={
'simple': frozenset({'foo', 'alpha'}),
'color': frozenset({'red'})
}),
TestCaseReport(name='dummy_test__color_blue',
tags={
'simple': frozenset({'alpha'}),
'color': frozenset({'blue'})
},
tags_index={
'simple': frozenset({'foo', 'alpha'}),
'color': frozenset({'blue'})
}),
TestCaseReport(name='dummy_test__color_green',
tags={
'simple': frozenset({'alpha'}),
'color': frozenset({'green'})
},
tags_index={
'simple': frozenset({'foo', 'alpha'}),
'color': frozenset({'green'})
}),
])
multitest = MultiTest(name='MyMultitest', suites=[DummySuite()])
plan = Testplan(name='plan', parse_cmdline=False)
plan.add(multitest)
plan.run()
expected_report = TestReport(
name='plan',
entries=[
TestGroupReport(name='MyMultitest',
tags_index=all_tags_index,
category=Categories.MULTITEST,
entries=[
TestGroupReport(
name='DummySuite',
tags={'simple': frozenset({'foo'})},
tags_index=all_tags_index,
category=Categories.SUITE,
entries=[parametrization_group])
])
])
check_report(expected_report, plan.report)
def make_multitest1():
# a test target shall only return 1 runnable object
test = MultiTest(name="Proj2-Suite1", suites=[Suite1()])
return test
def main(plan):
plan.add(MultiTest(name="Chart Assertions Test", suites=[SampleSuite()]))
def main(plan):
test1 = MultiTest(name="Primary", suites=[Alpha(), Beta()])
test2 = MultiTest(name="Secondary", suites=[Gamma()])
plan.add(test1)
plan.add(test2)
def main(plan):
multi_test_1 = MultiTest(name="Primary", suites=[Alpha(), Beta()])
multi_test_2 = MultiTest(name="Secondary", suites=[Gamma()])
plan.add(multi_test_1)
plan.add(multi_test_2)
def get_test():
test = MultiTest(name="API Test", suites=[api_testsuite()])
return test
