def _test_offline(self, engine):
"""
Test that a CommandError is raised with DEBUG being False as well as
True, as otherwise errors in configuration will never show in
production.
"""
with self.settings(DEBUG=True):
self.assertRaises(CommandError,
CompressCommand().compress,
engine=engine)
with self.settings(DEBUG=False):
self.assertRaises(CommandError,
CompressCommand().compress,
engine=engine)
def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity,
engine=engine)
manifest = get_offline_manifest()
manifest[list(manifest)[0]] = ""
self.assertEqual(self._render_template(engine), "\n")
def test_offline(self):
count, result = CompressCommand().compress()
self.assertEqual(2, count)
self.assertEqual(result, [
u'<link rel="stylesheet" href="/media/CACHE/css/a55e1cf95000.css" type="text/css">\n',
u'<script type="text/javascript" src="/media/CACHE/js/bf53fa5b13e2.js" charset="utf-8"></script>',
])
def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity,
engine=engine)
if engine == "django":
self.assertEqual(2, count)
else:
# Because we use env.parse in Jinja2Parser, the engine does not
# actually load the "extends" and "includes" templates, and so
# it is unable to detect that they are missing. So all the "compress"
# nodes are processed correctly.
self.assertEqual(4, count)
self.assertEqual(engine, "jinja2")
self.assertIn(
'<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(
'<script type="text/javascript" src="/static/CACHE/js/cd8870829421.js"></script>',
result)
def test_offline(self):
count, result = CompressCommand().compress()
self.assertEqual(2, count)
self.assertEqual([
u'<link rel="stylesheet" href="/media/CACHE/css/cd579b7deb7d.css" type="text/css">\n',
u'<script type="text/javascript" src="/media/CACHE/js/0a2bb9a287c0.js" charset="utf-8"></script>',
], result)
def test_offline(self):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity)
self.assertEqual(1, count)
self.assertEqual([
u'<script type="text/javascript" src="/media/CACHE/js/%s.js"></script>' % (self.expected_hash, ),
], result)
rendered_template = self.template.render(Context(settings.COMPRESS_OFFLINE_CONTEXT))
self.assertEqual(rendered_template, "".join(result) + "\n")
def test_offline(self):
"""
Test that a CommandError is raised with DEBUG being False as well as
True, as otherwise errors in configuration will never show in
production.
"""
self._old_debug = settings.DEBUG
try:
settings.DEBUG = True
self.assertRaises(CommandError, CompressCommand().compress)
settings.DEBUG = False
self.assertRaises(CommandError, CompressCommand().compress)
finally:
settings.DEBUG = self._old_debug
def test_offline(self):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity)
self.assertEqual(2, count)
self.assertEqual([
u'<script type="text/javascript" src="/media/CACHE/js/ced14aec5856.js"></script>',
u'<script type="text/javascript" src="/media/CACHE/js/7c02d201f69d.js"></script>'
], result)
rendered_template = self.template.render(Context(settings.COMPRESS_OFFLINE_CONTEXT))
self.assertEqual(rendered_template, "".join(result) + "\n")
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(2, count)
self.assertEqual([
self._render_script('9717f9c7e9ff'),
self._render_script('68c645740177')
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, self._render_result(result, ''))
def _test_offline(self, engine):
hashes = self.expected_hash
if not isinstance(hashes, (list, tuple)):
hashes = [hashes]
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(len(hashes), count)
self.assertEqual([self._render_script(h) for h in hashes], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, self._render_result(result))
def test_offline(self):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity)
self.assertEqual(2, count)
self.assertIn(
u'<script type="text/javascript" src="/static/CACHE/js/3872c9ae3f42.js"></script>',
result)
self.assertIn(
u'<script type="text/javascript" src="/static/CACHE/js/cd8870829421.js"></script>',
result)
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(2, count)
self.assertEqual([
self._render_script('bfcec76e0f28'),
self._render_script('817b5defb197')
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, self._render_result(result, ''))
def _test_offline(self, engine, verbosity=0):
# Test that we are properly generating ImportError when
# COMPRESS_OFFLINE_CONTEXT looks like a function but can't be imported
# for whatever reason.
with self.settings(
COMPRESS_OFFLINE_CONTEXT='invalid_mod.invalid_func'):
# Path with invalid module name -- ImportError:
self.assertRaises(ImportError,
CompressCommand().handle_inner,
engines=[engine])
with self.settings(COMPRESS_OFFLINE_CONTEXT='compressor'):
# Valid module name only without function -- AttributeError:
self.assertRaises(ImportError,
CompressCommand().handle_inner,
engines=[engine])
with self.settings(
COMPRESS_OFFLINE_CONTEXT='compressor.tests.invalid_function'):
# Path with invalid function name -- AttributeError:
self.assertRaises(ImportError,
CompressCommand().handle_inner,
engines=[engine])
with self.settings(
COMPRESS_OFFLINE_CONTEXT='compressor.tests.test_offline'):
# Path without function attempts call on module -- TypeError:
self.assertRaises(ImportError,
CompressCommand().handle_inner,
engines=[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:
try:
CompressCommand().handle_inner(engines=[engine],
verbosity=verbosity)
except ImportError:
self.fail('Valid path to offline context generator must'
' not raise ImportError.')
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(len(self.expected_hash), count)
for expected_hash, template in zip(self.expected_hash_offline,
self.templates):
expected = self._render_script(expected_hash)
self.assertIn(expected, result)
rendered_template = self._render_template(template, engine)
self.assertEqual(rendered_template,
self._render_result([expected]))
def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity,
engine=engine)
self.assertEqual(2, count)
self.assertEqual([
self._render_script('9717f9c7e9ff'),
self._render_script('68c645740177')
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, self._render_result(result, ''))
def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity,
engine=engine)
self.assertEqual(1, count)
self.assertEqual([
'<script type="text/javascript" src="/static/CACHE/js/'
'ea3267f3e9dd.js"></script>'
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, '\n' + result[0] + '\n')
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
# 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._render_script('822ac7501287')], result)
rendered_template = self._render_template(engine)
# But rendering the template returns both (identical) scripts.
self.assertEqual(rendered_template,
self._render_result(result * 2, ''))
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")
def _test_deleting_manifest_does_not_affect_rendering(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
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([self._render_script(self.expected_hash)], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, self._render_result(result))
def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity,
engine=engine)
self.assertEqual(len(self.expected_hash), count)
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, )
self.assertIn(expected_output, result)
rendered_template = self._render_template(template, engine)
self.assertEqual(rendered_template, expected_output + '\n')
def _test_offline(self, engine):
count, result = CompressCommand().compress(log=self.log,
verbosity=self.verbosity,
engine=engine)
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_offline(self, engine):
# Test that we are properly generating ImportError when
# COMPRESS_OFFLINE_CONTEXT looks like a function but can't be imported
# for whatever reason.
with self.settings(
COMPRESS_OFFLINE_CONTEXT="invalid_mod.invalid_func"):
# Path with invalid module name -- ImportError:
self.assertRaises(ImportError,
CompressCommand().compress,
engine=engine)
with self.settings(COMPRESS_OFFLINE_CONTEXT="compressor"):
# Valid module name only without function -- AttributeError:
self.assertRaises(ImportError,
CompressCommand().compress,
engine=engine)
with self.settings(
COMPRESS_OFFLINE_CONTEXT="compressor.tests.invalid_function"):
# Path with invalid function name -- AttributeError:
self.assertRaises(ImportError,
CompressCommand().compress,
engine=engine)
with self.settings(
COMPRESS_OFFLINE_CONTEXT="compressor.tests.test_offline"):
# Path without function attempts call on module -- TypeError:
self.assertRaises(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:
try:
CompressCommand().compress(engine=engine)
except ImportError:
self.fail("Valid path to offline context generator must"
" not raise ImportError.")
def test_offline_with_context(self):
self._old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT
settings.COMPRESS_OFFLINE_CONTEXT = {
'color': 'blue',
}
count, result = CompressCommand().compress()
self.assertEqual(2, count)
self.assertEqual(result, [
u'<link rel="stylesheet" href="/media/CACHE/css/8a2405e029de.css" type="text/css">\n',
u'<script type="text/javascript" src="/media/CACHE/js/bf53fa5b13e2.js" charset="utf-8"></script>',
])
settings.COMPRESS_OFFLINE_CONTEXT = self._old_offline_context
def test_offline_with_context(self):
self._old_offline_context = settings.COMPRESS_OFFLINE_CONTEXT
settings.COMPRESS_OFFLINE_CONTEXT = {
'color': 'blue',
}
count, result = CompressCommand().compress()
self.assertEqual(2, count)
self.assertEqual([
u'<link rel="stylesheet" href="/media/CACHE/css/ee62fbfd116a.css" type="text/css">\n',
u'<script type="text/javascript" src="/media/CACHE/js/0a2bb9a287c0.js" charset="utf-8"></script>',
], result)
settings.COMPRESS_OFFLINE_CONTEXT = self._old_offline_context
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(3, count)
self.assertEqual([
self._render_script('2c1f0f85a90d'),
self._render_script('8b594c4f7264'),
self._render_script('e0e424964c8c')
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template,
self._render_result([result[0], result[2]], ''))
def test_deleting_manifest_does_not_affect_rendering(self):
count, result = CompressCommand().compress(log=self.log, verbosity=self.verbosity)
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([
u'<script type="text/javascript" src="/media/CACHE/js/%s.js"></script>' % (self.expected_hash, ),
], result)
rendered_template = self.template.render(Context(settings.COMPRESS_OFFLINE_CONTEXT))
self.assertEqual(rendered_template, "".join(result) + "\n")
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([self._render_script(self.expected_hash)], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template, self._render_result(result))
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(3, count)
self.assertEqual([
self._render_script('76a82cfab9ab'),
self._render_script('7219642b8ab4'),
self._render_script('567bb77b13db')
], result)
rendered_template = self._render_template(engine)
self.assertEqual(rendered_template,
self._render_result([result[0], result[2]], ''))
def _test_offline(self, engine):
count, result = CompressCommand().compress(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._render_script("a432b6ddb2c4")], result)
rendered_template = self._render_template(engine)
# But rendering the template returns both (identical) scripts.
self.assertEqual(rendered_template,
self._render_result(result * 2, ""))
def _test_offline(self, engine):
count, result = CompressCommand().handle_inner(engines=[engine],
verbosity=0)
self.assertEqual(1, count)
self.assertEqual([self._render_script(self.expected_hash)], result)
self.assertEqual(self._render_template(engine),
self._render_result(result))
# Changing STATIC_URL setting doesn't break things despite that
# offline compression was made with different STATIC_URL.
with self.settings(STATIC_URL='/another/static/url/'):
self.assertEqual(self._render_template(engine),
self._render_result(result))
