_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

@case.skip(str(exception))

def testSkipped(self):

pass

attrs = {methodname: testSkipped}

TestClass = type("ModuleSkipped", (case.TestCase,), attrs)

"""

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.

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

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 = '%s.%s' % (testCaseClass.__module__, testFunc.__qualname__)

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

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.

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:

loader = TestLoader()

loader.sortTestMethodsUsing = sortUsing

loader.testMethodPrefix = prefix

loader.testNamePatterns = testNamePatterns

if suiteClass:

loader.suiteClass = suiteClass