1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
from unittest import skip
from django.template import Context
from django.test import modify_settings, override_settings, TestCase, RequestFactory
from render_block import render_block_to_string, BlockNotFound, UnsupportedEngine
class TestDjango(TestCase):
"""Test the Django templating engine."""
def assertExceptionMessageEquals(self, exception, expected):
self.assertEqual(expected, exception.args[0])
def test_block(self):
"""Test rendering an individual block."""
result = render_block_to_string('test1.html', 'block1')
self.assertEqual(result, 'block1 from test1')
# No reason this shouldn't work, but just in case.
result = render_block_to_string('test1.html', 'block2')
self.assertEqual(result, 'block2 from test1')
def test_override(self):
"""This block is overridden in test2."""
result = render_block_to_string('test2.html', 'block1')
self.assertEqual(result, 'block1 from test2')
def test_inherit(self):
"""This block is inherited from test1."""
result = render_block_to_string('test2.html', 'block2')
self.assertEqual(result, 'block2 from test1')
def test_no_block(self):
"""Check if there's no block available an exception is raised."""
with self.assertRaises(BlockNotFound) as exc:
render_block_to_string('test1.html', 'noblock')
self.assertExceptionMessageEquals(exc.exception,
"block with name 'noblock' does not exist")
def test_include(self):
"""Ensure that an include tag in a block still works."""
result = render_block_to_string('test3_django.html', 'block1')
self.assertEqual(result, 'included template')
def test_super(self):
"""Test that block.super works."""
result = render_block_to_string('test3_django.html', 'block2')
self.assertEqual(result, 'block2 from test3 - block2 from test1')
def test_multi_super(self):
result = render_block_to_string('test6_django.html', 'block2')
self.assertEqual(result, 'block2 from test6 - block2 from test3 - block2 from test1')
def test_super_with_same_context_on_multiple_executions(self):
"""Test that block.super works when fed the same context object twice."""
context = Context()
result_one = render_block_to_string('test3_django.html', 'block2', context=context)
result_two = render_block_to_string('test3_django.html', 'block2', context=context)
self.assertEqual(result_one, result_two, 'block2 from test3 - block2 from test1')
def test_subblock(self):
"""Test that a block within a block works."""
result = render_block_to_string('test5.html', 'block1')
self.assertEqual(result, 'block3 from test5')
result = render_block_to_string('test5.html', 'block3')
self.assertEqual(result, 'block3 from test5')
def test_subblock_no_parent(self):
"""
Test that a block within a block works if the parent block is only found
in the base template.
This is very similar to test_subblock, but the templates differ. In this
test the sub-template does not replace the entire block from the parent
template.
"""
result = render_block_to_string('test_sub.html', 'base')
self.assertEqual(result, '\n\nbar\n\n')
result = render_block_to_string('test_sub.html', 'first')
self.assertEqual(result, '\nbar\n')
def test_context(self):
"""Test that a context is properly rendered in a template."""
data = 'block2 from test5'
result = render_block_to_string('test5.html', 'block2', {'foo': data})
self.assertEqual(result, data)
def test_context_autoescape_off(self):
"""Test that the user can disable autoescape by providing a Context instance."""
data = "&'"
result = render_block_to_string('test5.html', 'block2', Context({'foo': data}, autoescape=False))
self.assertEqual(result, data)
@override_settings(
TEMPLATES=[{
'BACKEND': 'django.template.backends.dummy.TemplateStrings',
'DIRS': ['tests/templates'],
'APP_DIRS': True,
}]
)
def test_different_backend(self):
"""
Ensure an exception is thrown if a different backed from the Django
backend is used.
"""
with self.assertRaises(UnsupportedEngine) as exc:
render_block_to_string('test1.html', 'noblock')
self.assertExceptionMessageEquals(exc.exception,
"Can only render blocks from the Django template backend.")
@modify_settings(
INSTALLED_APPS={
'prepend': [
'django.contrib.auth',
'django.contrib.contenttypes',
],
},
)
def test_request_context(self):
"""Test that a request context data are properly rendered in a template."""
request = RequestFactory().get('dummy-url')
result = render_block_to_string('test_request_context.html', 'block1', {}, request)
self.assertEqual(result, '/dummy-url')
@override_settings(
TEMPLATES=[{
'BACKEND': 'django.template.backends.jinja2.Jinja2',
'DIRS': ['tests/templates'],
'APP_DIRS': True,
}]
)
class TestJinja2(TestCase):
"""Test the Django templating engine."""
def assertExceptionMessageEquals(self, exception, expected):
self.assertEqual(expected, exception.args[0])
def test_block(self):
"""Test rendering an individual block."""
result = render_block_to_string('test1.html', 'block1')
self.assertEqual(result, 'block1 from test1')
# No reason this shouldn't work, but just in case.
result = render_block_to_string('test1.html', 'block2')
self.assertEqual(result, 'block2 from test1')
def test_override(self):
"""This block is overridden in test2."""
result = render_block_to_string('test2.html', 'block1')
self.assertEqual(result, 'block1 from test2')
@skip('Not currently supported.')
def test_inherit(self):
"""This block is inherited from test1."""
result = render_block_to_string('test2.html', 'block2')
self.assertEqual(result, 'block2 from test1')
def test_no_block(self):
"""Check if there's no block available an exception is raised."""
with self.assertRaises(BlockNotFound) as exc:
render_block_to_string('test1.html', 'noblock')
self.assertExceptionMessageEquals(exc.exception,
"block with name 'noblock' does not exist")
def test_include(self):
"""Ensure that an include tag in a block still works."""
result = render_block_to_string('test3_jinja2.html', 'block1')
self.assertEqual(result, 'included template')
@skip('Not currently supported.')
def test_super(self):
"""Test that super() works."""
result = render_block_to_string('test3_jinja2.html', 'block2')
self.assertEqual(result, 'block2 from test3 - block2 from test1')
@skip('Not currently supported.')
def test_multi_super(self):
result = render_block_to_string('test6_jinja2.html', 'block2')
self.assertEqual(result, 'block2 from test6 - block2 from test3 - block2 from test1')
def test_subblock(self):
"""Test that a block within a block works."""
result = render_block_to_string('test5.html', 'block1')
self.assertEqual(result, 'block3 from test5')
result = render_block_to_string('test5.html', 'block3')
self.assertEqual(result, 'block3 from test5')
@skip('Not currently supported.')
def test_subblock_no_parent(self):
"""
Test that a block within a block works if the parent block is only found
in the base template.
This is very similar to test_subblock, but the templates differ. In this
test the sub-template does not replace the entire block from the parent
template.
"""
result = render_block_to_string('test_sub.html', 'base')
self.assertEqual(result, '\n\nbar\n\n')
result = render_block_to_string('test_sub.html', 'first')
self.assertEqual(result, '\nbar\n')
def test_context(self):
"""Test that a context is properly rendered in a template."""
data = 'block2 from test5'
result = render_block_to_string('test5.html', 'block2', {'foo': data})
self.assertEqual(result, data)
|
