← Back to branch summary

~brad-marshall/charms/trusty/apache2-wsgi/fix-haproxy-relations

« back to all changes in this revision

Viewing changes to hooks/lib/jinja2/testsuite/loader.py

  • Committer: Robin Winslow
  • Date: 2014-05-27 14:00:44 UTC
  • Revision ID: robin.winslow@canonical.com-20140527140044-8rpmb3wx4djzwa83
Add all files

Show diffs side-by-side

added added

removed removed

Lines of Context:
hooks/lib/jinja2/testsuite/loader.py
 
1
# -*- coding: utf-8 -*-
 
2
"""
 
3
    jinja2.testsuite.loader
 
4
    ~~~~~~~~~~~~~~~~~~~~~~~
 
5
 
 
6
    Test the loaders.
 
7
 
 
8
    :copyright: (c) 2010 by the Jinja Team.
 
9
    :license: BSD, see LICENSE for more details.
 
10
"""
 
11
import os
 
12
import sys
 
13
import tempfile
 
14
import shutil
 
15
import unittest
 
16
 
 
17
from jinja2.testsuite import JinjaTestCase, dict_loader, \
 
18
     package_loader, filesystem_loader, function_loader, \
 
19
     choice_loader, prefix_loader
 
20
 
 
21
from jinja2 import Environment, loaders
 
22
from jinja2._compat import PYPY, PY2
 
23
from jinja2.loaders import split_template_path
 
24
from jinja2.exceptions import TemplateNotFound
 
25
 
 
26
 
 
27
class LoaderTestCase(JinjaTestCase):
 
28
 
 
29
    def test_dict_loader(self):
 
30
        env = Environment(loader=dict_loader)
 
31
        tmpl = env.get_template('justdict.html')
 
32
        assert tmpl.render().strip() == 'FOO'
 
33
        self.assert_raises(TemplateNotFound, env.get_template, 'missing.html')
 
34
 
 
35
    def test_package_loader(self):
 
36
        env = Environment(loader=package_loader)
 
37
        tmpl = env.get_template('test.html')
 
38
        assert tmpl.render().strip() == 'BAR'
 
39
        self.assert_raises(TemplateNotFound, env.get_template, 'missing.html')
 
40
 
 
41
    def test_filesystem_loader(self):
 
42
        env = Environment(loader=filesystem_loader)
 
43
        tmpl = env.get_template('test.html')
 
44
        assert tmpl.render().strip() == 'BAR'
 
45
        tmpl = env.get_template('foo/test.html')
 
46
        assert tmpl.render().strip() == 'FOO'
 
47
        self.assert_raises(TemplateNotFound, env.get_template, 'missing.html')
 
48
 
 
49
    def test_choice_loader(self):
 
50
        env = Environment(loader=choice_loader)
 
51
        tmpl = env.get_template('justdict.html')
 
52
        assert tmpl.render().strip() == 'FOO'
 
53
        tmpl = env.get_template('test.html')
 
54
        assert tmpl.render().strip() == 'BAR'
 
55
        self.assert_raises(TemplateNotFound, env.get_template, 'missing.html')
 
56
 
 
57
    def test_function_loader(self):
 
58
        env = Environment(loader=function_loader)
 
59
        tmpl = env.get_template('justfunction.html')
 
60
        assert tmpl.render().strip() == 'FOO'
 
61
        self.assert_raises(TemplateNotFound, env.get_template, 'missing.html')
 
62
 
 
63
    def test_prefix_loader(self):
 
64
        env = Environment(loader=prefix_loader)
 
65
        tmpl = env.get_template('a/test.html')
 
66
        assert tmpl.render().strip() == 'BAR'
 
67
        tmpl = env.get_template('b/justdict.html')
 
68
        assert tmpl.render().strip() == 'FOO'
 
69
        self.assert_raises(TemplateNotFound, env.get_template, 'missing')
 
70
 
 
71
    def test_caching(self):
 
72
        changed = False
 
73
        class TestLoader(loaders.BaseLoader):
 
74
            def get_source(self, environment, template):
 
75
                return u'foo', None, lambda: not changed
 
76
        env = Environment(loader=TestLoader(), cache_size=-1)
 
77
        tmpl = env.get_template('template')
 
78
        assert tmpl is env.get_template('template')
 
79
        changed = True
 
80
        assert tmpl is not env.get_template('template')
 
81
        changed = False
 
82
 
 
83
        env = Environment(loader=TestLoader(), cache_size=0)
 
84
        assert env.get_template('template') \
 
85
               is not env.get_template('template')
 
86
 
 
87
        env = Environment(loader=TestLoader(), cache_size=2)
 
88
        t1 = env.get_template('one')
 
89
        t2 = env.get_template('two')
 
90
        assert t2 is env.get_template('two')
 
91
        assert t1 is env.get_template('one')
 
92
        t3 = env.get_template('three')
 
93
        assert 'one' in env.cache
 
94
        assert 'two' not in env.cache
 
95
        assert 'three' in env.cache
 
96
 
 
97
    def test_dict_loader_cache_invalidates(self):
 
98
        mapping = {'foo': "one"}
 
99
        env = Environment(loader=loaders.DictLoader(mapping))
 
100
        assert env.get_template('foo').render() == "one"
 
101
        mapping['foo'] = "two"
 
102
        assert env.get_template('foo').render() == "two"
 
103
 
 
104
    def test_split_template_path(self):
 
105
        assert split_template_path('foo/bar') == ['foo', 'bar']
 
106
        assert split_template_path('./foo/bar') == ['foo', 'bar']
 
