python/lib/django_1_4/tests/regressiontests/templates/custom.py

   1 from __future__ import absolute_import
   2
   3 from django import template
   4 from django.utils.unittest import TestCase
   5
   6 from .templatetags import custom
   7
   8
   9 class CustomFilterTests(TestCase):
  10     def test_filter(self):
  11         t = template.Template("{% load custom %}{{ string|trim:5 }}")
  12         self.assertEqual(
  13             t.render(template.Context({"string": "abcdefghijklmnopqrstuvwxyz"})),
  14             u"abcde"
  15         )
  16
  17
  18 class CustomTagTests(TestCase):
  19     def verify_tag(self, tag, name):
  20         self.assertEqual(tag.__name__, name)
  21         self.assertEqual(tag.__doc__, 'Expected %s __doc__' % name)
  22         self.assertEqual(tag.__dict__['anything'], 'Expected %s __dict__' % name)
  23
  24     def test_simple_tags(self):
  25         c = template.Context({'value': 42})
  26
  27         t = template.Template('{% load custom %}{% no_params %}')
  28         self.assertEqual(t.render(c), u'no_params - Expected result')
  29
  30         t = template.Template('{% load custom %}{% one_param 37 %}')
  31         self.assertEqual(t.render(c), u'one_param - Expected result: 37')
  32
  33         t = template.Template('{% load custom %}{% explicit_no_context 37 %}')
  34         self.assertEqual(t.render(c), u'explicit_no_context - Expected result: 37')
  35
  36         t = template.Template('{% load custom %}{% no_params_with_context %}')
  37         self.assertEqual(t.render(c), u'no_params_with_context - Expected result (context value: 42)')
  38
  39         t = template.Template('{% load custom %}{% params_and_context 37 %}')
  40         self.assertEqual(t.render(c), u'params_and_context - Expected result (context value: 42): 37')
  41
  42         t = template.Template('{% load custom %}{% simple_two_params 37 42 %}')
  43         self.assertEqual(t.render(c), u'simple_two_params - Expected result: 37, 42')
  44
  45         t = template.Template('{% load custom %}{% simple_one_default 37 %}')
  46         self.assertEqual(t.render(c), u'simple_one_default - Expected result: 37, hi')
  47
  48         t = template.Template('{% load custom %}{% simple_one_default 37 two="hello" %}')
  49         self.assertEqual(t.render(c), u'simple_one_default - Expected result: 37, hello')
  50
  51         t = template.Template('{% load custom %}{% simple_one_default one=99 two="hello" %}')
  52         self.assertEqual(t.render(c), u'simple_one_default - Expected result: 99, hello')
  53
  54         self.assertRaisesRegexp(template.TemplateSyntaxError,
  55             "'simple_one_default' received unexpected keyword argument 'three'",
  56             template.Template, '{% load custom %}{% simple_one_default 99 two="hello" three="foo" %}')
  57
  58         t = template.Template('{% load custom %}{% simple_one_default 37 42 %}')
  59         self.assertEqual(t.render(c), u'simple_one_default - Expected result: 37, 42')
  60
  61         t = template.Template('{% load custom %}{% simple_unlimited_args 37 %}')
  62         self.assertEqual(t.render(c), u'simple_unlimited_args - Expected result: 37, hi')
  63
  64         t = template.Template('{% load custom %}{% simple_unlimited_args 37 42 56 89 %}')
  65         self.assertEqual(t.render(c), u'simple_unlimited_args - Expected result: 37, 42, 56, 89')
  66
  67         t = template.Template('{% load custom %}{% simple_only_unlimited_args %}')
  68         self.assertEqual(t.render(c), u'simple_only_unlimited_args - Expected result: ')
  69
  70         t = template.Template('{% load custom %}{% simple_only_unlimited_args 37 42 56 89 %}')
  71         self.assertEqual(t.render(c), u'simple_only_unlimited_args - Expected result: 37, 42, 56, 89')
  72
  73         self.assertRaisesRegexp(template.TemplateSyntaxError,
  74             "'simple_two_params' received too many positional arguments",
  75             template.Template, '{% load custom %}{% simple_two_params 37 42 56 %}')
  76
  77         self.assertRaisesRegexp(template.TemplateSyntaxError,
  78             "'simple_one_default' received too many positional arguments",
  79             template.Template, '{% load custom %}{% simple_one_default 37 42 56 %}')
  80
  81         t = template.Template('{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 %}')
  82         self.assertEqual(t.render(c), u'simple_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4')
  83
  84         self.assertRaisesRegexp(template.TemplateSyntaxError,
  85             "'simple_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)",
  86             template.Template, '{% load custom %}{% simple_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 %}')
  87
  88         self.assertRaisesRegexp(template.TemplateSyntaxError,
  89             "'simple_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'",
  90             template.Template, '{% load custom %}{% simple_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" %}')
  91
  92     def test_simple_tag_registration(self):
  93         # Test that the decorators preserve the decorated function's docstring, name and attributes.
  94         self.verify_tag(custom.no_params, 'no_params')
  95         self.verify_tag(custom.one_param, 'one_param')
  96         self.verify_tag(custom.explicit_no_context, 'explicit_no_context')
  97         self.verify_tag(custom.no_params_with_context, 'no_params_with_context')
  98         self.verify_tag(custom.params_and_context, 'params_and_context')
  99         self.verify_tag(custom.simple_unlimited_args_kwargs, 'simple_unlimited_args_kwargs')
 100         self.verify_tag(custom.simple_tag_without_context_parameter, 'simple_tag_without_context_parameter')
 101
 102     def test_simple_tag_missing_context(self):
 103         # The 'context' parameter must be present when takes_context is True
 104         self.assertRaisesRegexp(template.TemplateSyntaxError,
 105             "'simple_tag_without_context_parameter' is decorated with takes_context=True so it must have a first argument of 'context'",
 106             template.Template, '{% load custom %}{% simple_tag_without_context_parameter 123 %}')
 107
 108     def test_inclusion_tags(self):
 109         c = template.Context({'value': 42})
 110
 111         t = template.Template('{% load custom %}{% inclusion_no_params %}')
 112         self.assertEqual(t.render(c), u'inclusion_no_params - Expected result\n')
 113
 114         t = template.Template('{% load custom %}{% inclusion_one_param 37 %}')
 115         self.assertEqual(t.render(c), u'inclusion_one_param - Expected result: 37\n')
 116
 117         t = template.Template('{% load custom %}{% inclusion_explicit_no_context 37 %}')
 118         self.assertEqual(t.render(c), u'inclusion_explicit_no_context - Expected result: 37\n')
 119
 120         t = template.Template('{% load custom %}{% inclusion_no_params_with_context %}')
 121         self.assertEqual(t.render(c), u'inclusion_no_params_with_context - Expected result (context value: 42)\n')
 122
 123         t = template.Template('{% load custom %}{% inclusion_params_and_context 37 %}')
 124         self.assertEqual(t.render(c), u'inclusion_params_and_context - Expected result (context value: 42): 37\n')
 125
 126         t = template.Template('{% load custom %}{% inclusion_two_params 37 42 %}')
 127         self.assertEqual(t.render(c), u'inclusion_two_params - Expected result: 37, 42\n')
 128
 129         t = template.Template('{% load custom %}{% inclusion_one_default 37 %}')
 130         self.assertEqual(t.render(c), u'inclusion_one_default - Expected result: 37, hi\n')
 131
 132         t = template.Template('{% load custom %}{% inclusion_one_default 37 two="hello" %}')
 133         self.assertEqual(t.render(c), u'inclusion_one_default - Expected result: 37, hello\n')
 134
 135         t = template.Template('{% load custom %}{% inclusion_one_default one=99 two="hello" %}')
 136         self.assertEqual(t.render(c), u'inclusion_one_default - Expected result: 99, hello\n')
 137
 138         self.assertRaisesRegexp(template.TemplateSyntaxError,
 139             "'inclusion_one_default' received unexpected keyword argument 'three'",
 140             template.Template, '{% load custom %}{% inclusion_one_default 99 two="hello" three="foo" %}')
 141
 142         t = template.Template('{% load custom %}{% inclusion_one_default 37 42 %}')
 143         self.assertEqual(t.render(c), u'inclusion_one_default - Expected result: 37, 42\n')
 144
 145         t = template.Template('{% load custom %}{% inclusion_unlimited_args 37 %}')
 146         self.assertEqual(t.render(c), u'inclusion_unlimited_args - Expected result: 37, hi\n')
 147
 148         t = template.Template('{% load custom %}{% inclusion_unlimited_args 37 42 56 89 %}')
 149         self.assertEqual(t.render(c), u'inclusion_unlimited_args - Expected result: 37, 42, 56, 89\n')
 150
 151         t = template.Template('{% load custom %}{% inclusion_only_unlimited_args %}')
 152         self.assertEqual(t.render(c), u'inclusion_only_unlimited_args - Expected result: \n')
 153
 154         t = template.Template('{% load custom %}{% inclusion_only_unlimited_args 37 42 56 89 %}')
 155         self.assertEqual(t.render(c), u'inclusion_only_unlimited_args - Expected result: 37, 42, 56, 89\n')
 156
 157         self.assertRaisesRegexp(template.TemplateSyntaxError,
 158             "'inclusion_two_params' received too many positional arguments",
 159             template.Template, '{% load custom %}{% inclusion_two_params 37 42 56 %}')
 160
 161         self.assertRaisesRegexp(template.TemplateSyntaxError,
 162             "'inclusion_one_default' received too many positional arguments",
 163             template.Template, '{% load custom %}{% inclusion_one_default 37 42 56 %}')
 164
 165         self.assertRaisesRegexp(template.TemplateSyntaxError,
 166             "'inclusion_one_default' did not receive value\(s\) for the argument\(s\): 'one'",
 167             template.Template, '{% load custom %}{% inclusion_one_default %}')
 168
 169         self.assertRaisesRegexp(template.TemplateSyntaxError,
 170             "'inclusion_unlimited_args' did not receive value\(s\) for the argument\(s\): 'one'",
 171             template.Template, '{% load custom %}{% inclusion_unlimited_args %}')
 172
 173         t = template.Template('{% load custom %}{% inclusion_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 %}')
 174         self.assertEqual(t.render(c), u'inclusion_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4\n')
 175
 176         self.assertRaisesRegexp(template.TemplateSyntaxError,
 177             "'inclusion_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)",
 178             template.Template, '{% load custom %}{% inclusion_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 %}')
 179
 180         self.assertRaisesRegexp(template.TemplateSyntaxError,
 181             "'inclusion_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'",
 182             template.Template, '{% load custom %}{% inclusion_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" %}')
 183
 184     def test_include_tag_missing_context(self):
 185         # The 'context' parameter must be present when takes_context is True
 186         self.assertRaisesRegexp(template.TemplateSyntaxError,
 187             "'inclusion_tag_without_context_parameter' is decorated with takes_context=True so it must have a first argument of 'context'",
 188             template.Template, '{% load custom %}{% inclusion_tag_without_context_parameter 123 %}')
 189
 190     def test_inclusion_tags_from_template(self):
 191         c = template.Context({'value': 42})
 192
 193         t = template.Template('{% load custom %}{% inclusion_no_params_from_template %}')
 194         self.assertEqual(t.render(c), u'inclusion_no_params_from_template - Expected result\n')
 195
 196         t = template.Template('{% load custom %}{% inclusion_one_param_from_template 37 %}')
 197         self.assertEqual(t.render(c), u'inclusion_one_param_from_template - Expected result: 37\n')
 198
 199         t = template.Template('{% load custom %}{% inclusion_explicit_no_context_from_template 37 %}')
 200         self.assertEqual(t.render(c), u'inclusion_explicit_no_context_from_template - Expected result: 37\n')
 201
 202         t = template.Template('{% load custom %}{% inclusion_no_params_with_context_from_template %}')
 203         self.assertEqual(t.render(c), u'inclusion_no_params_with_context_from_template - Expected result (context value: 42)\n')
 204
 205         t = template.Template('{% load custom %}{% inclusion_params_and_context_from_template 37 %}')
 206         self.assertEqual(t.render(c), u'inclusion_params_and_context_from_template - Expected result (context value: 42): 37\n')
 207
 208         t = template.Template('{% load custom %}{% inclusion_two_params_from_template 37 42 %}')
 209         self.assertEqual(t.render(c), u'inclusion_two_params_from_template - Expected result: 37, 42\n')
 210
 211         t = template.Template('{% load custom %}{% inclusion_one_default_from_template 37 %}')
 212         self.assertEqual(t.render(c), u'inclusion_one_default_from_template - Expected result: 37, hi\n')
 213
 214         t = template.Template('{% load custom %}{% inclusion_one_default_from_template 37 42 %}')
 215         self.assertEqual(t.render(c), u'inclusion_one_default_from_template - Expected result: 37, 42\n')
 216
 217         t = template.Template('{% load custom %}{% inclusion_unlimited_args_from_template 37 %}')
 218         self.assertEqual(t.render(c), u'inclusion_unlimited_args_from_template - Expected result: 37, hi\n')
 219
 220         t = template.Template('{% load custom %}{% inclusion_unlimited_args_from_template 37 42 56 89 %}')
 221         self.assertEqual(t.render(c), u'inclusion_unlimited_args_from_template - Expected result: 37, 42, 56, 89\n')
 222
 223         t = template.Template('{% load custom %}{% inclusion_only_unlimited_args_from_template %}')
 224         self.assertEqual(t.render(c), u'inclusion_only_unlimited_args_from_template - Expected result: \n')
 225
 226         t = template.Template('{% load custom %}{% inclusion_only_unlimited_args_from_template 37 42 56 89 %}')
 227         self.assertEqual(t.render(c), u'inclusion_only_unlimited_args_from_template - Expected result: 37, 42, 56, 89\n')
 228
 229     def test_inclusion_tag_registration(self):
 230         # Test that the decorators preserve the decorated function's docstring, name and attributes.
 231         self.verify_tag(custom.inclusion_no_params, 'inclusion_no_params')
 232         self.verify_tag(custom.inclusion_one_param, 'inclusion_one_param')
 233         self.verify_tag(custom.inclusion_explicit_no_context, 'inclusion_explicit_no_context')
 234         self.verify_tag(custom.inclusion_no_params_with_context, 'inclusion_no_params_with_context')
 235         self.verify_tag(custom.inclusion_params_and_context, 'inclusion_params_and_context')
 236         self.verify_tag(custom.inclusion_two_params, 'inclusion_two_params')
 237         self.verify_tag(custom.inclusion_one_default, 'inclusion_one_default')
 238         self.verify_tag(custom.inclusion_unlimited_args, 'inclusion_unlimited_args')
 239         self.verify_tag(custom.inclusion_only_unlimited_args, 'inclusion_only_unlimited_args')
 240         self.verify_tag(custom.inclusion_tag_without_context_parameter, 'inclusion_tag_without_context_parameter')
 241         self.verify_tag(custom.inclusion_tag_use_l10n, 'inclusion_tag_use_l10n')
 242         self.verify_tag(custom.inclusion_tag_current_app, 'inclusion_tag_current_app')
 243         self.verify_tag(custom.inclusion_unlimited_args_kwargs, 'inclusion_unlimited_args_kwargs')
 244
 245     def test_15070_current_app(self):
 246         """
 247         Test that inclusion tag passes down `current_app` of context to the
 248         Context of the included/rendered template as well.
 249         """
 250         c = template.Context({})
 251         t = template.Template('{% load custom %}{% inclusion_tag_current_app %}')
 252         self.assertEqual(t.render(c).strip(), u'None')
 253
 254         c.current_app = 'advanced'
 255         self.assertEqual(t.render(c).strip(), u'advanced')
 256
 257     def test_15070_use_l10n(self):
 258         """
 259         Test that inclusion tag passes down `use_l10n` of context to the
 260         Context of the included/rendered template as well.
 261         """
 262         c = template.Context({})
 263         t = template.Template('{% load custom %}{% inclusion_tag_use_l10n %}')
 264         self.assertEqual(t.render(c).strip(), u'None')
 265
 266         c.use_l10n = True
 267         self.assertEqual(t.render(c).strip(), u'True')
 268
 269     def test_assignment_tags(self):
 270         c = template.Context({'value': 42})
 271
 272         t = template.Template('{% load custom %}{% assignment_no_params as var %}The result is: {{ var }}')
 273         self.assertEqual(t.render(c), u'The result is: assignment_no_params - Expected result')
 274
 275         t = template.Template('{% load custom %}{% assignment_one_param 37 as var %}The result is: {{ var }}')
 276         self.assertEqual(t.render(c), u'The result is: assignment_one_param - Expected result: 37')
 277
 278         t = template.Template('{% load custom %}{% assignment_explicit_no_context 37 as var %}The result is: {{ var }}')
 279         self.assertEqual(t.render(c), u'The result is: assignment_explicit_no_context - Expected result: 37')
 280
 281         t = template.Template('{% load custom %}{% assignment_no_params_with_context as var %}The result is: {{ var }}')
 282         self.assertEqual(t.render(c), u'The result is: assignment_no_params_with_context - Expected result (context value: 42)')
 283
 284         t = template.Template('{% load custom %}{% assignment_params_and_context 37 as var %}The result is: {{ var }}')
 285         self.assertEqual(t.render(c), u'The result is: assignment_params_and_context - Expected result (context value: 42): 37')
 286
 287         t = template.Template('{% load custom %}{% assignment_two_params 37 42 as var %}The result is: {{ var }}')
 288         self.assertEqual(t.render(c), u'The result is: assignment_two_params - Expected result: 37, 42')
 289
 290         t = template.Template('{% load custom %}{% assignment_one_default 37 as var %}The result is: {{ var }}')
 291         self.assertEqual(t.render(c), u'The result is: assignment_one_default - Expected result: 37, hi')
 292
 293         t = template.Template('{% load custom %}{% assignment_one_default 37 two="hello" as var %}The result is: {{ var }}')
 294         self.assertEqual(t.render(c), u'The result is: assignment_one_default - Expected result: 37, hello')
 295
 296         t = template.Template('{% load custom %}{% assignment_one_default one=99 two="hello" as var %}The result is: {{ var }}')
 297         self.assertEqual(t.render(c), u'The result is: assignment_one_default - Expected result: 99, hello')
 298
 299         self.assertRaisesRegexp(template.TemplateSyntaxError,
 300             "'assignment_one_default' received unexpected keyword argument 'three'",
 301             template.Template, '{% load custom %}{% assignment_one_default 99 two="hello" three="foo" as var %}')
 302
 303         t = template.Template('{% load custom %}{% assignment_one_default 37 42 as var %}The result is: {{ var }}')
 304         self.assertEqual(t.render(c), u'The result is: assignment_one_default - Expected result: 37, 42')
 305
 306         t = template.Template('{% load custom %}{% assignment_unlimited_args 37 as var %}The result is: {{ var }}')
 307         self.assertEqual(t.render(c), u'The result is: assignment_unlimited_args - Expected result: 37, hi')
 308
 309         t = template.Template('{% load custom %}{% assignment_unlimited_args 37 42 56 89 as var %}The result is: {{ var }}')
 310         self.assertEqual(t.render(c), u'The result is: assignment_unlimited_args - Expected result: 37, 42, 56, 89')
 311
 312         t = template.Template('{% load custom %}{% assignment_only_unlimited_args as var %}The result is: {{ var }}')
 313         self.assertEqual(t.render(c), u'The result is: assignment_only_unlimited_args - Expected result: ')
 314
 315         t = template.Template('{% load custom %}{% assignment_only_unlimited_args 37 42 56 89 as var %}The result is: {{ var }}')
 316         self.assertEqual(t.render(c), u'The result is: assignment_only_unlimited_args - Expected result: 37, 42, 56, 89')
 317
 318         self.assertRaisesRegexp(template.TemplateSyntaxError,
 319             "'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'",
 320             template.Template, '{% load custom %}{% assignment_one_param 37 %}The result is: {{ var }}')
 321
 322         self.assertRaisesRegexp(template.TemplateSyntaxError,
 323             "'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'",
 324             template.Template, '{% load custom %}{% assignment_one_param 37 as %}The result is: {{ var }}')
 325
 326         self.assertRaisesRegexp(template.TemplateSyntaxError,
 327             "'assignment_one_param' tag takes at least 2 arguments and the second last argument must be 'as'",
 328             template.Template, '{% load custom %}{% assignment_one_param 37 ass var %}The result is: {{ var }}')
 329
 330         self.assertRaisesRegexp(template.TemplateSyntaxError,
 331             "'assignment_two_params' received too many positional arguments",
 332             template.Template, '{% load custom %}{% assignment_two_params 37 42 56 as var %}The result is: {{ var }}')
 333
 334         self.assertRaisesRegexp(template.TemplateSyntaxError,
 335             "'assignment_one_default' received too many positional arguments",
 336             template.Template, '{% load custom %}{% assignment_one_default 37 42 56 as var %}The result is: {{ var }}')
 337
 338         self.assertRaisesRegexp(template.TemplateSyntaxError,
 339             "'assignment_one_default' did not receive value\(s\) for the argument\(s\): 'one'",
 340             template.Template, '{% load custom %}{% assignment_one_default as var %}The result is: {{ var }}')
 341
 342         self.assertRaisesRegexp(template.TemplateSyntaxError,
 343             "'assignment_unlimited_args' did not receive value\(s\) for the argument\(s\): 'one'",
 344             template.Template, '{% load custom %}{% assignment_unlimited_args as var %}The result is: {{ var }}')
 345
 346         t = template.Template('{% load custom %}{% assignment_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" four=1|add:3 as var %}The result is: {{ var }}')
 347         self.assertEqual(t.render(c), u'The result is: assignment_unlimited_args_kwargs - Expected result: 37, 42, 56 / eggs=scrambled, four=4')
 348
 349         self.assertRaisesRegexp(template.TemplateSyntaxError,
 350             "'assignment_unlimited_args_kwargs' received some positional argument\(s\) after some keyword argument\(s\)",
 351             template.Template, '{% load custom %}{% assignment_unlimited_args_kwargs 37 40|add:2 eggs="scrambled" 56 four=1|add:3 as var %}The result is: {{ var }}')
 352
 353         self.assertRaisesRegexp(template.TemplateSyntaxError,
 354             "'assignment_unlimited_args_kwargs' received multiple values for keyword argument 'eggs'",
 355             template.Template, '{% load custom %}{% assignment_unlimited_args_kwargs 37 eggs="scrambled" eggs="scrambled" as var %}The result is: {{ var }}')
 356
 357     def test_assignment_tag_registration(self):
 358         # Test that the decorators preserve the decorated function's docstring, name and attributes.
 359         self.verify_tag(custom.assignment_no_params, 'assignment_no_params')
 360         self.verify_tag(custom.assignment_one_param, 'assignment_one_param')
 361         self.verify_tag(custom.assignment_explicit_no_context, 'assignment_explicit_no_context')
 362         self.verify_tag(custom.assignment_no_params_with_context, 'assignment_no_params_with_context')
 363         self.verify_tag(custom.assignment_params_and_context, 'assignment_params_and_context')
 364         self.verify_tag(custom.assignment_one_default, 'assignment_one_default')
 365         self.verify_tag(custom.assignment_two_params, 'assignment_two_params')
 366         self.verify_tag(custom.assignment_unlimited_args, 'assignment_unlimited_args')
 367         self.verify_tag(custom.assignment_only_unlimited_args, 'assignment_only_unlimited_args')
 368         self.verify_tag(custom.assignment_unlimited_args, 'assignment_unlimited_args')
 369         self.verify_tag(custom.assignment_unlimited_args_kwargs, 'assignment_unlimited_args_kwargs')
 370         self.verify_tag(custom.assignment_tag_without_context_parameter, 'assignment_tag_without_context_parameter')
 371
 372     def test_assignment_tag_missing_context(self):
 373         # The 'context' parameter must be present when takes_context is True
 374         self.assertRaisesRegexp(template.TemplateSyntaxError,
 375             "'assignment_tag_without_context_parameter' is decorated with takes_context=True so it must have a first argument of 'context'",
 376             template.Template, '{% load custom %}{% assignment_tag_without_context_parameter 123 as var %}')