Merge pull request #657 from karyon/remove_silent_exception_catching

remove silent exception catching

compressor/templatetags/compress.py

@@ -103,19 +103,11 @@ class CompressorMixin(object):
         if cache_content is not None:
             return cache_content
 
-        # call compressor output method and handle exceptions
-        try:
-            rendered_output = self.render_output(compressor, mode, forced=forced)
-            if cache_key:
-                cache_set(cache_key, rendered_output)
-            assert isinstance(rendered_output, six.string_types)
-            return rendered_output
-        except Exception:
-            if settings.DEBUG or forced:
-                raise
-
-        # Or don't do anything in production
-        return self.get_original_content(context)
+        rendered_output = self.render_output(compressor, mode, forced=forced)
+        assert isinstance(rendered_output, six.string_types)
+        if cache_key:
+            cache_set(cache_key, rendered_output)
+        return rendered_output
 
     def render_output(self, compressor, mode, forced=False):
         return compressor.output(mode, forced=forced)

compressor/tests/test_base.py

@@ -128,8 +128,8 @@ class CompressorTestCase(SimpleTestCase):
             self.assertTrue(is_date.match(str(float(date))),
                 "mtimes is returning something that doesn't look like a date: %s" % date)
 
+    @override_settings(COMPRESS_ENABLED=False)
     def test_css_return_if_off(self):
-        settings.COMPRESS_ENABLED = False
         self.assertEqualCollapsed(self.css, self.css_node.output())
 
     def test_cachekey(self):

compressor/tests/test_filters.py

@@ -47,6 +47,7 @@ class CssTidyTestCase(TestCase):
             "font,th,td,p{color:#000;}", CSSTidyFilter(content).input())
 
 
+@override_settings(COMPRESS_CACHEABLE_PRECOMPILERS=('text/css',))
 class PrecompilerTestCase(TestCase):
     def setUp(self):
         self.test_precompiler = os.path.join(test_dir, 'precompiler.py')
@@ -54,7 +55,6 @@ class PrecompilerTestCase(TestCase):
         self.cached_precompiler_args = dict(
             content=self.content, charset=settings.FILE_CHARSET,
             filename=self.filename, mimetype='text/css')
-        settings.COMPRESS_CACHEABLE_PRECOMPILERS = ('text/css',)
 
     def setup_infile(self, filename='static/css/one.css'):
         self.filename = os.path.join(test_dir, filename)
@@ -197,6 +197,10 @@ class JsMinTestCase(TestCase):
         self.assertEqual(output, JSMinFilter(content).output())
 
 
+@override_settings(
+        COMPRESS_ENABLED=True,
+        COMPRESS_URL='/static/',
+)
 class CssAbsolutizingTestCase(TestCase):
     hashing_method = 'mtime'
     hashing_func = staticmethod(get_hashed_mtime)
@@ -204,11 +208,7 @@ class CssAbsolutizingTestCase(TestCase):
                 "p { filter: Alpha(src='%(url)simg/python.png%(query)s%(hash)s%(frag)s') }")
 
     def setUp(self):
-        self.old_enabled = settings.COMPRESS_ENABLED
-        self.old_url = settings.COMPRESS_URL
         self.old_hashing_method = settings.COMPRESS_CSS_HASHING_METHOD
