1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
# testscenarios: extensions to python unittest to allow declarative
# dependency injection ('scenarios') by tests.
#
# Copyright (c) 2009, Robert Collins <robertc@robertcollins.net>
# Copyright (c) 2010 Martin Pool <mbp@sourcefrog.net>
#
# Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
# license at the users choice. A copy of both licenses are available in the
# project source as Apache-2.0 and BSD. You may not use this file except in
# compliance with one of these two licences.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# license you chose for the specific language governing permissions and
# limitations under that license.
__all__ = [
'apply_scenario',
'apply_scenarios',
'generate_scenarios',
'load_tests_apply_scenarios',
]
import unittest
from testtools.testcase import clone_test_with_new_id
from testtools import iterate_tests
def apply_scenario((name, parameters), test):
"""Apply scenario to test.
:param scenario: A tuple (name, parameters) to apply to the test. The test
is cloned, its id adjusted to have (name) after it, and the parameters
dict is used to update the new test.
:param test: The test to apply the scenario to. This test is unaltered.
:return: A new test cloned from test, with the scenario applied.
"""
scenario_suffix = '(' + name + ')'
newtest = clone_test_with_new_id(test,
test.id() + scenario_suffix)
test_desc = test.shortDescription()
if test_desc is not None:
newtest_desc = "%(test_desc)s %(scenario_suffix)s" % vars()
newtest.shortDescription = (lambda: newtest_desc)
for key, value in parameters.iteritems():
setattr(newtest, key, value)
return newtest
def apply_scenarios(scenarios, test):
"""Apply many scenarios to a test.
:param scenarios: An iterable of scenarios.
:param test: A test to apply the scenarios to.
:return: A generator of tests.
"""
for scenario in scenarios:
yield apply_scenario(scenario, test)
def generate_scenarios(test_or_suite):
"""Yield the tests in test_or_suite with scenario multiplication done.
TestCase objects with no scenarios specified are yielded unaltered. Tests
with scenarios are not yielded at all, instead the results of multiplying
them by the scenarios they specified gets yielded.
:param test_or_suite: A TestCase or TestSuite.
:return: A generator of tests - objects satisfying the TestCase protocol.
"""
for test in iterate_tests(test_or_suite):
scenarios = getattr(test, 'scenarios', None)
if scenarios:
for newtest in apply_scenarios(scenarios, test):
newtest.scenarios = None
yield newtest
else:
yield test
def load_tests_apply_scenarios(loader, standard_tests, pattern):
"""Multiply out all tests in a module that have scenarios.
If this is referenced by the `load_tests` attribute of a module, then
Python2.7 or other testloaders that implement this protocol will
automatically arrange for the scenarios to be expanded. In this case it
is not necessary (or desirable) to subclass TestWithScenarios.
Note that this function implements the protocol used by Python2.7
<http://docs.python.org/library/unittest.html#load-tests-protocol> which
is different from the `load_tests` method originally used in bzr
and some other projects <http://pad.lv/607412>.
:param loader: A TestLoader.
:param standard_test: The test objects found in this module before
multiplication.
"""
result = loader.suiteClass()
result.addTests(generate_scenarios(standard_tests))
return result
|