django/tests/template_tests/test_loaders.py

"""
Test cases for the template loaders

Note: This test requires setuptools!
"""

import os.path
import sys
import types
import unittest

from django.template import Context, TemplateDoesNotExist, loader
from django.template.engine import Engine
from django.template.loaders import cached, eggs
from django.test import SimpleTestCase, ignore_warnings, override_settings
from django.utils import six
from django.utils._os import upath
from django.utils.deprecation import RemovedInDjango20Warning
from django.utils.six import StringIO

try:
    import pkg_resources
except ImportError:
    pkg_resources = None

TEMPLATES_DIR = os.path.join(os.path.dirname(upath(__file__)), 'templates')

GLOBAL_TEMPLATES_DIR = os.path.join(os.path.dirname(os.path.dirname(upath(__file__))), 'templates')


# Mock classes and objects for pkg_resources functions.
class MockLoader(object):
    pass


def create_egg(name, resources):
    """
    Creates a mock egg with a list of resources.

    name: The name of the module.
    resources: A dictionary of resources. Keys are the names and values the data.
    """
    egg = types.ModuleType(name)
    egg.__loader__ = MockLoader()
    egg.__path__ = ['/some/bogus/path/']
    egg.__file__ = '/some/bogus/path/__init__.pyc'
    egg._resources = resources
    sys.modules[name] = egg


@unittest.skipUnless(pkg_resources, 'setuptools is not installed')
class EggLoaderTest(SimpleTestCase):

    def setUp(self):
        self.loader = eggs.Loader(Engine.get_default())

        # Defined here b/c at module scope we may not have pkg_resources
        class MockProvider(pkg_resources.NullProvider):
            def __init__(self, module):
                pkg_resources.NullProvider.__init__(self, module)
                self.module = module

            def _has(self, path):
                return path in self.module._resources

            def _isdir(self, path):
                return False

            def get_resource_stream(self, manager, resource_name):
                return self.module._resources[resource_name]

            def _get(self, path):
                return self.module._resources[path].read()

            def _fn(self, base, resource_name):
                return os.path.normcase(resource_name)

        pkg_resources._provider_factories[MockLoader] = MockProvider

        self.empty_egg = create_egg("egg_empty", {})
        self.egg_1 = create_egg("egg_1", {
            os.path.normcase('templates/y.html'): StringIO("y"),
            os.path.normcase('templates/x.txt'): StringIO("x"),
        })

    @override_settings(INSTALLED_APPS=['egg_empty'])
    def test_empty(self):
        "Loading any template on an empty egg should fail"
        with self.assertRaises(TemplateDoesNotExist):
            self.loader.load_template_source("not-existing.html")

    @override_settings(INSTALLED_APPS=['egg_1'])
    def test_non_existing(self):
        "Template loading fails if the template is not in the egg"
        with self.assertRaises(TemplateDoesNotExist):
            self.loader.load_template_source("not-existing.html")

    @override_settings(INSTALLED_APPS=['egg_1'])
    def test_existing(self):
        "A template can be loaded from an egg"
        contents, template_name = self.loader.load_template_source("y.html")
        self.assertEqual(contents, "y")
        self.assertEqual(template_name, "egg:egg_1:templates/y.html")

    def test_not_installed(self):
        "Loading an existent template from an egg not included in any app should fail"
        with self.assertRaises(TemplateDoesNotExist):
            self.loader.load_template_source("y.html")


class CachedLoader(SimpleTestCase):

    def setUp(self):
        self.loader = cached.Loader(Engine.get_default(), [
            'django.template.loaders.filesystem.Loader',
        ])

    def test_templatedir_caching(self):
        "Check that the template directories form part of the template cache key. Refs #13573"
        # Retrieve a template specifying a template directory to check
        t1, name = self.loader.find_template('test.html', (os.path.join(TEMPLATES_DIR, 'first'),))
        # Now retrieve the same template name, but from a different directory
        t2, name = self.loader.find_template('test.html', (os.path.join(TEMPLATES_DIR, 'second'),))

        # The two templates should not have the same content
        self.assertNotEqual(t1.render(Context({})), t2.render(Context({})))

    def test_missing_template_is_cached(self):
        "#19949 -- Check that the missing template is cached."
        # Check that 'missing.html' isn't already in cache before 'missing.html' is loaded
        with self.assertRaises(KeyError):
            self.loader.template_cache["missing.html"]
        # Try to load it, it should fail
        with self.assertRaises(TemplateDoesNotExist):
            self.loader.load_template("missing.html")
        # Verify that the fact that the missing template, which hasn't been found, has actually
        # been cached:
        cached_miss = self.loader.template_cache["missing.html"]
        self.assertEqual(cached_miss, TemplateDoesNotExist,
                         "Cached template loader doesn't cache file lookup misses. It should.")


