diff options
Diffstat (limited to 'tests/template_tests/syntax_tests/test_basic.py')
| -rw-r--r-- | tests/template_tests/syntax_tests/test_basic.py | 92 |
1 files changed, 45 insertions, 47 deletions
diff --git a/tests/template_tests/syntax_tests/test_basic.py b/tests/template_tests/syntax_tests/test_basic.py index 72b0b7486d..073d26e10b 100644 --- a/tests/template_tests/syntax_tests/test_basic.py +++ b/tests/template_tests/syntax_tests/test_basic.py @@ -1,9 +1,7 @@ -from django.conf import settings from django.template.base import Context, TemplateSyntaxError -from django.template.loader import get_template from django.test import SimpleTestCase -from ..utils import render, setup, SilentGetItemClass, SilentAttrClass, SomeClass +from ..utils import setup, SilentGetItemClass, SilentAttrClass, SomeClass basic_templates = { @@ -20,7 +18,7 @@ class BasicSyntaxTests(SimpleTestCase): """ Plain text should go through the template parser untouched. """ - output = render('basic-syntax01') + output = self.engine.render_to_string('basic-syntax01') self.assertEqual(output, "something cool") @setup(basic_templates) @@ -29,7 +27,7 @@ class BasicSyntaxTests(SimpleTestCase): Variables should be replaced with their value in the current context """ - output = render('basic-syntax02', {'headline': 'Success'}) + output = self.engine.render_to_string('basic-syntax02', {'headline': 'Success'}) self.assertEqual(output, 'Success') @setup(basic_templates) @@ -37,7 +35,7 @@ class BasicSyntaxTests(SimpleTestCase): """ More than one replacement variable is allowed in a template """ - output = render('basic-syntax03', {"first": 1, "second": 2}) + output = self.engine.render_to_string('basic-syntax03', {"first": 1, "second": 2}) self.assertEqual(output, '1 --- 2') @setup({'basic-syntax04': 'as{{ missing }}df'}) @@ -45,8 +43,8 @@ class BasicSyntaxTests(SimpleTestCase): """ Fail silently when a variable is not found in the current context """ - output = render('basic-syntax04') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('basic-syntax04') + if self.engine.string_if_invalid: self.assertEqual(output, 'asINVALIDdf') else: self.assertEqual(output, 'asdf') @@ -57,7 +55,7 @@ class BasicSyntaxTests(SimpleTestCase): A variable may not contain more than one word """ with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax06') + self.engine.get_template('basic-syntax06') @setup({'basic-syntax07': '{{ }}'}) def test_basic_syntax07(self): @@ -65,7 +63,7 @@ class BasicSyntaxTests(SimpleTestCase): Raise TemplateSyntaxError for empty variable tags. """ with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax07') + self.engine.get_template('basic-syntax07') @setup({'basic-syntax08': '{{ }}'}) def test_basic_syntax08(self): @@ -73,14 +71,14 @@ class BasicSyntaxTests(SimpleTestCase): Raise TemplateSyntaxError for empty variable tags. """ with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax08') + self.engine.get_template('basic-syntax08') @setup({'basic-syntax09': '{{ var.method }}'}) def test_basic_syntax09(self): """ Attribute syntax allows a template to call an object's attribute """ - output = render('basic-syntax09', {'var': SomeClass()}) + output = self.engine.render_to_string('basic-syntax09', {'var': SomeClass()}) self.assertEqual(output, 'SomeClass.method') @setup({'basic-syntax10': '{{ var.otherclass.method }}'}) @@ -88,7 +86,7 @@ class BasicSyntaxTests(SimpleTestCase): """ Multiple levels of attribute access are allowed. """ - output = render('basic-syntax10', {'var': SomeClass()}) + output = self.engine.render_to_string('basic-syntax10', {'var': SomeClass()}) self.assertEqual(output, 'OtherClass.method') @setup({'basic-syntax11': '{{ var.blech }}'}) @@ -96,9 +94,9 @@ class BasicSyntaxTests(SimpleTestCase): """ Fail silently when a variable's attribute isn't found. """ - output = render('basic-syntax11', {'var': SomeClass()}) + output = self.engine.render_to_string('basic-syntax11', {'var': SomeClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -110,34 +108,34 @@ class BasicSyntaxTests(SimpleTestCase): beginning with an underscore. """ with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax12') + self.engine.get_template('basic-syntax12') # Raise TemplateSyntaxError when trying to access a variable # containing an illegal character. @setup({'basic-syntax13': "{{ va>r }}"}) def test_basic_syntax13(self): with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax13') + self.engine.get_template('basic-syntax13') @setup({'basic-syntax14': "{{ (var.r) }}"}) def test_basic_syntax14(self): with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax14') + self.engine.get_template('basic-syntax14') @setup({'basic-syntax15': "{{ sp%am }}"}) def test_basic_syntax15(self): with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax15') + self.engine.get_template('basic-syntax15') @setup({'basic-syntax16': "{{ eggs! }}"}) def test_basic_syntax16(self): with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax16') + self.engine.get_template('basic-syntax16') @setup({'basic-syntax17': "{{ moo? }}"}) def test_basic_syntax17(self): with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax17') + self.engine.get_template('basic-syntax17') @setup({'basic-syntax18': "{{ foo.bar }}"}) def test_basic_syntax18(self): @@ -145,7 +143,7 @@ class BasicSyntaxTests(SimpleTestCase): Attribute syntax allows a template to call a dictionary key's value. """ - output = render('basic-syntax18', {"foo": {"bar": "baz"}}) + output = self.engine.render_to_string('basic-syntax18', {"foo": {"bar": "baz"}}) self.assertEqual(output, "baz") @setup({'basic-syntax19': "{{ foo.spam }}"}) @@ -153,9 +151,9 @@ class BasicSyntaxTests(SimpleTestCase): """ Fail silently when a variable's dictionary key isn't found. """ - output = render('basic-syntax19', {"foo": {"bar": "baz"}}) + output = self.engine.render_to_string('basic-syntax19', {"foo": {"bar": "baz"}}) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -165,9 +163,9 @@ class BasicSyntaxTests(SimpleTestCase): """ Fail silently when accessing a non-simple method """ - output = render('basic-syntax20', {'var': SomeClass()}) + output = self.engine.render_to_string('basic-syntax20', {'var': SomeClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -177,7 +175,7 @@ class BasicSyntaxTests(SimpleTestCase): """ Don't silence a TypeError if it was raised inside a callable. """ - template = get_template('basic-syntax20b') + template = self.engine.get_template('basic-syntax20b') with self.assertRaises(TypeError): template.render(Context({'var': SomeClass()})) @@ -186,12 +184,12 @@ class BasicSyntaxTests(SimpleTestCase): # quite, a template tag. @setup({'basic-syntax21': "a {{ moo %} b"}) def test_basic_syntax21(self): - output = render('basic-syntax21') + output = self.engine.render_to_string('basic-syntax21') self.assertEqual(output, "a {{ moo %} b") @setup({'basic-syntax22': "{{ moo #}"}) def test_basic_syntax22(self): - output = render('basic-syntax22') + output = self.engine.render_to_string('basic-syntax22') self.assertEqual(output, "{{ moo #}") @setup({'basic-syntax23': "{{ moo #} {{ cow }}"}) @@ -201,47 +199,47 @@ class BasicSyntaxTests(SimpleTestCase): around, so this triggers an error. """ with self.assertRaises(TemplateSyntaxError): - get_template('basic-syntax23') + self.engine.get_template('basic-syntax23') @setup({'basic-syntax24': "{{ moo\n }}"}) def test_basic_syntax24(self): """ Embedded newlines make it not-a-tag. """ - output = render('basic-syntax24') + output = self.engine.render_to_string('basic-syntax24') self.assertEqual(output, "{{ moo\n }}") # Literal strings are permitted inside variables, mostly for i18n # purposes. @setup({'basic-syntax25': '{{ "fred" }}'}) def test_basic_syntax25(self): - output = render('basic-syntax25') + output = self.engine.render_to_string('basic-syntax25') self.assertEqual(output, "fred") @setup({'basic-syntax26': r'{{ "\"fred\"" }}'}) def test_basic_syntax26(self): - output = render('basic-syntax26') + output = self.engine.render_to_string('basic-syntax26') self.assertEqual(output, "\"fred\"") @setup({'basic-syntax27': r'{{ _("\"fred\"") }}'}) def test_basic_syntax27(self): - output = render('basic-syntax27') + output = self.engine.render_to_string('basic-syntax27') self.assertEqual(output, "\"fred\"") # #12554 -- Make sure a silent_variable_failure Exception is # suppressed on dictionary and attribute lookup. @setup({'basic-syntax28': "{{ a.b }}"}) def test_basic_syntax28(self): - output = render('basic-syntax28', {'a': SilentGetItemClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('basic-syntax28', {'a': SilentGetItemClass()}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @setup({'basic-syntax29': "{{ a.b }}"}) def test_basic_syntax29(self): - output = render('basic-syntax29', {'a': SilentAttrClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('basic-syntax29', {'a': SilentAttrClass()}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -250,7 +248,7 @@ class BasicSyntaxTests(SimpleTestCase): # as a lookup. @setup({'basic-syntax30': "{{ 1.2.3 }}"}) def test_basic_syntax30(self): - output = render( + output = self.engine.render_to_string( 'basic-syntax30', {"1": {"2": {"3": "d"}}} ) @@ -258,7 +256,7 @@ class BasicSyntaxTests(SimpleTestCase): @setup({'basic-syntax31': "{{ 1.2.3 }}"}) def test_basic_syntax31(self): - output = render( + output = self.engine.render_to_string( 'basic-syntax31', {"1": {"2": ("a", "b", "c", "d")}}, ) @@ -266,7 +264,7 @@ class BasicSyntaxTests(SimpleTestCase): @setup({'basic-syntax32': "{{ 1.2.3 }}"}) def test_basic_syntax32(self): - output = render( + output = self.engine.render_to_string( 'basic-syntax32', {"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))}, ) @@ -274,7 +272,7 @@ class BasicSyntaxTests(SimpleTestCase): @setup({'basic-syntax33': "{{ 1.2.3 }}"}) def test_basic_syntax33(self): - output = render( + output = self.engine.render_to_string( 'basic-syntax33', {"1": ("xxxx", "yyyy", "abcd")}, ) @@ -282,7 +280,7 @@ class BasicSyntaxTests(SimpleTestCase): @setup({'basic-syntax34': "{{ 1.2.3 }}"}) def test_basic_syntax34(self): - output = render( + output = self.engine.render_to_string( 'basic-syntax34', {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})} ) @@ -291,12 +289,12 @@ class BasicSyntaxTests(SimpleTestCase): # Numbers are numbers even if their digits are in the context. @setup({'basic-syntax35': "{{ 1 }}"}) def test_basic_syntax35(self): - output = render('basic-syntax35', {"1": "abc"}) + output = self.engine.render_to_string('basic-syntax35', {"1": "abc"}) self.assertEqual(output, '1') @setup({'basic-syntax36': "{{ 1.2 }}"}) def test_basic_syntax36(self): - output = render('basic-syntax36', {"1": "abc"}) + output = self.engine.render_to_string('basic-syntax36', {"1": "abc"}) self.assertEqual(output, '1.2') @setup({'basic-syntax37': '{{ callable }}'}) @@ -304,7 +302,7 @@ class BasicSyntaxTests(SimpleTestCase): """ Call methods in the top level of the context. """ - output = render('basic-syntax37', {"callable": lambda: "foo bar"}) + output = self.engine.render_to_string('basic-syntax37', {"callable": lambda: "foo bar"}) self.assertEqual(output, 'foo bar') @setup({'basic-syntax38': '{{ var.callable }}'}) @@ -312,5 +310,5 @@ class BasicSyntaxTests(SimpleTestCase): """ Call methods returned from dictionary lookups. """ - output = render('basic-syntax38', {"var": {"callable": lambda: "foo bar"}}) + output = self.engine.render_to_string('basic-syntax38', {"var": {"callable": lambda: "foo bar"}}) self.assertEqual(output, 'foo bar') |