107
        self.assert_raises(TemplateNotFound, split_template_path, '../foo')
 
108
 
 
109
 
 
110
class ModuleLoaderTestCase(JinjaTestCase):
 
111
    archive = None
 
112
 
 
113
    def compile_down(self, zip='deflated', py_compile=False):
 
114
        super(ModuleLoaderTestCase, self).setup()
 
115
        log = []
 
116
        self.reg_env = Environment(loader=prefix_loader)
 
117
        if zip is not None:
 
118
            self.archive = tempfile.mkstemp(suffix='.zip')[1]
 
119
        else:
 
120
            self.archive = tempfile.mkdtemp()
 
121
        self.reg_env.compile_templates(self.archive, zip=zip,
 
122
                                       log_function=log.append,
 
123
                                       py_compile=py_compile)
 
124
        self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
 
125
        return ''.join(log)
 
126
 
 
127
    def teardown(self):
 
128
        super(ModuleLoaderTestCase, self).teardown()
 
129
        if hasattr(self, 'mod_env'):
 
130
            if os.path.isfile(self.archive):
 
131
                os.remove(self.archive)
 
132
            else:
 
133
                shutil.rmtree(self.archive)
 
134
            self.archive = None
 
135
 
 
136
    def test_log(self):
 
137
        log = self.compile_down()
 
138
        assert 'Compiled "a/foo/test.html" as ' \
 
139
               'tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a' in log
 
140
        assert 'Finished compiling templates' in log
 
141
        assert 'Could not compile "a/syntaxerror.html": ' \
 
142
               'Encountered unknown tag \'endif\'' in log
 
143
 
 
144
    def _test_common(self):
 
145
        tmpl1 = self.reg_env.get_template('a/test.html')
 
146
        tmpl2 = self.mod_env.get_template('a/test.html')
 
147
        assert tmpl1.render() == tmpl2.render()
 
148
 
 
149
        tmpl1 = self.reg_env.get_template('b/justdict.html')
 
150
        tmpl2 = self.mod_env.get_template('b/justdict.html')
 
151
        assert tmpl1.render() == tmpl2.render()
 
152
 
 
153
    def test_deflated_zip_compile(self):
 
154
        self.compile_down(zip='deflated')
 
155
        self._test_common()
 
156
 
 
157
    def test_stored_zip_compile(self):
 
158
        self.compile_down(zip='stored')
 
159
        self._test_common()
 
160
 
 
161
    def test_filesystem_compile(self):
 
162
        self.compile_down(zip=None)
 
163
        self._test_common()
 
164
 
 
165
    def test_weak_references(self):
 
166
        self.compile_down()
 
167
        tmpl = self.mod_env.get_template('a/test.html')
 
168
        key = loaders.ModuleLoader.get_template_key('a/test.html')
 
169
        name = self.mod_env.loader.module.__name__
 
170
 
 
171
        assert hasattr(self.mod_env.loader.module, key)
 
172
        assert name in sys.modules
 
173
 
 
174
        # unset all, ensure the module is gone from sys.modules
 
175
        self.mod_env = tmpl = None
 
176
 
 
177
        try:
 
178
            import gc
 
179
            gc.collect()
 
180
        except:
 
181
            pass
 
182
 
 
183
        assert name not in sys.modules
 
184
 
 
185
    # This test only makes sense on non-pypy python 2
 
186
    if PY2 and not PYPY:
 
187
        def test_byte_compilation(self):
 
188
            log = self.compile_down(py_compile=True)
 
189
            assert 'Byte-compiled "a/test.html"' in log
 
190
            tmpl1 = self.mod_env.get_template('a/test.html')
 
191
            mod = self.mod_env.loader.module. \
 
192
                tmpl_3c4ddf650c1a73df961a6d3d2ce2752f1b8fd490
 
193
            assert mod.__file__.endswith('.pyc')
 
194
 
 
195
    def test_choice_loader(self):
 
196
        log = self.compile_down()
 
197
 
 
198
        self.mod_env.loader = loaders.ChoiceLoader([
 
199
            self.mod_env.loader,
 
200
            loaders.DictLoader({'DICT_SOURCE': 'DICT_TEMPLATE'})
 
201
        ])
 
202
 
 
203
        tmpl1 = self.mod_env.get_template('a/test.html')
 
204
        self.assert_equal(tmpl1.render(), 'BAR')
 
205
        tmpl2 = self.mod_env.get_template('DICT_SOURCE')
 
206
        self.assert_equal(tmpl2.render(), 'DICT_TEMPLATE')
 
207
 
 
208
    def test_prefix_loader(self):
 
209
        log = self.compile_down()
 
210
 
 
211
        self.mod_env.loader = loaders.PrefixLoader({
 
212
            'MOD':      self.mod_env.loader,
 
213
            'DICT':     loaders.DictLoader({'test.html': 'DICT_TEMPLATE'})
 
214
        })
 
215
 
 
216
        tmpl1 = self.mod_env.get_template('MOD/a/test.html')
 
217
        self.assert_equal(tmpl1.render(), 'BAR')
 
218
        tmpl2 = self.mod_env.get_template('DICT/test.html')
 
219
        self.assert_equal(tmpl2.render(), 'DICT_TEMPLATE')
 
220
 
 
221
 
 
222
def suite():
 
223
    suite = unittest.TestSuite()
 
224
    suite.addTest(unittest.makeSuite(LoaderTestCase))
 
225
    suite.addTest(unittest.makeSuite(ModuleLoaderTestCase))
 
226
    return suite