-        settings.COMPRESS_ENABLED = True
-        settings.COMPRESS_URL = '/static/'
         settings.COMPRESS_CSS_HASHING_METHOD = self.hashing_method
         self.css = """
         <link rel="stylesheet" href="/static/css/url/url1.css" type="text/css">
@@ -217,12 +217,10 @@ class CssAbsolutizingTestCase(TestCase):
         self.css_node = CssCompressor(self.css)
 
     def tearDown(self):
-        settings.COMPRESS_ENABLED = self.old_enabled
-        settings.COMPRESS_URL = self.old_url
         settings.COMPRESS_CSS_HASHING_METHOD = self.old_hashing_method
 
+    @override_settings(COMPRESS_CSS_HASHING_METHOD=None)
     def test_css_no_hash(self):
-        settings.COMPRESS_CSS_HASHING_METHOD = None
         filename = os.path.join(settings.COMPRESS_ROOT, 'css/url/test.css')
         content = self.template % blankdict(url='../../')
         params = blankdict({
@@ -232,10 +230,11 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = params['url'] = 'http://static.example.com/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='http://static.example.com/'):
+            params['url'] = settings.COMPRESS_URL
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter(self):
         filename = os.path.join(settings.COMPRESS_ROOT, 'css/url/test.css')
@@ -249,10 +248,11 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = params['url'] = 'http://static.example.com/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='http://static.example.com/'):
+            params['url'] = settings.COMPRESS_URL
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter_url_fragment(self):
         filename = os.path.join(settings.COMPRESS_ROOT, 'css/url/test.css')
@@ -267,10 +267,11 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = params['url'] = 'http://media.example.com/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='http://media.example.com/'):
+            params['url'] = settings.COMPRESS_URL
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter_only_url_fragment(self):
         filename = os.path.join(settings.COMPRESS_ROOT, 'css/url/test.css')
@@ -278,9 +279,9 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(content, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = 'http://media.example.com/'
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(content, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='http://media.example.com/'):
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(content, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter_querystring(self):
         filename = os.path.join(settings.COMPRESS_ROOT, 'css/url/test.css')
@@ -295,10 +296,11 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = params['url'] = 'http://media.example.com/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='http://media.example.com/'):
+            params['url'] = settings.COMPRESS_URL
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter_https(self):
         filename = os.path.join(settings.COMPRESS_ROOT, 'css/url/test.css')
@@ -312,10 +314,11 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = params['url'] = 'https://static.example.com/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='https://static.example.com/'):
+            params['url'] = settings.COMPRESS_URL
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter_relative_path(self):
         filename = os.path.join(settings.TEST_DIR, 'whatever', '..', 'static', 'whatever/../css/url/test.css')
@@ -329,10 +332,11 @@ class CssAbsolutizingTestCase(TestCase):
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
-        settings.COMPRESS_URL = params['url'] = 'https://static.example.com/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
+        with self.settings(COMPRESS_URL='https://static.example.com/'):
+            params['url'] = settings.COMPRESS_URL
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='css/url/test.css'))
 
     def test_css_absolute_filter_filename_outside_compress_root(self):
         filename = '/foo/bar/baz/test.css'
@@ -343,11 +347,12 @@ class CssAbsolutizingTestCase(TestCase):
         output = self.template % params
         filter = CssAbsoluteFilter(content)
         self.assertEqual(output, filter.input(filename=filename, basename='bar/baz/test.css'))
-        settings.COMPRESS_URL = 'https://static.example.com/'
-        params['url'] = settings.COMPRESS_URL + 'bar/qux/'
-        output = self.template % params
-        filter = CssAbsoluteFilter(content)
-        self.assertEqual(output, filter.input(filename=filename, basename='bar/baz/test.css'))
+
+        with self.settings(COMPRESS_URL='https://static.example.com/'):
+            params['url'] = settings.COMPRESS_URL + 'bar/qux/'
+            output = self.template % params
+            filter = CssAbsoluteFilter(content)
+            self.assertEqual(output, filter.input(filename=filename, basename='bar/baz/test.css'))
 
     def test_css_hunks(self):
         hash_dict = {
@@ -371,12 +376,12 @@ p { filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(src='/static/img/
 
     def test_guess_filename(self):
         for base_url in ('/static/', 'http://static.example.com/'):
-            settings.COMPRESS_URL = base_url
-            url = '%s/img/python.png' % settings.COMPRESS_URL.rstrip('/')
-            path = os.path.join(settings.COMPRESS_ROOT, 'img/python.png')
-            content = "p { background: url('%s') }" % url
-            filter = CssAbsoluteFilter(content)
-            self.assertEqual(path, filter.guess_filename(url))
+            with self.settings(COMPRESS_URL=base_url):
+                url = '%s/img/python.png' % settings.COMPRESS_URL.rstrip('/')
+                path = os.path.join(settings.COMPRESS_ROOT, 'img/python.png')
+                content = "p { background: url('%s') }" % url
+                filter = CssAbsoluteFilter(content)
+                self.assertEqual(path, filter.guess_filename(url))
 
 
 class CssAbsolutizingTestCaseWithHash(CssAbsolutizingTestCase):
@@ -384,15 +389,17 @@ class CssAbsolutizingTestCaseWithHash(CssAbsolutizingTestCase):
     hashing_func = staticmethod(get_hashed_content)
 
 
+@override_settings(
+    COMPRESS_ENABLED=True,
+    COMPRESS_CSS_FILTERS=[
+        'compressor.filters.css_default.CssAbsoluteFilter',
+        'compressor.filters.datauri.CssDataUriFilter',
+    ],
+    COMPRESS_URL='/static/',
+    COMPRESS_CSS_HASHING_METHOD='mtime'
+)
 class CssDataUriTestCase(TestCase):
     def setUp(self):
-        settings.COMPRESS_ENABLED = True
-        settings.COMPRESS_CSS_FILTERS = [
-            'compressor.filters.css_default.CssAbsoluteFilter',
-            'compressor.filters.datauri.CssDataUriFilter',
-        ]
-        settings.COMPRESS_URL = '/static/'
-        settings.COMPRESS_CSS_HASHING_METHOD = 'mtime'
         self.css = """
         <link rel="stylesheet" href="/static/css/datauri.css" type="text/css">
         """

compressor/tests/test_jinja2ext.py

@@ -11,7 +11,7 @@ from compressor.conf import settings
 from compressor.tests.test_base import css_tag
 
 
-@unittest.skipUnless(not six.PY3 or sys.version_info[:2] >= (3, 3),
+@unittest.skipIf(six.PY3 and sys.version_info[:2] < (3, 3),
                      'Jinja can only run on Python < 3 and >= 3.3')
 class TestJinja2CompressorExtension(TestCase):
     """
