openstack/deb-python-django-compressor
Code Issues Proposed changes

Merge pull request #667 from diox/override_settings_in_tests

Browse Source 
Refactor offline tests to make them always use override_settings
This commit is contained in:
Mathieu Pillard
2015-09-26 02:28:00 +02:00
parent 9151bc9877 97728340fb
commit bbc8b9b170
1 changed files with 301 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

602
compressor/tests/test_offline.py
View File

@@ -30,7 +30,7 @@ else:
# The Jinja2 tests fail on Python 3.2 due to the following: # The Jinja2 tests fail on Python 3.2 due to the following:
# The line in compressor/management/commands/compress.py: # The line in compressor/management/commands/compress.py:
# compressor_nodes.setdefault(template, []).extend(nodes) # compressor_nodes.setdefault(template, []).extend(nodes)
# causes the error "unhashable type: 'Template'" # causes the error 'unhashable type: 'Template''
_TEST_JINJA2 = not(sys.version_info[0] == 3 and sys.version_info[1] == 2) _TEST_JINJA2 = not(sys.version_info[0] == 3 and sys.version_info[1] == 2)
@@ -40,16 +40,17 @@ def offline_context_generator():
class OfflineTestCaseMixin(object): class OfflineTestCaseMixin(object):
template_name = "test_compressor_offline.html" template_name = 'test_compressor_offline.html'
verbosity = 0 verbosity = 0
# Change this for each test class # Change this for each test class
templates_dir = "" templates_dir = ''
expected_hash = "" expected_hash = ''
# Engines to test # Engines to test
if _TEST_JINJA2: if _TEST_JINJA2:
engines = ("django", "jinja2") engines = ('django', 'jinja2')
else: else:
engines = ("django",) engines = ('django',)
additional_test_settings = None
def setUp(self): def setUp(self):
self.log = StringIO() self.log = StringIO()
@@ -57,11 +58,13 @@ class OfflineTestCaseMixin(object):
# Reset template dirs, because it enables us to force compress to # Reset template dirs, because it enables us to force compress to
# consider only a specific directory (helps us make true, # consider only a specific directory (helps us make true,
# independent unit tests). # independent unit tests).
# Specify both Jinja2 and Django template locations. When the wrong engine # Specify both Jinja2 and Django template locations. When the wrong
# is used to parse a template, the TemplateSyntaxError will cause the # engine is used to parse a template, the TemplateSyntaxError will
# template to be skipped over. # cause the template to be skipped over.
django_template_dir = os.path.join(settings.TEST_DIR, 'test_templates', self.templates_dir) django_template_dir = os.path.join(
jinja2_template_dir = os.path.join(settings.TEST_DIR, 'test_templates_jinja2', self.templates_dir) settings.TEST_DIR, 'test_templates', self.templates_dir)
jinja2_template_dir = os.path.join(
settings.TEST_DIR, 'test_templates_jinja2', self.templates_dir)
override_settings = { override_settings = {
'TEMPLATE_DIRS': (django_template_dir, jinja2_template_dir,), 'TEMPLATE_DIRS': (django_template_dir, jinja2_template_dir,),
@@ -69,24 +72,32 @@ class OfflineTestCaseMixin(object):
'COMPRESS_OFFLINE': True 'COMPRESS_OFFLINE': True
} }
if "jinja2" in self.engines: if 'jinja2' in self.engines:
override_settings["COMPRESS_JINJA2_GET_ENVIRONMENT"] = lambda: self._get_jinja2_env() override_settings['COMPRESS_JINJA2_GET_ENVIRONMENT'] = (
lambda: self._get_jinja2_env())
if self.additional_test_settings is not None:
override_settings.update(self.additional_test_settings)
self.override_settings = self.settings(**override_settings) self.override_settings = self.settings(**override_settings)
self.override_settings.__enter__() self.override_settings.__enter__()
if "django" in self.engines: if 'django' in self.engines:
self.template_path = os.path.join(django_template_dir, self.template_name) self.template_path = os.path.join(
django_template_dir, self.template_name)
with io.open(self.template_path, encoding=settings.FILE_CHARSET) as file: with io.open(self.template_path,
self.template = Template(file.read()) encoding=settings.FILE_CHARSET) as file_:
self.template = Template(file_.read())
if "jinja2" in self.engines: if 'jinja2' in self.engines:
jinja2_env = override_settings["COMPRESS_JINJA2_GET_ENVIRONMENT"]() self.template_path_jinja2 = os.path.join(
self.template_path_jinja2 = os.path.join(jinja2_template_dir, self.template_name) jinja2_template_dir, self.template_name)
jinja2_env = override_settings['COMPRESS_JINJA2_GET_ENVIRONMENT']()
with io.open(self.template_path_jinja2, encoding=settings.FILE_CHARSET) as file: with io.open(self.template_path_jinja2,
self.template_jinja2 = jinja2_env.from_string(file.read()) encoding=settings.FILE_CHARSET) as file_:
self.template_jinja2 = jinja2_env.from_string(file_.read())
def tearDown(self): def tearDown(self):
self.override_settings.__exit__(None, None, None) self.override_settings.__exit__(None, None, None)
@@ -107,16 +118,20 @@ class OfflineTestCaseMixin(object):
if engine == 'django': if engine == 'django':
return ''.join(self.template.render(c) for c in contexts) return ''.join(self.template.render(c) for c in contexts)
if engine == 'jinja2': if engine == 'jinja2':
return '\n'.join(self.template_jinja2.render(c) for c in contexts) + "\n" return '\n'.join(
self.template_jinja2.render(c) for c in contexts) + '\n'
return None return None
def _test_offline(self, engine): def _test_offline(self, engine):
hashes = self.expected_hash hashes = self.expected_hash
if not isinstance(hashes, (list, tuple)): if not isinstance(hashes, (list, tuple)):
hashes = [hashes] hashes = [hashes]
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
self.assertEqual(len(hashes), count) self.assertEqual(len(hashes), count)
self.assertEqual(['<script type="text/javascript" src="/static/CACHE/js/%s.js"></script>' % h for h in hashes], result) self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/'
'%s.js"></script>' % h for h in hashes], result)
rendered_template = self._render_template(engine) rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, '\n'.join(result) + '\n') self.assertEqual(rendered_template, '\n'.join(result) + '\n')
@@ -146,134 +161,175 @@ class OfflineTestCaseMixin(object):
def _get_jinja2_loader(self): def _get_jinja2_loader(self):
import jinja2 import jinja2
loader = jinja2.FileSystemLoader(settings.TEMPLATE_DIRS, encoding=settings.FILE_CHARSET) loader = jinja2.FileSystemLoader(
settings.TEMPLATE_DIRS, encoding=settings.FILE_CHARSET)
return loader return loader
class OfflineGenerationSkipDuplicatesTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressBasicTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_duplicate" templates_dir = 'basic'
expected_hash = 'f5e179b8eca4'
# We don't need to test multiples engines here. def test_rendering_without_manifest_raises_exception(self):
engines = ("django",) # flush cached manifest
flush_offline_manifest()
self.assertRaises(OfflineGenerationError,
self.template.render, Context({}))
def _test_offline(self, engine): @unittest.skipIf(not _TEST_JINJA2, 'No Jinja2 testing')
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) def test_rendering_without_manifest_raises_exception_jinja2(self):
# Only one block compressed, the second identical one was skipped. # flush cached manifest
flush_offline_manifest()
self.assertRaises(OfflineGenerationError,
self.template_jinja2.render, {})
def _test_deleting_manifest_does_not_affect_rendering(self, engine):
count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
get_offline_manifest()
manifest_path = os.path.join('CACHE', 'manifest.json')
if default_storage.exists(manifest_path):
default_storage.delete(manifest_path)
self.assertEqual(1, count) self.assertEqual(1, count)
# Only 1 <script> block in returned result as well.
self.assertEqual([ self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/f5e179b8eca4.js"></script>', '<script type="text/javascript" src="/static/CACHE/js/'
], result) '%s.js"></script>' % (self.expected_hash, )], result)
rendered_template = self._render_template(engine) rendered_template = self._render_template(engine)
# But rendering the template returns both (identical) scripts. self.assertEqual(rendered_template, ''.join(result) + '\n')
self.assertEqual(rendered_template, "".join(result * 2) + "\n")
def test_deleting_manifest_does_not_affect_rendering(self):
for engine in self.engines:
self._test_deleting_manifest_does_not_affect_rendering(engine)
class OfflineGenerationBlockSuperTestCase(OfflineTestCaseMixin, TestCase): def test_requires_model_validation(self):
templates_dir = "test_block_super" self.assertFalse(CompressCommand.requires_model_validation)
expected_hash = "7c02d201f69d"
# Block.super not supported for Jinja2 yet.
engines = ("django",)
def test_get_loaders(self):
class OfflineGenerationBlockSuperMultipleTestCase(OfflineTestCaseMixin, TestCase): TEMPLATE_LOADERS = (
templates_dir = "test_block_super_multiple"
expected_hash = "f8891c416981"
# Block.super not supported for Jinja2 yet.
engines = ("django",)
class OfflineGenerationBlockSuperMultipleWithCachedLoaderTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_block_super_multiple_cached"
expected_hash = "2f6ef61c488e"
# Block.super not supported for Jinja2 yet.
engines = ("django",)
def setUp(self):
self._old_template_loaders = settings.TEMPLATE_LOADERS
settings.TEMPLATE_LOADERS = (
('django.template.loaders.cached.Loader', ( ('django.template.loaders.cached.Loader', (
'django.template.loaders.filesystem.Loader', 'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader', 'django.template.loaders.app_directories.Loader',
)), )),
) )
super(OfflineGenerationBlockSuperMultipleWithCachedLoaderTestCase, self).setUp() with self.settings(TEMPLATE_LOADERS=TEMPLATE_LOADERS):
from django.template.loaders.filesystem import (
def tearDown(self): Loader as FileSystemLoader)
super(OfflineGenerationBlockSuperMultipleWithCachedLoaderTestCase, self).tearDown() from django.template.loaders.app_directories import (
settings.TEMPLATE_LOADERS = self._old_template_loaders Loader as AppDirectoriesLoader)
loaders = CompressCommand().get_loaders()
self.assertTrue(isinstance(loaders[0], FileSystemLoader))
self.assertTrue(isinstance(loaders[1], AppDirectoriesLoader))
class OfflineGenerationBlockSuperTestCaseWithExtraContent(OfflineTestCaseMixin, TestCase): class OfflineCompressSkipDuplicatesTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_block_super_extra" templates_dir = 'test_duplicate'
# Block.super not supported for Jinja2 yet.
engines = ("django",) # We don't need to test multiples engines here.
engines = ('django',)
def _test_offline(self, engine): def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
self.assertEqual(2, count) log=self.log, verbosity=self.verbosity, engine=engine)
# Only one block compressed, the second identical one was skipped.
self.assertEqual(1, count)
# Only 1 <script> block in returned result as well.
self.assertEqual([ self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/ced14aec5856.js"></script>', '<script type="text/javascript" src="/static/CACHE/js/'
'<script type="text/javascript" src="/static/CACHE/js/7c02d201f69d.js"></script>' 'f5e179b8eca4.js"></script>',
], result) ], result)
rendered_template = self._render_template(engine) rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, "".join(result) + "\n") # But rendering the template returns both (identical) scripts.
self.assertEqual(rendered_template, ''.join(result * 2) + '\n')
class OfflineGenerationConditionTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressBlockSuperTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_condition" templates_dir = 'test_block_super'
expected_hash = "4e3758d50224" expected_hash = '7c02d201f69d'
# Block.super not supported for Jinja2 yet.
engines = ('django',)
def setUp(self):
self.old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT class OfflineCompressBlockSuperMultipleTestCase(
settings.COMPRESS_OFFLINE_CONTEXT = { OfflineTestCaseMixin, TestCase):
templates_dir = 'test_block_super_multiple'
expected_hash = 'f8891c416981'
# Block.super not supported for Jinja2 yet.
engines = ('django',)
class OfflineCompressBlockSuperMultipleCachedLoaderTestCase(
OfflineTestCaseMixin, TestCase):
templates_dir = 'test_block_super_multiple_cached'
expected_hash = '2f6ef61c488e'
# Block.super not supported for Jinja2 yet.
engines = ('django',)
additional_test_settings = {
'TEMPLATE_LOADERS': (
('django.template.loaders.cached.Loader', (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)),
)
}
class OfflineCompressBlockSuperTestCaseWithExtraContent(
OfflineTestCaseMixin, TestCase):
templates_dir = 'test_block_super_extra'
# Block.super not supported for Jinja2 yet.
engines = ('django',)
def _test_offline(self, engine):
count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
self.assertEqual(2, count)
self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/'
'ced14aec5856.js"></script>',
'<script type="text/javascript" src="/static/CACHE/js/'
'7c02d201f69d.js"></script>',
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, ''.join(result) + '\n')
class OfflineCompressConditionTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = 'test_condition'
expected_hash = '4e3758d50224'
additional_test_settings = {
'COMPRESS_OFFLINE_CONTEXT': {
'condition': 'red', 'condition': 'red',
} }
super(OfflineGenerationConditionTestCase, self).setUp() }
def tearDown(self):
settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
super(OfflineGenerationConditionTestCase, self).tearDown()
class OfflineGenerationTemplateTagTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressTemplateTagTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_templatetag" templates_dir = 'test_templatetag'
expected_hash = "a27e1d3a619a" expected_hash = 'a27e1d3a619a'
class OfflineGenerationStaticTemplateTagTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressStaticTemplateTagTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_static_templatetag" templates_dir = 'test_static_templatetag'
expected_hash = "dfa2bb387fa8" expected_hash = 'dfa2bb387fa8'
class OfflineGenerationTestCaseWithContext(OfflineTestCaseMixin, TestCase): class OfflineCompressTestCaseWithContext(OfflineTestCaseMixin, TestCase):
templates_dir = "test_with_context" templates_dir = 'test_with_context'
expected_hash = "5838e2fd66af" expected_hash = '5838e2fd66af'
additional_test_settings = {
def setUp(self): 'COMPRESS_OFFLINE_CONTEXT': {
self.old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT
settings.COMPRESS_OFFLINE_CONTEXT = {
'content': 'OK!', 'content': 'OK!',
} }
super(OfflineGenerationTestCaseWithContext, self).setUp() }
def tearDown(self):
settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
super(OfflineGenerationTestCaseWithContext, self).tearDown()
class OfflineGenerationTestCaseWithContextList(OfflineTestCaseMixin, TestCase): class OfflineCompressTestCaseWithContextList(OfflineTestCaseMixin, TestCase):
templates_dir = 'test_with_context' templates_dir = 'test_with_context'
expected_hash = ['f8bcaea049b3', 'db12749b1e80', 'e9f4a0054a06'] expected_hash = ['f8bcaea049b3', 'db12749b1e80', 'e9f4a0054a06']
additional_test_settings = {
def setUp(self): 'COMPRESS_OFFLINE_CONTEXT': [{
self.old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT 'content': 'OK %d!' % i} for i in range(1, 4)]
settings.COMPRESS_OFFLINE_CONTEXT = [{'content': 'OK %d!' % i} for i in range(1, 4)] }
super(OfflineGenerationTestCaseWithContextList, self).setUp()
def tearDown(self):
settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
super(OfflineGenerationTestCaseWithContextList, self).tearDown()
def _prepare_contexts(self, engine): def _prepare_contexts(self, engine):
if engine == 'django': if engine == 'django':
@@ -283,18 +339,14 @@ class OfflineGenerationTestCaseWithContextList(OfflineTestCaseMixin, TestCase):
return None return None
class OfflineGenerationTestCaseWithContextGenerator(OfflineTestCaseMixin, TestCase): class OfflineCompressTestCaseWithContextGenerator(
OfflineTestCaseMixin, TestCase):
templates_dir = 'test_with_context' templates_dir = 'test_with_context'
expected_hash = ['f8bcaea049b3', 'db12749b1e80', 'e9f4a0054a06'] expected_hash = ['f8bcaea049b3', 'db12749b1e80', 'e9f4a0054a06']
additional_test_settings = {
def setUp(self): 'COMPRESS_OFFLINE_CONTEXT': 'compressor.tests.test_offline.'
self.old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT 'offline_context_generator'
settings.COMPRESS_OFFLINE_CONTEXT = 'compressor.tests.test_offline.offline_context_generator' }
super(OfflineGenerationTestCaseWithContextGenerator, self).setUp()
def tearDown(self):
settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
super(OfflineGenerationTestCaseWithContextGenerator, self).tearDown()
def _prepare_contexts(self, engine): def _prepare_contexts(self, engine):
module, function = get_mod_func(settings.COMPRESS_OFFLINE_CONTEXT) module, function = get_mod_func(settings.COMPRESS_OFFLINE_CONTEXT)
@@ -306,69 +358,85 @@ class OfflineGenerationTestCaseWithContextGenerator(OfflineTestCaseMixin, TestCa
return None return None
class OfflineGenerationTestCaseWithContextGeneratorImportError(OfflineTestCaseMixin, TestCase): class OfflineCompressTestCaseWithContextGeneratorImportError(
OfflineTestCaseMixin, TestCase):
templates_dir = 'test_with_context' templates_dir = 'test_with_context'
def _test_offline(self, engine): def _test_offline(self, engine):
old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT # Test that we are properly generating ImportError when
# COMPRESS_OFFLINE_CONTEXT looks like a function but can't be imported
# for whatever reason.
try: with self.settings(
COMPRESS_OFFLINE_CONTEXT='invalid_mod.invalid_func'):
# Path with invalid module name -- ImportError: # Path with invalid module name -- ImportError:
settings.COMPRESS_OFFLINE_CONTEXT = 'invalid_module.invalid_function' self.assertRaises(
self.assertRaises(ImportError, CompressCommand().compress, engine=engine) ImportError, CompressCommand().compress, engine=engine)
# Module name only without function -- AttributeError: with self.settings(COMPRESS_OFFLINE_CONTEXT='compressor'):
settings.COMPRESS_OFFLINE_CONTEXT = 'compressor' # Valid module name only without function -- AttributeError:
self.assertRaises(ImportError, CompressCommand().compress, engine=engine) self.assertRaises(
ImportError, CompressCommand().compress, engine=engine)
with self.settings(
COMPRESS_OFFLINE_CONTEXT='compressor.tests.invalid_function'):
# Path with invalid function name -- AttributeError: # Path with invalid function name -- AttributeError:
settings.COMPRESS_OFFLINE_CONTEXT = 'compressor.tests.invalid_function' self.assertRaises(
self.assertRaises(ImportError, CompressCommand().compress, engine=engine) ImportError, CompressCommand().compress, engine=engine)
with self.settings(
COMPRESS_OFFLINE_CONTEXT='compressor.tests.test_offline'):
# Path without function attempts call on module -- TypeError: # Path without function attempts call on module -- TypeError:
settings.COMPRESS_OFFLINE_CONTEXT = 'compressor.tests.test_offline' self.assertRaises(
self.assertRaises(ImportError, CompressCommand().compress, engine=engine) ImportError, CompressCommand().compress, engine=engine)
valid_path = 'compressor.tests.test_offline.offline_context_generator'
with self.settings(COMPRESS_OFFLINE_CONTEXT=valid_path):
# Valid path to generator function -- no ImportError: # Valid path to generator function -- no ImportError:
settings.COMPRESS_OFFLINE_CONTEXT = 'compressor.tests.test_offline.offline_context_generator'
try: try:
CompressCommand().compress(engine=engine) CompressCommand().compress(engine=engine)
except ImportError: except ImportError:
self.fail("Valid path to offline context generator mustn't raise ImportError.") self.fail('Valid path to offline context generator must'
' not raise ImportError.')
finally:
settings.COMPRESS_OFFLINE_CONTEXT = old_offline_context
class OfflineGenerationTestCaseErrors(OfflineTestCaseMixin, TestCase): class OfflineCompressTestCaseErrors(OfflineTestCaseMixin, TestCase):
templates_dir = "test_error_handling" templates_dir = 'test_error_handling'
def _test_offline(self, engine): def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
if engine == "django": if engine == 'django':
self.assertEqual(2, count) self.assertEqual(2, count)
else: else:
# Because we use env.parse in Jinja2Parser, the engine does not # Because we use env.parse in Jinja2Parser, the engine does not
# actually load the "extends" and "includes" templates, and so # actually load the 'extends' and 'includes' templates, and so
# it is unable to detect that they are missing. So all the "compress" # it is unable to detect that they are missing. So all the
# nodes are processed correctly. # 'compress' nodes are processed correctly.
self.assertEqual(4, count) self.assertEqual(4, count)
self.assertEqual(engine, "jinja2") self.assertEqual(engine, 'jinja2')
self.assertIn('<link rel="stylesheet" href="/static/CACHE/css/78bd7a762e2d.css" type="text/css" />', result) self.assertIn(
self.assertIn('<link rel="stylesheet" href="/static/CACHE/css/e31030430724.css" type="text/css" />', result) '<link rel="stylesheet" href="/static/CACHE/css/'
'78bd7a762e2d.css" type="text/css" />', result)
self.assertIn(
'<link rel="stylesheet" href="/static/CACHE/css/'
'e31030430724.css" type="text/css" />', result)
self.assertIn('<script type="text/javascript" src="/static/CACHE/js/3872c9ae3f42.js"></script>', result) self.assertIn(
self.assertIn('<script type="text/javascript" src="/static/CACHE/js/cd8870829421.js"></script>', result) '<script type="text/javascript" src="/static/CACHE/js/'
'3872c9ae3f42.js"></script>', result)
self.assertIn(
'<script type="text/javascript" src="/static/CACHE/js/'
'cd8870829421.js"></script>', result)
class OfflineGenerationTestCaseWithError(OfflineTestCaseMixin, TestCase): class OfflineCompressTestCaseWithError(OfflineTestCaseMixin, TestCase):
templates_dir = 'test_error_handling' templates_dir = 'test_error_handling'
additional_test_settings = {
def setUp(self): 'COMPRESS_PRECOMPILERS': (('text/coffeescript', 'nonexisting-binary'),)
self._old_compress_precompilers = settings.COMPRESS_PRECOMPILERS }
settings.COMPRESS_PRECOMPILERS = (('text/coffeescript', 'non-existing-binary'),)
super(OfflineGenerationTestCaseWithError, self).setUp()
def _test_offline(self, engine): def _test_offline(self, engine):
""" """
@@ -376,184 +444,118 @@ class OfflineGenerationTestCaseWithError(OfflineTestCaseMixin, TestCase):
True, as otherwise errors in configuration will never show in True, as otherwise errors in configuration will never show in
production. production.
""" """
self._old_debug = settings.DEBUG with self.settings(DEBUG=True):
self.assertRaises(
CommandError, CompressCommand().compress, engine=engine)
try: with self.settings(DEBUG=False):
settings.DEBUG = True self.assertRaises(
self.assertRaises(CommandError, CompressCommand().compress, engine=engine) CommandError, CompressCommand().compress, engine=engine)
settings.DEBUG = False
self.assertRaises(CommandError, CompressCommand().compress, engine=engine)
finally:
settings.DEBUG = self._old_debug
def tearDown(self):
settings.COMPRESS_PRECOMPILERS = self._old_compress_precompilers
super(OfflineGenerationTestCaseWithError, self).tearDown()
class OfflineGenerationTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressEmptyTag(OfflineTestCaseMixin, TestCase):
templates_dir = "basic"
expected_hash = "f5e179b8eca4"
def test_rendering_without_manifest_raises_exception(self):
# flush cached manifest
flush_offline_manifest()
self.assertRaises(OfflineGenerationError,
self.template.render, Context({}))
@unittest.skipIf(not _TEST_JINJA2, "No Jinja2 testing")
def test_rendering_without_manifest_raises_exception_jinja2(self):
# flush cached manifest
flush_offline_manifest()
self.assertRaises(OfflineGenerationError,
self.template_jinja2.render, {})
def _test_deleting_manifest_does_not_affect_rendering(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine)
get_offline_manifest()
manifest_path = os.path.join('CACHE', 'manifest.json')
if default_storage.exists(manifest_path):
default_storage.delete(manifest_path)
self.assertEqual(1, count)
self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/%s.js"></script>' % (self.expected_hash, ),
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, "".join(result) + "\n")
def test_deleting_manifest_does_not_affect_rendering(self):
for engine in self.engines:
self._test_deleting_manifest_does_not_affect_rendering(engine)
def test_requires_model_validation(self):
self.assertFalse(CompressCommand.requires_model_validation)
def test_get_loaders(self):
old_loaders = settings.TEMPLATE_LOADERS
settings.TEMPLATE_LOADERS = (
('django.template.loaders.cached.Loader', (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)),
)
try:
from django.template.loaders.filesystem import Loader as FileSystemLoader
from django.template.loaders.app_directories import Loader as AppDirectoriesLoader
except ImportError:
pass
else:
loaders = CompressCommand().get_loaders()
self.assertTrue(isinstance(loaders[0], FileSystemLoader))
self.assertTrue(isinstance(loaders[1], AppDirectoriesLoader))
finally:
settings.TEMPLATE_LOADERS = old_loaders
class OfflineGenerationEmptyTag(OfflineTestCaseMixin, TestCase):
""" """
In case of a compress template tag with no content, an entry In case of a compress template tag with no content, an entry
will be added to the manifest with an empty string as value. will be added to the manifest with an empty string as value.
This test makes sure there is no recompression happening when This test makes sure there is no recompression happening when
compressor encounters such an emptystring in the manifest. compressor encounters such an emptystring in the manifest.
""" """
templates_dir = "basic" templates_dir = 'basic'
expected_hash = "f5e179b8eca4" expected_hash = 'f5e179b8eca4'
engines = ("django",) engines = ('django',)
def _test_offline(self, engine): def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
manifest = get_offline_manifest() manifest = get_offline_manifest()
manifest[list(manifest)[0]] = "" manifest[list(manifest)[0]] = ''
self.assertEqual(self._render_template(engine), "\n") self.assertEqual(self._render_template(engine), '\n')
class OfflineGenerationBlockSuperBaseCompressed(OfflineTestCaseMixin, TestCase): class OfflineCompressBlockSuperBaseCompressed(OfflineTestCaseMixin, TestCase):
template_names = ["base.html", "base2.html", "test_compressor_offline.html"] template_names = ['base.html', 'base2.html',
'test_compressor_offline.html']
templates_dir = 'test_block_super_base_compressed' templates_dir = 'test_block_super_base_compressed'
expected_hash = ['028c3fc42232', '2e9d3f5545a6', 'f8891c416981'] expected_hash = ['028c3fc42232', '2e9d3f5545a6', 'f8891c416981']
# Block.super not supported for Jinja2 yet. # Block.super not supported for Jinja2 yet.
engines = ("django",) engines = ('django',)
def setUp(self): def setUp(self):
super(OfflineGenerationBlockSuperBaseCompressed, self).setUp() super(OfflineCompressBlockSuperBaseCompressed, self).setUp()
self.template_paths = [] self.template_paths = []
self.templates = [] self.templates = []
for template_name in self.template_names: for template_name in self.template_names:
template_path = os.path.join(settings.TEMPLATE_DIRS[0], template_name) template_path = os.path.join(
settings.TEMPLATE_DIRS[0], template_name)
self.template_paths.append(template_path) self.template_paths.append(template_path)
with io.open(template_path, encoding=settings.FILE_CHARSET) as file: with io.open(template_path,
template = Template(file.read()) encoding=settings.FILE_CHARSET) as file_:
template = Template(file_.read())
self.templates.append(template) self.templates.append(template)
def _render_template(self, template, engine): def _render_template(self, template, engine):
if engine == "django": if engine == 'django':
return template.render(Context(settings.COMPRESS_OFFLINE_CONTEXT)) return template.render(Context(settings.COMPRESS_OFFLINE_CONTEXT))
elif engine == "jinja2": elif engine == 'jinja2':
return template.render(settings.COMPRESS_OFFLINE_CONTEXT) + "\n" return template.render(settings.COMPRESS_OFFLINE_CONTEXT) + '\n'
else: else:
return None return None
def _test_offline(self, engine): def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
self.assertEqual(len(self.expected_hash), count) self.assertEqual(len(self.expected_hash), count)
for expected_hash, template in zip(self.expected_hash, self.templates): for expected_hash, template in zip(self.expected_hash, self.templates):
expected_output = '<script type="text/javascript" src="/static/CACHE/js/%s.js"></script>' % (expected_hash, ) expected = ('<script type="text/javascript" src="/static/CACHE/js/'
self.assertIn(expected_output, result) '%s.js"></script>' % (expected_hash, ))
self.assertIn(expected, result)
rendered_template = self._render_template(template, engine) rendered_template = self._render_template(template, engine)
self.assertEqual(rendered_template, expected_output + '\n') self.assertEqual(rendered_template, expected + '\n')
class OfflineGenerationInlineNonAsciiTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressInlineNonAsciiTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_inline_non_ascii" templates_dir = 'test_inline_non_ascii'
additional_test_settings = {
def setUp(self): 'COMPRESS_OFFLINE_CONTEXT': {
self.old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT
settings.COMPRESS_OFFLINE_CONTEXT = {
'test_non_ascii_value': '\u2014', 'test_non_ascii_value': '\u2014',
} }
super(OfflineGenerationInlineNonAsciiTestCase, self).setUp() }
def tearDown(self):
settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
super(OfflineGenerationInlineNonAsciiTestCase, self).tearDown()
def _test_offline(self, engine): def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
rendered_template = self._render_template(engine) rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, "".join(result) + "\n") self.assertEqual(rendered_template, ''.join(result) + '\n')
class OfflineGenerationComplexTestCase(OfflineTestCaseMixin, TestCase): class OfflineCompressComplexTestCase(OfflineTestCaseMixin, TestCase):
templates_dir = "test_complex" templates_dir = 'test_complex'
additional_test_settings = {
def setUp(self): 'COMPRESS_OFFLINE_CONTEXT': {
self.old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT
settings.COMPRESS_OFFLINE_CONTEXT = {
'condition': 'OK!', 'condition': 'OK!',
# Django templating does not allow definition of tuples in the # Django templating does not allow definition of tuples in the
# templates. Make sure this is same as test_templates_jinja2/test_complex. # templates.
'my_names': ("js/one.js", "js/nonasc.js"), # Make sure this is same as test_templates_jinja2/test_complex.
'my_names': ('js/one.js', 'js/nonasc.js'),
} }
super(OfflineGenerationComplexTestCase, self).setUp() }
def tearDown(self):
settings.COMPRESS_OFFLINE_CONTEXT = self.old_offline_context
super(OfflineGenerationComplexTestCase, self).tearDown()
def _test_offline(self, engine): def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity, engine=engine) count, result = CompressCommand().compress(
log=self.log, verbosity=self.verbosity, engine=engine)
self.assertEqual(3, count) self.assertEqual(3, count)
self.assertEqual([ self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/0e8807bebcee.js"></script>', '<script type="text/javascript" src="/static/CACHE/js/'
'<script type="text/javascript" src="/static/CACHE/js/eed1d222933e.js"></script>', '0e8807bebcee.js"></script>',
'<script type="text/javascript" src="/static/CACHE/js/00b4baffe335.js"></script>', '<script type="text/javascript" src="/static/CACHE/js/'
'eed1d222933e.js"></script>',
'<script type="text/javascript" src="/static/CACHE/js/'
'00b4baffe335.js"></script>',
], result) ], result)
rendered_template = self._render_template(engine) rendered_template = self._render_template(engine)
result = (result[0], result[2]) result = (result[0], result[2])
self.assertEqual(rendered_template, "".join(result) + "\n") self.assertEqual(rendered_template, ''.join(result) + '\n')
# Coffin does not work on Python 3.2+ due to: # Coffin does not work on Python 3.2+ due to:
@@ -561,14 +563,12 @@ class OfflineGenerationComplexTestCase(OfflineTestCaseMixin, TestCase):
# from library import * # from library import *
# causing 'ImportError: No module named library'. # causing 'ImportError: No module named library'.
# It seems there is no evidence nor indicated support for Python 3+. # It seems there is no evidence nor indicated support for Python 3+.
@unittest.skipIf(sys.version_info >= (3, 2), @unittest.skipIf(sys.version_info >= (3, 2), 'Coffin does not support 3.2+')
"Coffin does not support 3.2+") @unittest.skipIf(django.VERSION >= (1, 8), 'Import error on 1.8')
@unittest.skipIf(django.VERSION >= (1, 8), class OfflineCompressCoffinTestCase(OfflineTestCaseMixin, TestCase):
"Import error on 1.8") templates_dir = 'test_coffin'
class OfflineGenerationCoffinTestCase(OfflineTestCaseMixin, TestCase): expected_hash = '32c8281e3346'
templates_dir = "test_coffin" engines = ('jinja2',)
expected_hash = "32c8281e3346"
engines = ("jinja2",)
def _get_jinja2_env(self): def _get_jinja2_env(self):
import jinja2 import jinja2
@@ -584,17 +584,16 @@ class OfflineGenerationCoffinTestCase(OfflineTestCaseMixin, TestCase):
# Jingo does not work when using Python 3.2 due to the use of Unicode string # Jingo does not work when using Python 3.2 due to the use of Unicode string
# prefix (and possibly other stuff), but it actually works when using Python 3.3 # prefix (and possibly other stuff), but it actually works when using Python
# since it tolerates the use of the Unicode string prefix. Python 3.3 support # 3.3 since it tolerates the use of the Unicode string prefix. Python 3.3
# is also evident in its tox.ini file. # support is also evident in its tox.ini file.
@unittest.skipIf(sys.version_info >= (3, 2) and sys.version_info < (3, 3), @unittest.skipIf(sys.version_info >= (3, 2) and sys.version_info < (3, 3),
"Jingo does not support 3.2") 'Jingo does not support 3.2')
@unittest.skipIf(django.VERSION >= (1, 8), @unittest.skipIf(django.VERSION >= (1, 8), 'Import error on 1.8')
"Import error on 1.8") class OfflineCompressJingoTestCase(OfflineTestCaseMixin, TestCase):
class OfflineGenerationJingoTestCase(OfflineTestCaseMixin, TestCase): templates_dir = 'test_jingo'
templates_dir = "test_jingo" expected_hash = '61ec584468eb'
expected_hash = "61ec584468eb" engines = ('jinja2',)
engines = ("jinja2",)
def _get_jinja2_env(self): def _get_jinja2_env(self):
import jinja2 import jinja2
@@ -605,7 +604,8 @@ class OfflineGenerationJingoTestCase(OfflineTestCaseMixin, TestCase):
# Could have used the env.add_extension method, but it's only available # Could have used the env.add_extension method, but it's only available
# in Jinja2 v2.5 # in Jinja2 v2.5
new_env = jinja2.Environment(extensions=[CompressorExtension, SpacelessExtension, jinja2.ext.with_]) new_env = jinja2.Environment(extensions=[
CompressorExtension, SpacelessExtension, jinja2.ext.with_])
env.extensions.update(new_env.extensions) env.extensions.update(new_env.extensions)
env.globals['url_for'] = url_for env.globals['url_for'] = url_for