"""Support code for packaging test cases. 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, a create_distribution function and a skip_unless_symlink decorator. Also provided is a DummyCommand class, useful to mock commands in the tests of another command that needs them, a create_distribution function and a skip_unless_symlink decorator. Each class or function has a docstring to explain its purpose and usage. """ import os import errno import shutil import logging import weakref import tempfile from packaging import logger from packaging.dist import Distribution from packaging.tests import unittest from test.support import requires_zlib __all__ = ['LoggingCatcher', 'TempdirManager', 'EnvironRestorer', 'DummyCommand', 'unittest', 'create_distribution', 'skip_unless_symlink', 'requires_zlib'] class _TestHandler(logging.handlers.BufferingHandler): # stolen and adapted from test.support def __init__(self): logging.handlers.BufferingHandler.__init__(self, 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. """ def setUp(self): super(LoggingCatcher, self).setUp() self.loghandler = handler = _TestHandler() self.old_level = logger.level logger.addHandler(handler) logger.setLevel(logging.DEBUG) # we want all 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_level) super(LoggingCatcher, self).tearDown() def get_logs(self, *levels): """Return all log messages with level in *levels*. Without explicit levels given, returns all messages. *levels* defaults to all levels. For log calls with arguments (i.e. logger.info('bla bla %s', arg)), the messages Returns a list. Example: self.get_logs(logging.WARN, logging.DEBUG). """ if not levels: return [log.getMessage() for log in self.loghandler.buffer] return [log.getMessage() for log in self.loghandler.buffer if log.levelno in levels] 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._basetempdir = tempfile.mkdtemp() self._files = [] def tearDown(self): shutil.rmtree(self._basetempdir, os.name in ('nt', 'cygwin')) for handle, name in self._files: handle.close() if os.path.exists(name): try: os.remove(name) except OSError as exc: if exc.errno != errno.ENOENT: raise 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. """ 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 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 fake_dec(*args, **kw): """Fake decorator""" def _wrap(func): def __wrap(*args, **kw): return func(*args, **kw) return __wrap return _wrap try: from test.support import skip_unless_symlink except ImportError: skip_unless_symlink = unittest.skip( 'requires test.support.skip_unless_symlink')