cpython/Lib/packaging/tests/support.py

393 lines
13 KiB
Python

"""Support code for packaging test cases.
*This module should not be considered public: its content and API may
change in incompatible ways.*
A few helper classes are provided: LoggingCatcher, TempdirManager and
EnvironRestorer. They are written to be used as mixins::
from packaging.tests import unittest
from packaging.tests.support import LoggingCatcher
class SomeTestCase(LoggingCatcher, unittest.TestCase):
...
If you need to define a setUp method on your test class, you have to
call the mixin class' setUp method or it won't work (same thing for
tearDown):
def setUp(self):
super(SomeTestCase, self).setUp()
... # other setup code
Also provided is a DummyCommand class, useful to mock commands in the
tests of another command that needs them, for example to fake
compilation in build_ext (this requires that the mock build_ext command
be injected into the distribution object's command_obj dictionary).
For tests that need to compile an extension module, use the
copy_xxmodule_c and fixup_build_ext functions.
Each class or function has a docstring to explain its purpose and usage.
Existing tests should also be used as examples.
"""
import os
import sys
import shutil
import logging
import weakref
import tempfile
import sysconfig
from packaging.dist import Distribution
from packaging.util import resolve_name
from packaging.command import set_command, _COMMANDS
from packaging.tests import unittest
from test.support import requires_zlib, unlink
# define __all__ to make pydoc more useful
__all__ = [
# TestCase mixins
'LoggingCatcher', 'TempdirManager', 'EnvironRestorer',
# mocks
'DummyCommand', 'TestDistribution', 'Inputs',
# misc. functions and decorators
'fake_dec', 'create_distribution', 'use_command',
'copy_xxmodule_c', 'fixup_build_ext',
# imported from this module for backport purposes
'unittest', 'requires_zlib', 'skip_2to3_optimize', 'skip_unless_symlink',
]
logger = logging.getLogger('packaging')
logger2to3 = logging.getLogger('RefactoringTool')
class _TestHandler(logging.handlers.BufferingHandler):
# stolen and adapted from test.support
def __init__(self):
super(_TestHandler, self).__init__(0)
self.setLevel(logging.DEBUG)
def shouldFlush(self):
return False
def emit(self, record):
self.buffer.append(record)
class LoggingCatcher:
"""TestCase-compatible mixin to receive logging calls.
Upon setUp, instances of this classes get a BufferingHandler that's
configured to record all messages logged to the 'packaging' logger.
Use get_logs to retrieve messages and self.loghandler.flush to discard
them. get_logs automatically flushes the logs, unless you pass
*flush=False*, for example to make multiple calls to the method with
different level arguments. If your test calls some code that generates
logging message and then you don't call get_logs, you will need to flush
manually before testing other code in the same test_* method, otherwise
get_logs in the next lines will see messages from the previous lines.
See example in test_command_check.
"""
def setUp(self):
super(LoggingCatcher, self).setUp()
self.loghandler = handler = _TestHandler()
self._old_levels = logger.level, logger2to3.level
logger.addHandler(handler)
logger.setLevel(logging.DEBUG) # we want all messages
logger2to3.setLevel(logging.CRITICAL) # we don't want 2to3 messages
def tearDown(self):
handler = self.loghandler
# All this is necessary to properly shut down the logging system and
# avoid a regrtest complaint. Thanks to Vinay Sajip for the help.
handler.close()
logger.removeHandler(handler)
for ref in weakref.getweakrefs(handler):
logging._removeHandlerRef(ref)
del self.loghandler
logger.setLevel(self._old_levels[0])
logger2to3.setLevel(self._old_levels[1])
super(LoggingCatcher, self).tearDown()
def get_logs(self, level=logging.WARNING, flush=True):
"""Return all log messages with given level.
*level* defaults to logging.WARNING.
For log calls with arguments (i.e. logger.info('bla bla %r', arg)),
the messages will be formatted before being returned (e.g. "bla bla
'thing'").
Returns a list. Automatically flushes the loghandler after being
called, unless *flush* is False (this is useful to get e.g. all
warnings then all info messages).
"""
messages = [log.getMessage() for log in self.loghandler.buffer
if log.levelno == level]
if flush:
self.loghandler.flush()
return messages
class TempdirManager:
"""TestCase-compatible mixin to create temporary directories and files.
Directories and files created in a test_* method will be removed after it
has run.
"""
def setUp(self):
super(TempdirManager, self).setUp()
self._olddir = os.getcwd()
self._basetempdir = tempfile.mkdtemp()
self._files = []
def tearDown(self):
for handle, name in self._files:
handle.close()
unlink(name)
os.chdir(self._olddir)
shutil.rmtree(self._basetempdir)
super(TempdirManager, self).tearDown()
def mktempfile(self):
"""Create a read-write temporary file and return it."""
fd, fn = tempfile.mkstemp(dir=self._basetempdir)
os.close(fd)
fp = open(fn, 'w+')
self._files.append((fp, fn))
return fp
def mkdtemp(self):
"""Create a temporary directory and return its path."""
d = tempfile.mkdtemp(dir=self._basetempdir)
return d
def write_file(self, path, content='xxx', encoding=None):
"""Write a file at the given path.
path can be a string, a tuple or a list; if it's a tuple or list,
os.path.join will be used to produce a path.
"""
if isinstance(path, (list, tuple)):
path = os.path.join(*path)
with open(path, 'w', encoding=encoding) as f:
f.write(content)
def create_dist(self, **kw):
"""Create a stub distribution object and files.
This function creates a Distribution instance (use keyword arguments
to customize it) and a temporary directory with a project structure
(currently an empty directory).
It returns the path to the directory and the Distribution instance.
You can use self.write_file to write any file in that
directory, e.g. setup scripts or Python modules.
"""
if 'name' not in kw:
kw['name'] = 'foo'
tmp_dir = self.mkdtemp()
project_dir = os.path.join(tmp_dir, kw['name'])
os.mkdir(project_dir)
dist = Distribution(attrs=kw)
return project_dir, dist
def assertIsFile(self, *args):
path = os.path.join(*args)
dirname = os.path.dirname(path)
file = os.path.basename(path)
if os.path.isdir(dirname):
files = os.listdir(dirname)
msg = "%s not found in %s: %s" % (file, dirname, files)
assert os.path.isfile(path), msg
else:
raise AssertionError(
'%s not found. %s does not exist' % (file, dirname))
def assertIsNotFile(self, *args):
path = os.path.join(*args)
self.assertFalse(os.path.isfile(path), "%r exists" % path)
class EnvironRestorer:
"""TestCase-compatible mixin to restore or delete environment variables.
The variables to restore (or delete if they were not originally present)
must be explicitly listed in self.restore_environ. It's better to be
aware of what we're modifying instead of saving and restoring the whole
environment.
"""
def setUp(self):
super(EnvironRestorer, self).setUp()
self._saved = []
self._added = []
for key in self.restore_environ:
if key in os.environ:
self._saved.append((key, os.environ[key]))
else:
self._added.append(key)
def tearDown(self):
for key, value in self._saved:
os.environ[key] = value
for key in self._added:
os.environ.pop(key, None)
super(EnvironRestorer, self).tearDown()
class DummyCommand:
"""Class to store options for retrieval via set_undefined_options().
Useful for mocking one dependency command in the tests for another
command, see e.g. the dummy build command in test_build_scripts.
"""
# XXX does not work with dist.reinitialize_command, which typechecks
# and wants a finalized attribute
def __init__(self, **kwargs):
for kw, val in kwargs.items():
setattr(self, kw, val)
def ensure_finalized(self):
pass
class TestDistribution(Distribution):
"""Distribution subclasses that avoids the default search for
configuration files.
The ._config_files attribute must be set before
.parse_config_files() is called.
"""
def find_config_files(self):
return self._config_files
class Inputs:
"""Fakes user inputs."""
# TODO document usage
# TODO use context manager or something for auto cleanup
def __init__(self, *answers):
self.answers = answers
self.index = 0
def __call__(self, prompt=''):
try:
return self.answers[self.index]
finally:
self.index += 1
def create_distribution(configfiles=()):
"""Prepares a distribution with given config files parsed."""
d = TestDistribution()
d.config.find_config_files = d.find_config_files
d._config_files = configfiles
d.parse_config_files()
d.parse_command_line()
return d
def use_command(testcase, fullname):
"""Register command at *fullname* for the duration of a test."""
set_command(fullname)
# XXX maybe set_command should return the class object
name = resolve_name(fullname).get_command_name()
# XXX maybe we need a public API to remove commands
testcase.addCleanup(_COMMANDS.__delitem__, name)
def fake_dec(*args, **kw):
"""Fake decorator"""
def _wrap(func):
def __wrap(*args, **kw):
return func(*args, **kw)
return __wrap
return _wrap
def copy_xxmodule_c(directory):
"""Helper for tests that need the xxmodule.c source file.
Example use:
def test_compile(self):
copy_xxmodule_c(self.tmpdir)
self.assertIn('xxmodule.c', os.listdir(self.tmpdir))
If the source file can be found, it will be copied to *directory*. If not,
the test will be skipped. Errors during copy are not caught.
"""
filename = _get_xxmodule_path()
if filename is None:
raise unittest.SkipTest('cannot find xxmodule.c (test must run in '
'the python build dir)')
shutil.copy(filename, directory)
def _get_xxmodule_path():
srcdir = sysconfig.get_config_var('srcdir')
candidates = [
# use installed copy if available
os.path.join(os.path.dirname(__file__), 'xxmodule.c'),
# otherwise try using copy from build directory
os.path.join(srcdir, 'Modules', 'xxmodule.c'),
]
for path in candidates:
if os.path.exists(path):
return path
def fixup_build_ext(cmd):
"""Function needed to make build_ext tests pass.
When Python was built with --enable-shared on Unix, -L. is not enough to
find libpython<blah>.so, because regrtest runs in a tempdir, not in the
source directory where the .so lives.
When Python was built with in debug mode on Windows, build_ext commands
need their debug attribute set, and it is not done automatically for
some reason.
This function handles both of these things. Example use:
cmd = build_ext(dist)
support.fixup_build_ext(cmd)
cmd.ensure_finalized()
"""
if os.name == 'nt':
cmd.debug = sys.executable.endswith('_d.exe')
elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
# To further add to the shared builds fun on Unix, we can't just add
# library_dirs to the Extension() instance because that doesn't get
# plumbed through to the final compiler command.
runshared = sysconfig.get_config_var('RUNSHARED')
if runshared is None:
cmd.library_dirs = ['.']
else:
name, equals, value = runshared.partition('=')
cmd.library_dirs = value.split(os.pathsep)
try:
from test.support import skip_unless_symlink
except ImportError:
skip_unless_symlink = unittest.skip(
'requires test.support.skip_unless_symlink')
skip_2to3_optimize = unittest.skipIf(sys.flags.optimize,
"2to3 doesn't work under -O")