def test_suite():
packages = [
'arguments',
'commands',
'repository',
'ui',
]
names = [
'arguments',
'commands',
'matchers',
'monkeypatch',
'repository',
'results',
'setup',
'stubpackage',
'testcommand',
'testr',
'ui',
]
module_names = ['testrepository.tests.test_' + name for name in names]
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(module_names)
result = testresources.OptimisingTestSuite()
result.addTests(generate_scenarios(suite))
for pkgname in packages:
pkg = __import__('testrepository.tests.' + pkgname, globals(),
locals(), ['test_suite'])
result.addTests(generate_scenarios(pkg.test_suite()))
return result
def test_suite():
packages = [
'arguments',
'commands',
'repository',
'ui',
]
names = [
'arguments',
'commands',
'matchers',
'monkeypatch',
'repository',
'results',
'setup',
'stubpackage',
'testcommand',
'testr',
'ui',
]
module_names = ['testrepository.tests.test_' + name for name in names]
loader = unittest.TestLoader()
suite = loader.loadTestsFromNames(module_names)
result = testresources.OptimisingTestSuite()
result.addTests(generate_scenarios(suite))
for pkgname in packages:
pkg = __import__('testrepository.tests.' + pkgname, globals(),
locals(), ['test_suite'])
result.addTests(generate_scenarios(pkg.test_suite()))
return result
def load_tests(loader, standard_tests, pattern):
# top level directory cached on loader instance
this_dir = os.path.dirname(__file__)
package_tests = loader.discover(start_dir=this_dir, pattern=pattern)
result = testresources.OptimisingTestSuite()
result.addTests(generate_scenarios(standard_tests))
result.addTests(generate_scenarios(package_tests))
return result
def load_tests(loader, standard_tests, pattern):
# top level directory cached on loader instance
this_dir = os.path.dirname(__file__)
package_tests = loader.discover(start_dir=this_dir, pattern=pattern)
result = loader.suiteClass()
result.addTests(testscenarios.generate_scenarios(standard_tests))
result.addTests(testscenarios.generate_scenarios(package_tests))
return result
def load_tests(loader, standard_tests, pattern):
# top level directory cached on loader instance
this_dir = os.path.dirname(__file__)
package_tests = loader.discover(start_dir=this_dir, pattern=pattern)
result = testresources.OptimisingTestSuite()
result.addTests(generate_scenarios(standard_tests))
result.addTests(generate_scenarios(package_tests))
return result
def load_tests(loader, found_tests, pattern):
result = testresources.OptimisingTestSuite()
result.addTests(found_tests)
pkg_tests = loader.discover(start_dir=this_dir, pattern=pattern)
result.addTests(testscenarios.generate_scenarios(pkg_tests))
return result
def load_tests(loader, tests, pattern):
this_dir = os.path.dirname(__file__)
tests.addTests(loader.discover(start_dir=this_dir, pattern=pattern))
doctest.set_unittest_reportflags(doctest.REPORT_ONLY_FIRST_FAILURE)
tests.addTest(
doctest.DocFileSuite("../../README.rst", optionflags=doctest.ELLIPSIS))
return loader.suiteClass(generate_scenarios(tests))
def load_tests(loader, found_tests, pattern):
result = testresources.OptimisingTestSuite()
result.addTests(found_tests)
pkg_tests = loader.discover(start_dir=this_dir, pattern=pattern)
result.addTests(testscenarios.generate_scenarios(pkg_tests))
return result
def load_tests(loader, tests, pattern):
this_dir = os.path.dirname(__file__)
tests.addTests(loader.discover(start_dir=this_dir, pattern=pattern))
doctest.set_unittest_reportflags(doctest.REPORT_ONLY_FIRST_FAILURE)
tests.addTest(
doctest.DocFileSuite("../../README.rst", optionflags=doctest.ELLIPSIS))
return loader.suiteClass(generate_scenarios(tests))
def load_tests(loader, tests, pattern):
"""Test suite thunk, manually defined for Python 2.6."""
this_dir = os.path.dirname(__file__)
pkg_tests = loader.discover(start_dir=this_dir, pattern=pattern)
tests.addTest(pkg_tests)
result = generate_scenarios(tests)
result = testresources.OptimisingTestSuite(result)
return result
def load_with_scenarios(loader, standard_tests, pattern):
"""Load the tests in a given module.
This just applies testscenarios.generate_scenarios to all the tests that
are present. We do it at load time rather than at run time, because it
plays nicer with various tools.
"""
suite = loader.suiteClass()
suite.addTests(testscenarios.generate_scenarios(standard_tests))
return suite
def load_with_scenarios(loader, standard_tests, pattern):
"""Load the tests in a given module.
This just applies testscenarios.generate_scenarios to all the tests that
are present. We do it at load time rather than at run time, because it
plays nicer with various tools.
"""
suite = loader.suiteClass()
suite.addTests(testscenarios.generate_scenarios(standard_tests))
return suite
def load_tests(standard_tests, module, loader):
test_modules = [
'testcase',
'scenarios',
]
prefix = "testscenarios.tests.test_"
test_mod_names = [prefix + test_module for test_module in test_modules]
standard_tests.addTests(loader.loadTestsFromNames(test_mod_names))
doctest.set_unittest_reportflags(doctest.REPORT_ONLY_FIRST_FAILURE)
standard_tests.addTest(
doctest.DocFileSuite("../../README", optionflags=doctest.ELLIPSIS))
return loader.suiteClass(testscenarios.generate_scenarios(standard_tests))
def makeTest(self, obj, parent):
"""Attempt to expand test scenarios in the given test or tests.
If `obj` is a test case class, this loads tests and expands scenarios.
If `parent` is a test case class, this assumes that `obj` is a method,
instantiates the test case, then expands scenarios.
Everything else is ignored so the loader that invoked this will revert
to its default behaviour.
"""
# obj may be a test case class.
if isinstance(obj, type):
if issubclass(obj, unittest.TestCase):
loader = self._getTestLoader()
tests = loader.loadTestsFromTestCase(obj)
tests = map(self._unwrapTest, tests)
return generate_scenarios(tests)
# obj may be a function/method.
elif isinstance(parent, type):
if issubclass(parent, unittest.TestCase):
test = parent(obj.__name__)
return generate_scenarios(test)
def test_module_level(self):
load_tests = test_fixtures.optimize_module_test_loader()
loader = unittest.TestLoader()
found_tests = loader.discover(start_dir, pattern="test_fixtures.py")
new_loader = load_tests(loader, found_tests, "test_fixtures.py")
self.assertIsInstance(new_loader, testresources.OptimisingTestSuite)
actual_tests = unittest.TestSuite(
testscenarios.generate_scenarios(found_tests))
self.assertEqual(new_loader.countTestCases(),
actual_tests.countTestCases())
def test_suite():
from testtools.tests import (
matchers,
test_assert_that,
test_compat,
test_content,
test_content_type,
test_deferred,
test_deferredmatchers,
test_deferredruntest,
test_distutilscmd,
test_fixturesupport,
test_helpers,
test_monkey,
test_run,
test_runtest,
test_spinner,
test_tags,
test_testcase,
test_testresult,
test_testsuite,
test_with_with,
)
modules = [
matchers,
test_assert_that,
test_compat,
test_content,
test_content_type,
test_deferred,
test_deferredmatchers,
test_deferredruntest,
test_distutilscmd,
test_fixturesupport,
test_helpers,
test_monkey,
test_run,
test_runtest,
test_spinner,
test_tags,
test_testcase,
test_testresult,
test_testsuite,
test_with_with,
]
suites = map(lambda x: x.test_suite(), modules)
all_tests = TestSuite(suites)
return TestSuite(testscenarios.generate_scenarios(all_tests))
def test_suite():
from testtools.tests import (
matchers,
test_assert_that,
test_compat,
test_content,
test_content_type,
test_deferred,
test_deferredmatchers,
test_deferredruntest,
test_distutilscmd,
test_fixturesupport,
test_helpers,
test_monkey,
test_run,
test_runtest,
test_spinner,
test_tags,
test_testcase,
test_testresult,
test_testsuite,
test_with_with,
)
modules = [
matchers,
test_assert_that,
test_compat,
test_content,
test_content_type,
test_deferred,
test_deferredmatchers,
test_deferredruntest,
test_distutilscmd,
test_fixturesupport,
test_helpers,
test_monkey,
test_run,
test_runtest,
test_spinner,
test_tags,
test_testcase,
test_testresult,
test_testsuite,
test_with_with,
]
suites = map(lambda x: x.test_suite(), modules)
all_tests = TestSuite(suites)
return TestSuite(testscenarios.generate_scenarios(all_tests))
def _test_package_level(self, fn):
load_tests = fn(os.path.join(start_dir, "__init__.py"))
loader = unittest.TestLoader()
new_loader = load_tests(loader, unittest.suite.TestSuite(),
"test_fixtures.py")
self.assertIsInstance(new_loader, testresources.OptimisingTestSuite)
actual_tests = unittest.TestSuite(
testscenarios.generate_scenarios(
loader.discover(start_dir, pattern="test_fixtures.py")))
self.assertEqual(new_loader.countTestCases(),
actual_tests.countTestCases())
def test_suite():
loader = TestLoader()
result = loader.loadTestsFromModule(test_chunked)
result.addTest(loader.loadTestsFromModule(test_details))
result.addTest(loader.loadTestsFromModule(test_filters))
result.addTest(loader.loadTestsFromModule(test_progress_model))
result.addTest(loader.loadTestsFromModule(test_test_results))
result.addTest(loader.loadTestsFromModule(test_test_protocol))
result.addTest(loader.loadTestsFromModule(test_test_protocol2))
result.addTest(loader.loadTestsFromModule(test_tap2subunit))
result.addTest(loader.loadTestsFromModule(test_subunit_filter))
result.addTest(loader.loadTestsFromModule(test_subunit_tags))
result.addTest(loader.loadTestsFromModule(test_subunit_stats))
result.addTest(loader.loadTestsFromModule(test_run))
result.addTests(
generate_scenarios(loader.loadTestsFromModule(test_output_filter)))
return result
def test_suite():
loader = TestLoader()
result = loader.loadTestsFromModule(test_chunked)
result.addTest(loader.loadTestsFromModule(test_details))
result.addTest(loader.loadTestsFromModule(test_filters))
result.addTest(loader.loadTestsFromModule(test_progress_model))
result.addTest(loader.loadTestsFromModule(test_test_results))
result.addTest(loader.loadTestsFromModule(test_test_protocol))
result.addTest(loader.loadTestsFromModule(test_test_protocol2))
result.addTest(loader.loadTestsFromModule(test_tap2subunit))
result.addTest(loader.loadTestsFromModule(test_subunit_filter))
result.addTest(loader.loadTestsFromModule(test_subunit_tags))
result.addTest(loader.loadTestsFromModule(test_subunit_stats))
result.addTest(loader.loadTestsFromModule(test_run))
result.addTests(
generate_scenarios(loader.loadTestsFromModule(test_output_filter))
)
return result
def test_module_level(self):
load_tests = test_fixtures.optimize_module_test_loader()
loader = unittest.TestLoader()
found_tests = loader.discover(start_dir, pattern="test_fixtures.py")
new_loader = load_tests(loader, found_tests, "test_fixtures.py")
self.assertTrue(
isinstance(new_loader, testresources.OptimisingTestSuite)
)
actual_tests = unittest.TestSuite(
testscenarios.generate_scenarios(found_tests)
)
self.assertEqual(
new_loader.countTestCases(), actual_tests.countTestCases()
)
def _test_package_level(self, fn):
load_tests = fn(
os.path.join(start_dir, "__init__.py"))
loader = unittest.TestLoader()
new_loader = load_tests(
loader, unittest.suite.TestSuite(), "test_fixtures.py")
self.assertTrue(
isinstance(new_loader, testresources.OptimisingTestSuite)
)
actual_tests = unittest.TestSuite(
testscenarios.generate_scenarios(
loader.discover(start_dir, pattern="test_fixtures.py"))
)
self.assertEqual(
new_loader.countTestCases(), actual_tests.countTestCases()
)
def load_tests(loader, found_tests, pattern):
result = testresources.OptimisingTestSuite()
result.addTests(testscenarios.generate_scenarios(found_tests))
return result
def load_tests(loader, tests, pattern):
scenarios = testscenarios.generate_scenarios(tests)
return testresources.OptimisingTestSuite(scenarios)
def load_tests(loader, found_tests, pattern):
result = testresources.OptimisingTestSuite()
result.addTests(testscenarios.generate_scenarios(found_tests))
return result
def __call__(self, result=None):
if self._get_scenarios():
for test in testscenarios.generate_scenarios(self):
test.__call__(result)
else:
super(WithScenarios, self).__call__(result)
def __call__(self, result=None):
if self._get_scenarios():
for test in testscenarios.generate_scenarios(self):
test.__call__(result)
else:
super(WithScenarios, self).__call__(result)
