# This module contains some code copied from unittest2/loader.py and other
# code developed in reference to that module and others within unittest2.
# unittest2 is Copyright (c) 2001-2010 Python Software Foundation; All
# Rights Reserved. See: http://docs.python.org/license.html
import inspect
import logging
import os
import re
import sys
import traceback
import types
__unittest = True
IDENT_RE = re.compile(r"^[_a-zA-Z]\w*$", re.UNICODE)
VALID_MODULE_RE = re.compile(r"[_a-zA-Z]\w*\.py$", re.UNICODE)
[docs]
def ln(label, char="-", width=70):
"""Draw a divider, with ``label`` in the middle.
>>> ln('hello there')
'---------------------------- hello there -----------------------------'
``width`` and divider ``char`` may be specified. Defaults are ``70`` and ``'-'``,
respectively.
"""
label_len = len(label) + 2
chunk = (width - label_len) // 2
out = f"{char * chunk} {label} {char * chunk}"
pad = width - len(out)
if pad > 0:
out = out + (char * pad)
return out
[docs]
def valid_module_name(path):
"""Is ``path`` a valid module name?"""
return VALID_MODULE_RE.search(path)
[docs]
def name_from_path(path):
"""Translate ``path`` into module name
Returns a two-element tuple:
1. a dotted module name that can be used in an import statement
(e.g., ``pkg1.test.test_things``)
2. a full path to filesystem directory, which must be on ``sys.path``
for the import to succeed.
"""
# back up to find module root
parts = []
path = os.path.normpath(path)
base = os.path.splitext(path)[0]
candidate, top = os.path.split(base)
parts.append(top)
while candidate:
if ispackage(candidate):
candidate, top = os.path.split(candidate)
parts.append(top)
else:
break
return ".".join(reversed(parts)), candidate
[docs]
def module_from_name(name):
"""Import module from ``name``"""
__import__(name)
return sys.modules[name]
[docs]
def test_from_name(name, module):
"""Import test from ``name``"""
pos = name.find(":")
index = None
if pos != -1:
real_name, digits = name[:pos], name[pos + 1 :]
try:
index = int(digits)
except ValueError:
pass
else:
name = real_name
parent, obj = object_from_name(name, module)
return parent, obj, name, index
[docs]
def object_from_name(name, module=None):
"""
Given a dotted name, return the corresponding object.
Getting the object can fail for two reason:
- the object is a module that cannot be imported.
- the object is a class or a function that does not exists.
Since we cannot distinguish between these two cases, we assume we are in
the first one. We expect the stacktrace is explicit enough for the user to
understand the error.
"""
import_error = None
parts = name.split(".")
if module is None:
(module, import_error) = try_import_module_from_name(parts[:])
parts = parts[1:]
parent = None
obj = module
for part in parts:
try:
parent, obj = obj, getattr(obj, part)
except AttributeError as e:
if is_package_or_module(obj) and import_error:
raise e from import_error[1]
raise
return parent, obj
def is_package_or_module(obj):
if hasattr(obj, "__path__") or isinstance(obj, types.ModuleType):
return True
return False
[docs]
def try_import_module_from_name(splitted_name):
"""
Try to find the longest importable from the ``splitted_name``, and return
the corresponding module, as well as the potential ``ImportError``
exception that occurs when trying to import a longer name.
For instance, if ``splitted_name`` is ['a', 'b', 'c'] but only ``a.b`` is
importable, this function:
1. tries to import ``a.b.c`` and fails
2. tries to import ``a.b`` and succeeds
3. return ``a.b`` and the exception that occurred at step 1.
"""
module = None
import_error = None
while splitted_name:
try:
module = __import__(".".join(splitted_name))
break
except BaseException:
import_error = sys.exc_info()
del splitted_name[-1]
if not splitted_name:
raise
return (module, import_error)
[docs]
def name_from_args(name, index, args):
"""Create test name from test args"""
summary = ", ".join(repr(arg) for arg in args)
return f"{name}:{index + 1}\n{summary[:79]}"
def test_name(test, qualname=True):
# XXX does not work for test funcs; test.id() lacks module
if hasattr(test, "_funcName"):
tid = test._funcName
elif hasattr(test, "_testFunc"):
tid = f"{test._testFunc.__module__}.{test._testFunc.__name__}"
else:
if not qualname:
test_module = test.__class__.__module__
test_class = test.__class__.__name__
test_method = test._testMethodName
tid = f"{test_module}.{test_class}.{test_method}"
else:
tid = test.id()
if "\n" in tid:
tid = tid.split("\n")[0]
# subtest support
if " " in tid:
tid = tid.split(" ")[0]
return tid
[docs]
def ispackage(path):
"""Is this path a package directory?"""
if os.path.isdir(path):
# at least the end of the path must be a legal python identifier
# and __init__.py[co] must exist
end = os.path.basename(path)
if IDENT_RE.match(end):
for init in ("__init__.py", "__init__.pyc", "__init__.pyo"):
if os.path.isfile(os.path.join(path, init)):
return True
if sys.platform.startswith("java") and os.path.isfile(
os.path.join(path, "__init__$py.class")
):
return True
return False
[docs]
def ensure_importable(dirname):
"""Ensure a directory is on ``sys.path``."""
if dirname not in sys.path:
sys.path.insert(0, dirname)
[docs]
def has_module_fixtures(test):
"""Does this test live in a module with module fixtures?"""
# test may be class or instance
test_class = test if isinstance(test, type) else test.__class__
modname = test_class.__module__
try:
mod = sys.modules[modname]
except KeyError:
return
return hasattr(mod, "setUpModule") or hasattr(mod, "tearDownModule")
def has_class_fixtures(test):
# test may be class or instance
test_class = test if isinstance(test, type) else test.__class__
# hasattr would be the obvious thing to use here. Unfortunately, all tests
# inherit from unittest2.case.TestCase, and that *always* has setUpClass and
# tearDownClass methods. Thus, exclude the unitest and unittest2 base
# classes from the lookup.
def is_not_base_class(c):
return (
"unittest.case" not in c.__module__ and "unittest2.case" not in c.__module__
)
has_class_setups = any(
"setUpClass" in c.__dict__ for c in test_class.__mro__ if is_not_base_class(c)
)
has_class_teardowns = any(
"tearDownClass" in c.__dict__
for c in test_class.__mro__
if is_not_base_class(c)
)
return has_class_setups or has_class_teardowns
[docs]
def safe_decode(string):
"""Safely decode a byte string into unicode"""
if string is None:
return None
try:
return string.decode()
except AttributeError:
return string
except UnicodeDecodeError:
pass
try:
return string.decode("utf-8")
except UnicodeDecodeError:
return "<unable to decode>"
[docs]
def exc_info_to_string(err, test):
"""Format exception info for output"""
formatTraceback = getattr(test, "formatTraceback", None)
if formatTraceback is not None:
return test.formatTraceback(err)
else:
return format_traceback(test, err)
[docs]
def transplant_class(cls, module):
"""Make ``cls`` appear to reside in ``module``.
:param cls: A class
:param module: A module name
:returns: A subclass of ``cls`` that appears to have been defined in ``module``.
The returned class's ``__name__`` will be equal to
``cls.__name__``, and its ``__module__`` equal to ``module``.
"""
class C(cls):
pass
C.__module__ = module
C.__name__ = cls.__name__
return C
[docs]
def parse_log_level(lvl):
"""Return numeric log level given a string"""
try:
return int(lvl)
except ValueError:
pass
return getattr(logging, lvl.upper(), logging.WARN)
def _is_relevant_tb_level(tb):
return "__unittest" in tb.tb_frame.f_globals
def _count_relevant_tb_levels(tb):
length = 0
while tb and not _is_relevant_tb_level(tb):
length += 1
tb = tb.tb_next
return length
class _WritelnDecorator:
"""Used to decorate file-like objects with a handy :func:`writeln` method"""
def __init__(self, stream):
self.stream = stream
def __getattr__(self, attr):
if attr in ("stream", "__getstate__"):
raise AttributeError(attr)
return getattr(self.stream, attr)
def write(self, arg):
self.stream.write(arg)
def writeln(self, arg=None):
if arg:
self.write(arg)
self.write("\n") # text-mode streams translate to \r\n if needed
def ancestry(layer):
layers = [[layer]]
bases = [base for base in bases_and_mixins(layer) if base is not object]
while bases:
layers.append(bases)
newbases = []
for b in bases:
for bb in bases_and_mixins(b):
if bb is not object:
newbases.append(bb)
bases = newbases
layers.reverse()
return layers
def bases_and_mixins(layer):
return layer.__bases__ + getattr(layer, "mixins", ())
[docs]
def num_expected_args(func):
"""Return the number of arguments that :func: expects"""
return len(inspect.getfullargspec(func)[0])
[docs]
def call_with_args_if_expected(func, *args):
"""Take :func: and call it with supplied :args:, in case that signature expects any.
Otherwise call the function without any arguments.
"""
if num_expected_args(func) > 0:
func(*args)
else:
func()
def iter_attrs(obj):
# note: vars() can be surprising __slots__ is defined
# using dir(x) is the most general way of doing this
for attrname in dir(obj):
yield (attrname, getattr(obj, attrname))