/usr/lib/python3/dist-packages/testtools/run.py is in python3-testtools 1.8.1-0ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 | # Copyright (c) 2009 testtools developers. See LICENSE for details.
"""python -m testtools.run testspec [testspec...]
Run some tests with the testtools extended API.
For instance, to run the testtools test suite.
$ python -m testtools.run testtools.tests.test_suite
"""
import argparse
from functools import partial
import os.path
import sys
from extras import safe_hasattr, try_imports
# To let setup.py work, make this a conditional import.
unittest = try_imports(['unittest2', 'unittest'])
from testtools import TextTestResult, testcase
from testtools.compat import classtypes, istext, unicode_output_stream
from testtools.testsuite import filter_by_ids, iterate_tests, sorted_tests
defaultTestLoader = unittest.defaultTestLoader
defaultTestLoaderCls = unittest.TestLoader
have_discover = True
# This shouldn't really be public - its legacy. Try to set it if we can, and
# if we can't (during installs before unittest2 is installed) just stub it out
# to None.
discover_impl = getattr(unittest, 'loader', None)
# Kept for API compatibility, but no longer used.
BUFFEROUTPUT = ""
CATCHBREAK = ""
FAILFAST = ""
USAGE_AS_MAIN = ""
def list_test(test):
"""Return the test ids that would be run if test() was run.
When things fail to import they can be represented as well, though
we use an ugly hack (see http://bugs.python.org/issue19746 for details)
to determine that. The difference matters because if a user is
filtering tests to run on the returned ids, a failed import can reduce
the visible tests but it can be impossible to tell that the selected
test would have been one of the imported ones.
:return: A tuple of test ids that would run and error strings
describing things that failed to import.
"""
unittest_import_strs = set([
'unittest2.loader.ModuleImportFailure.',
'unittest.loader.ModuleImportFailure.',
'discover.ModuleImportFailure.'
])
test_ids = []
errors = []
for test in iterate_tests(test):
# Much ugly.
for prefix in unittest_import_strs:
if test.id().startswith(prefix):
errors.append(test.id()[len(prefix):])
break
else:
test_ids.append(test.id())
return test_ids, errors
class TestToolsTestRunner(object):
""" A thunk object to support unittest.TestProgram."""
def __init__(self, verbosity=None, failfast=None, buffer=None,
stdout=None, tb_locals=False, **kwargs):
"""Create a TestToolsTestRunner.
:param verbosity: Ignored.
:param failfast: Stop running tests at the first failure.
:param buffer: Ignored.
:param stdout: Stream to use for stdout.
:param tb_locals: If True include local variables in tracebacks.
"""
self.failfast = failfast
if stdout is None:
stdout = sys.stdout
self.stdout = stdout
self.tb_locals = tb_locals
def list(self, test, loader):
"""List the tests that would be run if test() was run."""
test_ids, _ = list_test(test)
for test_id in test_ids:
self.stdout.write('%s\n' % test_id)
errors = loader.errors
if errors:
for test_id in errors:
self.stdout.write('%s\n' % test_id)
sys.exit(2)
def run(self, test):
"Run the given test case or test suite."
result = TextTestResult(
unicode_output_stream(self.stdout), failfast=self.failfast,
tb_locals=self.tb_locals)
result.startTestRun()
try:
return test.run(result)
finally:
result.stopTestRun()
####################
# Taken from python 2.7 and slightly modified for compatibility with
# older versions. Delete when 2.7 is the oldest supported version.
# Modifications:
# - If --catch is given, check that installHandler is available, as
# it won't be on old python versions or python builds without signals.
# - --list has been added which can list tests (should be upstreamed).
# - --load-list has been added which can reduce the tests used (should be
# upstreamed).
class TestProgram(unittest.TestProgram):
"""A command-line program that runs a set of tests; this is primarily
for making test modules conveniently executable.
"""
# defaults for testing
module=None
verbosity = 1
failfast = catchbreak = buffer = progName = None
_discovery_parser = None
def __init__(self, module=__name__, defaultTest=None, argv=None,
testRunner=None, testLoader=defaultTestLoader,
exit=True, verbosity=1, failfast=None, catchbreak=None,
buffer=None, stdout=None, tb_locals=False):
if module == __name__:
self.module = None
elif istext(module):
self.module = __import__(module)
for part in module.split('.')[1:]:
self.module = getattr(self.module, part)
else:
self.module = module
if argv is None:
argv = sys.argv
if stdout is None:
stdout = sys.stdout
self.stdout = stdout
self.exit = exit
self.failfast = failfast
self.catchbreak = catchbreak
self.verbosity = verbosity
self.buffer = buffer
self.tb_locals = tb_locals
self.defaultTest = defaultTest
# XXX: Local edit (see http://bugs.python.org/issue22860)
self.listtests = False
self.load_list = None
self.testRunner = testRunner
self.testLoader = testLoader
progName = argv[0]
if progName.endswith('%srun.py' % os.path.sep):
elements = progName.split(os.path.sep)
progName = '%s.run' % elements[-2]
else:
progName = os.path.basename(argv[0])
self.progName = progName
self.parseArgs(argv)
# XXX: Local edit (see http://bugs.python.org/issue22860)
if self.load_list:
# TODO: preserve existing suites (like testresources does in
# OptimisingTestSuite.add, but with a standard protocol).
# This is needed because the load_tests hook allows arbitrary
# suites, even if that is rarely used.
source = open(self.load_list, 'rb')
try:
lines = source.readlines()
finally:
source.close()
test_ids = set(line.strip().decode('utf-8') for line in lines)
self.test = filter_by_ids(self.test, test_ids)
# XXX: Local edit (see http://bugs.python.org/issue22860)
if not self.listtests:
self.runTests()
else:
runner = self._get_runner()
if safe_hasattr(runner, 'list'):
try:
runner.list(self.test, loader=self.testLoader)
except TypeError:
runner.list(self.test)
else:
for test in iterate_tests(self.test):
self.stdout.write('%s\n' % test.id())
del self.testLoader.errors[:]
def _getParentArgParser(self):
parser = super(TestProgram, self)._getParentArgParser()
# XXX: Local edit (see http://bugs.python.org/issue22860)
parser.add_argument('-l', '--list', dest='listtests', default=False,
action='store_true', help='List tests rather than executing them')
parser.add_argument('--load-list', dest='load_list', default=None,
help='Specifies a file containing test ids, only tests matching '
'those ids are executed')
return parser
def _do_discovery(self, argv, Loader=None):
super(TestProgram, self)._do_discovery(argv, Loader=Loader)
# XXX: Local edit (see http://bugs.python.org/issue22860)
self.test = sorted_tests(self.test)
def runTests(self):
# XXX: Local edit (see http://bugs.python.org/issue22860)
if (self.catchbreak
and getattr(unittest, 'installHandler', None) is not None):
unittest.installHandler()
testRunner = self._get_runner()
self.result = testRunner.run(self.test)
if self.exit:
sys.exit(not self.result.wasSuccessful())
def _get_runner(self):
# XXX: Local edit (see http://bugs.python.org/issue22860)
if self.testRunner is None:
self.testRunner = TestToolsTestRunner
try:
try:
testRunner = self.testRunner(verbosity=self.verbosity,
failfast=self.failfast,
buffer=self.buffer,
stdout=self.stdout,
tb_locals=self.tb_locals)
except TypeError:
# didn't accept the tb_locals parameter
testRunner = self.testRunner(verbosity=self.verbosity,
failfast=self.failfast,
buffer=self.buffer,
stdout=self.stdout)
except TypeError:
# didn't accept the verbosity, buffer, failfast or stdout arguments
# Try with the prior contract
try:
testRunner = self.testRunner(verbosity=self.verbosity,
failfast=self.failfast,
buffer=self.buffer)
except TypeError:
# Now try calling it with defaults
try:
testRunner = self.testRunner()
except TypeError:
# it is assumed to be a TestRunner instance
testRunner = self.testRunner
return testRunner
################
def main(argv, stdout):
program = TestProgram(argv=argv, testRunner=partial(TestToolsTestRunner, stdout=stdout),
stdout=stdout)
if __name__ == '__main__':
main(sys.argv, sys.stdout)
|