@@ -143,13 +143,11 @@ class TestJinja2CompressorExtension(TestCase):
         self.assertEqual(out, template.render(context))
 
     def test_nonascii_inline_css(self):
-        org_COMPRESS_ENABLED = settings.COMPRESS_ENABLED
-        settings.COMPRESS_ENABLED = False
-        template = self.env.from_string('{% compress css %}'
-                                        '<style type="text/css">'
-                                        '/* русский текст */'
-                                        '</style>{% endcompress %}')
+        with self.settings(COMPRESS_ENABLED=False):
+            template = self.env.from_string('{% compress css %}'
+                                            '<style type="text/css">'
+                                            '/* русский текст */'
+                                            '</style>{% endcompress %}')
         out = '<link rel="stylesheet" href="/static/CACHE/css/b2cec0f8cb24.css" type="text/css" />'
-        settings.COMPRESS_ENABLED = org_COMPRESS_ENABLED
         context = {'STATIC_URL': settings.COMPRESS_URL}
         self.assertEqual(out, template.render(context))

compressor/tests/test_offline.py

@@ -217,7 +217,7 @@ class OfflineGenerationConditionTestCase(OfflineTestCaseMixin, TestCase):
         super(OfflineGenerationConditionTestCase, self).setUp()
 
     def tearDown(self):
-        self.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
+        settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
         super(OfflineGenerationConditionTestCase, self).tearDown()
 
 
@@ -406,7 +406,7 @@ class OfflineGenerationInlineNonAsciiTestCase(OfflineTestCaseMixin, TestCase):
         super(OfflineGenerationInlineNonAsciiTestCase, self).setUp()
 
     def tearDown(self):
