diff options
Diffstat (limited to 'coverage/test_helpers.py')
| -rw-r--r-- | coverage/test_helpers.py | 394 |
1 files changed, 0 insertions, 394 deletions
diff --git a/coverage/test_helpers.py b/coverage/test_helpers.py deleted file mode 100644 index 9649ed5..0000000 --- a/coverage/test_helpers.py +++ /dev/null @@ -1,394 +0,0 @@ -# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0 -# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt - -"""Mixin classes to help make good tests.""" - -import atexit -import collections -import contextlib -import os -import random -import shutil -import sys -import tempfile -import textwrap - -from coverage.backunittest import TestCase -from coverage.backward import StringIO, to_bytes - - -class Tee(object): - """A file-like that writes to all the file-likes it has.""" - - def __init__(self, *files): - """Make a Tee that writes to all the files in `files.`""" - self._files = files - if hasattr(files[0], "encoding"): - self.encoding = files[0].encoding - - def write(self, data): - """Write `data` to all the files.""" - for f in self._files: - f.write(data) - - def flush(self): - """Flush the data on all the files.""" - for f in self._files: - f.flush() - - def getvalue(self): - """StringIO file-likes have .getvalue()""" - return self._files[0].getvalue() - - if 0: - # Use this if you need to use a debugger, though it makes some tests - # fail, I'm not sure why... - def __getattr__(self, name): - return getattr(self._files[0], name) - - -@contextlib.contextmanager -def change_dir(new_dir): - """Change directory, and then change back. - - Use as a context manager, it will give you the new directory, and later - restore the old one. - - """ - old_dir = os.getcwd() - os.chdir(new_dir) - try: - yield os.getcwd() - finally: - os.chdir(old_dir) - - -@contextlib.contextmanager -def saved_sys_path(): - """Save sys.path, and restore it later.""" - old_syspath = sys.path[:] - try: - yield - finally: - sys.path = old_syspath - - -def setup_with_context_manager(testcase, cm): - """Use a contextmanager to setUp a test case. - - If you have a context manager you like:: - - with ctxmgr(a, b, c) as v: - # do something with v - - and you want to have that effect for a test case, call this function from - your setUp, and it will start the context manager for your test, and end it - when the test is done:: - - def setUp(self): - self.v = setup_with_context_manager(self, ctxmgr(a, b, c)) - - def test_foo(self): - # do something with self.v - - """ - val = cm.__enter__() - testcase.addCleanup(cm.__exit__, None, None, None) - return val - - -class ModuleAwareMixin(TestCase): - """A test case mixin that isolates changes to sys.modules.""" - - def setUp(self): - super(ModuleAwareMixin, self).setUp() - - # Record sys.modules here so we can restore it in cleanup_modules. - self.old_modules = list(sys.modules) - self.addCleanup(self.cleanup_modules) - - def cleanup_modules(self): - """Remove any new modules imported during the test run. - - This lets us import the same source files for more than one test. - - """ - for m in [m for m in sys.modules if m not in self.old_modules]: - del sys.modules[m] - - -class SysPathAwareMixin(TestCase): - """A test case mixin that isolates changes to sys.path.""" - - def setUp(self): - super(SysPathAwareMixin, self).setUp() - setup_with_context_manager(self, saved_sys_path()) - - -class EnvironmentAwareMixin(TestCase): - """A test case mixin that isolates changes to the environment.""" - - def setUp(self): - super(EnvironmentAwareMixin, self).setUp() - - # Record environment variables that we changed with set_environ. - self.environ_undos = {} - - self.addCleanup(self.cleanup_environ) - - def set_environ(self, name, value): - """Set an environment variable `name` to be `value`. - - The environment variable is set, and record is kept that it was set, - so that `cleanup_environ` can restore its original value. - - """ - if name not in self.environ_undos: - self.environ_undos[name] = os.environ.get(name) - os.environ[name] = value - - def cleanup_environ(self): - """Undo all the changes made by `set_environ`.""" - for name, value in self.environ_undos.items(): - if value is None: - del os.environ[name] - else: - os.environ[name] = value - - -class StdStreamCapturingMixin(TestCase): - """A test case mixin that captures stdout and stderr.""" - - def setUp(self): - super(StdStreamCapturingMixin, self).setUp() - - # Capture stdout and stderr so we can examine them in tests. - # nose keeps stdout from littering the screen, so we can safely Tee it, - # but it doesn't capture stderr, so we don't want to Tee stderr to the - # real stderr, since it will interfere with our nice field of dots. - old_stdout = sys.stdout - self.captured_stdout = StringIO() - sys.stdout = Tee(sys.stdout, self.captured_stdout) - - old_stderr = sys.stderr - self.captured_stderr = StringIO() - sys.stderr = self.captured_stderr - - self.addCleanup(self.cleanup_std_streams, old_stdout, old_stderr) - - def cleanup_std_streams(self, old_stdout, old_stderr): - """Restore stdout and stderr.""" - sys.stdout = old_stdout - sys.stderr = old_stderr - - def stdout(self): - """Return the data written to stdout during the test.""" - return self.captured_stdout.getvalue() - - def stderr(self): - """Return the data written to stderr during the test.""" - return self.captured_stderr.getvalue() - - -class DelayedAssertionMixin(TestCase): - """A test case mixin that provides a `delayed_assertions` context manager. - - Use it like this:: - - with self.delayed_assertions(): - self.assertEqual(x, y) - self.assertEqual(z, w) - - All of the assertions will run. The failures will be displayed at the end - of the with-statement. - - NOTE: this only works with some assertions. These are known to work: - - - `assertEqual(str, str)` - - - `assertMultilineEqual(str, str)` - - """ - def __init__(self, *args, **kwargs): - super(DelayedAssertionMixin, self).__init__(*args, **kwargs) - # This mixin only works with assert methods that call `self.fail`. In - # Python 2.7, `assertEqual` didn't, but we can do what Python 3 does, - # and use `assertMultiLineEqual` for comparing strings. - self.addTypeEqualityFunc(str, 'assertMultiLineEqual') - self._delayed_assertions = None - - @contextlib.contextmanager - def delayed_assertions(self): - """The context manager: assert that we didn't collect any assertions.""" - self._delayed_assertions = [] - old_fail = self.fail - self.fail = self._delayed_fail - try: - yield - finally: - self.fail = old_fail - if self._delayed_assertions: - if len(self._delayed_assertions) == 1: - self.fail(self._delayed_assertions[0]) - else: - self.fail( - "{0} failed assertions:\n{1}".format( - len(self._delayed_assertions), - "\n".join(self._delayed_assertions), - ) - ) - - def _delayed_fail(self, msg=None): - """The stand-in for TestCase.fail during delayed_assertions.""" - self._delayed_assertions.append(msg) - - -class TempDirMixin(SysPathAwareMixin, ModuleAwareMixin, TestCase): - """A test case mixin that creates a temp directory and files in it. - - Includes SysPathAwareMixin and ModuleAwareMixin, because making and using - temp directories like this will also need that kind of isolation. - - """ - - # Our own setting: most of these tests run in their own temp directory. - # Set this to False in your subclass if you don't want a temp directory - # created. - run_in_temp_dir = True - - # Set this if you aren't creating any files with make_file, but still want - # the temp directory. This will stop the test behavior checker from - # complaining. - no_files_in_temp_dir = False - - def setUp(self): - super(TempDirMixin, self).setUp() - - if self.run_in_temp_dir: - # Create a temporary directory. - self.temp_dir = self.make_temp_dir("test_cover") - self.chdir(self.temp_dir) - - # Modules should be importable from this temp directory. We don't - # use '' because we make lots of different temp directories and - # nose's caching importer can get confused. The full path prevents - # problems. - sys.path.insert(0, os.getcwd()) - - class_behavior = self.class_behavior() - class_behavior.tests += 1 - class_behavior.temp_dir = self.run_in_temp_dir - class_behavior.no_files_ok = self.no_files_in_temp_dir - - self.addCleanup(self.check_behavior) - - def make_temp_dir(self, slug="test_cover"): - """Make a temp directory that is cleaned up when the test is done.""" - name = "%s_%08d" % (slug, random.randint(0, 99999999)) - temp_dir = os.path.join(tempfile.gettempdir(), name) - os.makedirs(temp_dir) - self.addCleanup(shutil.rmtree, temp_dir) - return temp_dir - - def chdir(self, new_dir): - """Change directory, and change back when the test is done.""" - old_dir = os.getcwd() - os.chdir(new_dir) - self.addCleanup(os.chdir, old_dir) - - def check_behavior(self): - """Check that we did the right things.""" - - class_behavior = self.class_behavior() - if class_behavior.test_method_made_any_files: - class_behavior.tests_making_files += 1 - - def make_file(self, filename, text="", newline=None): - """Create a file for testing. - - `filename` is the relative path to the file, including directories if - desired, which will be created if need be. - - `text` is the content to create in the file, a native string (bytes in - Python 2, unicode in Python 3). - - If `newline` is provided, it is a string that will be used as the line - endings in the created file, otherwise the line endings are as provided - in `text`. - - Returns `filename`. - - """ - # Tests that call `make_file` should be run in a temp environment. - assert self.run_in_temp_dir - self.class_behavior().test_method_made_any_files = True - - text = textwrap.dedent(text) - if newline: - text = text.replace("\n", newline) - - # Make sure the directories are available. - dirs, _ = os.path.split(filename) - if dirs and not os.path.exists(dirs): - os.makedirs(dirs) - - # Create the file. - with open(filename, 'wb') as f: - f.write(to_bytes(text)) - - return filename - - # We run some tests in temporary directories, because they may need to make - # files for the tests. But this is expensive, so we can change per-class - # whether a temp directory is used or not. It's easy to forget to set that - # option properly, so we track information about what the tests did, and - # then report at the end of the process on test classes that were set - # wrong. - - class ClassBehavior(object): - """A value object to store per-class.""" - def __init__(self): - self.tests = 0 - self.skipped = 0 - self.temp_dir = True - self.no_files_ok = False - self.tests_making_files = 0 - self.test_method_made_any_files = False - - # Map from class to info about how it ran. - class_behaviors = collections.defaultdict(ClassBehavior) - - @classmethod - def report_on_class_behavior(cls): - """Called at process exit to report on class behavior.""" - for test_class, behavior in cls.class_behaviors.items(): - bad = "" - if behavior.tests <= behavior.skipped: - bad = "" - elif behavior.temp_dir and behavior.tests_making_files == 0: - if not behavior.no_files_ok: - bad = "Inefficient" - elif not behavior.temp_dir and behavior.tests_making_files > 0: - bad = "Unsafe" - - if bad: - if behavior.temp_dir: - where = "in a temp directory" - else: - where = "without a temp directory" - print( - "%s: %s ran %d tests, %d made files %s" % ( - bad, - test_class.__name__, - behavior.tests, - behavior.tests_making_files, - where, - ) - ) - - def class_behavior(self): - """Get the ClassBehavior instance for this test.""" - return self.class_behaviors[self.__class__] - -# When the process ends, find out about bad classes. -atexit.register(TempDirMixin.report_on_class_behavior) |