Check settings later, to avoid errors. #18

Some programs don't need settings.  If we check early, then our plugin
will fail where the original program would not.  Now we check later,
when we know that we will actually be involved.

Author: nedbat

django_coverage_plugin/plugin.py

@@ -13,6 +13,7 @@
 
 import django
 import django.template
+from django.core.exceptions import ImproperlyConfigured
 from django.template.base import (
     Lexer, TextNode, NodeList, Template,
     TOKEN_BLOCK, TOKEN_MAPPING, TOKEN_TEXT, TOKEN_VAR,
@@ -49,7 +50,16 @@ def check_debug():
     # settings exist, use them, otherwise use the old.
 
     from django.conf import settings
-    templates = getattr(settings, 'TEMPLATES', [])
+
+    try:
+        templates = getattr(settings, 'TEMPLATES', [])
+    except ImproperlyConfigured:
+        # Maybe there are no settings at all.  We are fine with this.  Our
+        # code will need settings, but if this program we're in runs without
+        # settings, then it must be that it never uses templates, and our code
+        # will never try to use the settings anyway.
+        return
+
     if templates:
         for template_settings in templates:
             if template_settings['BACKEND'] != 'django.template.backends.django.DjangoTemplates':
@@ -118,7 +128,7 @@ class DjangoTemplatePlugin(
 ):
 
     def __init__(self):
-        check_debug()
+        self.debug_checked = False
 
         self.django_template_dir = os.path.realpath(
             os.path.dirname(django.template.__file__)
@@ -140,6 +150,10 @@ def sys_info(self):
 
     def file_tracer(self, filename):
         if filename.startswith(self.django_template_dir):
+            if not self.debug_checked:
+                check_debug()
+                self.debug_checked = True
+
             return self
         return None
 

tests/plugin_test.py

@@ -3,6 +3,7 @@
 
 """Base classes and helpers for testing the plugin."""
 
+import contextlib
 import os
 import os.path
 import re
@@ -14,6 +15,8 @@
 import django
 from django.conf import settings
 
+from django_coverage_plugin.plugin import DjangoTemplatePlugin
+
 
 def test_settings():
     """Create a dict full of default Django settings for the tests."""
@@ -69,7 +72,7 @@ def test_settings():
 from django.test import TestCase                        # noqa
 
 
-class DjangoPluginTestCase(TempDirMixin, TestCase):
+class DjangoPluginTestCase(StdStreamCapturingMixin, TempDirMixin, TestCase):
     """A base class for all our tests."""
 
     def setUp(self):
@@ -110,6 +113,8 @@ def run_django_coverage(
             str: the text produced by the template.
 
         """
+        use_real_context = (django.VERSION < (1, 8))
+
         if options is None:
             options = {'source': ["."]}
 
@@ -122,9 +127,15 @@ def run_django_coverage(
                 tem = engine.get_template(name or self.template_file)
         elif text is not None:
             tem = Template(text)
+            use_real_context = True
         else:
             tem = get_template(name or self.template_file)
-        ctx = Context(context or {})
+
+        ctx = context or {}
+        if use_real_context:
+            # Before 1.8, render() wanted a Context. After, it wants a dict.
+            ctx = Context(ctx)
+
         self.cov = coverage.Coverage(**options)
         self.append_config("run:plugins", "django_coverage_plugin")
         if 0:
@@ -133,6 +144,11 @@ def run_django_coverage(
         text = tem.render(ctx)
         self.cov.stop()
         self.cov.save()
+        # Warning! Accessing secret internals!
+        for pl in self.cov.plugins:
+            if isinstance(pl, DjangoTemplatePlugin):
+                if not pl._coverage_enabled:
+                    raise PluginDisabled()
         return text
 
     def append_config(self, option, value):
@@ -209,6 +225,25 @@ def get_xml_report(self, name=None):
         xml_coverage = self.cov.xml_report(os.path.abspath(path))
         return xml_coverage
 
+    @contextlib.contextmanager
+    def assert_plugin_disabled(self, msg):
+        """Assert that our plugin was disabled during an operation."""
+        # self.run_django_coverage will raise PluginDisabled if the plugin
+        # was disabled.
+        with self.assertRaises(PluginDisabled):
+            yield
+        stderr = self.stderr()
+        self.assertIn(
+            "Coverage.py warning: "
+            "Disabling plugin 'django_coverage_plugin.DjangoTemplatePlugin' "
+            "due to an exception:",
+            stderr
+        )
+        self.assertIn(
+            "DjangoTemplatePluginException: " + msg,
+            stderr
+        )
+
 
 def squashed(s):
     """Remove all of the whitespace from s."""
@@ -241,3 +276,8 @@ def test_thing(self):
         return lambda func: func
     else:
         return unittest.skip("Django version must be older")
+
+
+class PluginDisabled(Exception):
+    """Raised if we find that our plugin has been disabled."""
+    pass

tests/test_engines.py

@@ -3,8 +3,6 @@
 
 """Tests of multiple engines for django_coverage_plugin."""
 
-from django_coverage_plugin import DjangoTemplatePluginException
-
 from .plugin_test import DjangoPluginTestCase, django_start_at
 
 
@@ -51,6 +49,5 @@ def test_third_engine_not_debug(self):
         self.addCleanup(modified_settings.disable)
 
         self.make_template('Hello')
-        msg = "Template debugging must be enabled in settings."
-        with self.assertRaisesRegexp(DjangoTemplatePluginException, msg):
+        with self.assert_plugin_disabled("Template debugging must be enabled in settings."):
             self.run_django_coverage()

tests/test_settings.py

@@ -6,8 +6,6 @@
 import django
 from django.test.utils import override_settings
 
-from django_coverage_plugin import DjangoTemplatePluginException
-
 from .plugin_test import DjangoPluginTestCase, test_settings, django_start_at
 
 
@@ -30,26 +28,24 @@
 
 
 class SettingsTest(DjangoPluginTestCase):
+    """Tests of detecting that the settings need to be right for the plugin to work."""
 
     @override_settings(**DEBUG_FALSE_OVERRIDES)
     def test_debug_false(self):
         self.make_template('Hello')
-        msg = "Template debugging must be enabled in settings."
-        with self.assertRaisesRegexp(DjangoTemplatePluginException, msg):
+        with self.assert_plugin_disabled("Template debugging must be enabled in settings."):
             self.run_django_coverage()
 
     @django_start_at(1, 8)
     @override_settings(**NO_OPTIONS_OVERRIDES)
     def test_no_options(self):
         self.make_template('Hello')
-        msg = "Template debugging must be enabled in settings."
-        with self.assertRaisesRegexp(DjangoTemplatePluginException, msg):
+        with self.assert_plugin_disabled("Template debugging must be enabled in settings."):
             self.run_django_coverage()
 
     @django_start_at(1, 8)
     @override_settings(**OTHER_ENGINE_OVERRIDES)
     def test_other_engine(self):
         self.make_template('Hello')
-        msg = "Can't use non-Django templates."
-        with self.assertRaisesRegexp(DjangoTemplatePluginException, msg):
+        with self.assert_plugin_disabled("Can't use non-Django templates."):
             self.run_django_coverage()