-        self.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
+        settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
         super(OfflineGenerationInlineNonAsciiTestCase, self).tearDown()
 
     def _test_offline(self, engine):
@@ -429,7 +429,7 @@ class OfflineGenerationComplexTestCase(OfflineTestCaseMixin, TestCase):
         super(OfflineGenerationComplexTestCase, self).setUp()
 
     def tearDown(self):
-        self.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
+        settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
         super(OfflineGenerationComplexTestCase, self).tearDown()
 
     def _test_offline(self, engine):

compressor/tests/test_parsers.py

@@ -101,8 +101,8 @@ class Html5LibParserTests(ParserTestCase, CompressorTestCase):
                                                split[1][3].attrib,
                                                split[1][3].text))
 
+    @override_settings(COMPRESS_ENABLED=False)
     def test_css_return_if_off(self):
-        settings.COMPRESS_ENABLED = False
         # Yes, they are semantically equal but attributes might be
         # scrambled in unpredictable order. A more elaborate check
         # would require parsing both arguments with a different parser

compressor/tests/test_signals.py

@@ -1,18 +1,20 @@
 from django.test import TestCase
+from django.test.utils import override_settings
 
 from mock import Mock
 
-from compressor.conf import settings
 from compressor.css import CssCompressor
 from compressor.js import JsCompressor
 from compressor.signals import post_compress
 
 
+@override_settings(
+    COMPRESS_ENABLED=True,
+    COMPRESS_PRECOMPILERS=(),
+    COMPRESS_DEBUG_TOGGLE='nocompress'
+)
 class PostCompressSignalTestCase(TestCase):
     def setUp(self):
-        settings.COMPRESS_ENABLED = True
-        settings.COMPRESS_PRECOMPILERS = ()
-        settings.COMPRESS_DEBUG_TOGGLE = 'nocompress'
         self.css = """\
 <link rel="stylesheet" href="/static/css/one.css" type="text/css" />
 <style type="text/css">p { border:5px solid green;}</style>

compressor/tests/test_storages.py

@@ -5,6 +5,7 @@ import os
 from django.core.files.base import ContentFile
 from django.core.files.storage import get_storage_class
 from django.test import TestCase
+from django.test.utils import override_settings
 from django.utils.functional import LazyObject
 
 from compressor import storage
@@ -18,16 +19,14 @@ class GzipStorage(LazyObject):
         self._wrapped = get_storage_class('compressor.storage.GzipCompressorFileStorage')()
 
 
+@override_settings(COMPRESS_ENABLED=True)
 class StorageTestCase(TestCase):
     def setUp(self):
-        self.old_enabled = settings.COMPRESS_ENABLED
-        settings.COMPRESS_ENABLED = True
         self.default_storage = storage.default_storage
         storage.default_storage = GzipStorage()
 
     def tearDown(self):
         storage.default_storage = self.default_storage
-        settings.COMPRESS_ENABLED = self.old_enabled
 
     def test_gzip_storage(self):
         storage.default_storage.save('test.txt', ContentFile('yeah yeah'))

compressor/tests/test_templatetags.py

@@ -25,15 +25,11 @@ def render(template_string, context_dict=None):
     return t.render(c).strip()
 
 
+@override_settings(COMPRESS_ENABLED=True)
 class TemplatetagTestCase(TestCase):
     def setUp(self):
-        self.old_enabled = settings.COMPRESS_ENABLED
-        settings.COMPRESS_ENABLED = True
         self.context = {'STATIC_URL': settings.COMPRESS_URL}
 
-    def tearDown(self):
-        settings.COMPRESS_ENABLED = self.old_enabled
-
     def test_empty_tag(self):
         template = """{% load compress %}{% compress js %}{% block js %}
         {% endblock %}{% endcompress %}"""