518 lines
22 KiB
Python
518 lines
22 KiB
Python
|
"""Loading unittests."""
|
||
|
|
|
||
|
|
import os
|
||
|
|
import re
|
||
|
|
import sys
|
||
|
|
import traceback
|
||
|
|
import types
|
||
|
|
import functools
|
||
|
|
import warnings
|
||
|
|
|
||
|
|
from fnmatch import fnmatch, fnmatchcase
|
||
|
|
|
||
|
|
from . import case, suite, util
|
||
|
|
|
||
|
|
__unittest = True
|
||
|
|
|
||
|
|
# what about .pyc (etc)
|
||
|
|
# we would need to avoid loading the same tests multiple times
|
||
|
|
# from '.py', *and* '.pyc'
|
||
|
|
VALID_MODULE_NAME = re.compile(r'[_a-z]\w*\.py$', re.IGNORECASE)
|
||
|
|
|
||
|
|
|
||
|
|
class _FailedTest(case.TestCase):
|
||
|
|
_testMethodName = None
|
||
|
|
|
||
|
|
def __init__(self, method_name, exception):
|
||
|
|
self._exception = exception
|
||
|
|
super(_FailedTest, self).__init__(method_name)
|
||
|
|
|
||
|
|
def __getattr__(self, name):
|
||
|
|
if name != self._testMethodName:
|
||
|
|
return super(_FailedTest, self).__getattr__(name)
|
||
|
|
def testFailure():
|
||
|
|
raise self._exception
|
||
|
|
return testFailure
|
||
|
|
|
||
|
|
|
||
|
|
def _make_failed_import_test(name, suiteClass):
|
||
|
|
message = 'Failed to import test module: %s\n%s' % (
|
||
|
|
name, traceback.format_exc())
|
||
|
|
return _make_failed_test(name, ImportError(message), suiteClass, message)
|
||
|
|
|
||
|
|
def _make_failed_load_tests(name, exception, suiteClass):
|
||
|
|
message = 'Failed to call load_tests:\n%s' % (traceback.format_exc(),)
|
||
|
|
return _make_failed_test(
|
||
|
|
name, exception, suiteClass, message)
|
||
|
|
|
||
|
|
def _make_failed_test(methodname, exception, suiteClass, message):
|
||
|
|
test = _FailedTest(methodname, exception)
|
||
|
|
return suiteClass((test,)), message
|
||
|
|
|
||
|
|
def _make_skipped_test(methodname, exception, suiteClass):
|
||
|
|
@case.skip(str(exception))
|
||
|
|
def testSkipped(self):
|
||
|
|
pass
|
||
|
|
attrs = {methodname: testSkipped}
|
||
|
|
TestClass = type("ModuleSkipped", (case.TestCase,), attrs)
|
||
|
|
return suiteClass((TestClass(methodname),))
|
||
|
|
|
||
|
|
def _jython_aware_splitext(path):
|
||
|
|
if path.lower().endswith('$py.class'):
|
||
|
|
return path[:-9]
|
||
|
|
return os.path.splitext(path)[0]
|
||
|
|
|
||
|
|
|
||
|
|
class TestLoader(object):
|
||
|
|
"""
|
||
|
|
This class is responsible for loading tests according to various criteria
|
||
|
|
and returning them wrapped in a TestSuite
|
||
|
|
"""
|
||
|
|
testMethodPrefix = 'test'
|
||
|
|
sortTestMethodsUsing = staticmethod(util.three_way_cmp)
|
||
|
|
testNamePatterns = None
|
||
|
|
suiteClass = suite.TestSuite
|
||
|
|
_top_level_dir = None
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
super(TestLoader, self).__init__()
|
||
|
|
self.errors = []
|
||
|
|
# Tracks packages which we have called into via load_tests, to
|
||
|
|
# avoid infinite re-entrancy.
|
||
|
|
self._loading_packages = set()
|
||
|
|
|
||
|
|
def loadTestsFromTestCase(self, testCaseClass):
|
||
|
|
"""Return a suite of all test cases contained in testCaseClass"""
|
||
|
|
if issubclass(testCaseClass, suite.TestSuite):
|
||
|
|
raise TypeError("Test cases should not be derived from "
|
||
|
|
"TestSuite. Maybe you meant to derive from "
|
||
|
|
"TestCase?")
|
||
|
|
testCaseNames = self.getTestCaseNames(testCaseClass)
|
||
|
|
if not testCaseNames and hasattr(testCaseClass, 'runTest'):
|
||
|
|
testCaseNames = ['runTest']
|
||
|
|
loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames))
|
||
|
|
return loaded_suite
|
||
|
|
|
||
|
|
# XXX After Python 3.5, remove backward compatibility hacks for
|
||
|
|
# use_load_tests deprecation via *args and **kws. See issue 16662.
|
||
|
|
def loadTestsFromModule(self, module, *args, pattern=None, **kws):
|
||
|
|
"""Return a suite of all test cases contained in the given module"""
|
||
|
|
# This method used to take an undocumented and unofficial
|
||
|
|
# use_load_tests argument. For backward compatibility, we still
|
||
|
|
# accept the argument (which can also be the first position) but we
|
||
|
|
# ignore it and issue a deprecation warning if it's present.
|
||
|
|
if len(args) > 0 or 'use_load_tests' in kws:
|
||
|
|
warnings.warn('use_load_tests is deprecated and ignored',
|
||
|
|
DeprecationWarning)
|
||
|
|
kws.pop('use_load_tests', None)
|
||
|
|
if len(args) > 1:
|
||
|
|
# Complain about the number of arguments, but don't forget the
|
||
|
|
# required `module` argument.
|
||
|
|
complaint = len(args) + 1
|
||
|
|
raise TypeError('loadTestsFromModule() takes 1 positional argument but {} were given'.format(complaint))
|
||
|
|
if len(kws) != 0:
|
||
|
|
# Since the keyword arguments are unsorted (see PEP 468), just
|
||
|
|
# pick the alphabetically sorted first argument to complain about,
|
||
|
|
# if multiple were given. At least the error message will be
|
||
|
|
# predictable.
|
||
|
|
complaint = sorted(kws)[0]
|
||
|
|
raise TypeError("loadTestsFromModule() got an unexpected keyword argument '{}'".format(complaint))
|
||
|
|
tests = []
|
||
|
|
for name in dir(module):
|
||
|
|
obj = getattr(module, name)
|
||
|
|
if isinstance(obj, type) and issubclass(obj, case.TestCase):
|
||
|
|
tests.append(self.loadTestsFromTestCase(obj))
|
||
|
|
|
||
|
|
load_tests = getattr(module, 'load_tests', None)
|
||
|
|
tests = self.suiteClass(tests)
|
||
|
|
if load_tests is not None:
|
||
|
|
try:
|
||
|
|
return load_tests(self, tests, pattern)
|
||
|
|
except Exception as e:
|
||
|
|
error_case, error_message = _make_failed_load_tests(
|
||
|
|
module.__name__, e, self.suiteClass)
|
||
|
|
self.errors.append(error_message)
|
||
|
|
return error_case
|
||
|
|
return tests
|
||
|
|
|
||
|
|
def loadTestsFromName(self, name, module=None):
|
||
|
|
"""Return a suite of all test cases given a string specifier.
|
||
|
|
|
||
|
|
The name may resolve either to a module, a test case class, a
|
||
|
|
test method within a test case class, or a callable object which
|
||
|
|
returns a TestCase or TestSuite instance.
|
||
|
|
|
||
|
|
The method optionally resolves the names relative to a given module.
|
||
|
|
"""
|
||
|
|
parts = name.split('.')
|
||
|
|
error_case, error_message = None, None
|
||
|
|
if module is None:
|
||
|
|
parts_copy = parts[:]
|
||
|
|
while parts_copy:
|
||
|
|
try:
|
||
|
|
module_name = '.'.join(parts_copy)
|
||
|
|
module = __import__(module_name)
|
||
|
|
break
|
||
|
|
except ImportError:
|
||
|
|
next_attribute = parts_copy.pop()
|
||
|
|
# Last error so we can give it to the user if needed.
|
||
|
|
error_case, error_message = _make_failed_import_test(
|
||
|
|
next_attribute, self.suiteClass)
|
||
|
|
if not parts_copy:
|
||
|
|
# Even the top level import failed: report that error.
|
||
|
|
self.errors.append(error_message)
|
||
|
|
return error_case
|
||
|
|
parts = parts[1:]
|
||
|
|
obj = module
|
||
|
|
for part in parts:
|
||
|
|
try:
|
||
|
|
parent, obj = obj, getattr(obj, part)
|
||
|
|
except AttributeError as e:
|
||
|
|
# We can't traverse some part of the name.
|
||
|
|
if (getattr(obj, '__path__', None) is not None
|
||
|
|
and error_case is not None):
|
||
|
|
# This is a package (no __path__ per importlib docs), and we
|
||
|
|
# encountered an error importing something. We cannot tell
|
||
|
|
# the difference between package.WrongNameTestClass and
|
||
|
|
# package.wrong_module_name so we just report the
|
||
|
|
# ImportError - it is more informative.
|
||
|
|
self.errors.append(error_message)
|
||
|
|
return error_case
|
||
|
|
else:
|
||
|
|
# Otherwise, we signal that an AttributeError has occurred.
|
||
|
|
error_case, error_message = _make_failed_test(
|
||
|
|
part, e, self.suiteClass,
|
||
|
|
'Failed to access attribute:\n%s' % (
|
||
|
|
traceback.format_exc(),))
|
||
|
|
self.errors.append(error_message)
|
||
|
|
return error_case
|
||
|
|
|
||
|
|
if isinstance(obj, types.ModuleType):
|
||
|
|
return self.loadTestsFromModule(obj)
|
||
|
|
elif isinstance(obj, type) and issubclass(obj, case.TestCase):
|
||
|
|
return self.loadTestsFromTestCase(obj)
|
||
|
|
elif (isinstance(obj, types.FunctionType) and
|
||
|
|
isinstance(parent, type) and
|
||
|
|
issubclass(parent, case.TestCase)):
|
||
|
|
name = parts[-1]
|
||
|
|
inst = parent(name)
|
||
|
|
# static methods follow a different path
|
||
|
|
if not isinstance(getattr(inst, name), types.FunctionType):
|
||
|
|
return self.suiteClass([inst])
|
||
|
|
elif isinstance(obj, suite.TestSuite):
|
||
|
|
return obj
|
||
|
|
if callable(obj):
|
||
|
|
test = obj()
|
||
|
|
if isinstance(test, suite.TestSuite):
|
||
|
|
return test
|
||
|
|
elif isinstance(test, case.TestCase):
|
||
|
|
return self.suiteClass([test])
|
||
|
|
else:
|
||
|
|
raise TypeError("calling %s returned %s, not a test" %
|
||
|
|
(obj, test))
|
||
|
|
else:
|
||
|
|
raise TypeError("don't know how to make test from: %s" % obj)
|
||
|
|
|
||
|
|
def loadTestsFromNames(self, names, module=None):
|
||
|
|
"""Return a suite of all test cases found using the given sequence
|
||
|
|
of string specifiers. See 'loadTestsFromName()'.
|
||
|
|
"""
|
||
|
|
suites = [self.loadTestsFromName(name, module) for name in names]
|
||
|
|
return self.suiteClass(suites)
|
||
|
|
|
||
|
|
def getTestCaseNames(self, testCaseClass):
|
||
|
|
"""Return a sorted sequence of method names found within testCaseClass
|
||
|
|
"""
|
||
|
|
def shouldIncludeMethod(attrname):
|
||
|
|
if not attrname.startswith(self.testMethodPrefix):
|
||
|
|
return False
|
||
|
|
testFunc = getattr(testCaseClass, attrname)
|
||
|
|
if not callable(testFunc):
|
||
|
|
return False
|
||
|
|
fullName = f'%s.%s.%s' % (
|
||
|
|
testCaseClass.__module__, testCaseClass.__qualname__, attrname
|
||
|
|
)
|
||
|
|
return self.testNamePatterns is None or \
|
||
|
|
any(fnmatchcase(fullName, pattern) for pattern in self.testNamePatterns)
|
||
|
|
testFnNames = list(filter(shouldIncludeMethod, dir(testCaseClass)))
|
||
|
|
if self.sortTestMethodsUsing:
|
||
|
|
testFnNames.sort(key=functools.cmp_to_key(self.sortTestMethodsUsing))
|
||
|
|
return testFnNames
|
||
|
|
|
||
|
|
def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
|
||
|
|
"""Find and return all test modules from the specified start
|
||
|
|
directory, recursing into subdirectories to find them and return all
|
||
|
|
tests found within them. Only test files that match the pattern will
|
||
|
|
be loaded. (Using shell style pattern matching.)
|
||
|
|
|
||
|
|
All test modules must be importable from the top level of the project.
|
||
|
|
If the start directory is not the top level directory then the top
|
||
|
|
level directory must be specified separately.
|
||
|
|
|
||
|
|
If a test package name (directory with '__init__.py') matches the
|
||
|
|
pattern then the package will be checked for a 'load_tests' function. If
|
||
|
|
this exists then it will be called with (loader, tests, pattern) unless
|
||
|
|
the package has already had load_tests called from the same discovery
|
||
|
|
invocation, in which case the package module object is not scanned for
|
||
|
|
tests - this ensures that when a package uses discover to further
|
||
|
|
discover child tests that infinite recursion does not happen.
|
||
|
|
|
||
|
|
If load_tests exists then discovery does *not* recurse into the package,
|
||
|
|
load_tests is responsible for loading all tests in the package.
|
||
|
|
|
||
|
|
The pattern is deliberately not stored as a loader attribute so that
|
||
|
|
packages can continue discovery themselves. top_level_dir is stored so
|
||
|
|
load_tests does not need to pass this argument in to loader.discover().
|
||
|
|
|
||
|
|
Paths are sorted before being imported to ensure reproducible execution
|
||
|
|
order even on filesystems with non-alphabetical ordering like ext3/4.
|
||
|
|
"""
|
||
|
|
set_implicit_top = False
|
||
|
|
if top_level_dir is None and self._top_level_dir is not None:
|
||
|
|
# make top_level_dir optional if called from load_tests in a package
|
||
|
|
top_level_dir = self._top_level_dir
|
||
|
|
elif top_level_dir is None:
|
||
|
|
set_implicit_top = True
|
||
|
|
top_level_dir = start_dir
|
||
|
|
|
||
|
|
top_level_dir = os.path.abspath(top_level_dir)
|
||
|
|
|
||
|
|
if not top_level_dir in sys.path:
|
||
|
|
# all test modules must be importable from the top level directory
|
||
|
|
# should we *unconditionally* put the start directory in first
|
||
|
|
# in sys.path to minimise likelihood of conflicts between installed
|
||
|
|
# modules and development versions?
|
||
|
|
sys.path.insert(0, top_level_dir)
|
||
|
|
self._top_level_dir = top_level_dir
|
||
|
|
|
||
|
|
is_not_importable = False
|
||
|
|
is_namespace = False
|
||
|
|
tests = []
|
||
|
|
if os.path.isdir(os.path.abspath(start_dir)):
|
||
|
|
start_dir = os.path.abspath(start_dir)
|
||
|
|
if start_dir != top_level_dir:
|
||
|
|
is_not_importable = not os.path.isfile(os.path.join(start_dir, '__init__.py'))
|
||
|
|
else:
|
||
|
|
# support for discovery from dotted module names
|
||
|
|
try:
|
||
|
|
__import__(start_dir)
|
||
|
|
except ImportError:
|
||
|
|
is_not_importable = True
|
||
|
|
else:
|
||
|
|
the_module = sys.modules[start_dir]
|
||
|
|
top_part = start_dir.split('.')[0]
|
||
|
|
try:
|
||
|
|
start_dir = os.path.abspath(
|
||
|
|
os.path.dirname((the_module.__file__)))
|
||
|
|
except AttributeError:
|
||
|
|
# look for namespace packages
|
||
|
|
try:
|
||
|
|
spec = the_module.__spec__
|
||
|
|
except AttributeError:
|
||
|
|
spec = None
|
||
|
|
|
||
|
|
if spec and spec.loader is None:
|
||
|
|
if spec.submodule_search_locations is not None:
|
||
|
|
is_namespace = True
|
||
|
|
|
||
|
|
for path in the_module.__path__:
|
||
|
|
if (not set_implicit_top and
|
||
|
|
not path.startswith(top_level_dir)):
|
||
|
|
continue
|
||
|
|
self._top_level_dir = \
|
||
|
|
(path.split(the_module.__name__
|
||
|
|
.replace(".", os.path.sep))[0])
|
||
|
|
tests.extend(self._find_tests(path,
|
||
|
|
pattern,
|
||
|
|
namespace=True))
|
||
|
|
elif the_module.__name__ in sys.builtin_module_names:
|
||
|
|
# builtin module
|
||
|
|
raise TypeError('Can not use builtin modules '
|
||
|
|
'as dotted module names') from None
|
||
|
|
else:
|
||
|
|
raise TypeError(
|
||
|
|
'don\'t know how to discover from {!r}'
|
||
|
|
.format(the_module)) from None
|
||
|
|
|
||
|
|
if set_implicit_top:
|
||
|
|
if not is_namespace:
|
||
|
|
self._top_level_dir = \
|
||
|
|
self._get_directory_containing_module(top_part)
|
||
|
|
sys.path.remove(top_level_dir)
|
||
|
|
else:
|
||
|
|
sys.path.remove(top_level_dir)
|
||
|
|
|
||
|
|
if is_not_importable:
|
||
|
|
raise ImportError('Start directory is not importable: %r' % start_dir)
|
||
|
|
|
||
|
|
if not is_namespace:
|
||
|
|
tests = list(self._find_tests(start_dir, pattern))
|
||
|
|
return self.suiteClass(tests)
|
||
|
|
|
||
|
|
def _get_directory_containing_module(self, module_name):
|
||
|
|
module = sys.modules[module_name]
|
||
|
|
full_path = os.path.abspath(module.__file__)
|
||
|
|
|
||
|
|
if os.path.basename(full_path).lower().startswith('__init__.py'):
|
||
|
|
return os.path.dirname(os.path.dirname(full_path))
|
||
|
|
else:
|
||
|
|
# here we have been given a module rather than a package - so
|
||
|
|
# all we can do is search the *same* directory the module is in
|
||
|
|
# should an exception be raised instead
|
||
|
|
return os.path.dirname(full_path)
|
||
|
|
|
||
|
|
def _get_name_from_path(self, path):
|
||
|
|
if path == self._top_level_dir:
|
||
|
|
return '.'
|
||
|
|
path = _jython_aware_splitext(os.path.normpath(path))
|
||
|
|
|
||
|
|
_relpath = os.path.relpath(path, self._top_level_dir)
|
||
|
|
assert not os.path.isabs(_relpath), "Path must be within the project"
|
||
|
|
assert not _relpath.startswith('..'), "Path must be within the project"
|
||
|
|
|
||
|
|
name = _relpath.replace(os.path.sep, '.')
|
||
|
|
return name
|
||
|
|
|
||
|
|
def _get_module_from_name(self, name):
|
||
|
|
__import__(name)
|
||
|
|
return sys.modules[name]
|
||
|
|
|
||
|
|
def _match_path(self, path, full_path, pattern):
|
||
|
|
# override this method to use alternative matching strategy
|
||
|
|
return fnmatch(path, pattern)
|
||
|
|
|
||
|
|
def _find_tests(self, start_dir, pattern, namespace=False):
|
||
|
|
"""Used by discovery. Yields test suites it loads."""
|
||
|
|
# Handle the __init__ in this package
|
||
|
|
name = self._get_name_from_path(start_dir)
|
||
|
|
# name is '.' when start_dir == top_level_dir (and top_level_dir is by
|
||
|
|
# definition not a package).
|
||
|
|
if name != '.' and name not in self._loading_packages:
|
||
|
|
# name is in self._loading_packages while we have called into
|
||
|
|
# loadTestsFromModule with name.
|
||
|
|
tests, should_recurse = self._find_test_path(
|
||
|
|
start_dir, pattern, namespace)
|
||
|
|
if tests is not None:
|
||
|
|
yield tests
|
||
|
|
if not should_recurse:
|
||
|
|
# Either an error occurred, or load_tests was used by the
|
||
|
|
# package.
|
||
|
|
return
|
||
|
|
# Handle the contents.
|
||
|
|
paths = sorted(os.listdir(start_dir))
|
||
|
|
for path in paths:
|
||
|
|
full_path = os.path.join(start_dir, path)
|
||
|
|
tests, should_recurse = self._find_test_path(
|
||
|
|
full_path, pattern, namespace)
|
||
|
|
if tests is not None:
|
||
|
|
yield tests
|
||
|
|
if should_recurse:
|
||
|
|
# we found a package that didn't use load_tests.
|
||
|
|
name = self._get_name_from_path(full_path)
|
||
|
|
self._loading_packages.add(name)
|
||
|
|
try:
|
||
|
|
yield from self._find_tests(full_path, pattern, namespace)
|
||
|
|
finally:
|
||
|
|
self._loading_packages.discard(name)
|
||
|
|
|
||
|
|
def _find_test_path(self, full_path, pattern, namespace=False):
|
||
|
|
"""Used by discovery.
|
||
|
|
|
||
|
|
Loads tests from a single file, or a directories' __init__.py when
|
||
|
|
passed the directory.
|
||
|
|
|
||
|
|
Returns a tuple (None_or_tests_from_file, should_recurse).
|
||
|
|
"""
|
||
|
|
basename = os.path.basename(full_path)
|
||
|
|
if os.path.isfile(full_path):
|
||
|
|
if not VALID_MODULE_NAME.match(basename):
|
||
|
|
# valid Python identifiers only
|
||
|
|
return None, False
|
||
|
|
if not self._match_path(basename, full_path, pattern):
|
||
|
|
return None, False
|
||
|
|
# if the test file matches, load it
|
||
|
|
name = self._get_name_from_path(full_path)
|
||
|
|
try:
|
||
|
|
module = self._get_module_from_name(name)
|
||
|
|
except case.SkipTest as e:
|
||
|
|
return _make_skipped_test(name, e, self.suiteClass), False
|
||
|
|
except:
|
||
|
|
error_case, error_message = \
|
||
|
|
_make_failed_import_test(name, self.suiteClass)
|
||
|
|
self.errors.append(error_message)
|
||
|
|
return error_case, False
|
||
|
|
else:
|
||
|
|
mod_file = os.path.abspath(
|
||
|
|
getattr(module, '__file__', full_path))
|
||
|
|
realpath = _jython_aware_splitext(
|
||
|
|
os.path.realpath(mod_file))
|
||
|
|
fullpath_noext = _jython_aware_splitext(
|
||
|
|
os.path.realpath(full_path))
|
||
|
|
if realpath.lower() != fullpath_noext.lower():
|
||
|
|
module_dir = os.path.dirname(realpath)
|
||
|
|
mod_name = _jython_aware_splitext(
|
||
|
|
os.path.basename(full_path))
|
||
|
|
expected_dir = os.path.dirname(full_path)
|
||
|
|
msg = ("%r module incorrectly imported from %r. Expected "
|
||
|
|
"%r. Is this module globally installed?")
|
||
|
|
raise ImportError(
|
||
|
|
msg % (mod_name, module_dir, expected_dir))
|
||
|
|
return self.loadTestsFromModule(module, pattern=pattern), False
|
||
|
|
elif os.path.isdir(full_path):
|
||
|
|
if (not namespace and
|
||
|
|
not os.path.isfile(os.path.join(full_path, '__init__.py'))):
|
||
|
|
return None, False
|
||
|
|
|
||
|
|
load_tests = None
|
||
|
|
tests = None
|
||
|
|
name = self._get_name_from_path(full_path)
|
||
|
|
try:
|
||
|
|
package = self._get_module_from_name(name)
|
||
|
|
except case.SkipTest as e:
|
||
|
|
return _make_skipped_test(name, e, self.suiteClass), False
|
||
|
|
except:
|
||
|
|
error_case, error_message = \
|
||
|
|
_make_failed_import_test(name, self.suiteClass)
|
||
|
|
self.errors.append(error_message)
|
||
|
|
return error_case, False
|
||
|
|
else:
|
||
|
|
load_tests = getattr(package, 'load_tests', None)
|
||
|
|
# Mark this package as being in load_tests (possibly ;))
|
||
|
|
self._loading_packages.add(name)
|
||
|
|
try:
|
||
|
|
tests = self.loadTestsFromModule(package, pattern=pattern)
|
||
|
|
if load_tests is not None:
|
||
|
|
# loadTestsFromModule(package) has loaded tests for us.
|
||
|
|
return tests, False
|
||
|
|
return tests, True
|
||
|
|
finally:
|
||
|
|
self._loading_packages.discard(name)
|
||
|
|
else:
|
||
|
|
return None, False
|
||
|
|
|
||
|
|
|
||
|
|
defaultTestLoader = TestLoader()
|
||
|
|
|
||
|
|
|
||
|
|
def _makeLoader(prefix, sortUsing, suiteClass=None, testNamePatterns=None):
|
||
|
|
loader = TestLoader()
|
||
|
|
loader.sortTestMethodsUsing = sortUsing
|
||
|
|
loader.testMethodPrefix = prefix
|
||
|
|
loader.testNamePatterns = testNamePatterns
|
||
|
|
if suiteClass:
|
||
|
|
loader.suiteClass = suiteClass
|
||
|
|
return loader
|
||
|
|
|
||
|
|
def getTestCaseNames(testCaseClass, prefix, sortUsing=util.three_way_cmp, testNamePatterns=None):
|
||
|
|
return _makeLoader(prefix, sortUsing, testNamePatterns=testNamePatterns).getTestCaseNames(testCaseClass)
|
||
|
|
|
||
|
|
def makeSuite(testCaseClass, prefix='test', sortUsing=util.three_way_cmp,
|
||
|
|
suiteClass=suite.TestSuite):
|
||
|
|
return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(
|
||
|
|
testCaseClass)
|
||
|
|
|
||
|
|
def findTestCases(module, prefix='test', sortUsing=util.three_way_cmp,
|
||
|
|
suiteClass=suite.TestSuite):
|
||
|
|
return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(\
|
||
|
|
module)
|