def test_moduleImportFailureIgnored(self):
"toProtoTestList() does not raise errors when doing completions"
suite = MagicMock()
suite.__class__.__name__ = str('ModuleImportFailure')
suite.__str__.return_value = "exception_method other_stuff"
suite.exception_method.side_effect = AttributeError
self.assertEqual(loader.toProtoTestList(suite, doing_completions=True), [])
def test_moduleImportFailureIgnored(self):
"""
toProtoTestList() does not raise errors when doing completions
"""
suite = MagicMock()
suite.__class__.__name__ = str("ModuleImportFailure")
suite.__str__.return_value = "exception_method other_stuff"
suite.exception_method.side_effect = AttributeError
self.assertEqual(loader.toProtoTestList(suite, doing_completions=True), [])
def run(self, suite):
"Run the given test case or test suite."
result = GreenTestResult(
self.stream, self.descriptions, self.verbosity, html=self.html,
termcolor=self.termcolor)
registerResult(result)
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.warnings)
# if the filter is 'default' or 'always', special-case the
# warnings from the deprecated unittest methods to show them
# no more than once per module, because they can be fairly
# noisy. The -Wd and -Wa flags can be used to bypass this
# only when self.warnings is None.
if self.warnings in ['default', 'always']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
result.startTestRun()
if self.subprocesses == 1:
suite.run(result)
else:
tests = toProtoTestList(suite)
pool = LoggingDaemonlessPool(processes=self.subprocesses)
if tests:
async_responses = []
for index, test in enumerate(tests):
if self.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
async_responses.append(pool.apply_async(
poolRunner,
(test.dotted_name, coverage_number, self.omit)))
pool.close()
for test, async_response in zip(tests, async_responses):
# Prints out the white 'processing...' version of the output
result.startTest(test)
# This blocks until the worker who is processing this
# particular test actually finishes
result.addProtoTestResult(async_response.get())
pool.terminate()
pool.join()
result.stopTestRun()
return result
def test_BigDirWithAbsoluteImports(self):
"""
Big dir discovers tests and doesn't crash on absolute import
"""
sub_tmpdir = tempfile.mkdtemp(dir=self.tmpdir)
pkg_name = os.path.basename(sub_tmpdir)
# Child setup
# pkg/__init__.py
fh = open(os.path.join(sub_tmpdir, "__init__.py"), "w")
fh.write("\n")
fh.close()
# pkg/target_module.py
fh = open(os.path.join(sub_tmpdir, "target_module.py"), "w")
fh.write("a = 1\n")
fh.close()
# pkg/test/__init__.py
os.mkdir(os.path.join(sub_tmpdir, "test"))
fh = open(os.path.join(sub_tmpdir, "test", "__init__.py"), "w")
fh.write("\n")
fh.close()
# pkg/test/test_target_module.py
fh = open(os.path.join(sub_tmpdir, "test", "test_target_module.py"), "w")
fh.write(
dedent(
"""
import unittest
import {}.target_module
class A(unittest.TestCase):
def testPass(self):
pass
""".format(
pkg_name
)
)
)
fh.close()
# Load the tests
os.chdir(self.tmpdir)
test_suite = self.loader.loadTargets(pkg_name)
self.assertEqual(test_suite.countTestCases(), 1)
# Dotted name should start with the package!
self.assertEqual(
pkg_name + ".test.test_target_module.A.testPass",
loader.toProtoTestList(test_suite)[0].dotted_name,
)
def test_BigDirWithAbsoluteImports(self):
"""
Big dir discovers tests and doesn't crash on absolute import
"""
sub_tmpdir = tempfile.mkdtemp(dir=self.tmpdir)
pkg_name = os.path.basename(sub_tmpdir)
# Child setup
# pkg/__init__.py
fh = open(os.path.join(sub_tmpdir, "__init__.py"), "w")
fh.write("\n")
fh.close()
# pkg/target_module.py
fh = open(os.path.join(sub_tmpdir, "target_module.py"), "w")
fh.write("a = 1\n")
fh.close()
# pkg/test/__init__.py
os.mkdir(os.path.join(sub_tmpdir, "test"))
fh = open(os.path.join(sub_tmpdir, "test", "__init__.py"), "w")
fh.write("\n")
fh.close()
# pkg/test/test_target_module.py
fh = open(os.path.join(sub_tmpdir, "test", "test_target_module.py"), "w")
fh.write(
dedent(
"""
import unittest
import {}.target_module
class A(unittest.TestCase):
def testPass(self):
pass
""".format(
pkg_name
)
)
)
fh.close()
# Load the tests
os.chdir(self.tmpdir)
test_suite = loader.loadTargets(pkg_name)
self.assertEqual(test_suite.countTestCases(), 1)
# Dotted name should start with the package!
self.assertEqual(
pkg_name + ".test.test_target_module.A.testPass", loader.toProtoTestList(test_suite)[0].dotted_name
)
def run(suite, stream, args):
"""
Run the given test case or test suite with the specified arguments.
Any args.stream passed in will be wrapped in a GreenStream
"""
if not issubclass(GreenStream, type(stream)):
stream = GreenStream(stream)
result = GreenTestResult(args, stream)
# Note: Catching SIGINT isn't supported by Python on windows (python
# "WONTFIX" issue 18040)
installHandler()
registerResult(result)
with warnings.catch_warnings():
if args.warnings:
# if args.warnings is set, use it to filter all the warnings
warnings.simplefilter(args.warnings)
# if the filter is 'default' or 'always', special-case the
# warnings from the deprecated unittest methods to show them
# no more than once per module, because they can be fairly
# noisy. The -Wd and -Wa flags can be used to bypass this
# only when args.warnings is None.
if args.warnings in ['default', 'always']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
result.startTestRun()
tests = toProtoTestList(suite)
pool = LoggingDaemonlessPool(processes=args.subprocesses or None)
if tests:
async_responses = []
for index, test in enumerate(tests):
if args.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
async_responses.append(pool.apply_async(
poolRunner,
(test.dotted_name, coverage_number, args.omit_patterns)))
pool.close()
for test, async_response in zip(tests, async_responses):
# Prints out the white 'processing...' version of the output
result.startTest(test)
# This blocks until the worker who is processing this
# particular test actually finishes
try:
result.addProtoTestResult(async_response.get())
except KeyboardInterrupt: # pragma: no cover
result.shouldStop = True
if result.shouldStop:
break
pool.terminate()
pool.join()
result.stopTestRun()
removeResult(result)
return result