@override_settings(TEMPLATES=[{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [TEMPLATES_DIR],
}])
class RenderToStringTest(SimpleTestCase):
    def test_basic(self):
        self.assertEqual(loader.render_to_string('test_context.html'), 'obj:\n')

    def test_basic_context(self):
        self.assertEqual(loader.render_to_string('test_context.html',
                                                 {'obj': 'test'}), 'obj:test\n')

    def test_empty_list(self):
        six.assertRaisesRegex(self, TemplateDoesNotExist,
            'No template names provided$',
            loader.render_to_string, [])

    def test_select_templates_from_empty_list(self):
        six.assertRaisesRegex(self, TemplateDoesNotExist,
            'No template names provided$',
            loader.select_template, [])


@ignore_warnings(category=RemovedInDjango20Warning)
@override_settings(TEMPLATES=[{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [TEMPLATES_DIR],
}])
class DeprecatedRenderToStringTest(SimpleTestCase):

    def test_existing_context_kept_clean(self):
        context = Context({'obj': 'before'})
        output = loader.render_to_string('test_context.html', {'obj': 'after'},
                                         context_instance=context)
        self.assertEqual(output, 'obj:after\n')
        self.assertEqual(context['obj'], 'before')

    def test_no_empty_dict_pushed_to_stack(self):
        """
        No empty dict should be pushed to the context stack when render_to_string
        is called without any argument (#21741).
        """

        # The stack should have a length of 1, corresponding to the builtins
        self.assertEqual('1',
            loader.render_to_string('test_context_stack.html').strip())
        self.assertEqual('1',
            loader.render_to_string('test_context_stack.html', context_instance=Context()).strip())


@ignore_warnings(category=RemovedInDjango20Warning)
@override_settings(TEMPLATES=[{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
}])
class TemplateDirsOverrideTest(SimpleTestCase):

    dirs_tuple = (os.path.join(os.path.dirname(upath(__file__)), 'other_templates'),)
    dirs_list = list(dirs_tuple)
    dirs_iter = (dirs_tuple, dirs_list)

    def test_render_to_string(self):
        for dirs in self.dirs_iter:
            self.assertEqual(loader.render_to_string('test_dirs.html', dirs=dirs), 'spam eggs\n')

    def test_get_template(self):
        for dirs in self.dirs_iter:
            template = loader.get_template('test_dirs.html', dirs=dirs)
            self.assertEqual(template.render(), 'spam eggs\n')

    def test_select_template(self):
        for dirs in self.dirs_iter:
            template = loader.select_template(['test_dirs.html'], dirs=dirs)
            self.assertEqual(template.render(), 'spam eggs\n')


@override_settings(TEMPLATES=[{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [GLOBAL_TEMPLATES_DIR],
    'OPTIONS': {
        'loaders': [
            ('django.template.loaders.cached.Loader', [
                'django.template.loaders.filesystem.Loader',
                'django.template.loaders.app_directories.Loader',
            ]),
        ],
    },
}])
class PriorityCacheLoader(SimpleTestCase):
    def test_basic(self):
        """
        Check that the order of template loader works. Refs #21460.
        """
        t1 = loader.get_template('priority/foo.html')
        self.assertEqual(t1.render(), 'priority\n')


@override_settings(TEMPLATES=[{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [GLOBAL_TEMPLATES_DIR],
    'OPTIONS': {
        'loaders': [
            'django.template.loaders.filesystem.Loader',
            'django.template.loaders.app_directories.Loader',
        ],
    },
}])
class PriorityLoader(SimpleTestCase):
    def test_basic(self):
        """
        Check that the order of template loader works. Refs #21460.
        """
        t1 = loader.get_template('priority/foo.html')
        self.assertEqual(t1.render(), 'priority\n')