Tweak some details of how the tests are run so that better coverage reports can be collected.

Author: embray

.coveragerc

@@ -0,0 +1,24 @@
+[run]
+source = setup/cfg
+omit =
+    setup/cfg/extern/*
+    setup/cfg/tests/*
+
+[report]
+exclude_lines =
+   # Have to re-enable the standard pragma
+   pragma: no cover
+
+   # Don't complain about packages we have installed
+   except ImportError
+
+   # Don't complain if tests don't hit assertions
+   raise AssertionError
+   raise NotImplementedError
+
+   # Don't complain about script hooks
+   def main\(.*\):
+
+   # Ignore branches that don't pertain to this version of Python
+   pragma: py{ignore_python_version}
+   six.PY{ignore_python_version}

setup/cfg/tests/__init__.py

@@ -1,4 +1,6 @@
 from __future__ import with_statement
+
+import io
 import os
 import shutil
 import subprocess
@@ -8,7 +10,10 @@
 
 import pkg_resources
 
+from setuptools.sandbox import run_setup
+
 from .util import rmtree, open_config
+from ..util import monkeypatch_method
 
 
 SETUP_CFG_DIR = os.path.abspath(
@@ -68,14 +73,25 @@ def teardown(self):
                 del sys.modules[k]
         rmtree(self.temp_dir)
 
+        # Undo all monkey-patching that occurred during the test
+        monkeypatch_method.unpatch_all()
+
     def run_setup(self, *args):
-        cmd = ('-c',
-               'import sys;sys.path.insert(0, %r);'
-               'from setup.cfg.tests import fake_setup_cfg_dist;'
-               'from setup.cfg.extern.six import exec_;'
-               'fake_setup_cfg_dist();exec_(open("setup.py").read())' %
-               SETUP_CFG_DIR)
-        return self._run_cmd(sys.executable, cmd + args)
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        stdout = sys.stdout = io.StringIO()
+        stderr = sys.stderr = io.StringIO()
+        try:
+            run_setup('setup.py', args)
+            returncode = 0
+        except SystemExit as e:
+            returncode = e.args[0]
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+        return (stdout.getvalue().strip(), stderr.getvalue().strip(),
+                returncode)
 
     def run_svn(self, *args):
         return self._run_cmd('svn', args)

setup/cfg/tests/test_core.py

@@ -1,6 +1,7 @@
 import glob
 import os
 import tarfile
+import sys
 
 from . import D2to1TestCase
 
@@ -9,6 +10,21 @@
 
 
 class TestCore(D2to1TestCase):
+    def test_import_setup_cfg(self):
+        """
+        Test importing the main modules of setup.cfg.
+
+        This both tests that importing it is possible, but is also kind
+        of necessary for coverage.py to pick up the fact that those modules
+        were imported.
+        """
+
+        modules = ['setup.cfg', 'setup.cfg.core', 'setup.cfg.util']
+        for module in modules:
+            if module in sys.modules:
+                del sys.modules[module]
+            __import__(module)
+
     def test_setup_py_version(self):
         """
         Test that the `./setup.py --version` command returns the correct

setup/cfg/util.py

@@ -213,6 +213,7 @@ def cfg_to_args(path='setup.cfg'):
                     raise DistutilsFileError(
                         '%s from the extra_files option in setup.cfg does not '
                         'exist' % filename)
+
             # Unfortunately the only really sensible way to do this is to
             # monkey-patch the manifest_maker class
             @monkeypatch_method(manifest_maker)
@@ -536,19 +537,41 @@ def split_csv(value):
     return value
 
 
-def monkeypatch_method(cls):
-    """A function decorator to monkey-patch a method of the same name on the
-    given class.
-    """
+class MonkeyPatcher(object):
+    def __init__(self):
+        self._patched = set()
+
+    def __call__(self, cls):
+        """
+        A function decorator to monkey-patch a method of the same name on the
+        given class.
+        """
 
-    def wrapper(func):
-        orig = getattr(cls, func.__name__, None)
-        if orig and not hasattr(orig, '_orig'):  # Already patched
-            setattr(func, '_orig', orig)
+        def wrapper(func):
+            orig = getattr(cls, func.__name__, None)
+            if hasattr(orig, '_orig'):  # Already patched
+                return orig
+
+            func._orig = orig
             setattr(cls, func.__name__, func)
-        return func
+            self._patched.add((cls, orig))
+
+            return func
+
+        return wrapper
+
+    def unpatch_all(self):
+        """
+        Remove all monkey-patches.
+        """
+
+        for cls, func in self._patched:
+            setattr(cls, func.__name__, func)
+
+        self._patched.clear()
+
 
-    return wrapper
+monkeypatch_method = MonkeyPatcher()
 
 
 # The following classes are used to hack Distribution.command_options a bit