diff options
Diffstat (limited to 'tests/template_tests/syntax_tests')
36 files changed, 780 insertions, 798 deletions
diff --git a/tests/template_tests/syntax_tests/test_autoescape.py b/tests/template_tests/syntax_tests/test_autoescape.py index 589265082c..7b5c12c59c 100644 --- a/tests/template_tests/syntax_tests/test_autoescape.py +++ b/tests/template_tests/syntax_tests/test_autoescape.py @@ -1,49 +1,49 @@ -from django.template.base import TemplateSyntaxError +from django.template import TemplateSyntaxError from django.test import SimpleTestCase from django.utils.safestring import mark_safe -from ..utils import render, setup, SafeClass, UnsafeClass +from ..utils import setup, SafeClass, UnsafeClass class AutoescapeTagTests(SimpleTestCase): @setup({'autoescape-tag01': '{% autoescape off %}hello{% endautoescape %}'}) def test_autoescape_tag01(self): - output = render('autoescape-tag01') + output = self.engine.render_to_string('autoescape-tag01') self.assertEqual(output, 'hello') @setup({'autoescape-tag02': '{% autoescape off %}{{ first }}{% endautoescape %}'}) def test_autoescape_tag02(self): - output = render('autoescape-tag02', {'first': '<b>hello</b>'}) + output = self.engine.render_to_string('autoescape-tag02', {'first': '<b>hello</b>'}) self.assertEqual(output, '<b>hello</b>') @setup({'autoescape-tag03': '{% autoescape on %}{{ first }}{% endautoescape %}'}) def test_autoescape_tag03(self): - output = render('autoescape-tag03', {'first': '<b>hello</b>'}) + output = self.engine.render_to_string('autoescape-tag03', {'first': '<b>hello</b>'}) self.assertEqual(output, '<b>hello</b>') # Autoescape disabling and enabling nest in a predictable way. @setup({'autoescape-tag04': '{% autoescape off %}' '{{ first }} {% autoescape on %}{{ first }}{% endautoescape %}{% endautoescape %}'}) def test_autoescape_tag04(self): - output = render('autoescape-tag04', {'first': '<a>'}) + output = self.engine.render_to_string('autoescape-tag04', {'first': '<a>'}) self.assertEqual(output, '<a> <a>') @setup({'autoescape-tag05': '{% autoescape on %}{{ first }}{% endautoescape %}'}) def test_autoescape_tag05(self): - output = render('autoescape-tag05', {'first': '<b>first</b>'}) + output = self.engine.render_to_string('autoescape-tag05', {'first': '<b>first</b>'}) self.assertEqual(output, '<b>first</b>') # Strings (ASCII or unicode) already marked as "safe" are not # auto-escaped @setup({'autoescape-tag06': '{{ first }}'}) def test_autoescape_tag06(self): - output = render('autoescape-tag06', {'first': mark_safe('<b>first</b>')}) + output = self.engine.render_to_string('autoescape-tag06', {'first': mark_safe('<b>first</b>')}) self.assertEqual(output, '<b>first</b>') @setup({'autoescape-tag07': '{% autoescape on %}{{ first }}{% endautoescape %}'}) def test_autoescape_tag07(self): - output = render('autoescape-tag07', {'first': mark_safe('<b>Apple</b>')}) + output = self.engine.render_to_string('autoescape-tag07', {'first': mark_safe('<b>Apple</b>')}) self.assertEqual(output, '<b>Apple</b>') @setup({'autoescape-tag08': r'{% autoescape on %}' @@ -52,19 +52,19 @@ class AutoescapeTagTests(SimpleTestCase): """ Literal string arguments to filters, if used in the result, are safe. """ - output = render('autoescape-tag08', {"var": None}) + output = self.engine.render_to_string('autoescape-tag08', {"var": None}) self.assertEqual(output, ' endquote" hah') # Objects which return safe strings as their __str__ method # won't get double-escaped. @setup({'autoescape-tag09': r'{{ unsafe }}'}) def test_autoescape_tag09(self): - output = render('autoescape-tag09', {'unsafe': UnsafeClass()}) + output = self.engine.render_to_string('autoescape-tag09', {'unsafe': UnsafeClass()}) self.assertEqual(output, 'you & me') @setup({'autoescape-tag10': r'{{ safe }}'}) def test_autoescape_tag10(self): - output = render('autoescape-tag10', {'safe': SafeClass()}) + output = self.engine.render_to_string('autoescape-tag10', {'safe': SafeClass()}) self.assertEqual(output, 'you > me') @setup({'autoescape-filtertag01': '{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}'}) @@ -75,25 +75,25 @@ class AutoescapeTagTests(SimpleTestCase): tags can be used in those cases) """ with self.assertRaises(TemplateSyntaxError): - render('autoescape-filtertag01', {'first': '<a>'}) + self.engine.render_to_string('autoescape-filtertag01', {'first': '<a>'}) @setup({'autoescape-ifequal01': '{% ifequal var "this & that" %}yes{% endifequal %}'}) def test_autoescape_ifequal01(self): """ ifequal compares unescaped vales. """ - output = render('autoescape-ifequal01', {'var': 'this & that'}) + output = self.engine.render_to_string('autoescape-ifequal01', {'var': 'this & that'}) self.assertEqual(output, 'yes') # Arguments to filters are 'safe' and manipulate their input unescaped. @setup({'autoescape-filters01': '{{ var|cut:"&" }}'}) def test_autoescape_filters01(self): - output = render('autoescape-filters01', {'var': 'this & that'}) + output = self.engine.render_to_string('autoescape-filters01', {'var': 'this & that'}) self.assertEqual(output, 'this that') @setup({'autoescape-filters02': '{{ var|join:" & " }}'}) def test_autoescape_filters02(self): - output = render('autoescape-filters02', {'var': ('Tom', 'Dick', 'Harry')}) + output = self.engine.render_to_string('autoescape-filters02', {'var': ('Tom', 'Dick', 'Harry')}) self.assertEqual(output, 'Tom & Dick & Harry') @setup({'autoescape-literals01': '{{ "this & that" }}'}) @@ -101,7 +101,7 @@ class AutoescapeTagTests(SimpleTestCase): """ Literal strings are safe. """ - output = render('autoescape-literals01') + output = self.engine.render_to_string('autoescape-literals01') self.assertEqual(output, 'this & that') @setup({'autoescape-stringiterations01': '{% for l in var %}{{ l }},{% endfor %}'}) @@ -109,7 +109,7 @@ class AutoescapeTagTests(SimpleTestCase): """ Iterating over strings outputs safe characters. """ - output = render('autoescape-stringiterations01', {'var': 'K&R'}) + output = self.engine.render_to_string('autoescape-stringiterations01', {'var': 'K&R'}) self.assertEqual(output, 'K,&,R,') @setup({'autoescape-lookup01': '{{ var.key }}'}) @@ -117,5 +117,5 @@ class AutoescapeTagTests(SimpleTestCase): """ Escape requirement survives lookup. """ - output = render('autoescape-lookup01', {'var': {'key': 'this & that'}}) + output = self.engine.render_to_string('autoescape-lookup01', {'var': {'key': 'this & that'}}) self.assertEqual(output, 'this & that') 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') diff --git a/tests/template_tests/syntax_tests/test_builtins.py b/tests/template_tests/syntax_tests/test_builtins.py index a45b1567f1..8ade96c65a 100644 --- a/tests/template_tests/syntax_tests/test_builtins.py +++ b/tests/template_tests/syntax_tests/test_builtins.py @@ -1,18 +1,21 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class BuiltinsTests(SimpleTestCase): @setup({'builtins01': '{{ True }}'}) def test_builtins01(self): - self.assertEqual(render('builtins01'), 'True') + output = self.engine.render_to_string('builtins01') + self.assertEqual(output, 'True') @setup({'builtins02': '{{ False }}'}) def test_builtins02(self): - self.assertEqual(render('builtins02'), 'False') + output = self.engine.render_to_string('builtins02') + self.assertEqual(output, 'False') @setup({'builtins03': '{{ None }}'}) def test_builtins03(self): - self.assertEqual(render('builtins03'), 'None') + output = self.engine.render_to_string('builtins03') + self.assertEqual(output, 'None') diff --git a/tests/template_tests/syntax_tests/test_cache.py b/tests/template_tests/syntax_tests/test_cache.py index a702fc05e4..52ce9b827c 100644 --- a/tests/template_tests/syntax_tests/test_cache.py +++ b/tests/template_tests/syntax_tests/test_cache.py @@ -1,9 +1,8 @@ from django.core.cache import cache -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class CacheTagTests(SimpleTestCase): @@ -13,7 +12,7 @@ class CacheTagTests(SimpleTestCase): @setup({'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}'}) def test_cache03(self): - output = render('cache03') + output = self.engine.render_to_string('cache03') self.assertEqual(output, 'cache03') @setup({ @@ -21,18 +20,18 @@ class CacheTagTests(SimpleTestCase): 'cache04': '{% load cache %}{% cache 2 test %}cache04{% endcache %}', }) def test_cache04(self): - render('cache03') - output = render('cache04') + self.engine.render_to_string('cache03') + output = self.engine.render_to_string('cache04') self.assertEqual(output, 'cache03') @setup({'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}'}) def test_cache05(self): - output = render('cache05', {'foo': 1}) + output = self.engine.render_to_string('cache05', {'foo': 1}) self.assertEqual(output, 'cache05') @setup({'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}'}) def test_cache06(self): - output = render('cache06', {'foo': 2}) + output = self.engine.render_to_string('cache06', {'foo': 2}) self.assertEqual(output, 'cache06') @setup({ @@ -41,8 +40,8 @@ class CacheTagTests(SimpleTestCase): }) def test_cache07(self): context = {'foo': 1} - render('cache05', context) - output = render('cache07', context) + self.engine.render_to_string('cache05', context) + output = self.engine.render_to_string('cache07', context) self.assertEqual(output, 'cache05') @setup({ @@ -54,42 +53,42 @@ class CacheTagTests(SimpleTestCase): Allow first argument to be a variable. """ context = {'foo': 2, 'time': 2} - render('cache06', context) - output = render('cache08', context) + self.engine.render_to_string('cache06', context) + output = self.engine.render_to_string('cache08', context) self.assertEqual(output, 'cache06') # Raise exception if we don't have at least 2 args, first one integer. @setup({'cache11': '{% load cache %}{% cache %}{% endcache %}'}) def test_cache11(self): with self.assertRaises(TemplateSyntaxError): - get_template('cache11') + self.engine.get_template('cache11') @setup({'cache12': '{% load cache %}{% cache 1 %}{% endcache %}'}) def test_cache12(self): with self.assertRaises(TemplateSyntaxError): - get_template('cache12') + self.engine.get_template('cache12') @setup({'cache13': '{% load cache %}{% cache foo bar %}{% endcache %}'}) def test_cache13(self): with self.assertRaises(TemplateSyntaxError): - render('cache13') + self.engine.render_to_string('cache13') @setup({'cache14': '{% load cache %}{% cache foo bar %}{% endcache %}'}) def test_cache14(self): with self.assertRaises(TemplateSyntaxError): - render('cache14', {'foo': 'fail'}) + self.engine.render_to_string('cache14', {'foo': 'fail'}) @setup({'cache15': '{% load cache %}{% cache foo bar %}{% endcache %}'}) def test_cache15(self): with self.assertRaises(TemplateSyntaxError): - render('cache15', {'foo': []}) + self.engine.render_to_string('cache15', {'foo': []}) @setup({'cache16': '{% load cache %}{% cache 1 foo bar %}{% endcache %}'}) def test_cache16(self): """ Regression test for #7460. """ - output = render('cache16', {'foo': 'foo', 'bar': 'with spaces'}) + output = self.engine.render_to_string('cache16', {'foo': 'foo', 'bar': 'with spaces'}) self.assertEqual(output, '') @setup({'cache17': '{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}'}) @@ -97,7 +96,7 @@ class CacheTagTests(SimpleTestCase): """ Regression test for #11270. """ - output = render('cache17', {'poem': 'Oh freddled gruntbuggly/' + output = self.engine.render_to_string('cache17', {'poem': 'Oh freddled gruntbuggly/' 'Thy micturations are to me/' 'As plurdled gabbleblotchits/' 'On a lurgid bee/' @@ -114,5 +113,5 @@ class CacheTagTests(SimpleTestCase): """ Test whitespace in filter arguments """ - output = render('cache18') + output = self.engine.render_to_string('cache18') self.assertEqual(output, 'cache18') diff --git a/tests/template_tests/syntax_tests/test_comment.py b/tests/template_tests/syntax_tests/test_comment.py index 73099e963b..d1b4dcf147 100644 --- a/tests/template_tests/syntax_tests/test_comment.py +++ b/tests/template_tests/syntax_tests/test_comment.py @@ -1,92 +1,92 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class CommentSyntaxTests(SimpleTestCase): @setup({'comment-syntax01': '{# this is hidden #}hello'}) def test_comment_syntax01(self): - output = render('comment-syntax01') + output = self.engine.render_to_string('comment-syntax01') self.assertEqual(output, 'hello') @setup({'comment-syntax02': '{# this is hidden #}hello{# foo #}'}) def test_comment_syntax02(self): - output = render('comment-syntax02') + output = self.engine.render_to_string('comment-syntax02') self.assertEqual(output, 'hello') @setup({'comment-syntax03': 'foo{# {% if %} #}'}) def test_comment_syntax03(self): - output = render('comment-syntax03') + output = self.engine.render_to_string('comment-syntax03') self.assertEqual(output, 'foo') @setup({'comment-syntax04': 'foo{# {% endblock %} #}'}) def test_comment_syntax04(self): - output = render('comment-syntax04') + output = self.engine.render_to_string('comment-syntax04') self.assertEqual(output, 'foo') @setup({'comment-syntax05': 'foo{# {% somerandomtag %} #}'}) def test_comment_syntax05(self): - output = render('comment-syntax05') + output = self.engine.render_to_string('comment-syntax05') self.assertEqual(output, 'foo') @setup({'comment-syntax06': 'foo{# {% #}'}) def test_comment_syntax06(self): - output = render('comment-syntax06') + output = self.engine.render_to_string('comment-syntax06') self.assertEqual(output, 'foo') @setup({'comment-syntax07': 'foo{# %} #}'}) def test_comment_syntax07(self): - output = render('comment-syntax07') + output = self.engine.render_to_string('comment-syntax07') self.assertEqual(output, 'foo') @setup({'comment-syntax08': 'foo{# %} #}bar'}) def test_comment_syntax08(self): - output = render('comment-syntax08') + output = self.engine.render_to_string('comment-syntax08') self.assertEqual(output, 'foobar') @setup({'comment-syntax09': 'foo{# {{ #}'}) def test_comment_syntax09(self): - output = render('comment-syntax09') + output = self.engine.render_to_string('comment-syntax09') self.assertEqual(output, 'foo') @setup({'comment-syntax10': 'foo{# }} #}'}) def test_comment_syntax10(self): - output = render('comment-syntax10') + output = self.engine.render_to_string('comment-syntax10') self.assertEqual(output, 'foo') @setup({'comment-syntax11': 'foo{# { #}'}) def test_comment_syntax11(self): - output = render('comment-syntax11') + output = self.engine.render_to_string('comment-syntax11') self.assertEqual(output, 'foo') @setup({'comment-syntax12': 'foo{# } #}'}) def test_comment_syntax12(self): - output = render('comment-syntax12') + output = self.engine.render_to_string('comment-syntax12') self.assertEqual(output, 'foo') @setup({'comment-tag01': '{% comment %}this is hidden{% endcomment %}hello'}) def test_comment_tag01(self): - output = render('comment-tag01') + output = self.engine.render_to_string('comment-tag01') self.assertEqual(output, 'hello') @setup({'comment-tag02': '{% comment %}this is hidden{% endcomment %}' 'hello{% comment %}foo{% endcomment %}'}) def test_comment_tag02(self): - output = render('comment-tag02') + output = self.engine.render_to_string('comment-tag02') self.assertEqual(output, 'hello') @setup({'comment-tag03': 'foo{% comment %} {% if %} {% endcomment %}'}) def test_comment_tag03(self): - output = render('comment-tag03') + output = self.engine.render_to_string('comment-tag03') self.assertEqual(output, 'foo') @setup({'comment-tag04': 'foo{% comment %} {% endblock %} {% endcomment %}'}) def test_comment_tag04(self): - output = render('comment-tag04') + output = self.engine.render_to_string('comment-tag04') self.assertEqual(output, 'foo') @setup({'comment-tag05': 'foo{% comment %} {% somerandomtag %} {% endcomment %}'}) def test_comment_tag05(self): - output = render('comment-tag05') + output = self.engine.render_to_string('comment-tag05') self.assertEqual(output, 'foo') diff --git a/tests/template_tests/syntax_tests/test_cycle.py b/tests/template_tests/syntax_tests/test_cycle.py index 0c18ccba90..8a47ff8879 100644 --- a/tests/template_tests/syntax_tests/test_cycle.py +++ b/tests/template_tests/syntax_tests/test_cycle.py @@ -1,11 +1,10 @@ import warnings -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase from django.utils.deprecation import RemovedInDjango20Warning -from ..utils import render, setup +from ..utils import setup class CycleTagTests(SimpleTestCase): @@ -13,119 +12,119 @@ class CycleTagTests(SimpleTestCase): @setup({'cycle01': '{% cycle a %}'}) def test_cycle01(self): with self.assertRaises(TemplateSyntaxError): - get_template('cycle01') + self.engine.get_template('cycle01') @setup({'cycle02': '{% cycle a,b,c as abc %}{% cycle abc %}'}) def test_cycle02(self): - output = render('cycle02') + output = self.engine.render_to_string('cycle02') self.assertEqual(output, 'ab') @setup({'cycle03': '{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}'}) def test_cycle03(self): - output = render('cycle03') + output = self.engine.render_to_string('cycle03') self.assertEqual(output, 'abc') @setup({'cycle04': '{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}'}) def test_cycle04(self): - output = render('cycle04') + output = self.engine.render_to_string('cycle04') self.assertEqual(output, 'abca') @setup({'cycle05': '{% cycle %}'}) def test_cycle05(self): with self.assertRaises(TemplateSyntaxError): - get_template('cycle05') + self.engine.get_template('cycle05') @setup({'cycle06': '{% cycle a %}'}) def test_cycle06(self): with self.assertRaises(TemplateSyntaxError): - get_template('cycle06') + self.engine.get_template('cycle06') @setup({'cycle07': '{% cycle a,b,c as foo %}{% cycle bar %}'}) def test_cycle07(self): with self.assertRaises(TemplateSyntaxError): - get_template('cycle07') + self.engine.get_template('cycle07') @setup({'cycle08': '{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}'}) def test_cycle08(self): - output = render('cycle08') + output = self.engine.render_to_string('cycle08') self.assertEqual(output, 'abbbcc') @setup({'cycle09': '{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}'}) def test_cycle09(self): - output = render('cycle09', {'test': list(range(5))}) + output = self.engine.render_to_string('cycle09', {'test': list(range(5))}) self.assertEqual(output, 'a0,b1,a2,b3,a4,') @setup({'cycle10': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"}) def test_cycle10(self): - output = render('cycle10') + output = self.engine.render_to_string('cycle10') self.assertEqual(output, 'ab') @setup({'cycle11': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"}) def test_cycle11(self): - output = render('cycle11') + output = self.engine.render_to_string('cycle11') self.assertEqual(output, 'abc') @setup({'cycle12': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"}) def test_cycle12(self): - output = render('cycle12') + output = self.engine.render_to_string('cycle12') self.assertEqual(output, 'abca') @setup({'cycle13': "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"}) def test_cycle13(self): - output = render('cycle13', {'test': list(range(5))}) + output = self.engine.render_to_string('cycle13', {'test': list(range(5))}) self.assertEqual(output, 'a0,b1,a2,b3,a4,') @setup({'cycle14': '{% cycle one two as foo %}{% cycle foo %}'}) def test_cycle14(self): - output = render('cycle14', {'one': '1', 'two': '2'}) + output = self.engine.render_to_string('cycle14', {'one': '1', 'two': '2'}) self.assertEqual(output, '12') @setup({'cycle15': '{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}'}) def test_cycle15(self): - output = render('cycle15', {'test': list(range(5)), 'aye': 'a', 'bee': 'b'}) + output = self.engine.render_to_string('cycle15', {'test': list(range(5)), 'aye': 'a', 'bee': 'b'}) self.assertEqual(output, 'a0,b1,a2,b3,a4,') @setup({'cycle16': '{% cycle one|lower two as foo %}{% cycle foo %}'}) def test_cycle16(self): - output = render('cycle16', {'one': 'A', 'two': '2'}) + output = self.engine.render_to_string('cycle16', {'one': 'A', 'two': '2'}) self.assertEqual(output, 'a2') @setup({'cycle17': "{% cycle 'a' 'b' 'c' as abc silent %}" "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"}) def test_cycle17(self): - output = render('cycle17') + output = self.engine.render_to_string('cycle17') self.assertEqual(output, '') @setup({'cycle18': "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"}) def test_cycle18(self): with self.assertRaises(TemplateSyntaxError): - get_template('cycle18') + self.engine.get_template('cycle18') @setup({'cycle19': "{% cycle 'a' 'b' as silent %}{% cycle silent %}"}) def test_cycle19(self): - output = render('cycle19') + output = self.engine.render_to_string('cycle19') self.assertEqual(output, 'ab') @setup({'cycle20': '{% cycle one two as foo %} & {% cycle foo %}'}) def test_cycle20(self): - output = render('cycle20', {'two': 'C & D', 'one': 'A & B'}) + output = self.engine.render_to_string('cycle20', {'two': 'C & D', 'one': 'A & B'}) self.assertEqual(output, 'A & B & C & D') @setup({'cycle21': '{% filter force_escape %}' '{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}'}) def test_cycle21(self): - output = render('cycle21', {'two': 'C & D', 'one': 'A & B'}) + output = self.engine.render_to_string('cycle21', {'two': 'C & D', 'one': 'A & B'}) self.assertEqual(output, 'A &amp; B & C &amp; D') @setup({'cycle22': "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"}) def test_cycle22(self): - output = render('cycle22', {'values': [1, 2, 3, 4]}) + output = self.engine.render_to_string('cycle22', {'values': [1, 2, 3, 4]}) self.assertEqual(output, '1234') @setup({'cycle23': "{% for x in values %}" "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"}) def test_cycle23(self): - output = render('cycle23', {'values': [1, 2, 3, 4]}) + output = self.engine.render_to_string('cycle23', {'values': [1, 2, 3, 4]}) self.assertEqual(output, 'a1b2c3a4') @setup({ @@ -134,19 +133,19 @@ class CycleTagTests(SimpleTestCase): 'included-cycle': '{{ abc }}', }) def test_cycle24(self): - output = render('cycle24', {'values': [1, 2, 3, 4]}) + output = self.engine.render_to_string('cycle24', {'values': [1, 2, 3, 4]}) self.assertEqual(output, 'abca') @setup({'cycle25': '{% cycle a as abc %}'}) def test_cycle25(self): - output = render('cycle25', {'a': '<'}) + output = self.engine.render_to_string('cycle25', {'a': '<'}) self.assertEqual(output, '<') @setup({'cycle26': '{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}'}) def test_cycle26(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('cycle26', {'a': '<', 'b': '>'}) + output = self.engine.render_to_string('cycle26', {'a': '<', 'b': '>'}) self.assertEqual(output, '<>') @setup({'cycle27': '{% load cycle from future %}' @@ -154,12 +153,12 @@ class CycleTagTests(SimpleTestCase): def test_cycle27(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('cycle27', {'a': '<', 'b': '>'}) + output = self.engine.render_to_string('cycle27', {'a': '<', 'b': '>'}) self.assertEqual(output, '<>') @setup({'cycle28': '{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}'}) def test_cycle28(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('cycle28', {'a': '<', 'b': '>'}) + output = self.engine.render_to_string('cycle28', {'a': '<', 'b': '>'}) self.assertEqual(output, '<>') diff --git a/tests/template_tests/syntax_tests/test_exceptions.py b/tests/template_tests/syntax_tests/test_exceptions.py index be313d8e76..e3645cb13f 100644 --- a/tests/template_tests/syntax_tests/test_exceptions.py +++ b/tests/template_tests/syntax_tests/test_exceptions.py @@ -1,10 +1,8 @@ -from django.conf import settings -from django.template.base import TemplateDoesNotExist, TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateDoesNotExist, TemplateSyntaxError from django.test import SimpleTestCase from .test_extends import inheritance_templates -from ..utils import render, setup +from ..utils import setup class ExceptionsTests(SimpleTestCase): @@ -15,19 +13,19 @@ class ExceptionsTests(SimpleTestCase): Raise exception for invalid template name """ with self.assertRaises(TemplateDoesNotExist): - render('exception01') + self.engine.render_to_string('exception01') @setup({'exception02': '{% extends nonexistent %}'}) def test_exception02(self): """ Raise exception for invalid variable template name """ - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: with self.assertRaises(TemplateDoesNotExist): - render('exception02') + self.engine.render_to_string('exception02') else: with self.assertRaises(TemplateSyntaxError): - render('exception02') + self.engine.render_to_string('exception02') @setup( {'exception03': "{% extends 'inheritance01' %}" @@ -39,7 +37,7 @@ class ExceptionsTests(SimpleTestCase): Raise exception for extra {% extends %} tags """ with self.assertRaises(TemplateSyntaxError): - get_template('exception03') + self.engine.get_template('exception03') @setup( {'exception04': "{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"}, @@ -50,7 +48,7 @@ class ExceptionsTests(SimpleTestCase): Raise exception for custom tags used in child with {% load %} tag in parent, not in child """ with self.assertRaises(TemplateSyntaxError): - get_template('exception04') + self.engine.get_template('exception04') @setup({'exception05': '{% block first %}{{ block.super }}{% endblock %}'}) def test_exception05(self): @@ -58,4 +56,4 @@ class ExceptionsTests(SimpleTestCase): Raise exception for block.super used in base template """ with self.assertRaises(TemplateSyntaxError): - render('exception05') + self.engine.render_to_string('exception05') diff --git a/tests/template_tests/syntax_tests/test_extends.py b/tests/template_tests/syntax_tests/test_extends.py index 8d546633ab..3ad19616af 100644 --- a/tests/template_tests/syntax_tests/test_extends.py +++ b/tests/template_tests/syntax_tests/test_extends.py @@ -1,7 +1,6 @@ -from django.template.base import Template from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup inheritance_templates = { @@ -64,7 +63,7 @@ class InheritanceTests(SimpleTestCase): """ Standard template with no inheritance """ - output = render('inheritance01') + output = self.engine.render_to_string('inheritance01') self.assertEqual(output, '1&3_') @setup(inheritance_templates) @@ -72,7 +71,7 @@ class InheritanceTests(SimpleTestCase): """ Standard two-level inheritance """ - output = render('inheritance02') + output = self.engine.render_to_string('inheritance02') self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -80,7 +79,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level with no redefinitions on third level """ - output = render('inheritance03') + output = self.engine.render_to_string('inheritance03') self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -88,7 +87,7 @@ class InheritanceTests(SimpleTestCase): """ Two-level with no redefinitions on second level """ - output = render('inheritance04') + output = self.engine.render_to_string('inheritance04') self.assertEqual(output, '1&3_') @setup(inheritance_templates) @@ -96,7 +95,7 @@ class InheritanceTests(SimpleTestCase): """ Two-level with double quotes instead of single quotes """ - output = render('inheritance05') + output = self.engine.render_to_string('inheritance05') self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -104,7 +103,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level with variable parent-template name """ - output = render('inheritance06', {'foo': 'inheritance02'}) + output = self.engine.render_to_string('inheritance06', {'foo': 'inheritance02'}) self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -112,7 +111,7 @@ class InheritanceTests(SimpleTestCase): """ Two-level with one block defined, one block not defined """ - output = render('inheritance07') + output = self.engine.render_to_string('inheritance07') self.assertEqual(output, '1&35') @setup(inheritance_templates) @@ -121,7 +120,7 @@ class InheritanceTests(SimpleTestCase): Three-level with one block defined on this level, two blocks defined next level """ - output = render('inheritance08') + output = self.engine.render_to_string('inheritance08') self.assertEqual(output, '1235') @setup(inheritance_templates) @@ -129,7 +128,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level with second and third levels blank """ - output = render('inheritance09') + output = self.engine.render_to_string('inheritance09') self.assertEqual(output, '1&3_') @setup(inheritance_templates) @@ -137,7 +136,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level with space NOT in a block -- should be ignored """ - output = render('inheritance10') + output = self.engine.render_to_string('inheritance10') self.assertEqual(output, '1&3_') @setup(inheritance_templates) @@ -146,7 +145,7 @@ class InheritanceTests(SimpleTestCase): Three-level with both blocks defined on this level, but none on second level """ - output = render('inheritance11') + output = self.engine.render_to_string('inheritance11') self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -155,7 +154,7 @@ class InheritanceTests(SimpleTestCase): Three-level with this level providing one and second level providing the other """ - output = render('inheritance12') + output = self.engine.render_to_string('inheritance12') self.assertEqual(output, '1235') @setup(inheritance_templates) @@ -163,7 +162,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level with this level overriding second level """ - output = render('inheritance13') + output = self.engine.render_to_string('inheritance13') self.assertEqual(output, '1a3b') @setup(inheritance_templates) @@ -171,7 +170,7 @@ class InheritanceTests(SimpleTestCase): """ A block defined only in a child template shouldn't be displayed """ - output = render('inheritance14') + output = self.engine.render_to_string('inheritance14') self.assertEqual(output, '1&3_') @setup(inheritance_templates) @@ -179,7 +178,7 @@ class InheritanceTests(SimpleTestCase): """ A block within another block """ - output = render('inheritance15') + output = self.engine.render_to_string('inheritance15') self.assertEqual(output, '12inner3_') @setup(inheritance_templates) @@ -187,7 +186,7 @@ class InheritanceTests(SimpleTestCase): """ A block within another block (level 2) """ - output = render('inheritance16') + output = self.engine.render_to_string('inheritance16') self.assertEqual(output, '12out3_') @setup(inheritance_templates) @@ -195,7 +194,7 @@ class InheritanceTests(SimpleTestCase): """ {% load %} tag (parent -- setup for exception04) """ - output = render('inheritance17') + output = self.engine.render_to_string('inheritance17') self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -203,7 +202,7 @@ class InheritanceTests(SimpleTestCase): """ {% load %} tag (standard usage, without inheritance) """ - output = render('inheritance18') + output = self.engine.render_to_string('inheritance18') self.assertEqual(output, 'this that theother5678') @setup(inheritance_templates) @@ -211,7 +210,7 @@ class InheritanceTests(SimpleTestCase): """ {% load %} tag (within a child template) """ - output = render('inheritance19') + output = self.engine.render_to_string('inheritance19') self.assertEqual(output, '140056783_') @setup(inheritance_templates) @@ -219,7 +218,7 @@ class InheritanceTests(SimpleTestCase): """ Two-level inheritance with {{ block.super }} """ - output = render('inheritance20') + output = self.engine.render_to_string('inheritance20') self.assertEqual(output, '1&a3_') @setup(inheritance_templates) @@ -227,7 +226,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level inheritance with {{ block.super }} from parent """ - output = render('inheritance21') + output = self.engine.render_to_string('inheritance21') self.assertEqual(output, '12a34') @setup(inheritance_templates) @@ -235,7 +234,7 @@ class InheritanceTests(SimpleTestCase): """ Three-level inheritance with {{ block.super }} from grandparent """ - output = render('inheritance22') + output = self.engine.render_to_string('inheritance22') self.assertEqual(output, '1&a3_') @setup(inheritance_templates) @@ -244,7 +243,7 @@ class InheritanceTests(SimpleTestCase): Three-level inheritance with {{ block.super }} from parent and grandparent """ - output = render('inheritance23') + output = self.engine.render_to_string('inheritance23') self.assertEqual(output, '1&ab3_') @setup(inheritance_templates) @@ -252,9 +251,8 @@ class InheritanceTests(SimpleTestCase): """ Inheritance from local context without use of template loader """ - output = render('inheritance24', { - 'context_template': Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}") - }) + context_template = self.engine.from_string("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}") + output = self.engine.render_to_string('inheritance24', {'context_template': context_template}) self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -262,12 +260,11 @@ class InheritanceTests(SimpleTestCase): """ Inheritance from local context with variable parent template """ - output = render('inheritance25', { - 'context_template': [ - Template("Wrong"), - Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"), - ], - }) + context_template = [ + self.engine.from_string("Wrong"), + self.engine.from_string("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"), + ] + output = self.engine.render_to_string('inheritance25', {'context_template': context_template}) self.assertEqual(output, '1234') @setup(inheritance_templates) @@ -275,7 +272,7 @@ class InheritanceTests(SimpleTestCase): """ Set up a base template to extend """ - output = render('inheritance26') + output = self.engine.render_to_string('inheritance26') self.assertEqual(output, 'no tags') @setup(inheritance_templates) @@ -283,7 +280,7 @@ class InheritanceTests(SimpleTestCase): """ Inheritance from a template that doesn't have any blocks """ - output = render('inheritance27') + output = self.engine.render_to_string('inheritance27') self.assertEqual(output, 'no tags') @setup(inheritance_templates) @@ -291,7 +288,7 @@ class InheritanceTests(SimpleTestCase): """ Set up a base template with a space in it. """ - output = render('inheritance 28') + output = self.engine.render_to_string('inheritance 28') self.assertEqual(output, '!') @setup(inheritance_templates) @@ -299,7 +296,7 @@ class InheritanceTests(SimpleTestCase): """ Inheritance from a template with a space in its name should work. """ - output = render('inheritance29') + output = self.engine.render_to_string('inheritance29') self.assertEqual(output, '!') @setup(inheritance_templates) @@ -307,19 +304,19 @@ class InheritanceTests(SimpleTestCase): """ Base template, putting block in a conditional {% if %} tag """ - output = render('inheritance30', {'optional': True}) + output = self.engine.render_to_string('inheritance30', {'optional': True}) self.assertEqual(output, '123') # Inherit from a template with block wrapped in an {% if %} tag # (in parent), still gets overridden @setup(inheritance_templates) def test_inheritance31(self): - output = render('inheritance31', {'optional': True}) + output = self.engine.render_to_string('inheritance31', {'optional': True}) self.assertEqual(output, '1two3') @setup(inheritance_templates) def test_inheritance32(self): - output = render('inheritance32') + output = self.engine.render_to_string('inheritance32') self.assertEqual(output, '13') @setup(inheritance_templates) @@ -327,7 +324,7 @@ class InheritanceTests(SimpleTestCase): """ Base template, putting block in a conditional {% ifequal %} tag """ - output = render('inheritance33', {'optional': 1}) + output = self.engine.render_to_string('inheritance33', {'optional': 1}) self.assertEqual(output, '123') @setup(inheritance_templates) @@ -336,7 +333,7 @@ class InheritanceTests(SimpleTestCase): Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden """ - output = render('inheritance34', {'optional': 1}) + output = self.engine.render_to_string('inheritance34', {'optional': 1}) self.assertEqual(output, '1two3') @setup(inheritance_templates) @@ -345,7 +342,7 @@ class InheritanceTests(SimpleTestCase): Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden """ - output = render('inheritance35', {'optional': 2}) + output = self.engine.render_to_string('inheritance35', {'optional': 2}) self.assertEqual(output, '13') @setup(inheritance_templates) @@ -353,7 +350,7 @@ class InheritanceTests(SimpleTestCase): """ Base template, putting block in a {% for %} tag """ - output = render('inheritance36', {'numbers': '123'}) + output = self.engine.render_to_string('inheritance36', {'numbers': '123'}) self.assertEqual(output, '_1_2_3_') @setup(inheritance_templates) @@ -362,7 +359,7 @@ class InheritanceTests(SimpleTestCase): Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden """ - output = render('inheritance37', {'numbers': '123'}) + output = self.engine.render_to_string('inheritance37', {'numbers': '123'}) self.assertEqual(output, '_X_X_X_') @setup(inheritance_templates) @@ -371,23 +368,23 @@ class InheritanceTests(SimpleTestCase): Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden """ - output = render('inheritance38') + output = self.engine.render_to_string('inheritance38') self.assertEqual(output, '_') # The super block will still be found. @setup(inheritance_templates) def test_inheritance39(self): - output = render('inheritance39', {'optional': True}) + output = self.engine.render_to_string('inheritance39', {'optional': True}) self.assertEqual(output, '1new23') @setup(inheritance_templates) def test_inheritance40(self): - output = render('inheritance40', {'optional': 1}) + output = self.engine.render_to_string('inheritance40', {'optional': 1}) self.assertEqual(output, '1new23') @setup(inheritance_templates) def test_inheritance41(self): - output = render('inheritance41', {'numbers': '123'}) + output = self.engine.render_to_string('inheritance41', {'numbers': '123'}) self.assertEqual(output, '_new1_new2_new3_') @setup(inheritance_templates) @@ -395,5 +392,5 @@ class InheritanceTests(SimpleTestCase): """ Expression starting and ending with a quote """ - output = render('inheritance42') + output = self.engine.render_to_string('inheritance42') self.assertEqual(output, '1234') diff --git a/tests/template_tests/syntax_tests/test_filter_syntax.py b/tests/template_tests/syntax_tests/test_filter_syntax.py index dda222ddc7..4fd62be7c8 100644 --- a/tests/template_tests/syntax_tests/test_filter_syntax.py +++ b/tests/template_tests/syntax_tests/test_filter_syntax.py @@ -2,13 +2,11 @@ from __future__ import unicode_literals import warnings -from django.conf import settings -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase from django.utils.deprecation import RemovedInDjango20Warning -from ..utils import render, setup, SomeClass, SomeOtherException, UTF8Class +from ..utils import setup, SomeClass, SomeOtherException, UTF8Class class FilterSyntaxTests(SimpleTestCase): @@ -18,7 +16,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Basic filter usage """ - output = render('filter-syntax01', {"var": "Django is the greatest!"}) + output = self.engine.render_to_string('filter-syntax01', {"var": "Django is the greatest!"}) self.assertEqual(output, "DJANGO IS THE GREATEST!") @setup({'filter-syntax02': '{{ var|upper|lower }}'}) @@ -26,7 +24,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Chained filters """ - output = render('filter-syntax02', {"var": "Django is the greatest!"}) + output = self.engine.render_to_string('filter-syntax02', {"var": "Django is the greatest!"}) self.assertEqual(output, "django is the greatest!") @setup({'filter-syntax03': '{{ var |upper }}'}) @@ -34,7 +32,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Allow spaces before the filter pipe """ - output = render('filter-syntax03', {'var': 'Django is the greatest!'}) + output = self.engine.render_to_string('filter-syntax03', {'var': 'Django is the greatest!'}) self.assertEqual(output, 'DJANGO IS THE GREATEST!') @setup({'filter-syntax04': '{{ var| upper }}'}) @@ -42,7 +40,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Allow spaces after the filter pipe """ - output = render('filter-syntax04', {'var': 'Django is the greatest!'}) + output = self.engine.render_to_string('filter-syntax04', {'var': 'Django is the greatest!'}) self.assertEqual(output, 'DJANGO IS THE GREATEST!') @setup({'filter-syntax05': '{{ var|does_not_exist }}'}) @@ -51,7 +49,7 @@ class FilterSyntaxTests(SimpleTestCase): Raise TemplateSyntaxError for a nonexistent filter """ with self.assertRaises(TemplateSyntaxError): - get_template('filter-syntax05') + self.engine.get_template('filter-syntax05') @setup({'filter-syntax06': '{{ var|fil(ter) }}'}) def test_filter_syntax06(self): @@ -60,7 +58,7 @@ class FilterSyntaxTests(SimpleTestCase): an illegal character """ with self.assertRaises(TemplateSyntaxError): - get_template('filter-syntax06') + self.engine.get_template('filter-syntax06') @setup({'filter-syntax07': "{% nothing_to_see_here %}"}) def test_filter_syntax07(self): @@ -68,7 +66,7 @@ class FilterSyntaxTests(SimpleTestCase): Raise TemplateSyntaxError for invalid block tags """ with self.assertRaises(TemplateSyntaxError): - get_template('filter-syntax07') + self.engine.get_template('filter-syntax07') @setup({'filter-syntax08': "{% %}"}) def test_filter_syntax08(self): @@ -76,7 +74,7 @@ class FilterSyntaxTests(SimpleTestCase): Raise TemplateSyntaxError for empty block tags """ with self.assertRaises(TemplateSyntaxError): - get_template('filter-syntax08') + self.engine.get_template('filter-syntax08') @setup({'filter-syntax09': '{{ var|removetags:"b i"|upper|lower }}'}) def test_filter_syntax09(self): @@ -85,7 +83,7 @@ class FilterSyntaxTests(SimpleTestCase): """ with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('filter-syntax09', {'var': '<b><i>Yes</i></b>'}) + output = self.engine.render_to_string('filter-syntax09', {'var': '<b><i>Yes</i></b>'}) self.assertEqual(output, 'yes') @setup({'filter-syntax10': r'{{ var|default_if_none:" endquote\" hah" }}'}) @@ -93,7 +91,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Literal string as argument is always "safe" from auto-escaping. """ - output = render('filter-syntax10', {"var": None}) + output = self.engine.render_to_string('filter-syntax10', {"var": None}) self.assertEqual(output, ' endquote" hah') @setup({'filter-syntax11': r'{{ var|default_if_none:var2 }}'}) @@ -101,7 +99,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Variable as argument """ - output = render('filter-syntax11', {"var": None, "var2": "happy"}) + output = self.engine.render_to_string('filter-syntax11', {"var": None, "var2": "happy"}) self.assertEqual(output, 'happy') @setup({'filter-syntax12': r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}'}) @@ -109,7 +107,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Default argument testing """ - output = render('filter-syntax12', {"var": True}) + output = self.engine.render_to_string('filter-syntax12', {"var": True}) self.assertEqual(output, 'yup yes') @setup({'filter-syntax13': r'1{{ var.method3 }}2'}) @@ -118,8 +116,8 @@ class FilterSyntaxTests(SimpleTestCase): Fail silently for methods that raise an exception with a `silent_variable_failure` attribute """ - output = render('filter-syntax13', {"var": SomeClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('filter-syntax13', {"var": SomeClass()}) + if self.engine.string_if_invalid: self.assertEqual(output, "1INVALID2") else: self.assertEqual(output, "12") @@ -131,14 +129,14 @@ class FilterSyntaxTests(SimpleTestCase): `silent_variable_attribute` set to True, the exception propagates """ with self.assertRaises(SomeOtherException): - render('filter-syntax14', {"var": SomeClass()}) + self.engine.render_to_string('filter-syntax14', {"var": SomeClass()}) @setup({'filter-syntax15': r'{{ var|default_if_none:"foo\bar" }}'}) def test_filter_syntax15(self): """ Escaped backslash in argument """ - output = render('filter-syntax15', {"var": None}) + output = self.engine.render_to_string('filter-syntax15', {"var": None}) self.assertEqual(output, r'foo\bar') @setup({'filter-syntax16': r'{{ var|default_if_none:"foo\now" }}'}) @@ -146,7 +144,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Escaped backslash using known escape char """ - output = render('filter-syntax16', {"var": None}) + output = self.engine.render_to_string('filter-syntax16', {"var": None}) self.assertEqual(output, r'foo\now') @setup({'filter-syntax17': r'{{ var|join:"" }}'}) @@ -154,7 +152,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Empty strings can be passed as arguments to filters """ - output = render('filter-syntax17', {'var': ['a', 'b', 'c']}) + output = self.engine.render_to_string('filter-syntax17', {'var': ['a', 'b', 'c']}) self.assertEqual(output, 'abc') @setup({'filter-syntax18': r'{{ var }}'}) @@ -163,7 +161,7 @@ class FilterSyntaxTests(SimpleTestCase): Make sure that any unicode strings are converted to bytestrings in the final output. """ - output = render('filter-syntax18', {'var': UTF8Class()}) + output = self.engine.render_to_string('filter-syntax18', {'var': UTF8Class()}) self.assertEqual(output, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111') @setup({'filter-syntax19': '{{ var|truncatewords:1 }}'}) @@ -171,7 +169,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Numbers as filter arguments should work """ - output = render('filter-syntax19', {"var": "hello world"}) + output = self.engine.render_to_string('filter-syntax19', {"var": "hello world"}) self.assertEqual(output, "hello ...") @setup({'filter-syntax20': '{{ ""|default_if_none:"was none" }}'}) @@ -179,7 +177,7 @@ class FilterSyntaxTests(SimpleTestCase): """ Filters should accept empty string constants """ - output = render('filter-syntax20') + output = self.engine.render_to_string('filter-syntax20') self.assertEqual(output, "") @setup({'filter-syntax21': r'1{{ var.silent_fail_key }}2'}) @@ -188,8 +186,8 @@ class FilterSyntaxTests(SimpleTestCase): Fail silently for non-callable attribute and dict lookups which raise an exception with a "silent_variable_failure" attribute """ - output = render('filter-syntax21', {"var": SomeClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('filter-syntax21', {"var": SomeClass()}) + if self.engine.string_if_invalid: self.assertEqual(output, "1INVALID2") else: self.assertEqual(output, "12") @@ -200,8 +198,8 @@ class FilterSyntaxTests(SimpleTestCase): Fail silently for non-callable attribute and dict lookups which raise an exception with a `silent_variable_failure` attribute """ - output = render('filter-syntax22', {"var": SomeClass()}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('filter-syntax22', {"var": SomeClass()}) + if self.engine.string_if_invalid: self.assertEqual(output, "1INVALID2") else: self.assertEqual(output, "12") @@ -214,7 +212,7 @@ class FilterSyntaxTests(SimpleTestCase): propagates """ with self.assertRaises(SomeOtherException): - render('filter-syntax23', {"var": SomeClass()}) + self.engine.render_to_string('filter-syntax23', {"var": SomeClass()}) @setup({'filter-syntax24': r'1{{ var.noisy_fail_attribute }}2'}) def test_filter_syntax24(self): @@ -224,7 +222,7 @@ class FilterSyntaxTests(SimpleTestCase): propagates """ with self.assertRaises(SomeOtherException): - render('filter-syntax24', {"var": SomeClass()}) + self.engine.render_to_string('filter-syntax24', {"var": SomeClass()}) @setup({'filter-syntax25': '{{ var.attribute_error_attribute }}'}) def test_filter_syntax25(self): @@ -233,4 +231,4 @@ class FilterSyntaxTests(SimpleTestCase): reraised. """ with self.assertRaises(AttributeError): - render('filter-syntax25', {'var': SomeClass()}) + self.engine.render_to_string('filter-syntax25', {'var': SomeClass()}) diff --git a/tests/template_tests/syntax_tests/test_filter_tag.py b/tests/template_tests/syntax_tests/test_filter_tag.py index 8d2e67c692..003140a105 100644 --- a/tests/template_tests/syntax_tests/test_filter_tag.py +++ b/tests/template_tests/syntax_tests/test_filter_tag.py @@ -1,48 +1,47 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class FilterTagTests(SimpleTestCase): @setup({'filter01': '{% filter upper %}{% endfilter %}'}) def test_filter01(self): - output = render('filter01') + output = self.engine.render_to_string('filter01') self.assertEqual(output, '') @setup({'filter02': '{% filter upper %}django{% endfilter %}'}) def test_filter02(self): - output = render('filter02') + output = self.engine.render_to_string('filter02') self.assertEqual(output, 'DJANGO') @setup({'filter03': '{% filter upper|lower %}django{% endfilter %}'}) def test_filter03(self): - output = render('filter03') + output = self.engine.render_to_string('filter03') self.assertEqual(output, 'django') @setup({'filter04': '{% filter cut:remove %}djangospam{% endfilter %}'}) def test_filter04(self): - output = render('filter04', {'remove': 'spam'}) + output = self.engine.render_to_string('filter04', {'remove': 'spam'}) self.assertEqual(output, 'django') @setup({'filter05': '{% filter safe %}fail{% endfilter %}'}) def test_filter05(self): with self.assertRaises(TemplateSyntaxError): - get_template('filter05') + self.engine.get_template('filter05') @setup({'filter05bis': '{% filter upper|safe %}fail{% endfilter %}'}) def test_filter05bis(self): with self.assertRaises(TemplateSyntaxError): - get_template('filter05bis') + self.engine.get_template('filter05bis') @setup({'filter06': '{% filter escape %}fail{% endfilter %}'}) def test_filter06(self): with self.assertRaises(TemplateSyntaxError): - get_template('filter06') + self.engine.get_template('filter06') @setup({'filter06bis': '{% filter upper|escape %}fail{% endfilter %}'}) def test_filter06bis(self): with self.assertRaises(TemplateSyntaxError): - get_template('filter06bis') + self.engine.get_template('filter06bis') diff --git a/tests/template_tests/syntax_tests/test_firstof.py b/tests/template_tests/syntax_tests/test_firstof.py index 3c8291849b..c7c4434446 100644 --- a/tests/template_tests/syntax_tests/test_firstof.py +++ b/tests/template_tests/syntax_tests/test_firstof.py @@ -1,77 +1,76 @@ import warnings -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase from django.utils.deprecation import RemovedInDjango20Warning -from ..utils import render, setup +from ..utils import setup class FirstOfTagTests(SimpleTestCase): @setup({'firstof01': '{% firstof a b c %}'}) def test_firstof01(self): - output = render('firstof01', {'a': 0, 'c': 0, 'b': 0}) + output = self.engine.render_to_string('firstof01', {'a': 0, 'c': 0, 'b': 0}) self.assertEqual(output, '') @setup({'firstof02': '{% firstof a b c %}'}) def test_firstof02(self): - output = render('firstof02', {'a': 1, 'c': 0, 'b': 0}) + output = self.engine.render_to_string('firstof02', {'a': 1, 'c': 0, 'b': 0}) self.assertEqual(output, '1') @setup({'firstof03': '{% firstof a b c %}'}) def test_firstof03(self): - output = render('firstof03', {'a': 0, 'c': 0, 'b': 2}) + output = self.engine.render_to_string('firstof03', {'a': 0, 'c': 0, 'b': 2}) self.assertEqual(output, '2') @setup({'firstof04': '{% firstof a b c %}'}) def test_firstof04(self): - output = render('firstof04', {'a': 0, 'c': 3, 'b': 0}) + output = self.engine.render_to_string('firstof04', {'a': 0, 'c': 3, 'b': 0}) self.assertEqual(output, '3') @setup({'firstof05': '{% firstof a b c %}'}) def test_firstof05(self): - output = render('firstof05', {'a': 1, 'c': 3, 'b': 2}) + output = self.engine.render_to_string('firstof05', {'a': 1, 'c': 3, 'b': 2}) self.assertEqual(output, '1') @setup({'firstof06': '{% firstof a b c %}'}) def test_firstof06(self): - output = render('firstof06', {'c': 3, 'b': 0}) + output = self.engine.render_to_string('firstof06', {'c': 3, 'b': 0}) self.assertEqual(output, '3') @setup({'firstof07': '{% firstof a b "c" %}'}) def test_firstof07(self): - output = render('firstof07', {'a': 0}) + output = self.engine.render_to_string('firstof07', {'a': 0}) self.assertEqual(output, 'c') @setup({'firstof08': '{% firstof a b "c and d" %}'}) def test_firstof08(self): - output = render('firstof08', {'a': 0, 'b': 0}) + output = self.engine.render_to_string('firstof08', {'a': 0, 'b': 0}) self.assertEqual(output, 'c and d') @setup({'firstof09': '{% firstof %}'}) def test_firstof09(self): with self.assertRaises(TemplateSyntaxError): - get_template('firstof09') + self.engine.get_template('firstof09') @setup({'firstof10': '{% firstof a %}'}) def test_firstof10(self): - output = render('firstof10', {'a': '<'}) + output = self.engine.render_to_string('firstof10', {'a': '<'}) self.assertEqual(output, '<') @setup({'firstof11': '{% load firstof from future %}{% firstof a b %}'}) def test_firstof11(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('firstof11', {'a': '<', 'b': '>'}) + output = self.engine.render_to_string('firstof11', {'a': '<', 'b': '>'}) self.assertEqual(output, '<') @setup({'firstof12': '{% load firstof from future %}{% firstof a b %}'}) def test_firstof12(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('firstof12', {'a': '', 'b': '>'}) + output = self.engine.render_to_string('firstof12', {'a': '', 'b': '>'}) self.assertEqual(output, '>') @setup({'firstof13': '{% load firstof from future %}' @@ -79,12 +78,12 @@ class FirstOfTagTests(SimpleTestCase): def test_firstof13(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('firstof13', {'a': '<'}) + output = self.engine.render_to_string('firstof13', {'a': '<'}) self.assertEqual(output, '<') @setup({'firstof14': '{% load firstof from future %}{% firstof a|safe b %}'}) def test_firstof14(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('firstof14', {'a': '<'}) + output = self.engine.render_to_string('firstof14', {'a': '<'}) self.assertEqual(output, '<') diff --git a/tests/template_tests/syntax_tests/test_for.py b/tests/template_tests/syntax_tests/test_for.py index 674ca6015b..156d17d0b1 100644 --- a/tests/template_tests/syntax_tests/test_for.py +++ b/tests/template_tests/syntax_tests/test_for.py @@ -1,122 +1,121 @@ import warnings -from django.conf import settings -from django.template.base import TemplateSyntaxError +from django.template import TemplateSyntaxError from django.test import SimpleTestCase from django.utils.deprecation import RemovedInDjango20Warning -from ..utils import render, setup +from ..utils import setup class ForTagTests(SimpleTestCase): @setup({'for-tag01': '{% for val in values %}{{ val }}{% endfor %}'}) def test_for_tag01(self): - output = render('for-tag01', {'values': [1, 2, 3]}) + output = self.engine.render_to_string('for-tag01', {'values': [1, 2, 3]}) self.assertEqual(output, '123') @setup({'for-tag02': '{% for val in values reversed %}{{ val }}{% endfor %}'}) def test_for_tag02(self): - output = render('for-tag02', {'values': [1, 2, 3]}) + output = self.engine.render_to_string('for-tag02', {'values': [1, 2, 3]}) self.assertEqual(output, '321') @setup({'for-tag-vars01': '{% for val in values %}{{ forloop.counter }}{% endfor %}'}) def test_for_tag_vars01(self): - output = render('for-tag-vars01', {'values': [6, 6, 6]}) + output = self.engine.render_to_string('for-tag-vars01', {'values': [6, 6, 6]}) self.assertEqual(output, '123') @setup({'for-tag-vars02': '{% for val in values %}{{ forloop.counter0 }}{% endfor %}'}) def test_for_tag_vars02(self): - output = render('for-tag-vars02', {'values': [6, 6, 6]}) + output = self.engine.render_to_string('for-tag-vars02', {'values': [6, 6, 6]}) self.assertEqual(output, '012') @setup({'for-tag-vars03': '{% for val in values %}{{ forloop.revcounter }}{% endfor %}'}) def test_for_tag_vars03(self): - output = render('for-tag-vars03', {'values': [6, 6, 6]}) + output = self.engine.render_to_string('for-tag-vars03', {'values': [6, 6, 6]}) self.assertEqual(output, '321') @setup({'for-tag-vars04': '{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}'}) def test_for_tag_vars04(self): - output = render('for-tag-vars04', {'values': [6, 6, 6]}) + output = self.engine.render_to_string('for-tag-vars04', {'values': [6, 6, 6]}) self.assertEqual(output, '210') @setup({'for-tag-vars05': '{% for val in values %}' '{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}'}) def test_for_tag_vars05(self): - output = render('for-tag-vars05', {'values': [6, 6, 6]}) + output = self.engine.render_to_string('for-tag-vars05', {'values': [6, 6, 6]}) self.assertEqual(output, 'fxx') @setup({'for-tag-vars06': '{% for val in values %}' '{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}'}) def test_for_tag_vars06(self): - output = render('for-tag-vars06', {'values': [6, 6, 6]}) + output = self.engine.render_to_string('for-tag-vars06', {'values': [6, 6, 6]}) self.assertEqual(output, 'xxl') @setup({'for-tag-unpack01': '{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack01(self): - output = render('for-tag-unpack01', {'items': (('one', 1), ('two', 2))}) + output = self.engine.render_to_string('for-tag-unpack01', {'items': (('one', 1), ('two', 2))}) self.assertEqual(output, 'one:1/two:2/') @setup({'for-tag-unpack03': '{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack03(self): - output = render('for-tag-unpack03', {'items': (('one', 1), ('two', 2))}) + output = self.engine.render_to_string('for-tag-unpack03', {'items': (('one', 1), ('two', 2))}) self.assertEqual(output, 'one:1/two:2/') @setup({'for-tag-unpack04': '{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack04(self): - output = render('for-tag-unpack04', {'items': (('one', 1), ('two', 2))}) + output = self.engine.render_to_string('for-tag-unpack04', {'items': (('one', 1), ('two', 2))}) self.assertEqual(output, 'one:1/two:2/') @setup({'for-tag-unpack05': '{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack05(self): - output = render('for-tag-unpack05', {'items': (('one', 1), ('two', 2))}) + output = self.engine.render_to_string('for-tag-unpack05', {'items': (('one', 1), ('two', 2))}) self.assertEqual(output, 'one:1/two:2/') @setup({'for-tag-unpack06': '{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack06(self): with self.assertRaises(TemplateSyntaxError): - render('for-tag-unpack06', {'items': (('one', 1), ('two', 2))}) + self.engine.render_to_string('for-tag-unpack06', {'items': (('one', 1), ('two', 2))}) @setup({'for-tag-unpack07': '{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack07(self): with self.assertRaises(TemplateSyntaxError): - render('for-tag-unpack07', {'items': (('one', 1), ('two', 2))}) + self.engine.render_to_string('for-tag-unpack07', {'items': (('one', 1), ('two', 2))}) @setup({'for-tag-unpack08': '{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}'}) def test_for_tag_unpack08(self): with self.assertRaises(TemplateSyntaxError): - render('for-tag-unpack08', {'items': (('one', 1), ('two', 2))}) + self.engine.render_to_string('for-tag-unpack08', {'items': (('one', 1), ('two', 2))}) @setup({'for-tag-unpack09': '{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}'}) def test_for_tag_unpack09(self): """ Ensure that a single loopvar doesn't truncate the list in val. """ - output = render('for-tag-unpack09', {'items': (('one', 1), ('two', 2))}) + output = self.engine.render_to_string('for-tag-unpack09', {'items': (('one', 1), ('two', 2))}) self.assertEqual(output, 'one:1/two:2/') @setup({'for-tag-unpack13': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'}) def test_for_tag_unpack13(self): - output = render('for-tag-unpack13', {'items': (('one', 1, 'carrot'), ('two', 2, 'cheese'))}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('for-tag-unpack13', {'items': (('one', 1, 'carrot'), ('two', 2, 'cheese'))}) + if self.engine.string_if_invalid: self.assertEqual(output, 'one:1,carrot/two:2,cheese/') else: self.assertEqual(output, 'one:1,carrot/two:2,cheese/') @setup({'for-tag-empty01': '{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}'}) def test_for_tag_empty01(self): - output = render('for-tag-empty01', {'values': [1, 2, 3]}) + output = self.engine.render_to_string('for-tag-empty01', {'values': [1, 2, 3]}) self.assertEqual(output, '123') @setup({'for-tag-empty02': '{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}'}) def test_for_tag_empty02(self): - output = render('for-tag-empty02', {'values': []}) + output = self.engine.render_to_string('for-tag-empty02', {'values': []}) self.assertEqual(output, 'values array empty') @setup({'for-tag-empty03': '{% for val in values %}' '{{ val }}{% empty %}values array not found{% endfor %}'}) def test_for_tag_empty03(self): - output = render('for-tag-empty03') + output = self.engine.render_to_string('for-tag-empty03') self.assertEqual(output, 'values array not found') @setup({'for-tag-filter-ws': "{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"}) @@ -124,7 +123,7 @@ class ForTagTests(SimpleTestCase): """ #19882 """ - output = render('for-tag-filter-ws', {'s': 'abc'}) + output = self.engine.render_to_string('for-tag-filter-ws', {'s': 'abc'}) self.assertEqual(output, 'abc') # These tests raise deprecation warnings and will raise an exception @@ -134,7 +133,7 @@ class ForTagTests(SimpleTestCase): def test_for_tag_unpack10(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render( + output = self.engine.render_to_string( 'for-tag-unpack10', {'items': (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ) @@ -144,12 +143,12 @@ class ForTagTests(SimpleTestCase): def test_for_tag_unpack11(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render( + output = self.engine.render_to_string( 'for-tag-unpack11', {'items': (('one', 1), ('two', 2))}, ) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'one:1,INVALID/two:2,INVALID/') else: self.assertEqual(output, 'one:1,/two:2,/') @@ -158,11 +157,11 @@ class ForTagTests(SimpleTestCase): def test_for_tag_unpack12(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render( + output = self.engine.render_to_string( 'for-tag-unpack12', {'items': (('one', 1, 'carrot'), ('two', 2))} ) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'one:1,carrot/two:2,INVALID/') else: self.assertEqual(output, 'one:1,carrot/two:2,/') @@ -171,9 +170,9 @@ class ForTagTests(SimpleTestCase): def test_for_tag_unpack14(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('for-tag-unpack14', {'items': (1, 2)}) + output = self.engine.render_to_string('for-tag-unpack14', {'items': (1, 2)}) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID:INVALID/INVALID:INVALID/') else: self.assertEqual(output, ':/:/') diff --git a/tests/template_tests/syntax_tests/test_i18n.py b/tests/template_tests/syntax_tests/test_i18n.py index da54b68d84..11ca002440 100644 --- a/tests/template_tests/syntax_tests/test_i18n.py +++ b/tests/template_tests/syntax_tests/test_i18n.py @@ -1,11 +1,11 @@ # coding: utf-8 from __future__ import unicode_literals -from django.conf import settings from django.test import SimpleTestCase +from django.utils import translation from django.utils.safestring import mark_safe -from ..utils import render, setup +from ..utils import setup class I18nTagTests(SimpleTestCase): @@ -15,7 +15,7 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a string delimited by ' """ - output = render('i18n01') + output = self.engine.render_to_string('i18n01') self.assertEqual(output, 'xxxyyyxxx') @setup({'i18n02': '{% load i18n %}{% trans "xxxyyyxxx" %}'}) @@ -23,7 +23,7 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a string delimited by " """ - output = render('i18n02') + output = self.engine.render_to_string('i18n02') self.assertEqual(output, 'xxxyyyxxx') @setup({'i18n03': '{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}'}) @@ -31,7 +31,7 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a variable """ - output = render('i18n03', {'anton': b'\xc3\x85'}) + output = self.engine.render_to_string('i18n03', {'anton': b'\xc3\x85'}) self.assertEqual(output, 'Å') @setup({'i18n04': '{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}'}) @@ -39,7 +39,7 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a variable and filter """ - output = render('i18n04', {'anton': b'\xc3\x85'}) + output = self.engine.render_to_string('i18n04', {'anton': b'\xc3\x85'}) self.assertEqual(output, 'å') @setup({'legacyi18n04': '{% load i18n %}' @@ -48,7 +48,7 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a variable and filter """ - output = render('legacyi18n04', {'anton': b'\xc3\x85'}) + output = self.engine.render_to_string('legacyi18n04', {'anton': b'\xc3\x85'}) self.assertEqual(output, 'å') @setup({'i18n05': '{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}'}) @@ -56,7 +56,7 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a string with interpolation """ - output = render('i18n05', {'anton': 'yyy'}) + output = self.engine.render_to_string('i18n05', {'anton': 'yyy'}) self.assertEqual(output, 'xxxyyyxxx') @setup({'i18n06': '{% load i18n %}{% trans "Page not found" %}'}) @@ -64,7 +64,8 @@ class I18nTagTests(SimpleTestCase): """ simple translation of a string to german """ - output = render('i18n06', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n06') self.assertEqual(output, 'Seite nicht gefunden') @setup({'i18n07': '{% load i18n %}' @@ -74,7 +75,7 @@ class I18nTagTests(SimpleTestCase): """ translation of singular form """ - output = render('i18n07', {'number': 1}) + output = self.engine.render_to_string('i18n07', {'number': 1}) self.assertEqual(output, 'singular') @setup({'legacyi18n07': '{% load i18n %}' @@ -84,7 +85,7 @@ class I18nTagTests(SimpleTestCase): """ translation of singular form """ - output = render('legacyi18n07', {'number': 1}) + output = self.engine.render_to_string('legacyi18n07', {'number': 1}) self.assertEqual(output, 'singular') @setup({'i18n08': '{% load i18n %}' @@ -94,7 +95,7 @@ class I18nTagTests(SimpleTestCase): """ translation of plural form """ - output = render('i18n08', {'number': 2}) + output = self.engine.render_to_string('i18n08', {'number': 2}) self.assertEqual(output, '2 plural') @setup({'legacyi18n08': '{% load i18n %}' @@ -104,7 +105,7 @@ class I18nTagTests(SimpleTestCase): """ translation of plural form """ - output = render('legacyi18n08', {'number': 2}) + output = self.engine.render_to_string('legacyi18n08', {'number': 2}) self.assertEqual(output, '2 plural') @setup({'i18n09': '{% load i18n %}{% trans "Page not found" noop %}'}) @@ -112,7 +113,8 @@ class I18nTagTests(SimpleTestCase): """ simple non-translation (only marking) of a string to german """ - output = render('i18n09', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n09') self.assertEqual(output, 'Page not found') @setup({'i18n10': '{{ bool|yesno:_("yes,no,maybe") }}'}) @@ -120,7 +122,8 @@ class I18nTagTests(SimpleTestCase): """ translation of a variable with a translated filter """ - output = render('i18n10', {'bool': True, 'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n10', {'bool': True}) self.assertEqual(output, 'Ja') @setup({'i18n11': '{{ bool|yesno:"ja,nein" }}'}) @@ -128,7 +131,7 @@ class I18nTagTests(SimpleTestCase): """ translation of a variable with a non-translated filter """ - output = render('i18n11', {'bool': True}) + output = self.engine.render_to_string('i18n11', {'bool': True}) self.assertEqual(output, 'ja') @setup({'i18n12': '{% load i18n %}' @@ -138,7 +141,7 @@ class I18nTagTests(SimpleTestCase): """ usage of the get_available_languages tag """ - output = render('i18n12') + output = self.engine.render_to_string('i18n12') self.assertEqual(output, 'de') @setup({'i18n13': '{{ _("Password") }}'}) @@ -146,7 +149,8 @@ class I18nTagTests(SimpleTestCase): """ translation of constant strings """ - output = render('i18n13', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n13') self.assertEqual(output, 'Passwort') @setup({'i18n14': '{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}'}) @@ -154,7 +158,8 @@ class I18nTagTests(SimpleTestCase): """ translation of constant strings """ - output = render('i18n14', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n14') self.assertEqual(output, 'foo Passwort Passwort') @setup({'i18n15': '{{ absent|default:_("Password") }}'}) @@ -162,7 +167,8 @@ class I18nTagTests(SimpleTestCase): """ translation of constant strings """ - output = render('i18n15', {'absent': '', 'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n15', {'absent': ''}) self.assertEqual(output, 'Passwort') @setup({'i18n16': '{{ _("<") }}'}) @@ -170,7 +176,8 @@ class I18nTagTests(SimpleTestCase): """ translation of constant strings """ - output = render('i18n16', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n16') self.assertEqual(output, '<') @setup({'i18n17': '{% load i18n %}' @@ -179,46 +186,46 @@ class I18nTagTests(SimpleTestCase): """ Escaping inside blocktrans and trans works as if it was directly in the template. """ - output = render('i18n17', {'anton': 'α & β'}) + output = self.engine.render_to_string('i18n17', {'anton': 'α & β'}) self.assertEqual(output, 'α & β') @setup({'i18n18': '{% load i18n %}' '{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}'}) def test_i18n18(self): - output = render('i18n18', {'anton': 'α & β'}) + output = self.engine.render_to_string('i18n18', {'anton': 'α & β'}) self.assertEqual(output, 'α & β') @setup({'i18n19': '{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}'}) def test_i18n19(self): - output = render('i18n19', {'andrew': 'a & b'}) + output = self.engine.render_to_string('i18n19', {'andrew': 'a & b'}) self.assertEqual(output, 'a & b') @setup({'i18n20': '{% load i18n %}{% trans andrew %}'}) def test_i18n20(self): - output = render('i18n20', {'andrew': 'a & b'}) + output = self.engine.render_to_string('i18n20', {'andrew': 'a & b'}) self.assertEqual(output, 'a & b') @setup({'i18n21': '{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}'}) def test_i18n21(self): - output = render('i18n21', {'andrew': mark_safe('a & b')}) + output = self.engine.render_to_string('i18n21', {'andrew': mark_safe('a & b')}) self.assertEqual(output, 'a & b') @setup({'i18n22': '{% load i18n %}{% trans andrew %}'}) def test_i18n22(self): - output = render('i18n22', {'andrew': mark_safe('a & b')}) + output = self.engine.render_to_string('i18n22', {'andrew': mark_safe('a & b')}) self.assertEqual(output, 'a & b') @setup({'legacyi18n17': '{% load i18n %}' '{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}'}) def test_legacyi18n17(self): - output = render('legacyi18n17', {'anton': 'α & β'}) + output = self.engine.render_to_string('legacyi18n17', {'anton': 'α & β'}) self.assertEqual(output, 'α & β') @setup({'legacyi18n18': '{% load i18n %}' '{% blocktrans with anton|force_escape as berta %}' '{{ berta }}{% endblocktrans %}'}) def test_legacyi18n18(self): - output = render('legacyi18n18', {'anton': 'α & β'}) + output = self.engine.render_to_string('legacyi18n18', {'anton': 'α & β'}) self.assertEqual(output, 'α & β') @setup({'i18n23': '{% load i18n %}{% trans "Page not found"|capfirst|slice:"6:" %}'}) @@ -226,17 +233,20 @@ class I18nTagTests(SimpleTestCase): """ #5972 - Use filters with the {% trans %} tag """ - output = render('i18n23', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n23') self.assertEqual(output, 'nicht gefunden') @setup({'i18n24': '{% load i18n %}{% trans \'Page not found\'|upper %}'}) def test_i18n24(self): - output = render('i18n24', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n24') self.assertEqual(output, 'SEITE NICHT GEFUNDEN') @setup({'i18n25': '{% load i18n %}{% trans somevar|upper %}'}) def test_i18n25(self): - output = render('i18n25', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n25', {'somevar': 'Page not found'}) self.assertEqual(output, 'SEITE NICHT GEFUNDEN') @setup({'i18n26': '{% load i18n %}' @@ -246,14 +256,14 @@ class I18nTagTests(SimpleTestCase): """ translation of plural form with extra field in singular form (#13568) """ - output = render('i18n26', {'myextra_field': 'test', 'number': 1}) + output = self.engine.render_to_string('i18n26', {'myextra_field': 'test', 'number': 1}) self.assertEqual(output, 'singular test') @setup({'legacyi18n26': '{% load i18n %}' '{% blocktrans with myextra_field as extra_field count number as counter %}' 'singular {{ extra_field }}{% plural %}plural{% endblocktrans %}'}) def test_legacyi18n26(self): - output = render('legacyi18n26', {'myextra_field': 'test', 'number': 1}) + output = self.engine.render_to_string('legacyi18n26', {'myextra_field': 'test', 'number': 1}) self.assertEqual(output, 'singular test') @setup({'i18n27': '{% load i18n %}{% blocktrans count counter=number %}' @@ -263,14 +273,16 @@ class I18nTagTests(SimpleTestCase): """ translation of singular form in russian (#14126) """ - output = render('i18n27', {'number': 1, 'LANGUAGE_CODE': 'ru'}) + with translation.override('ru'): + output = self.engine.render_to_string('i18n27', {'number': 1}) self.assertEqual(output, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442') @setup({'legacyi18n27': '{% load i18n %}' '{% blocktrans count number as counter %}{{ counter }} result' '{% plural %}{{ counter }} results{% endblocktrans %}'}) def test_legacyi18n27(self): - output = render('legacyi18n27', {'number': 1, 'LANGUAGE_CODE': 'ru'}) + with translation.override('ru'): + output = self.engine.render_to_string('legacyi18n27', {'number': 1}) self.assertEqual(output, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442') @setup({'i18n28': '{% load i18n %}' @@ -279,14 +291,14 @@ class I18nTagTests(SimpleTestCase): """ simple translation of multiple variables """ - output = render('i18n28', {'anton': 'α', 'berta': 'β'}) + output = self.engine.render_to_string('i18n28', {'anton': 'α', 'berta': 'β'}) self.assertEqual(output, 'α + β') @setup({'legacyi18n28': '{% load i18n %}' '{% blocktrans with anton as a and berta as b %}' '{{ a }} + {{ b }}{% endblocktrans %}'}) def test_legacyi18n28(self): - output = render('legacyi18n28', {'anton': 'α', 'berta': 'β'}) + output = self.engine.render_to_string('legacyi18n28', {'anton': 'α', 'berta': 'β'}) self.assertEqual(output, 'α + β') # retrieving language information @@ -294,14 +306,14 @@ class I18nTagTests(SimpleTestCase): '{% get_language_info for "de" as l %}' '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'}) def test_i18n28_2(self): - output = render('i18n28_2') + output = self.engine.render_to_string('i18n28_2') self.assertEqual(output, 'de: German/Deutsch bidi=False') @setup({'i18n29': '{% load i18n %}' '{% get_language_info for LANGUAGE_CODE as l %}' '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'}) def test_i18n29(self): - output = render('i18n29', {'LANGUAGE_CODE': 'fi'}) + output = self.engine.render_to_string('i18n29', {'LANGUAGE_CODE': 'fi'}) self.assertEqual(output, 'fi: Finnish/suomi bidi=False') @setup({'i18n30': '{% load i18n %}' @@ -309,7 +321,7 @@ class I18nTagTests(SimpleTestCase): '{% for l in langs %}{{ l.code }}: {{ l.name }}/' '{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}'}) def test_i18n30(self): - output = render('i18n30', {'langcodes': ['it', 'no']}) + output = self.engine.render_to_string('i18n30', {'langcodes': ['it', 'no']}) self.assertEqual(output, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; ') @setup({'i18n31': '{% load i18n %}' @@ -317,7 +329,7 @@ class I18nTagTests(SimpleTestCase): '{% for l in langs %}{{ l.code }}: {{ l.name }}/' '{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}'}) def test_i18n31(self): - output = render('i18n31', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}) + output = self.engine.render_to_string('i18n31', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}) self.assertEqual( output, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; ' @@ -327,38 +339,38 @@ class I18nTagTests(SimpleTestCase): @setup({'i18n32': '{% load i18n %}{{ "hu"|language_name }} ' '{{ "hu"|language_name_local }} {{ "hu"|language_bidi }}'}) def test_i18n32(self): - output = render('i18n32') + output = self.engine.render_to_string('i18n32') self.assertEqual(output, 'Hungarian Magyar False') @setup({'i18n33': '{% load i18n %}' '{{ langcode|language_name }} {{ langcode|language_name_local }} ' '{{ langcode|language_bidi }}'}) def test_i18n33(self): - output = render('i18n33', {'langcode': 'nl'}) + output = self.engine.render_to_string('i18n33', {'langcode': 'nl'}) self.assertEqual(output, 'Dutch Nederlands False') # blocktrans handling of variables which are not in the context. # this should work as if blocktrans was not there (#19915) @setup({'i18n34': '{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}'}) def test_i18n34(self): - output = render('i18n34') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('i18n34') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @setup({'i18n34_2': '{% load i18n %}{% blocktrans with a=\'α\' %}{{ missing }}{% endblocktrans %}'}) def test_i18n34_2(self): - output = render('i18n34_2') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('i18n34_2') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @setup({'i18n34_3': '{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}'}) def test_i18n34_3(self): - output = render('i18n34_3', {'anton': '\xce\xb1'}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('i18n34_3', {'anton': '\xce\xb1'}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -366,20 +378,23 @@ class I18nTagTests(SimpleTestCase): # trans tag with as var @setup({'i18n35': '{% load i18n %}{% trans "Page not found" as page_not_found %}{{ page_not_found }}'}) def test_i18n35(self): - output = render('i18n35', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n35') self.assertEqual(output, 'Seite nicht gefunden') @setup({'i18n36': '{% load i18n %}' '{% trans "Page not found" noop as page_not_found %}{{ page_not_found }}'}) def test_i18n36(self): - output = render('i18n36', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n36') self.assertEqual(output, 'Page not found') @setup({'i18n37': '{% load i18n %}' '{% trans "Page not found" as page_not_found %}' '{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}'}) def test_i18n37(self): - output = render('i18n37', {'LANGUAGE_CODE': 'de'}) + with translation.override('de'): + output = self.engine.render_to_string('i18n37') self.assertEqual(output, 'Error: Seite nicht gefunden') # Test whitespace in filter arguments @@ -387,7 +402,7 @@ class I18nTagTests(SimpleTestCase): '{% get_language_info for "de"|noop:"x y" as l %}' '{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}'}) def test_i18n38(self): - output = render('i18n38') + output = self.engine.render_to_string('i18n38') self.assertEqual(output, 'de: German/Deutsch bidi=False') @setup({'i18n38_2': '{% load i18n custom %}' @@ -395,5 +410,5 @@ class I18nTagTests(SimpleTestCase): '{% for l in langs %}{{ l.code }}: {{ l.name }}/' '{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}'}) def test_i18n38_2(self): - output = render('i18n38_2', {'langcodes': ['it', 'no']}) + output = self.engine.render_to_string('i18n38_2', {'langcodes': ['it', 'no']}) self.assertEqual(output, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; ') diff --git a/tests/template_tests/syntax_tests/test_if.py b/tests/template_tests/syntax_tests/test_if.py index 76135c7308..4ca11fb79d 100644 --- a/tests/template_tests/syntax_tests/test_if.py +++ b/tests/template_tests/syntax_tests/test_if.py @@ -1,256 +1,255 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup, TestObj +from ..utils import setup, TestObj class IfTagTests(SimpleTestCase): @setup({'if-tag01': '{% if foo %}yes{% else %}no{% endif %}'}) def test_if_tag01(self): - output = render('if-tag01', {'foo': True}) + output = self.engine.render_to_string('if-tag01', {'foo': True}) self.assertEqual(output, 'yes') @setup({'if-tag02': '{% if foo %}yes{% else %}no{% endif %}'}) def test_if_tag02(self): - output = render('if-tag02', {'foo': False}) + output = self.engine.render_to_string('if-tag02', {'foo': False}) self.assertEqual(output, 'no') @setup({'if-tag03': '{% if foo %}yes{% else %}no{% endif %}'}) def test_if_tag03(self): - output = render('if-tag03') + output = self.engine.render_to_string('if-tag03') self.assertEqual(output, 'no') @setup({'if-tag04': '{% if foo %}foo{% elif bar %}bar{% endif %}'}) def test_if_tag04(self): - output = render('if-tag04', {'foo': True}) + output = self.engine.render_to_string('if-tag04', {'foo': True}) self.assertEqual(output, 'foo') @setup({'if-tag05': '{% if foo %}foo{% elif bar %}bar{% endif %}'}) def test_if_tag05(self): - output = render('if-tag05', {'bar': True}) + output = self.engine.render_to_string('if-tag05', {'bar': True}) self.assertEqual(output, 'bar') @setup({'if-tag06': '{% if foo %}foo{% elif bar %}bar{% endif %}'}) def test_if_tag06(self): - output = render('if-tag06') + output = self.engine.render_to_string('if-tag06') self.assertEqual(output, '') @setup({'if-tag07': '{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}'}) def test_if_tag07(self): - output = render('if-tag07', {'foo': True}) + output = self.engine.render_to_string('if-tag07', {'foo': True}) self.assertEqual(output, 'foo') @setup({'if-tag08': '{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}'}) def test_if_tag08(self): - output = render('if-tag08', {'bar': True}) + output = self.engine.render_to_string('if-tag08', {'bar': True}) self.assertEqual(output, 'bar') @setup({'if-tag09': '{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}'}) def test_if_tag09(self): - output = render('if-tag09') + output = self.engine.render_to_string('if-tag09') self.assertEqual(output, 'nothing') @setup({'if-tag10': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'}) def test_if_tag10(self): - output = render('if-tag10', {'foo': True}) + output = self.engine.render_to_string('if-tag10', {'foo': True}) self.assertEqual(output, 'foo') @setup({'if-tag11': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'}) def test_if_tag11(self): - output = render('if-tag11', {'bar': True}) + output = self.engine.render_to_string('if-tag11', {'bar': True}) self.assertEqual(output, 'bar') @setup({'if-tag12': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'}) def test_if_tag12(self): - output = render('if-tag12', {'baz': True}) + output = self.engine.render_to_string('if-tag12', {'baz': True}) self.assertEqual(output, 'baz') @setup({'if-tag13': '{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}'}) def test_if_tag13(self): - output = render('if-tag13') + output = self.engine.render_to_string('if-tag13') self.assertEqual(output, 'nothing') # Filters @setup({'if-tag-filter01': '{% if foo|length == 5 %}yes{% else %}no{% endif %}'}) def test_if_tag_filter01(self): - output = render('if-tag-filter01', {'foo': 'abcde'}) + output = self.engine.render_to_string('if-tag-filter01', {'foo': 'abcde'}) self.assertEqual(output, 'yes') @setup({'if-tag-filter02': '{% if foo|upper == \'ABC\' %}yes{% else %}no{% endif %}'}) def test_if_tag_filter02(self): - output = render('if-tag-filter02') + output = self.engine.render_to_string('if-tag-filter02') self.assertEqual(output, 'no') # Equality @setup({'if-tag-eq01': '{% if foo == bar %}yes{% else %}no{% endif %}'}) def test_if_tag_eq01(self): - output = render('if-tag-eq01') + output = self.engine.render_to_string('if-tag-eq01') self.assertEqual(output, 'yes') @setup({'if-tag-eq02': '{% if foo == bar %}yes{% else %}no{% endif %}'}) def test_if_tag_eq02(self): - output = render('if-tag-eq02', {'foo': 1}) + output = self.engine.render_to_string('if-tag-eq02', {'foo': 1}) self.assertEqual(output, 'no') @setup({'if-tag-eq03': '{% if foo == bar %}yes{% else %}no{% endif %}'}) def test_if_tag_eq03(self): - output = render('if-tag-eq03', {'foo': 1, 'bar': 1}) + output = self.engine.render_to_string('if-tag-eq03', {'foo': 1, 'bar': 1}) self.assertEqual(output, 'yes') @setup({'if-tag-eq04': '{% if foo == bar %}yes{% else %}no{% endif %}'}) def test_if_tag_eq04(self): - output = render('if-tag-eq04', {'foo': 1, 'bar': 2}) + output = self.engine.render_to_string('if-tag-eq04', {'foo': 1, 'bar': 2}) self.assertEqual(output, 'no') @setup({'if-tag-eq05': '{% if foo == \'\' %}yes{% else %}no{% endif %}'}) def test_if_tag_eq05(self): - output = render('if-tag-eq05') + output = self.engine.render_to_string('if-tag-eq05') self.assertEqual(output, 'no') # Comparison @setup({'if-tag-gt-01': '{% if 2 > 1 %}yes{% else %}no{% endif %}'}) def test_if_tag_gt_01(self): - output = render('if-tag-gt-01') + output = self.engine.render_to_string('if-tag-gt-01') self.assertEqual(output, 'yes') @setup({'if-tag-gt-02': '{% if 1 > 1 %}yes{% else %}no{% endif %}'}) def test_if_tag_gt_02(self): - output = render('if-tag-gt-02') + output = self.engine.render_to_string('if-tag-gt-02') self.assertEqual(output, 'no') @setup({'if-tag-gte-01': '{% if 1 >= 1 %}yes{% else %}no{% endif %}'}) def test_if_tag_gte_01(self): - output = render('if-tag-gte-01') + output = self.engine.render_to_string('if-tag-gte-01') self.assertEqual(output, 'yes') @setup({'if-tag-gte-02': '{% if 1 >= 2 %}yes{% else %}no{% endif %}'}) def test_if_tag_gte_02(self): - output = render('if-tag-gte-02') + output = self.engine.render_to_string('if-tag-gte-02') self.assertEqual(output, 'no') @setup({'if-tag-lt-01': '{% if 1 < 2 %}yes{% else %}no{% endif %}'}) def test_if_tag_lt_01(self): - output = render('if-tag-lt-01') + output = self.engine.render_to_string('if-tag-lt-01') self.assertEqual(output, 'yes') @setup({'if-tag-lt-02': '{% if 1 < 1 %}yes{% else %}no{% endif %}'}) def test_if_tag_lt_02(self): - output = render('if-tag-lt-02') + output = self.engine.render_to_string('if-tag-lt-02') self.assertEqual(output, 'no') @setup({'if-tag-lte-01': '{% if 1 <= 1 %}yes{% else %}no{% endif %}'}) def test_if_tag_lte_01(self): - output = render('if-tag-lte-01') + output = self.engine.render_to_string('if-tag-lte-01') self.assertEqual(output, 'yes') @setup({'if-tag-lte-02': '{% if 2 <= 1 %}yes{% else %}no{% endif %}'}) def test_if_tag_lte_02(self): - output = render('if-tag-lte-02') + output = self.engine.render_to_string('if-tag-lte-02') self.assertEqual(output, 'no') # Contains @setup({'if-tag-in-01': '{% if 1 in x %}yes{% else %}no{% endif %}'}) def test_if_tag_in_01(self): - output = render('if-tag-in-01', {'x': [1]}) + output = self.engine.render_to_string('if-tag-in-01', {'x': [1]}) self.assertEqual(output, 'yes') @setup({'if-tag-in-02': '{% if 2 in x %}yes{% else %}no{% endif %}'}) def test_if_tag_in_02(self): - output = render('if-tag-in-02', {'x': [1]}) + output = self.engine.render_to_string('if-tag-in-02', {'x': [1]}) self.assertEqual(output, 'no') @setup({'if-tag-not-in-01': '{% if 1 not in x %}yes{% else %}no{% endif %}'}) def test_if_tag_not_in_01(self): - output = render('if-tag-not-in-01', {'x': [1]}) + output = self.engine.render_to_string('if-tag-not-in-01', {'x': [1]}) self.assertEqual(output, 'no') @setup({'if-tag-not-in-02': '{% if 2 not in x %}yes{% else %}no{% endif %}'}) def test_if_tag_not_in_02(self): - output = render('if-tag-not-in-02', {'x': [1]}) + output = self.engine.render_to_string('if-tag-not-in-02', {'x': [1]}) self.assertEqual(output, 'yes') # AND @setup({'if-tag-and01': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and01(self): - output = render('if-tag-and01', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-and01', {'foo': True, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-and02': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and02(self): - output = render('if-tag-and02', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-and02', {'foo': True, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-and03': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and03(self): - output = render('if-tag-and03', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-and03', {'foo': False, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-and04': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and04(self): - output = render('if-tag-and04', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-and04', {'foo': False, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-and05': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and05(self): - output = render('if-tag-and05', {'foo': False}) + output = self.engine.render_to_string('if-tag-and05', {'foo': False}) self.assertEqual(output, 'no') @setup({'if-tag-and06': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and06(self): - output = render('if-tag-and06', {'bar': False}) + output = self.engine.render_to_string('if-tag-and06', {'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-and07': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and07(self): - output = render('if-tag-and07', {'foo': True}) + output = self.engine.render_to_string('if-tag-and07', {'foo': True}) self.assertEqual(output, 'no') @setup({'if-tag-and08': '{% if foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_and08(self): - output = render('if-tag-and08', {'bar': True}) + output = self.engine.render_to_string('if-tag-and08', {'bar': True}) self.assertEqual(output, 'no') # OR @setup({'if-tag-or01': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or01(self): - output = render('if-tag-or01', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-or01', {'foo': True, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-or02': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or02(self): - output = render('if-tag-or02', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-or02', {'foo': True, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-or03': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or03(self): - output = render('if-tag-or03', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-or03', {'foo': False, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-or04': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or04(self): - output = render('if-tag-or04', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-or04', {'foo': False, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-or05': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or05(self): - output = render('if-tag-or05', {'foo': False}) + output = self.engine.render_to_string('if-tag-or05', {'foo': False}) self.assertEqual(output, 'no') @setup({'if-tag-or06': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or06(self): - output = render('if-tag-or06', {'bar': False}) + output = self.engine.render_to_string('if-tag-or06', {'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-or07': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or07(self): - output = render('if-tag-or07', {'foo': True}) + output = self.engine.render_to_string('if-tag-or07', {'foo': True}) self.assertEqual(output, 'yes') @setup({'if-tag-or08': '{% if foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_or08(self): - output = render('if-tag-or08', {'bar': True}) + output = self.engine.render_to_string('if-tag-or08', {'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-or09': '{% if foo or bar or baz %}yes{% else %}no{% endif %}'}) @@ -258,237 +257,237 @@ class IfTagTests(SimpleTestCase): """ multiple ORs """ - output = render('if-tag-or09', {'baz': True}) + output = self.engine.render_to_string('if-tag-or09', {'baz': True}) self.assertEqual(output, 'yes') # NOT @setup({'if-tag-not01': '{% if not foo %}no{% else %}yes{% endif %}'}) def test_if_tag_not01(self): - output = render('if-tag-not01', {'foo': True}) + output = self.engine.render_to_string('if-tag-not01', {'foo': True}) self.assertEqual(output, 'yes') @setup({'if-tag-not02': '{% if not not foo %}no{% else %}yes{% endif %}'}) def test_if_tag_not02(self): - output = render('if-tag-not02', {'foo': True}) + output = self.engine.render_to_string('if-tag-not02', {'foo': True}) self.assertEqual(output, 'no') @setup({'if-tag-not06': '{% if foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not06(self): - output = render('if-tag-not06') + output = self.engine.render_to_string('if-tag-not06') self.assertEqual(output, 'no') @setup({'if-tag-not07': '{% if foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not07(self): - output = render('if-tag-not07', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-not07', {'foo': True, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not08': '{% if foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not08(self): - output = render('if-tag-not08', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-not08', {'foo': True, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-not09': '{% if foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not09(self): - output = render('if-tag-not09', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-not09', {'foo': False, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not10': '{% if foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not10(self): - output = render('if-tag-not10', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-not10', {'foo': False, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-not11': '{% if not foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not11(self): - output = render('if-tag-not11') + output = self.engine.render_to_string('if-tag-not11') self.assertEqual(output, 'no') @setup({'if-tag-not12': '{% if not foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not12(self): - output = render('if-tag-not12', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-not12', {'foo': True, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not13': '{% if not foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not13(self): - output = render('if-tag-not13', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-not13', {'foo': True, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-not14': '{% if not foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not14(self): - output = render('if-tag-not14', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-not14', {'foo': False, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-not15': '{% if not foo and bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not15(self): - output = render('if-tag-not15', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-not15', {'foo': False, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-not16': '{% if foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not16(self): - output = render('if-tag-not16') + output = self.engine.render_to_string('if-tag-not16') self.assertEqual(output, 'yes') @setup({'if-tag-not17': '{% if foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not17(self): - output = render('if-tag-not17', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-not17', {'foo': True, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-not18': '{% if foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not18(self): - output = render('if-tag-not18', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-not18', {'foo': True, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-not19': '{% if foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not19(self): - output = render('if-tag-not19', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-not19', {'foo': False, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not20': '{% if foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not20(self): - output = render('if-tag-not20', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-not20', {'foo': False, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-not21': '{% if not foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not21(self): - output = render('if-tag-not21') + output = self.engine.render_to_string('if-tag-not21') self.assertEqual(output, 'yes') @setup({'if-tag-not22': '{% if not foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not22(self): - output = render('if-tag-not22', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-not22', {'foo': True, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-not23': '{% if not foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not23(self): - output = render('if-tag-not23', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-not23', {'foo': True, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-not24': '{% if not foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not24(self): - output = render('if-tag-not24', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-not24', {'foo': False, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-not25': '{% if not foo or bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not25(self): - output = render('if-tag-not25', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-not25', {'foo': False, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-not26': '{% if not foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not26(self): - output = render('if-tag-not26') + output = self.engine.render_to_string('if-tag-not26') self.assertEqual(output, 'yes') @setup({'if-tag-not27': '{% if not foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not27(self): - output = render('if-tag-not27', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-not27', {'foo': True, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not28': '{% if not foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not28(self): - output = render('if-tag-not28', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-not28', {'foo': True, 'bar': False}) self.assertEqual(output, 'no') @setup({'if-tag-not29': '{% if not foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not29(self): - output = render('if-tag-not29', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-not29', {'foo': False, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not30': '{% if not foo and not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not30(self): - output = render('if-tag-not30', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-not30', {'foo': False, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-not31': '{% if not foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not31(self): - output = render('if-tag-not31') + output = self.engine.render_to_string('if-tag-not31') self.assertEqual(output, 'yes') @setup({'if-tag-not32': '{% if not foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not32(self): - output = render('if-tag-not32', {'foo': True, 'bar': True}) + output = self.engine.render_to_string('if-tag-not32', {'foo': True, 'bar': True}) self.assertEqual(output, 'no') @setup({'if-tag-not33': '{% if not foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not33(self): - output = render('if-tag-not33', {'foo': True, 'bar': False}) + output = self.engine.render_to_string('if-tag-not33', {'foo': True, 'bar': False}) self.assertEqual(output, 'yes') @setup({'if-tag-not34': '{% if not foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not34(self): - output = render('if-tag-not34', {'foo': False, 'bar': True}) + output = self.engine.render_to_string('if-tag-not34', {'foo': False, 'bar': True}) self.assertEqual(output, 'yes') @setup({'if-tag-not35': '{% if not foo or not bar %}yes{% else %}no{% endif %}'}) def test_if_tag_not35(self): - output = render('if-tag-not35', {'foo': False, 'bar': False}) + output = self.engine.render_to_string('if-tag-not35', {'foo': False, 'bar': False}) self.assertEqual(output, 'yes') # Various syntax errors @setup({'if-tag-error01': '{% if %}yes{% endif %}'}) def test_if_tag_error01(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error01') + self.engine.get_template('if-tag-error01') @setup({'if-tag-error02': '{% if foo and %}yes{% else %}no{% endif %}'}) def test_if_tag_error02(self): with self.assertRaises(TemplateSyntaxError): - render('if-tag-error02', {'foo': True}) + self.engine.render_to_string('if-tag-error02', {'foo': True}) @setup({'if-tag-error03': '{% if foo or %}yes{% else %}no{% endif %}'}) def test_if_tag_error03(self): with self.assertRaises(TemplateSyntaxError): - render('if-tag-error03', {'foo': True}) + self.engine.render_to_string('if-tag-error03', {'foo': True}) @setup({'if-tag-error04': '{% if not foo and %}yes{% else %}no{% endif %}'}) def test_if_tag_error04(self): with self.assertRaises(TemplateSyntaxError): - render('if-tag-error04', {'foo': True}) + self.engine.render_to_string('if-tag-error04', {'foo': True}) @setup({'if-tag-error05': '{% if not foo or %}yes{% else %}no{% endif %}'}) def test_if_tag_error05(self): with self.assertRaises(TemplateSyntaxError): - render('if-tag-error05', {'foo': True}) + self.engine.render_to_string('if-tag-error05', {'foo': True}) @setup({'if-tag-error06': '{% if abc def %}yes{% endif %}'}) def test_if_tag_error06(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error06') + self.engine.get_template('if-tag-error06') @setup({'if-tag-error07': '{% if not %}yes{% endif %}'}) def test_if_tag_error07(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error07') + self.engine.get_template('if-tag-error07') @setup({'if-tag-error08': '{% if and %}yes{% endif %}'}) def test_if_tag_error08(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error08') + self.engine.get_template('if-tag-error08') @setup({'if-tag-error09': '{% if or %}yes{% endif %}'}) def test_if_tag_error09(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error09') + self.engine.get_template('if-tag-error09') @setup({'if-tag-error10': '{% if == %}yes{% endif %}'}) def test_if_tag_error10(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error10') + self.engine.get_template('if-tag-error10') @setup({'if-tag-error11': '{% if 1 == %}yes{% endif %}'}) def test_if_tag_error11(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error11') + self.engine.get_template('if-tag-error11') @setup({'if-tag-error12': '{% if a not b %}yes{% endif %}'}) def test_if_tag_error12(self): with self.assertRaises(TemplateSyntaxError): - get_template('if-tag-error12') + self.engine.get_template('if-tag-error12') @setup({'if-tag-shortcircuit01': '{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}'}) def test_if_tag_shortcircuit01(self): """ If evaluations are shortcircuited where possible """ - output = render('if-tag-shortcircuit01', {'x': TestObj()}) + output = self.engine.render_to_string('if-tag-shortcircuit01', {'x': TestObj()}) self.assertEqual(output, 'yes') @setup({'if-tag-shortcircuit02': '{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}'}) @@ -497,7 +496,7 @@ class IfTagTests(SimpleTestCase): The is_bad() function should not be evaluated. If it is, an exception is raised. """ - output = render('if-tag-shortcircuit02', {'x': TestObj()}) + output = self.engine.render_to_string('if-tag-shortcircuit02', {'x': TestObj()}) self.assertEqual(output, 'no') @setup({'if-tag-badarg01': '{% if x|default_if_none:y %}yes{% endif %}'}) @@ -505,20 +504,20 @@ class IfTagTests(SimpleTestCase): """ Non-existent args """ - output = render('if-tag-badarg01') + output = self.engine.render_to_string('if-tag-badarg01') self.assertEqual(output, '') @setup({'if-tag-badarg02': '{% if x|default_if_none:y %}yes{% endif %}'}) def test_if_tag_badarg02(self): - output = render('if-tag-badarg02', {'y': 0}) + output = self.engine.render_to_string('if-tag-badarg02', {'y': 0}) self.assertEqual(output, '') @setup({'if-tag-badarg03': '{% if x|default_if_none:y %}yes{% endif %}'}) def test_if_tag_badarg03(self): - output = render('if-tag-badarg03', {'y': 1}) + output = self.engine.render_to_string('if-tag-badarg03', {'y': 1}) self.assertEqual(output, 'yes') @setup({'if-tag-badarg04': '{% if x|default_if_none:y %}yes{% else %}no{% endif %}'}) def test_if_tag_badarg04(self): - output = render('if-tag-badarg04') + output = self.engine.render_to_string('if-tag-badarg04') self.assertEqual(output, 'no') diff --git a/tests/template_tests/syntax_tests/test_if_changed.py b/tests/template_tests/syntax_tests/test_if_changed.py index 705530d39f..0d94365733 100644 --- a/tests/template_tests/syntax_tests/test_if_changed.py +++ b/tests/template_tests/syntax_tests/test_if_changed.py @@ -1,44 +1,44 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class IfChangedTagTests(SimpleTestCase): @setup({'ifchanged01': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'}) def test_ifchanged01(self): - output = render('ifchanged01', {'num': (1, 2, 3)}) + output = self.engine.render_to_string('ifchanged01', {'num': (1, 2, 3)}) self.assertEqual(output, '123') @setup({'ifchanged02': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'}) def test_ifchanged02(self): - output = render('ifchanged02', {'num': (1, 1, 3)}) + output = self.engine.render_to_string('ifchanged02', {'num': (1, 1, 3)}) self.assertEqual(output, '13') @setup({'ifchanged03': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'}) def test_ifchanged03(self): - output = render('ifchanged03', {'num': (1, 1, 1)}) + output = self.engine.render_to_string('ifchanged03', {'num': (1, 1, 1)}) self.assertEqual(output, '1') @setup({'ifchanged04': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}' '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}' '{% endfor %}{% endfor %}'}) def test_ifchanged04(self): - output = render('ifchanged04', {'num': (1, 2, 3), 'numx': (2, 2, 2)}) + output = self.engine.render_to_string('ifchanged04', {'num': (1, 2, 3), 'numx': (2, 2, 2)}) self.assertEqual(output, '122232') @setup({'ifchanged05': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}' '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}' '{% endfor %}{% endfor %}'}) def test_ifchanged05(self): - output = render('ifchanged05', {'num': (1, 1, 1), 'numx': (1, 2, 3)}) + output = self.engine.render_to_string('ifchanged05', {'num': (1, 1, 1), 'numx': (1, 2, 3)}) self.assertEqual(output, '1123123123') @setup({'ifchanged06': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}' '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}' '{% endfor %}{% endfor %}'}) def test_ifchanged06(self): - output = render('ifchanged06', {'num': (1, 1, 1), 'numx': (2, 2, 2)}) + output = self.engine.render_to_string('ifchanged06', {'num': (1, 1, 1), 'numx': (2, 2, 2)}) self.assertEqual(output, '1222') @setup({'ifchanged07': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}' @@ -46,14 +46,14 @@ class IfChangedTagTests(SimpleTestCase): '{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}' '{% endfor %}{% endfor %}{% endfor %}'}) def test_ifchanged07(self): - output = render('ifchanged07', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}) + output = self.engine.render_to_string('ifchanged07', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}) self.assertEqual(output, '1233323332333') @setup({'ifchanged08': '{% for data in datalist %}{% for c,d in data %}' '{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}' '{% endif %}{% endfor %}{% endfor %}'}) def test_ifchanged08(self): - output = render('ifchanged08', {'datalist': [ + output = self.engine.render_to_string('ifchanged08', {'datalist': [ [(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')] ]}) @@ -65,13 +65,13 @@ class IfChangedTagTests(SimpleTestCase): """ Test one parameter given to ifchanged. """ - output = render('ifchanged-param01', {'num': (1, 2, 3)}) + output = self.engine.render_to_string('ifchanged-param01', {'num': (1, 2, 3)}) self.assertEqual(output, '..1..2..3') @setup({'ifchanged-param02': '{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}' '{{ x }}{% endfor %}{% endfor %}'}) def test_ifchanged_param02(self): - output = render('ifchanged-param02', {'num': (1, 2, 3), 'numx': (5, 6, 7)}) + output = self.engine.render_to_string('ifchanged-param02', {'num': (1, 2, 3), 'numx': (5, 6, 7)}) self.assertEqual(output, '..567..567..567') @setup({'ifchanged-param03': '{% for n in num %}{{ n }}{% for x in numx %}' @@ -81,7 +81,7 @@ class IfChangedTagTests(SimpleTestCase): """ Test multiple parameters to ifchanged. """ - output = render('ifchanged-param03', {'num': (1, 1, 2), 'numx': (5, 6, 6)}) + output = self.engine.render_to_string('ifchanged-param03', {'num': (1, 1, 2), 'numx': (5, 6, 6)}) self.assertEqual(output, '156156256') @setup({'ifchanged-param04': '{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}' @@ -92,7 +92,7 @@ class IfChangedTagTests(SimpleTestCase): Test a date+hour like construct, where the hour of the last day is the same but the date had changed, so print the hour anyway. """ - output = render( + output = self.engine.render_to_string( 'ifchanged-param04', {'days': [{'hours': [1, 2, 3], 'day': 1}, {'hours': [3], 'day': 2}]}, ) @@ -106,7 +106,7 @@ class IfChangedTagTests(SimpleTestCase): Logically the same as above, just written with explicit ifchanged for the day. """ - output = render( + output = self.engine.render_to_string( 'ifchanged-param05', {'days': [{'hours': [1, 2, 3], 'day': 1}, {'hours': [3], 'day': 2}]}, ) @@ -119,28 +119,28 @@ class IfChangedTagTests(SimpleTestCase): """ Test the else clause of ifchanged. """ - output = render('ifchanged-else01', {'ids': [1, 1, 2, 2, 2, 3]}) + output = self.engine.render_to_string('ifchanged-else01', {'ids': [1, 1, 2, 2, 2, 3]}) self.assertEqual(output, '1-first,1-other,2-first,2-other,2-other,3-first,') @setup({'ifchanged-else02': '{% for id in ids %}{{ id }}-' '{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %}' ',{% endfor %}'}) def test_ifchanged_else02(self): - output = render('ifchanged-else02', {'ids': [1, 1, 2, 2, 2, 3]}) + output = self.engine.render_to_string('ifchanged-else02', {'ids': [1, 1, 2, 2, 2, 3]}) self.assertEqual(output, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,') @setup({'ifchanged-else03': '{% for id in ids %}{{ id }}' '{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %}' ',{% endfor %}'}) def test_ifchanged_else03(self): - output = render('ifchanged-else03', {'ids': [1, 1, 2, 2, 2, 3]}) + output = self.engine.render_to_string('ifchanged-else03', {'ids': [1, 1, 2, 2, 2, 3]}) self.assertEqual(output, '1-red,1,2-blue,2,2,3-red,') @setup({'ifchanged-else04': '{% for id in ids %}' '{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}' '{{ forloop.counter }}{% endfor %}'}) def test_ifchanged_else04(self): - output = render('ifchanged-else04', {'ids': [1, 1, 2, 2, 2, 3, 4]}) + output = self.engine.render_to_string('ifchanged-else04', {'ids': [1, 1, 2, 2, 2, 3, 4]}) self.assertEqual(output, '***1*1...2***2*3...4...5***3*6***4*7') @setup({'ifchanged-filter-ws': '{% load custom %}{% for n in num %}' @@ -150,5 +150,5 @@ class IfChangedTagTests(SimpleTestCase): """ Test whitespace in filter arguments """ - output = render('ifchanged-filter-ws', {'num': (1, 2, 3)}) + output = self.engine.render_to_string('ifchanged-filter-ws', {'num': (1, 2, 3)}) self.assertEqual(output, '..1..2..3') diff --git a/tests/template_tests/syntax_tests/test_if_equal.py b/tests/template_tests/syntax_tests/test_if_equal.py index 6aca815e8f..db02b090c0 100644 --- a/tests/template_tests/syntax_tests/test_if_equal.py +++ b/tests/template_tests/syntax_tests/test_if_equal.py @@ -1,196 +1,196 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class IfEqualTagTests(SimpleTestCase): @setup({'ifequal01': '{% ifequal a b %}yes{% endifequal %}'}) def test_ifequal01(self): - output = render('ifequal01', {'a': 1, 'b': 2}) + output = self.engine.render_to_string('ifequal01', {'a': 1, 'b': 2}) self.assertEqual(output, '') @setup({'ifequal02': '{% ifequal a b %}yes{% endifequal %}'}) def test_ifequal02(self): - output = render('ifequal02', {'a': 1, 'b': 1}) + output = self.engine.render_to_string('ifequal02', {'a': 1, 'b': 1}) self.assertEqual(output, 'yes') @setup({'ifequal03': '{% ifequal a b %}yes{% else %}no{% endifequal %}'}) def test_ifequal03(self): - output = render('ifequal03', {'a': 1, 'b': 2}) + output = self.engine.render_to_string('ifequal03', {'a': 1, 'b': 2}) self.assertEqual(output, 'no') @setup({'ifequal04': '{% ifequal a b %}yes{% else %}no{% endifequal %}'}) def test_ifequal04(self): - output = render('ifequal04', {'a': 1, 'b': 1}) + output = self.engine.render_to_string('ifequal04', {'a': 1, 'b': 1}) self.assertEqual(output, 'yes') @setup({'ifequal05': '{% ifequal a \'test\' %}yes{% else %}no{% endifequal %}'}) def test_ifequal05(self): - output = render('ifequal05', {'a': 'test'}) + output = self.engine.render_to_string('ifequal05', {'a': 'test'}) self.assertEqual(output, 'yes') @setup({'ifequal06': '{% ifequal a \'test\' %}yes{% else %}no{% endifequal %}'}) def test_ifequal06(self): - output = render('ifequal06', {'a': 'no'}) + output = self.engine.render_to_string('ifequal06', {'a': 'no'}) self.assertEqual(output, 'no') @setup({'ifequal07': '{% ifequal a "test" %}yes{% else %}no{% endifequal %}'}) def test_ifequal07(self): - output = render('ifequal07', {'a': 'test'}) + output = self.engine.render_to_string('ifequal07', {'a': 'test'}) self.assertEqual(output, 'yes') @setup({'ifequal08': '{% ifequal a "test" %}yes{% else %}no{% endifequal %}'}) def test_ifequal08(self): - output = render('ifequal08', {'a': 'no'}) + output = self.engine.render_to_string('ifequal08', {'a': 'no'}) self.assertEqual(output, 'no') @setup({'ifequal09': '{% ifequal a "test" %}yes{% else %}no{% endifequal %}'}) def test_ifequal09(self): - output = render('ifequal09') + output = self.engine.render_to_string('ifequal09') self.assertEqual(output, 'no') @setup({'ifequal10': '{% ifequal a b %}yes{% else %}no{% endifequal %}'}) def test_ifequal10(self): - output = render('ifequal10') + output = self.engine.render_to_string('ifequal10') self.assertEqual(output, 'yes') # SMART SPLITTING @setup({'ifequal-split01': '{% ifequal a "test man" %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split01(self): - output = render('ifequal-split01') + output = self.engine.render_to_string('ifequal-split01') self.assertEqual(output, 'no') @setup({'ifequal-split02': '{% ifequal a "test man" %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split02(self): - output = render('ifequal-split02', {'a': 'foo'}) + output = self.engine.render_to_string('ifequal-split02', {'a': 'foo'}) self.assertEqual(output, 'no') @setup({'ifequal-split03': '{% ifequal a "test man" %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split03(self): - output = render('ifequal-split03', {'a': 'test man'}) + output = self.engine.render_to_string('ifequal-split03', {'a': 'test man'}) self.assertEqual(output, 'yes') @setup({'ifequal-split04': '{% ifequal a \'test man\' %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split04(self): - output = render('ifequal-split04', {'a': 'test man'}) + output = self.engine.render_to_string('ifequal-split04', {'a': 'test man'}) self.assertEqual(output, 'yes') @setup({'ifequal-split05': '{% ifequal a \'i "love" you\' %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split05(self): - output = render('ifequal-split05', {'a': ''}) + output = self.engine.render_to_string('ifequal-split05', {'a': ''}) self.assertEqual(output, 'no') @setup({'ifequal-split06': '{% ifequal a \'i "love" you\' %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split06(self): - output = render('ifequal-split06', {'a': 'i "love" you'}) + output = self.engine.render_to_string('ifequal-split06', {'a': 'i "love" you'}) self.assertEqual(output, 'yes') @setup({'ifequal-split07': '{% ifequal a \'i "love" you\' %}yes{% else %}no{% endifequal %}'}) def test_ifequal_split07(self): - output = render('ifequal-split07', {'a': 'i love you'}) + output = self.engine.render_to_string('ifequal-split07', {'a': 'i love you'}) self.assertEqual(output, 'no') @setup({'ifequal-split08': r"{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"}) def test_ifequal_split08(self): - output = render('ifequal-split08', {'a': "I'm happy"}) + output = self.engine.render_to_string('ifequal-split08', {'a': "I'm happy"}) self.assertEqual(output, 'yes') @setup({'ifequal-split09': r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"}) def test_ifequal_split09(self): - output = render('ifequal-split09', {'a': 'slash\man'}) + output = self.engine.render_to_string('ifequal-split09', {'a': 'slash\man'}) self.assertEqual(output, 'yes') @setup({'ifequal-split10': r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"}) def test_ifequal_split10(self): - output = render('ifequal-split10', {'a': 'slashman'}) + output = self.engine.render_to_string('ifequal-split10', {'a': 'slashman'}) self.assertEqual(output, 'no') # NUMERIC RESOLUTION @setup({'ifequal-numeric01': '{% ifequal x 5 %}yes{% endifequal %}'}) def test_ifequal_numeric01(self): - output = render('ifequal-numeric01', {'x': '5'}) + output = self.engine.render_to_string('ifequal-numeric01', {'x': '5'}) self.assertEqual(output, '') @setup({'ifequal-numeric02': '{% ifequal x 5 %}yes{% endifequal %}'}) def test_ifequal_numeric02(self): - output = render('ifequal-numeric02', {'x': 5}) + output = self.engine.render_to_string('ifequal-numeric02', {'x': 5}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric03': '{% ifequal x 5.2 %}yes{% endifequal %}'}) def test_ifequal_numeric03(self): - output = render('ifequal-numeric03', {'x': 5}) + output = self.engine.render_to_string('ifequal-numeric03', {'x': 5}) self.assertEqual(output, '') @setup({'ifequal-numeric04': '{% ifequal x 5.2 %}yes{% endifequal %}'}) def test_ifequal_numeric04(self): - output = render('ifequal-numeric04', {'x': 5.2}) + output = self.engine.render_to_string('ifequal-numeric04', {'x': 5.2}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric05': '{% ifequal x 0.2 %}yes{% endifequal %}'}) def test_ifequal_numeric05(self): - output = render('ifequal-numeric05', {'x': 0.2}) + output = self.engine.render_to_string('ifequal-numeric05', {'x': 0.2}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric06': '{% ifequal x .2 %}yes{% endifequal %}'}) def test_ifequal_numeric06(self): - output = render('ifequal-numeric06', {'x': 0.2}) + output = self.engine.render_to_string('ifequal-numeric06', {'x': 0.2}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric07': '{% ifequal x 2. %}yes{% endifequal %}'}) def test_ifequal_numeric07(self): - output = render('ifequal-numeric07', {'x': 2}) + output = self.engine.render_to_string('ifequal-numeric07', {'x': 2}) self.assertEqual(output, '') @setup({'ifequal-numeric08': '{% ifequal x "5" %}yes{% endifequal %}'}) def test_ifequal_numeric08(self): - output = render('ifequal-numeric08', {'x': 5}) + output = self.engine.render_to_string('ifequal-numeric08', {'x': 5}) self.assertEqual(output, '') @setup({'ifequal-numeric09': '{% ifequal x "5" %}yes{% endifequal %}'}) def test_ifequal_numeric09(self): - output = render('ifequal-numeric09', {'x': '5'}) + output = self.engine.render_to_string('ifequal-numeric09', {'x': '5'}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric10': '{% ifequal x -5 %}yes{% endifequal %}'}) def test_ifequal_numeric10(self): - output = render('ifequal-numeric10', {'x': -5}) + output = self.engine.render_to_string('ifequal-numeric10', {'x': -5}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric11': '{% ifequal x -5.2 %}yes{% endifequal %}'}) def test_ifequal_numeric11(self): - output = render('ifequal-numeric11', {'x': -5.2}) + output = self.engine.render_to_string('ifequal-numeric11', {'x': -5.2}) self.assertEqual(output, 'yes') @setup({'ifequal-numeric12': '{% ifequal x +5 %}yes{% endifequal %}'}) def test_ifequal_numeric12(self): - output = render('ifequal-numeric12', {'x': 5}) + output = self.engine.render_to_string('ifequal-numeric12', {'x': 5}) self.assertEqual(output, 'yes') # FILTER EXPRESSIONS AS ARGUMENTS @setup({'ifequal-filter01': '{% ifequal a|upper "A" %}x{% endifequal %}'}) def test_ifequal_filter01(self): - output = render('ifequal-filter01', {'a': 'a'}) + output = self.engine.render_to_string('ifequal-filter01', {'a': 'a'}) self.assertEqual(output, 'x') @setup({'ifequal-filter02': '{% ifequal "A" a|upper %}x{% endifequal %}'}) def test_ifequal_filter02(self): - output = render('ifequal-filter02', {'a': 'a'}) + output = self.engine.render_to_string('ifequal-filter02', {'a': 'a'}) self.assertEqual(output, 'x') @setup({'ifequal-filter03': '{% ifequal a|upper b|upper %}x{% endifequal %}'}) def test_ifequal_filter03(self): - output = render('ifequal-filter03', {'a': 'x', 'b': 'X'}) + output = self.engine.render_to_string('ifequal-filter03', {'a': 'x', 'b': 'X'}) self.assertEqual(output, 'x') @setup({'ifequal-filter04': '{% ifequal x|slice:"1" "a" %}x{% endifequal %}'}) def test_ifequal_filter04(self): - output = render('ifequal-filter04', {'x': 'aaa'}) + output = self.engine.render_to_string('ifequal-filter04', {'x': 'aaa'}) self.assertEqual(output, 'x') @setup({'ifequal-filter05': '{% ifequal x|slice:"1"|upper "A" %}x{% endifequal %}'}) def test_ifequal_filter05(self): - output = render('ifequal-filter05', {'x': 'aaa'}) + output = self.engine.render_to_string('ifequal-filter05', {'x': 'aaa'}) self.assertEqual(output, 'x') @@ -198,20 +198,20 @@ class IfNotEqualTagTests(SimpleTestCase): @setup({'ifnotequal01': '{% ifnotequal a b %}yes{% endifnotequal %}'}) def test_ifnotequal01(self): - output = render('ifnotequal01', {'a': 1, 'b': 2}) + output = self.engine.render_to_string('ifnotequal01', {'a': 1, 'b': 2}) self.assertEqual(output, 'yes') @setup({'ifnotequal02': '{% ifnotequal a b %}yes{% endifnotequal %}'}) def test_ifnotequal02(self): - output = render('ifnotequal02', {'a': 1, 'b': 1}) + output = self.engine.render_to_string('ifnotequal02', {'a': 1, 'b': 1}) self.assertEqual(output, '') @setup({'ifnotequal03': '{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}'}) def test_ifnotequal03(self): - output = render('ifnotequal03', {'a': 1, 'b': 2}) + output = self.engine.render_to_string('ifnotequal03', {'a': 1, 'b': 2}) self.assertEqual(output, 'yes') @setup({'ifnotequal04': '{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}'}) def test_ifnotequal04(self): - output = render('ifnotequal04', {'a': 1, 'b': 1}) + output = self.engine.render_to_string('ifnotequal04', {'a': 1, 'b': 1}) self.assertEqual(output, 'no') diff --git a/tests/template_tests/syntax_tests/test_include.py b/tests/template_tests/syntax_tests/test_include.py index 5b4c3ee8f8..7f3adfd8fe 100644 --- a/tests/template_tests/syntax_tests/test_include.py +++ b/tests/template_tests/syntax_tests/test_include.py @@ -1,10 +1,8 @@ -from django.conf import settings -from django.template.base import Context, TemplateDoesNotExist, TemplateSyntaxError -from django.template.loader import get_template +from django.template import Context, TemplateDoesNotExist, TemplateSyntaxError from django.test import SimpleTestCase from .test_basic import basic_templates -from ..utils import render, setup +from ..utils import setup include_fail_templates = { @@ -17,17 +15,17 @@ class IncludeTagTests(SimpleTestCase): @setup({'include01': '{% include "basic-syntax01" %}'}, basic_templates) def test_include01(self): - output = render('include01') + output = self.engine.render_to_string('include01') self.assertEqual(output, 'something cool') @setup({'include02': '{% include "basic-syntax02" %}'}, basic_templates) def test_include02(self): - output = render('include02', {'headline': 'Included'}) + output = self.engine.render_to_string('include02', {'headline': 'Included'}) self.assertEqual(output, 'Included') @setup({'include03': '{% include template_name %}'}, basic_templates) def test_include03(self): - output = render( + output = self.engine.render_to_string( 'include03', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ) @@ -35,9 +33,9 @@ class IncludeTagTests(SimpleTestCase): @setup({'include04': 'a{% include "nonexistent" %}b'}) def test_include04(self): - template = get_template('include04') + template = self.engine.get_template('include04') - if settings.TEMPLATE_DEBUG: + if self.engine.debug: with self.assertRaises(TemplateDoesNotExist): template.render(Context({})) else: @@ -49,17 +47,17 @@ class IncludeTagTests(SimpleTestCase): 'include06': '{% include "include 05"%}', }) def test_include06(self): - output = render('include06') + output = self.engine.render_to_string('include06') self.assertEqual(output, "template with a space") @setup({'include07': '{% include "basic-syntax02" with headline="Inline" %}'}, basic_templates) def test_include07(self): - output = render('include07', {'headline': 'Included'}) + output = self.engine.render_to_string('include07', {'headline': 'Included'}) self.assertEqual(output, 'Inline') @setup({'include08': '{% include headline with headline="Dynamic" %}'}, basic_templates) def test_include08(self): - output = render('include08', {'headline': 'basic-syntax02'}) + output = self.engine.render_to_string('include08', {'headline': 'basic-syntax02'}) self.assertEqual(output, 'Dynamic') @setup( @@ -69,29 +67,29 @@ class IncludeTagTests(SimpleTestCase): basic_templates, ) def test_include09(self): - output = render('include09', {'first': 'Ul', 'second': 'lU'}) + output = self.engine.render_to_string('include09', {'first': 'Ul', 'second': 'lU'}) self.assertEqual(output, 'Ul--LU --- UL--lU') @setup({'include10': '{% include "basic-syntax03" only %}'}, basic_templates) def test_include10(self): - output = render('include10', {'first': '1'}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('include10', {'first': '1'}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID --- INVALID') else: self.assertEqual(output, ' --- ') @setup({'include11': '{% include "basic-syntax03" only with second=2 %}'}, basic_templates) def test_include11(self): - output = render('include11', {'first': '1'}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('include11', {'first': '1'}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID --- 2') else: self.assertEqual(output, ' --- 2') @setup({'include12': '{% include "basic-syntax03" with first=1 only %}'}, basic_templates) def test_include12(self): - output = render('include12', {'second': '2'}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('include12', {'second': '2'}) + if self.engine.string_if_invalid: self.assertEqual(output, '1 --- INVALID') else: self.assertEqual(output, '1 --- ') @@ -101,8 +99,8 @@ class IncludeTagTests(SimpleTestCase): basic_templates, ) def test_include13(self): - output = render('include13', {'first': '&'}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('include13', {'first': '&'}) + if self.engine.string_if_invalid: self.assertEqual(output, '& --- INVALID') else: self.assertEqual(output, '& --- ') @@ -114,8 +112,8 @@ class IncludeTagTests(SimpleTestCase): basic_templates, ) def test_include14(self): - output = render('include14', {'var1': '&'}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('include14', {'var1': '&'}) + if self.engine.string_if_invalid: self.assertEqual(output, '& --- INVALID') else: self.assertEqual(output, '& --- ') @@ -124,81 +122,81 @@ class IncludeTagTests(SimpleTestCase): @setup({'include-error01': '{% include "basic-syntax01" with %}'}) def test_include_error01(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-error01') + self.engine.get_template('include-error01') @setup({'include-error02': '{% include "basic-syntax01" with "no key" %}'}) def test_include_error02(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-error02') + self.engine.get_template('include-error02') @setup({'include-error03': '{% include "basic-syntax01" with dotted.arg="error" %}'}) def test_include_error03(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-error03') + self.engine.get_template('include-error03') @setup({'include-error04': '{% include "basic-syntax01" something_random %}'}) def test_include_error04(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-error04') + self.engine.get_template('include-error04') @setup({'include-error05': '{% include "basic-syntax01" foo="duplicate" foo="key" %}'}) def test_include_error05(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-error05') + self.engine.get_template('include-error05') @setup({'include-error06': '{% include "basic-syntax01" only only %}'}) def test_include_error06(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-error06') + self.engine.get_template('include-error06') @setup(include_fail_templates) def test_include_fail1(self): with self.assertRaises(RuntimeError): - get_template('include-fail1') + self.engine.get_template('include-fail1') @setup(include_fail_templates) def test_include_fail2(self): with self.assertRaises(TemplateSyntaxError): - get_template('include-fail2') + self.engine.get_template('include-fail2') @setup({'include-error07': '{% include "include-fail1" %}'}, include_fail_templates) def test_include_error07(self): - t = get_template('include-error07') + template = self.engine.get_template('include-error07') - if settings.TEMPLATE_DEBUG: + if self.engine.debug: with self.assertRaises(RuntimeError): - t.render(Context()) + template.render(Context()) else: - self.assertEqual(t.render(Context()), '') + self.assertEqual(template.render(Context()), '') @setup({'include-error08': '{% include "include-fail2" %}'}, include_fail_templates) def test_include_error08(self): - t = get_template('include-error08') + template = self.engine.get_template('include-error08') - if settings.TEMPLATE_DEBUG: + if self.engine.debug: with self.assertRaises(TemplateSyntaxError): - t.render(Context()) + template.render(Context()) else: - self.assertEqual(t.render(Context()), '') + self.assertEqual(template.render(Context()), '') @setup({'include-error09': '{% include failed_include %}'}, include_fail_templates) def test_include_error09(self): - c = Context({'failed_include': 'include-fail1'}) - t = get_template('include-error09') + context = Context({'failed_include': 'include-fail1'}) + template = self.engine.get_template('include-error09') - if settings.TEMPLATE_DEBUG: + if self.engine.debug: with self.assertRaises(RuntimeError): - t.render(c) + template.render(context) else: - self.assertEqual(t.render(c), '') + self.assertEqual(template.render(context), '') @setup({'include-error10': '{% include failed_include %}'}, include_fail_templates) def test_include_error10(self): - c = Context({'failed_include': 'include-fail2'}) - t = get_template('include-error10') + context = Context({'failed_include': 'include-fail2'}) + template = self.engine.get_template('include-error10') - if settings.TEMPLATE_DEBUG: + if self.engine.debug: with self.assertRaises(TemplateSyntaxError): - t.render(c) + template.render(context) else: - self.assertEqual(t.render(c), '') + self.assertEqual(template.render(context), '') diff --git a/tests/template_tests/syntax_tests/test_invalid_string.py b/tests/template_tests/syntax_tests/test_invalid_string.py index f56b091389..2bb8c71fd1 100644 --- a/tests/template_tests/syntax_tests/test_invalid_string.py +++ b/tests/template_tests/syntax_tests/test_invalid_string.py @@ -1,62 +1,61 @@ -from django.conf import settings from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class InvalidStringTests(SimpleTestCase): @setup({'invalidstr01': '{{ var|default:"Foo" }}'}) def test_invalidstr01(self): - output = render('invalidstr01') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('invalidstr01') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, 'Foo') @setup({'invalidstr02': '{{ var|default_if_none:"Foo" }}'}) def test_invalidstr02(self): - output = render('invalidstr02') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('invalidstr02') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @setup({'invalidstr03': '{% for v in var %}({{ v }}){% endfor %}'}) def test_invalidstr03(self): - output = render('invalidstr03') + output = self.engine.render_to_string('invalidstr03') self.assertEqual(output, '') @setup({'invalidstr04': '{% if var %}Yes{% else %}No{% endif %}'}) def test_invalidstr04(self): - output = render('invalidstr04') + output = self.engine.render_to_string('invalidstr04') self.assertEqual(output, 'No') @setup({'invalidstr04_2': '{% if var|default:"Foo" %}Yes{% else %}No{% endif %}'}) def test_invalidstr04_2(self): - output = render('invalidstr04_2') + output = self.engine.render_to_string('invalidstr04_2') self.assertEqual(output, 'Yes') @setup({'invalidstr05': '{{ var }}'}) def test_invalidstr05(self): - output = render('invalidstr05') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('invalidstr05') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @setup({'invalidstr06': '{{ var.prop }}'}) def test_invalidstr06(self): - output = render('invalidstr06') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('invalidstr06') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @setup({'invalidstr07': '{% load i18n %}{% blocktrans %}{{ var }}{% endblocktrans %}'}) def test_invalidstr07(self): - output = render('invalidstr07') - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('invalidstr07') + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') diff --git a/tests/template_tests/syntax_tests/test_list_index.py b/tests/template_tests/syntax_tests/test_list_index.py index 5d7319651b..d1be0cb1a4 100644 --- a/tests/template_tests/syntax_tests/test_list_index.py +++ b/tests/template_tests/syntax_tests/test_list_index.py @@ -1,7 +1,6 @@ -from django.conf import settings from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class ListIndexTests(SimpleTestCase): @@ -12,7 +11,7 @@ class ListIndexTests(SimpleTestCase): List-index syntax allows a template to access a certain item of a subscriptable object. """ - output = render('list-index01', {'var': ['first item', 'second item']}) + output = self.engine.render_to_string('list-index01', {'var': ['first item', 'second item']}) self.assertEqual(output, 'second item') @setup({'list-index02': '{{ var.5 }}'}) @@ -20,8 +19,8 @@ class ListIndexTests(SimpleTestCase): """ Fail silently when the list index is out of range. """ - output = render('list-index02', {'var': ['first item', 'second item']}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('list-index02', {'var': ['first item', 'second item']}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -31,8 +30,8 @@ class ListIndexTests(SimpleTestCase): """ Fail silently when the list index is out of range. """ - output = render('list-index03', {'var': None}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('list-index03', {'var': None}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -42,8 +41,8 @@ class ListIndexTests(SimpleTestCase): """ Fail silently when variable is a dict without the specified key. """ - output = render('list-index04', {'var': {}}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('list-index04', {'var': {}}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') @@ -53,7 +52,7 @@ class ListIndexTests(SimpleTestCase): """ Dictionary lookup wins out when dict's key is a string. """ - output = render('list-index05', {'var': {'1': "hello"}}) + output = self.engine.render_to_string('list-index05', {'var': {'1': "hello"}}) self.assertEqual(output, 'hello') @setup({'list-index06': '{{ var.1 }}'}) @@ -63,7 +62,7 @@ class ListIndexTests(SimpleTestCase): behind the scenes is really a dictionary lookup (for a dict) after converting the key to an int. """ - output = render('list-index06', {"var": {1: "hello"}}) + output = self.engine.render_to_string('list-index06', {"var": {1: "hello"}}) self.assertEqual(output, 'hello') @setup({'list-index07': '{{ var.1 }}'}) @@ -72,5 +71,5 @@ class ListIndexTests(SimpleTestCase): Dictionary lookup wins out when there is a string and int version of the key. """ - output = render('list-index07', {"var": {'1': "hello", 1: "world"}}) + output = self.engine.render_to_string('list-index07', {"var": {'1': "hello", 1: "world"}}) self.assertEqual(output, 'hello') diff --git a/tests/template_tests/syntax_tests/test_load.py b/tests/template_tests/syntax_tests/test_load.py index 96c657582b..711a9da632 100644 --- a/tests/template_tests/syntax_tests/test_load.py +++ b/tests/template_tests/syntax_tests/test_load.py @@ -1,72 +1,71 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class LoadTagTests(SimpleTestCase): @setup({'load01': '{% load testtags subpackage.echo %}{% echo test %} {% echo2 "test" %}'}) def test_load01(self): - output = render('load01') + output = self.engine.render_to_string('load01') self.assertEqual(output, 'test test') @setup({'load02': '{% load subpackage.echo %}{% echo2 "test" %}'}) def test_load02(self): - output = render('load02') + output = self.engine.render_to_string('load02') self.assertEqual(output, 'test') # {% load %} tag, importing individual tags @setup({'load03': '{% load echo from testtags %}{% echo this that theother %}'}) def test_load03(self): - output = render('load03') + output = self.engine.render_to_string('load03') self.assertEqual(output, 'this that theother') @setup({'load04': '{% load echo other_echo from testtags %}' '{% echo this that theother %} {% other_echo and another thing %}'}) def test_load04(self): - output = render('load04') + output = self.engine.render_to_string('load04') self.assertEqual(output, 'this that theother and another thing') @setup({'load05': '{% load echo upper from testtags %}' '{% echo this that theother %} {{ statement|upper }}'}) def test_load05(self): - output = render('load05', {'statement': 'not shouting'}) + output = self.engine.render_to_string('load05', {'statement': 'not shouting'}) self.assertEqual(output, 'this that theother NOT SHOUTING') @setup({'load06': '{% load echo2 from subpackage.echo %}{% echo2 "test" %}'}) def test_load06(self): - output = render('load06') + output = self.engine.render_to_string('load06') self.assertEqual(output, 'test') # {% load %} tag errors @setup({'load07': '{% load echo other_echo bad_tag from testtags %}'}) def test_load07(self): with self.assertRaises(TemplateSyntaxError): - get_template('load07') + self.engine.get_template('load07') @setup({'load08': '{% load echo other_echo bad_tag from %}'}) def test_load08(self): with self.assertRaises(TemplateSyntaxError): - get_template('load08') + self.engine.get_template('load08') @setup({'load09': '{% load from testtags %}'}) def test_load09(self): with self.assertRaises(TemplateSyntaxError): - get_template('load09') + self.engine.get_template('load09') @setup({'load10': '{% load echo from bad_library %}'}) def test_load10(self): with self.assertRaises(TemplateSyntaxError): - get_template('load10') + self.engine.get_template('load10') @setup({'load11': '{% load subpackage.echo_invalid %}'}) def test_load11(self): with self.assertRaises(TemplateSyntaxError): - get_template('load11') + self.engine.get_template('load11') @setup({'load12': '{% load subpackage.missing %}'}) def test_load12(self): with self.assertRaises(TemplateSyntaxError): - get_template('load12') + self.engine.get_template('load12') diff --git a/tests/template_tests/syntax_tests/test_lorem.py b/tests/template_tests/syntax_tests/test_lorem.py index 339163ea8d..9963bbd026 100644 --- a/tests/template_tests/syntax_tests/test_lorem.py +++ b/tests/template_tests/syntax_tests/test_lorem.py @@ -1,11 +1,11 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class LoremTagTests(SimpleTestCase): @setup({'lorem1': '{% lorem 3 w %}'}) def test_lorem1(self): - output = render('lorem1') + output = self.engine.render_to_string('lorem1') self.assertEqual(output, 'lorem ipsum dolor') diff --git a/tests/template_tests/syntax_tests/test_multiline.py b/tests/template_tests/syntax_tests/test_multiline.py index 23a0a2f253..b2371f7fd1 100644 --- a/tests/template_tests/syntax_tests/test_multiline.py +++ b/tests/template_tests/syntax_tests/test_multiline.py @@ -1,6 +1,6 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup multiline_string = """ @@ -17,5 +17,5 @@ class MultilineTests(SimpleTestCase): @setup({'multiline01': multiline_string}) def test_multiline01(self): - output = render('multiline01') + output = self.engine.render_to_string('multiline01') self.assertEqual(output, multiline_string) diff --git a/tests/template_tests/syntax_tests/test_named_endblock.py b/tests/template_tests/syntax_tests/test_named_endblock.py index a83ea390f7..73a66a34d0 100644 --- a/tests/template_tests/syntax_tests/test_named_endblock.py +++ b/tests/template_tests/syntax_tests/test_named_endblock.py @@ -1,8 +1,7 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class NamedEndblockTests(SimpleTestCase): @@ -10,7 +9,7 @@ class NamedEndblockTests(SimpleTestCase): @setup({'namedendblocks01': '1{% block first %}_{% block second %}' '2{% endblock second %}_{% endblock first %}3'}) def test_namedendblocks01(self): - output = render('namedendblocks01') + output = self.engine.render_to_string('namedendblocks01') self.assertEqual(output, '1_2_3') # Unbalanced blocks @@ -18,24 +17,24 @@ class NamedEndblockTests(SimpleTestCase): '2{% endblock first %}_{% endblock second %}3'}) def test_namedendblocks02(self): with self.assertRaises(TemplateSyntaxError): - get_template('namedendblocks02') + self.engine.get_template('namedendblocks02') @setup({'namedendblocks03': '1{% block first %}_{% block second %}' '2{% endblock %}_{% endblock second %}3'}) def test_namedendblocks03(self): with self.assertRaises(TemplateSyntaxError): - get_template('namedendblocks03') + self.engine.get_template('namedendblocks03') @setup({'namedendblocks04': '1{% block first %}_{% block second %}' '2{% endblock second %}_{% endblock third %}3'}) def test_namedendblocks04(self): with self.assertRaises(TemplateSyntaxError): - get_template('namedendblocks04') + self.engine.get_template('namedendblocks04') @setup({'namedendblocks05': '1{% block first %}_{% block second %}2{% endblock first %}'}) def test_namedendblocks05(self): with self.assertRaises(TemplateSyntaxError): - get_template('namedendblocks05') + self.engine.get_template('namedendblocks05') # Mixed named and unnamed endblocks @setup({'namedendblocks06': '1{% block first %}_{% block second %}' @@ -44,11 +43,11 @@ class NamedEndblockTests(SimpleTestCase): """ Mixed named and unnamed endblocks """ - output = render('namedendblocks06') + output = self.engine.render_to_string('namedendblocks06') self.assertEqual(output, '1_2_3') @setup({'namedendblocks07': '1{% block first %}_{% block second %}' '2{% endblock second %}_{% endblock %}3'}) def test_namedendblocks07(self): - output = render('namedendblocks07') + output = self.engine.render_to_string('namedendblocks07') self.assertEqual(output, '1_2_3') diff --git a/tests/template_tests/syntax_tests/test_now.py b/tests/template_tests/syntax_tests/test_now.py index 82c4bc1c4d..54cd4ccd2e 100644 --- a/tests/template_tests/syntax_tests/test_now.py +++ b/tests/template_tests/syntax_tests/test_now.py @@ -3,7 +3,7 @@ from datetime import datetime from django.test import SimpleTestCase from django.utils.formats import date_format -from ..utils import render, setup +from ..utils import setup class NowTagTests(SimpleTestCase): @@ -13,7 +13,7 @@ class NowTagTests(SimpleTestCase): """ Simple case """ - output = render('now01') + output = self.engine.render_to_string('now01') self.assertEqual(output, "%d %d %d" % ( datetime.now().day, datetime.now().month, datetime.now().year, )) @@ -21,7 +21,7 @@ class NowTagTests(SimpleTestCase): # Check parsing of locale strings @setup({'now02': '{% now "DATE_FORMAT" %}'}) def test_now02(self): - output = render('now02') + output = self.engine.render_to_string('now02') self.assertEqual(output, date_format(datetime.now())) @setup({'now03': '{% now \'j n Y\' %}'}) @@ -29,33 +29,33 @@ class NowTagTests(SimpleTestCase): """ #15092 - Also accept simple quotes """ - output = render('now03') + output = self.engine.render_to_string('now03') self.assertEqual(output, "%d %d %d" % ( datetime.now().day, datetime.now().month, datetime.now().year, )) @setup({'now04': '{% now \'DATE_FORMAT\' %}'}) def test_now04(self): - output = render('now04') + output = self.engine.render_to_string('now04') self.assertEqual(output, date_format(datetime.now())) @setup({'now05': '{% now \'j "n" Y\'%}'}) def test_now05(self): - output = render('now05') + output = self.engine.render_to_string('now05') self.assertEqual(output, '%d "%d" %d' % ( datetime.now().day, datetime.now().month, datetime.now().year, )) @setup({'now06': '{% now "j \'n\' Y"%}'}) def test_now06(self): - output = render('now06') + output = self.engine.render_to_string('now06') self.assertEqual(output, "%d '%d' %d" % ( datetime.now().day, datetime.now().month, datetime.now().year, )) @setup({'now07': '{% now "j n Y" as N %}-{{N}}-'}) def test_now07(self): - output = render('now07') + output = self.engine.render_to_string('now07') self.assertEqual(output, '-%d %d %d-' % ( datetime.now().day, datetime.now().month, datetime.now().year, )) diff --git a/tests/template_tests/syntax_tests/test_numpy.py b/tests/template_tests/syntax_tests/test_numpy.py index 8425d8ecc0..dd6c01f976 100644 --- a/tests/template_tests/syntax_tests/test_numpy.py +++ b/tests/template_tests/syntax_tests/test_numpy.py @@ -1,10 +1,9 @@ from unittest import skipIf import warnings -from django.conf import settings from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup try: import numpy @@ -28,7 +27,7 @@ class NumpyTests(SimpleTestCase): Numpy's array-index syntax allows a template to access a certain item of a subscriptable object. """ - output = render( + output = self.engine.render_to_string( 'numpy-array-index01', {'var': numpy.array(["first item", "second item"])}, ) @@ -39,11 +38,11 @@ class NumpyTests(SimpleTestCase): """ Fail silently when the array index is out of range. """ - output = render( + output = self.engine.render_to_string( 'numpy-array-index02', {'var': numpy.array(["first item", "second item"])}, ) - if settings.TEMPLATE_STRING_IF_INVALID: + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID') else: self.assertEqual(output, '') diff --git a/tests/template_tests/syntax_tests/test_regroup.py b/tests/template_tests/syntax_tests/test_regroup.py index cd06420c50..d747c016f8 100644 --- a/tests/template_tests/syntax_tests/test_regroup.py +++ b/tests/template_tests/syntax_tests/test_regroup.py @@ -1,10 +1,9 @@ from datetime import date -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class RegroupTagTests(SimpleTestCase): @@ -18,7 +17,7 @@ class RegroupTagTests(SimpleTestCase): '{% endfor %},' '{% endfor %}'}) def test_regroup01(self): - output = render('regroup01', { + output = self.engine.render_to_string('regroup01', { 'data': [{'foo': 'c', 'bar': 1}, {'foo': 'd', 'bar': 1}, {'foo': 'a', 'bar': 2}, @@ -39,7 +38,7 @@ class RegroupTagTests(SimpleTestCase): """ Test for silent failure when target variable isn't found """ - output = render('regroup02', {}) + output = self.engine.render_to_string('regroup02', {}) self.assertEqual(output, '') @setup({'regroup03': '' @@ -55,7 +54,7 @@ class RegroupTagTests(SimpleTestCase): Regression tests for #17675 The date template filter has expects_localtime = True """ - output = render('regroup03', { + output = self.engine.render_to_string('regroup03', { 'data': [{'at': date(2012, 2, 14)}, {'at': date(2012, 2, 28)}, {'at': date(2012, 7, 4)}], @@ -74,7 +73,7 @@ class RegroupTagTests(SimpleTestCase): """ The join template filter has needs_autoescape = True """ - output = render('regroup04', { + output = self.engine.render_to_string('regroup04', { 'data': [{'foo': 'x', 'bar': ['ab', 'c']}, {'foo': 'y', 'bar': ['a', 'bc']}, {'foo': 'z', 'bar': ['a', 'd']}], @@ -85,19 +84,19 @@ class RegroupTagTests(SimpleTestCase): @setup({'regroup05': '{% regroup data by bar as %}'}) def test_regroup05(self): with self.assertRaises(TemplateSyntaxError): - get_template('regroup05') + self.engine.get_template('regroup05') @setup({'regroup06': '{% regroup data by bar thisaintright grouped %}'}) def test_regroup06(self): with self.assertRaises(TemplateSyntaxError): - get_template('regroup06') + self.engine.get_template('regroup06') @setup({'regroup07': '{% regroup data thisaintright bar as grouped %}'}) def test_regroup07(self): with self.assertRaises(TemplateSyntaxError): - get_template('regroup07') + self.engine.get_template('regroup07') @setup({'regroup08': '{% regroup data by bar as grouped toomanyargs %}'}) def test_regroup08(self): with self.assertRaises(TemplateSyntaxError): - get_template('regroup08') + self.engine.get_template('regroup08') diff --git a/tests/template_tests/syntax_tests/test_setup.py b/tests/template_tests/syntax_tests/test_setup.py index fd7355a738..07377cea3f 100644 --- a/tests/template_tests/syntax_tests/test_setup.py +++ b/tests/template_tests/syntax_tests/test_setup.py @@ -1,4 +1,3 @@ -from django.conf import settings from django.test import SimpleTestCase from ..utils import setup @@ -15,8 +14,8 @@ class SetupTests(SimpleTestCase): @setup({}) def method(self): cases.append([ - settings.TEMPLATE_STRING_IF_INVALID, - settings.TEMPLATE_DEBUG, + self.engine.string_if_invalid, + self.engine.debug, ]) method(self) diff --git a/tests/template_tests/syntax_tests/test_simple_tag.py b/tests/template_tests/syntax_tests/test_simple_tag.py index 79c43f88c9..b89af4c72b 100644 --- a/tests/template_tests/syntax_tests/test_simple_tag.py +++ b/tests/template_tests/syntax_tests/test_simple_tag.py @@ -1,23 +1,22 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class SimpleTagTests(SimpleTestCase): @setup({'simpletag-renamed01': '{% load custom %}{% minusone 7 %}'}) def test_simpletag_renamed01(self): - output = render('simpletag-renamed01') + output = self.engine.render_to_string('simpletag-renamed01') self.assertEqual(output, '6') @setup({'simpletag-renamed02': '{% load custom %}{% minustwo 7 %}'}) def test_simpletag_renamed02(self): - output = render('simpletag-renamed02') + output = self.engine.render_to_string('simpletag-renamed02') self.assertEqual(output, '5') @setup({'simpletag-renamed03': '{% load custom %}{% minustwo_overridden_name 7 %}'}) def test_simpletag_renamed03(self): with self.assertRaises(TemplateSyntaxError): - get_template('simpletag-renamed03') + self.engine.get_template('simpletag-renamed03') diff --git a/tests/template_tests/syntax_tests/test_spaceless.py b/tests/template_tests/syntax_tests/test_spaceless.py index 18bda09c83..398b7919a1 100644 --- a/tests/template_tests/syntax_tests/test_spaceless.py +++ b/tests/template_tests/syntax_tests/test_spaceless.py @@ -1,38 +1,38 @@ from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class SpacelessTagTests(SimpleTestCase): @setup({'spaceless01': "{% spaceless %} <b> <i> text </i> </b> {% endspaceless %}"}) def test_spaceless01(self): - output = render('spaceless01') + output = self.engine.render_to_string('spaceless01') self.assertEqual(output, "<b><i> text </i></b>") @setup({'spaceless02': "{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"}) def test_spaceless02(self): - output = render('spaceless02') + output = self.engine.render_to_string('spaceless02') self.assertEqual(output, "<b><i> text </i></b>") @setup({'spaceless03': "{% spaceless %}<b><i>text</i></b>{% endspaceless %}"}) def test_spaceless03(self): - output = render('spaceless03') + output = self.engine.render_to_string('spaceless03') self.assertEqual(output, "<b><i>text</i></b>") @setup({'spaceless04': "{% spaceless %}<b> <i>{{ text }}</i> </b>{% endspaceless %}"}) def test_spaceless04(self): - output = render('spaceless04', {'text': 'This & that'}) + output = self.engine.render_to_string('spaceless04', {'text': 'This & that'}) self.assertEqual(output, "<b><i>This & that</i></b>") @setup({'spaceless05': "{% autoescape off %}{% spaceless %}" "<b> <i>{{ text }}</i> </b>{% endspaceless %}" "{% endautoescape %}"}) def test_spaceless05(self): - output = render('spaceless05', {'text': 'This & that'}) + output = self.engine.render_to_string('spaceless05', {'text': 'This & that'}) self.assertEqual(output, "<b><i>This & that</i></b>") @setup({'spaceless06': "{% spaceless %}<b> <i>{{ text|safe }}</i> </b>{% endspaceless %}"}) def test_spaceless06(self): - output = render('spaceless06', {'text': 'This & that'}) + output = self.engine.render_to_string('spaceless06', {'text': 'This & that'}) self.assertEqual(output, "<b><i>This & that</i></b>") diff --git a/tests/template_tests/syntax_tests/test_ssi.py b/tests/template_tests/syntax_tests/test_ssi.py index caa1901943..c5e89b0d2f 100644 --- a/tests/template_tests/syntax_tests/test_ssi.py +++ b/tests/template_tests/syntax_tests/test_ssi.py @@ -1,40 +1,34 @@ import os import warnings -from django.test import override_settings, SimpleTestCase -from django.utils._os import upath +from django.test import SimpleTestCase from django.utils.deprecation import RemovedInDjango19Warning -from ..utils import render, setup +from ..utils import ROOT, setup -cwd = os.path.dirname(os.path.abspath(upath(__file__))) -root = os.path.abspath(os.path.join(cwd, "..")) - - -@override_settings(ALLOWED_INCLUDE_ROOTS=(root)) class SsiTagTests(SimpleTestCase): # Test normal behavior @setup({'ssi01': '{%% ssi "%s" %%}' % os.path.join( - root, 'templates', 'ssi_include.html', + ROOT, 'templates', 'ssi_include.html', )}) def test_ssi01(self): - output = render('ssi01') + output = self.engine.render_to_string('ssi01') self.assertEqual(output, 'This is for testing an ssi include. {{ test }}\n') @setup({'ssi02': '{%% ssi "%s" %%}' % os.path.join( - root, 'not_here', + ROOT, 'not_here', )}) def test_ssi02(self): - output = render('ssi02') + output = self.engine.render_to_string('ssi02') self.assertEqual(output, ''), @setup({'ssi03': "{%% ssi '%s' %%}" % os.path.join( - root, 'not_here', + ROOT, 'not_here', )}) def test_ssi03(self): - output = render('ssi03') + output = self.engine.render_to_string('ssi03') self.assertEqual(output, ''), # Test passing as a variable @@ -42,8 +36,8 @@ class SsiTagTests(SimpleTestCase): def test_ssi04(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango19Warning) - output = render('ssi04', { - 'ssi_file': os.path.join(root, 'templates', 'ssi_include.html') + output = self.engine.render_to_string('ssi04', { + 'ssi_file': os.path.join(ROOT, 'templates', 'ssi_include.html') }) self.assertEqual(output, 'This is for testing an ssi include. {{ test }}\n') @@ -51,38 +45,38 @@ class SsiTagTests(SimpleTestCase): def test_ssi05(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango19Warning) - output = render('ssi05', {'ssi_file': 'no_file'}) + output = self.engine.render_to_string('ssi05', {'ssi_file': 'no_file'}) self.assertEqual(output, '') # Test parsed output @setup({'ssi06': '{%% ssi "%s" parsed %%}' % os.path.join( - root, 'templates', 'ssi_include.html', + ROOT, 'templates', 'ssi_include.html', )}) def test_ssi06(self): - output = render('ssi06', {'test': 'Look ma! It parsed!'}) + output = self.engine.render_to_string('ssi06', {'test': 'Look ma! It parsed!'}) self.assertEqual(output, 'This is for testing an ssi include. ' 'Look ma! It parsed!\n') @setup({'ssi07': '{%% ssi "%s" parsed %%}' % os.path.join( - root, 'not_here', + ROOT, 'not_here', )}) def test_ssi07(self): - output = render('ssi07', {'test': 'Look ma! It parsed!'}) + output = self.engine.render_to_string('ssi07', {'test': 'Look ma! It parsed!'}) self.assertEqual(output, '') # Test space in file name @setup({'ssi08': '{%% ssi "%s" %%}' % os.path.join( - root, 'templates', 'ssi include with spaces.html', + ROOT, 'templates', 'ssi include with spaces.html', )}) def test_ssi08(self): - output = render('ssi08') + output = self.engine.render_to_string('ssi08') self.assertEqual(output, 'This is for testing an ssi include ' 'with spaces in its name. {{ test }}\n') @setup({'ssi09': '{%% ssi "%s" parsed %%}' % os.path.join( - root, 'templates', 'ssi include with spaces.html', + ROOT, 'templates', 'ssi include with spaces.html', )}) def test_ssi09(self): - output = render('ssi09', {'test': 'Look ma! It parsed!'}) + output = self.engine.render_to_string('ssi09', {'test': 'Look ma! It parsed!'}) self.assertEqual(output, 'This is for testing an ssi include ' 'with spaces in its name. Look ma! It parsed!\n') diff --git a/tests/template_tests/syntax_tests/test_static.py b/tests/template_tests/syntax_tests/test_static.py index 95ddb196af..19b4e53cde 100644 --- a/tests/template_tests/syntax_tests/test_static.py +++ b/tests/template_tests/syntax_tests/test_static.py @@ -2,7 +2,7 @@ from django.conf import settings from django.test import override_settings, SimpleTestCase from django.utils.six.moves.urllib.parse import urljoin -from ..utils import render, setup +from ..utils import setup @override_settings(MEDIA_URL="/media/", STATIC_URL="/static/") @@ -10,42 +10,42 @@ class StaticTagTests(SimpleTestCase): @setup({'static-prefixtag01': '{% load static %}{% get_static_prefix %}'}) def test_static_prefixtag01(self): - output = render('static-prefixtag01') + output = self.engine.render_to_string('static-prefixtag01') self.assertEqual(output, settings.STATIC_URL) @setup({'static-prefixtag02': '{% load static %}' '{% get_static_prefix as static_prefix %}{{ static_prefix }}'}) def test_static_prefixtag02(self): - output = render('static-prefixtag02') + output = self.engine.render_to_string('static-prefixtag02') self.assertEqual(output, settings.STATIC_URL) @setup({'static-prefixtag03': '{% load static %}{% get_media_prefix %}'}) def test_static_prefixtag03(self): - output = render('static-prefixtag03') + output = self.engine.render_to_string('static-prefixtag03') self.assertEqual(output, settings.MEDIA_URL) @setup({'static-prefixtag04': '{% load static %}' '{% get_media_prefix as media_prefix %}{{ media_prefix }}'}) def test_static_prefixtag04(self): - output = render('static-prefixtag04') + output = self.engine.render_to_string('static-prefixtag04') self.assertEqual(output, settings.MEDIA_URL) @setup({'static-statictag01': '{% load static %}{% static "admin/base.css" %}'}) def test_static_statictag01(self): - output = render('static-statictag01') + output = self.engine.render_to_string('static-statictag01') self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css')) @setup({'static-statictag02': '{% load static %}{% static base_css %}'}) def test_static_statictag02(self): - output = render('static-statictag02', {'base_css': 'admin/base.css'}) + output = self.engine.render_to_string('static-statictag02', {'base_css': 'admin/base.css'}) self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css')) @setup({'static-statictag03': '{% load static %}{% static "admin/base.css" as foo %}{{ foo }}'}) def test_static_statictag03(self): - output = render('static-statictag03') + output = self.engine.render_to_string('static-statictag03') self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css')) @setup({'static-statictag04': '{% load static %}{% static base_css as foo %}{{ foo }}'}) def test_static_statictag04(self): - output = render('static-statictag04', {'base_css': 'admin/base.css'}) + output = self.engine.render_to_string('static-statictag04', {'base_css': 'admin/base.css'}) self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css')) diff --git a/tests/template_tests/syntax_tests/test_template_tag.py b/tests/template_tests/syntax_tests/test_template_tag.py index 18faafd252..e868c9f21a 100644 --- a/tests/template_tests/syntax_tests/test_template_tag.py +++ b/tests/template_tests/syntax_tests/test_template_tag.py @@ -1,68 +1,67 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class TemplateTagTests(SimpleTestCase): @setup({'templatetag01': '{% templatetag openblock %}'}) def test_templatetag01(self): - output = render('templatetag01') + output = self.engine.render_to_string('templatetag01') self.assertEqual(output, '{%') @setup({'templatetag02': '{% templatetag closeblock %}'}) def test_templatetag02(self): - output = render('templatetag02') + output = self.engine.render_to_string('templatetag02') self.assertEqual(output, '%}') @setup({'templatetag03': '{% templatetag openvariable %}'}) def test_templatetag03(self): - output = render('templatetag03') + output = self.engine.render_to_string('templatetag03') self.assertEqual(output, '{{') @setup({'templatetag04': '{% templatetag closevariable %}'}) def test_templatetag04(self): - output = render('templatetag04') + output = self.engine.render_to_string('templatetag04') self.assertEqual(output, '}}') @setup({'templatetag05': '{% templatetag %}'}) def test_templatetag05(self): with self.assertRaises(TemplateSyntaxError): - get_template('templatetag05') + self.engine.get_template('templatetag05') @setup({'templatetag06': '{% templatetag foo %}'}) def test_templatetag06(self): with self.assertRaises(TemplateSyntaxError): - get_template('templatetag06') + self.engine.get_template('templatetag06') @setup({'templatetag07': '{% templatetag openbrace %}'}) def test_templatetag07(self): - output = render('templatetag07') + output = self.engine.render_to_string('templatetag07') self.assertEqual(output, '{') @setup({'templatetag08': '{% templatetag closebrace %}'}) def test_templatetag08(self): - output = render('templatetag08') + output = self.engine.render_to_string('templatetag08') self.assertEqual(output, '}') @setup({'templatetag09': '{% templatetag openbrace %}{% templatetag openbrace %}'}) def test_templatetag09(self): - output = render('templatetag09') + output = self.engine.render_to_string('templatetag09') self.assertEqual(output, '{{') @setup({'templatetag10': '{% templatetag closebrace %}{% templatetag closebrace %}'}) def test_templatetag10(self): - output = render('templatetag10') + output = self.engine.render_to_string('templatetag10') self.assertEqual(output, '}}') @setup({'templatetag11': '{% templatetag opencomment %}'}) def test_templatetag11(self): - output = render('templatetag11') + output = self.engine.render_to_string('templatetag11') self.assertEqual(output, '{#') @setup({'templatetag12': '{% templatetag closecomment %}'}) def test_templatetag12(self): - output = render('templatetag12') + output = self.engine.render_to_string('templatetag12') self.assertEqual(output, '#}') diff --git a/tests/template_tests/syntax_tests/test_url.py b/tests/template_tests/syntax_tests/test_url.py index 56af43d131..389aefa00a 100644 --- a/tests/template_tests/syntax_tests/test_url.py +++ b/tests/template_tests/syntax_tests/test_url.py @@ -2,12 +2,11 @@ import warnings from django.core.urlresolvers import NoReverseMatch -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import override_settings, SimpleTestCase from django.utils.deprecation import RemovedInDjango20Warning -from ..utils import render, setup +from ..utils import setup @override_settings(ROOT_URLCONF='template_tests.urls') @@ -18,88 +17,88 @@ class UrlTagTests(SimpleTestCase): def test_url01(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url01', {'client': {'id': 1}}) + output = self.engine.render_to_string('url01', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/') @setup({'url02': '{% url "template_tests.views.client_action" id=client.id action="update" %}'}) def test_url02(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url02', {'client': {'id': 1}}) + output = self.engine.render_to_string('url02', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/update/') @setup({'url02a': '{% url "template_tests.views.client_action" client.id "update" %}'}) def test_url02a(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url02a', {'client': {'id': 1}}) + output = self.engine.render_to_string('url02a', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/update/') @setup({'url02b': "{% url 'template_tests.views.client_action' id=client.id action='update' %}"}) def test_url02b(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url02b', {'client': {'id': 1}}) + output = self.engine.render_to_string('url02b', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/update/') @setup({'url02c': "{% url 'template_tests.views.client_action' client.id 'update' %}"}) def test_url02c(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url02c', {'client': {'id': 1}}) + output = self.engine.render_to_string('url02c', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/update/') @setup({'url03': '{% url "template_tests.views.index" %}'}) def test_url03(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url03') + output = self.engine.render_to_string('url03') self.assertEqual(output, '/') @setup({'url04': '{% url "named.client" client.id %}'}) def test_url04(self): - output = render('url04', {'client': {'id': 1}}) + output = self.engine.render_to_string('url04', {'client': {'id': 1}}) self.assertEqual(output, '/named-client/1/') @setup({'url05': '{% url "метка_оператора" v %}'}) def test_url05(self): - output = render('url05', {'v': 'Ω'}) + output = self.engine.render_to_string('url05', {'v': 'Ω'}) self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/') @setup({'url06': '{% url "метка_оператора_2" tag=v %}'}) def test_url06(self): - output = render('url06', {'v': 'Ω'}) + output = self.engine.render_to_string('url06', {'v': 'Ω'}) self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/') @setup({'url07': '{% url "template_tests.views.client2" tag=v %}'}) def test_url07(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url07', {'v': 'Ω'}) + output = self.engine.render_to_string('url07', {'v': 'Ω'}) self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/') @setup({'url08': '{% url "метка_оператора" v %}'}) def test_url08(self): - output = render('url08', {'v': 'Ω'}) + output = self.engine.render_to_string('url08', {'v': 'Ω'}) self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/') @setup({'url09': '{% url "метка_оператора_2" tag=v %}'}) def test_url09(self): - output = render('url09', {'v': 'Ω'}) + output = self.engine.render_to_string('url09', {'v': 'Ω'}) self.assertEqual(output, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/') @setup({'url10': '{% url "template_tests.views.client_action" id=client.id action="two words" %}'}) def test_url10(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url10', {'client': {'id': 1}}) + output = self.engine.render_to_string('url10', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/two%20words/') @setup({'url11': '{% url "template_tests.views.client_action" id=client.id action="==" %}'}) def test_url11(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url11', {'client': {'id': 1}}) + output = self.engine.render_to_string('url11', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/==/') @setup({'url12': '{% url "template_tests.views.client_action" ' @@ -107,7 +106,7 @@ class UrlTagTests(SimpleTestCase): def test_url12(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url12', {'client': {'id': 1}}) + output = self.engine.render_to_string('url12', {'client': {'id': 1}}) self.assertEqual(output, '/client/1/!$&\'()*+,;=~:@,/') @setup({'url13': '{% url "template_tests.views.client_action" ' @@ -115,153 +114,153 @@ class UrlTagTests(SimpleTestCase): def test_url13(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url13', {'client': {'id': 1}, 'arg': ['a', 'b']}) + output = self.engine.render_to_string('url13', {'client': {'id': 1}, 'arg': ['a', 'b']}) self.assertEqual(output, '/client/1/a-b/') @setup({'url14': '{% url "template_tests.views.client_action" client.id arg|join:"-" %}'}) def test_url14(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url14', {'client': {'id': 1}, 'arg': ['a', 'b']}) + output = self.engine.render_to_string('url14', {'client': {'id': 1}, 'arg': ['a', 'b']}) self.assertEqual(output, '/client/1/a-b/') @setup({'url15': '{% url "template_tests.views.client_action" 12 "test" %}'}) def test_url15(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url15') + output = self.engine.render_to_string('url15') self.assertEqual(output, '/client/12/test/') @setup({'url18': '{% url "template_tests.views.client" "1,2" %}'}) def test_url18(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url18') + output = self.engine.render_to_string('url18') self.assertEqual(output, '/client/1,2/') @setup({'url19': '{% url named_url client.id %}'}) def test_url19(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url19', {'client': {'id': 1}, 'named_url': 'template_tests.views.client'}) + output = self.engine.render_to_string('url19', {'client': {'id': 1}, 'named_url': 'template_tests.views.client'}) self.assertEqual(output, '/client/1/') @setup({'url20': '{% url url_name_in_var client.id %}'}) def test_url20(self): - output = render('url20', {'client': {'id': 1}, 'url_name_in_var': 'named.client'}) + output = self.engine.render_to_string('url20', {'client': {'id': 1}, 'url_name_in_var': 'named.client'}) self.assertEqual(output, '/named-client/1/') # Failures @setup({'url-fail01': '{% url %}'}) def test_url_fail01(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail01') + self.engine.get_template('url-fail01') @setup({'url-fail02': '{% url "no_such_view" %}'}) def test_url_fail02(self): with self.assertRaises(NoReverseMatch): - render('url-fail02') + self.engine.render_to_string('url-fail02') @setup({'url-fail03': '{% url "template_tests.views.client" %}'}) def test_url_fail03(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) with self.assertRaises(NoReverseMatch): - render('url-fail03') + self.engine.render_to_string('url-fail03') @setup({'url-fail04': '{% url "view" id, %}'}) def test_url_fail04(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail04') + self.engine.get_template('url-fail04') @setup({'url-fail05': '{% url "view" id= %}'}) def test_url_fail05(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail05') + self.engine.get_template('url-fail05') @setup({'url-fail06': '{% url "view" a.id=id %}'}) def test_url_fail06(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail06') + self.engine.get_template('url-fail06') @setup({'url-fail07': '{% url "view" a.id!id %}'}) def test_url_fail07(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail07') + self.engine.get_template('url-fail07') @setup({'url-fail08': '{% url "view" id="unterminatedstring %}'}) def test_url_fail08(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail08') + self.engine.get_template('url-fail08') @setup({'url-fail09': '{% url "view" id=", %}'}) def test_url_fail09(self): with self.assertRaises(TemplateSyntaxError): - get_template('url-fail09') + self.engine.get_template('url-fail09') @setup({'url-fail11': '{% url named_url %}'}) def test_url_fail11(self): with self.assertRaises(NoReverseMatch): - render('url-fail11') + self.engine.render_to_string('url-fail11') @setup({'url-fail12': '{% url named_url %}'}) def test_url_fail12(self): with self.assertRaises(NoReverseMatch): - render('url-fail12', {'named_url': 'no_such_view'}) + self.engine.render_to_string('url-fail12', {'named_url': 'no_such_view'}) @setup({'url-fail13': '{% url named_url %}'}) def test_url_fail13(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) with self.assertRaises(NoReverseMatch): - render('url-fail13', {'named_url': 'template_tests.views.client'}) + self.engine.render_to_string('url-fail13', {'named_url': 'template_tests.views.client'}) @setup({'url-fail14': '{% url named_url id, %}'}) def test_url_fail14(self): with self.assertRaises(TemplateSyntaxError): - render('url-fail14', {'named_url': 'view'}) + self.engine.render_to_string('url-fail14', {'named_url': 'view'}) @setup({'url-fail15': '{% url named_url id= %}'}) def test_url_fail15(self): with self.assertRaises(TemplateSyntaxError): - render('url-fail15', {'named_url': 'view'}) + self.engine.render_to_string('url-fail15', {'named_url': 'view'}) @setup({'url-fail16': '{% url named_url a.id=id %}'}) def test_url_fail16(self): with self.assertRaises(TemplateSyntaxError): - render('url-fail16', {'named_url': 'view'}) + self.engine.render_to_string('url-fail16', {'named_url': 'view'}) @setup({'url-fail17': '{% url named_url a.id!id %}'}) def test_url_fail17(self): with self.assertRaises(TemplateSyntaxError): - render('url-fail17', {'named_url': 'view'}) + self.engine.render_to_string('url-fail17', {'named_url': 'view'}) @setup({'url-fail18': '{% url named_url id="unterminatedstring %}'}) def test_url_fail18(self): with self.assertRaises(TemplateSyntaxError): - render('url-fail18', {'named_url': 'view'}) + self.engine.render_to_string('url-fail18', {'named_url': 'view'}) @setup({'url-fail19': '{% url named_url id=", %}'}) def test_url_fail19(self): with self.assertRaises(TemplateSyntaxError): - render('url-fail19', {'named_url': 'view'}) + self.engine.render_to_string('url-fail19', {'named_url': 'view'}) # {% url ... as var %} @setup({'url-asvar01': '{% url "template_tests.views.index" as url %}'}) def test_url_asvar01(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url-asvar01') + output = self.engine.render_to_string('url-asvar01') self.assertEqual(output, '') @setup({'url-asvar02': '{% url "template_tests.views.index" as url %}{{ url }}'}) def test_url_asvar02(self): with warnings.catch_warnings(): warnings.simplefilter("ignore", RemovedInDjango20Warning) - output = render('url-asvar02') + output = self.engine.render_to_string('url-asvar02') self.assertEqual(output, '/') @setup({'url-asvar03': '{% url "no_such_view" as url %}{{ url }}'}) def test_url_asvar03(self): - output = render('url-asvar03') + output = self.engine.render_to_string('url-asvar03') self.assertEqual(output, '') diff --git a/tests/template_tests/syntax_tests/test_verbatim.py b/tests/template_tests/syntax_tests/test_verbatim.py index 43a6e8546c..7304796b4b 100644 --- a/tests/template_tests/syntax_tests/test_verbatim.py +++ b/tests/template_tests/syntax_tests/test_verbatim.py @@ -1,39 +1,38 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class VerbatimTagTests(SimpleTestCase): @setup({'verbatim-tag01': '{% verbatim %}{{bare }}{% endverbatim %}'}) def test_verbatim_tag01(self): - output = render('verbatim-tag01') + output = self.engine.render_to_string('verbatim-tag01') self.assertEqual(output, '{{bare }}') @setup({'verbatim-tag02': '{% verbatim %}{% endif %}{% endverbatim %}'}) def test_verbatim_tag02(self): - output = render('verbatim-tag02') + output = self.engine.render_to_string('verbatim-tag02') self.assertEqual(output, '{% endif %}') @setup({'verbatim-tag03': '{% verbatim %}It\'s the {% verbatim %} tag{% endverbatim %}'}) def test_verbatim_tag03(self): - output = render('verbatim-tag03') + output = self.engine.render_to_string('verbatim-tag03') self.assertEqual(output, 'It\'s the {% verbatim %} tag') @setup({'verbatim-tag04': '{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}'}) def test_verbatim_tag04(self): with self.assertRaises(TemplateSyntaxError): - get_template('verbatim-tag04') + self.engine.get_template('verbatim-tag04') @setup({'verbatim-tag05': '{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}'}) def test_verbatim_tag05(self): - output = render('verbatim-tag05') + output = self.engine.render_to_string('verbatim-tag05') self.assertEqual(output, '') @setup({'verbatim-tag06': '{% verbatim special %}' 'Don\'t {% endverbatim %} just yet{% endverbatim special %}'}) def test_verbatim_tag06(self): - output = render('verbatim-tag06') + output = self.engine.render_to_string('verbatim-tag06') self.assertEqual(output, 'Don\'t {% endverbatim %} just yet') diff --git a/tests/template_tests/syntax_tests/test_width_ratio.py b/tests/template_tests/syntax_tests/test_width_ratio.py index 225cd602fd..9799b7d6ab 100644 --- a/tests/template_tests/syntax_tests/test_width_ratio.py +++ b/tests/template_tests/syntax_tests/test_width_ratio.py @@ -1,36 +1,35 @@ -from django.template.base import TemplateSyntaxError -from django.template.loader import get_template +from django.template import TemplateSyntaxError from django.test import SimpleTestCase from django.utils import six -from ..utils import render, setup +from ..utils import setup class WidthRatioTagTests(SimpleTestCase): @setup({'widthratio01': '{% widthratio a b 0 %}'}) def test_widthratio01(self): - output = render('widthratio01', {'a': 50, 'b': 100}) + output = self.engine.render_to_string('widthratio01', {'a': 50, 'b': 100}) self.assertEqual(output, '0') @setup({'widthratio02': '{% widthratio a b 100 %}'}) def test_widthratio02(self): - output = render('widthratio02', {'a': 0, 'b': 0}) + output = self.engine.render_to_string('widthratio02', {'a': 0, 'b': 0}) self.assertEqual(output, '0') @setup({'widthratio03': '{% widthratio a b 100 %}'}) def test_widthratio03(self): - output = render('widthratio03', {'a': 0, 'b': 100}) + output = self.engine.render_to_string('widthratio03', {'a': 0, 'b': 100}) self.assertEqual(output, '0') @setup({'widthratio04': '{% widthratio a b 100 %}'}) def test_widthratio04(self): - output = render('widthratio04', {'a': 50, 'b': 100}) + output = self.engine.render_to_string('widthratio04', {'a': 50, 'b': 100}) self.assertEqual(output, '50') @setup({'widthratio05': '{% widthratio a b 100 %}'}) def test_widthratio05(self): - output = render('widthratio05', {'a': 100, 'b': 100}) + output = self.engine.render_to_string('widthratio05', {'a': 100, 'b': 100}) self.assertEqual(output, '100') @setup({'widthratio06': '{% widthratio a b 100 %}'}) @@ -39,7 +38,7 @@ class WidthRatioTagTests(SimpleTestCase): 62.5 should round to 63 on Python 2 and 62 on Python 3 See http://docs.python.org/py3k/whatsnew/3.0.html """ - output = render('widthratio06', {'a': 50, 'b': 80}) + output = self.engine.render_to_string('widthratio06', {'a': 50, 'b': 80}) self.assertEqual(output, '62' if six.PY3 else '63') @setup({'widthratio07': '{% widthratio a b 100 %}'}) @@ -47,23 +46,23 @@ class WidthRatioTagTests(SimpleTestCase): """ 71.4 should round to 71 """ - output = render('widthratio07', {'a': 50, 'b': 70}) + output = self.engine.render_to_string('widthratio07', {'a': 50, 'b': 70}) self.assertEqual(output, '71') # Raise exception if we don't have 3 args, last one an integer @setup({'widthratio08': '{% widthratio %}'}) def test_widthratio08(self): with self.assertRaises(TemplateSyntaxError): - get_template('widthratio08') + self.engine.get_template('widthratio08') @setup({'widthratio09': '{% widthratio a b %}'}) def test_widthratio09(self): with self.assertRaises(TemplateSyntaxError): - render('widthratio09', {'a': 50, 'b': 100}) + self.engine.render_to_string('widthratio09', {'a': 50, 'b': 100}) @setup({'widthratio10': '{% widthratio a b 100.0 %}'}) def test_widthratio10(self): - output = render('widthratio10', {'a': 50, 'b': 100}) + output = self.engine.render_to_string('widthratio10', {'a': 50, 'b': 100}) self.assertEqual(output, '50') @setup({'widthratio11': '{% widthratio a b c %}'}) @@ -71,76 +70,76 @@ class WidthRatioTagTests(SimpleTestCase): """ #10043: widthratio should allow max_width to be a variable """ - output = render('widthratio11', {'a': 50, 'c': 100, 'b': 100}) + output = self.engine.render_to_string('widthratio11', {'a': 50, 'c': 100, 'b': 100}) self.assertEqual(output, '50') # #18739: widthratio should handle None args consistently with # non-numerics @setup({'widthratio12a': '{% widthratio a b c %}'}) def test_widthratio12a(self): - output = render('widthratio12a', {'a': 'a', 'c': 100, 'b': 100}) + output = self.engine.render_to_string('widthratio12a', {'a': 'a', 'c': 100, 'b': 100}) self.assertEqual(output, '') @setup({'widthratio12b': '{% widthratio a b c %}'}) def test_widthratio12b(self): - output = render('widthratio12b', {'a': None, 'c': 100, 'b': 100}) + output = self.engine.render_to_string('widthratio12b', {'a': None, 'c': 100, 'b': 100}) self.assertEqual(output, '') @setup({'widthratio13a': '{% widthratio a b c %}'}) def test_widthratio13a(self): - output = render('widthratio13a', {'a': 0, 'c': 100, 'b': 'b'}) + output = self.engine.render_to_string('widthratio13a', {'a': 0, 'c': 100, 'b': 'b'}) self.assertEqual(output, '') @setup({'widthratio13b': '{% widthratio a b c %}'}) def test_widthratio13b(self): - output = render('widthratio13b', {'a': 0, 'c': 100, 'b': None}) + output = self.engine.render_to_string('widthratio13b', {'a': 0, 'c': 100, 'b': None}) self.assertEqual(output, '') @setup({'widthratio14a': '{% widthratio a b c %}'}) def test_widthratio14a(self): with self.assertRaises(TemplateSyntaxError): - render('widthratio14a', {'a': 0, 'c': 'c', 'b': 100}) + self.engine.render_to_string('widthratio14a', {'a': 0, 'c': 'c', 'b': 100}) @setup({'widthratio14b': '{% widthratio a b c %}'}) def test_widthratio14b(self): with self.assertRaises(TemplateSyntaxError): - render('widthratio14b', {'a': 0, 'c': None, 'b': 100}) + self.engine.render_to_string('widthratio14b', {'a': 0, 'c': None, 'b': 100}) @setup({'widthratio15': '{% load custom %}{% widthratio a|noop:"x y" b 0 %}'}) def test_widthratio15(self): """ Test whitespace in filter argument """ - output = render('widthratio15', {'a': 50, 'b': 100}) + output = self.engine.render_to_string('widthratio15', {'a': 50, 'b': 100}) self.assertEqual(output, '0') # Widthratio with variable assignment @setup({'widthratio16': '{% widthratio a b 100 as variable %}-{{ variable }}-'}) def test_widthratio16(self): - output = render('widthratio16', {'a': 50, 'b': 100}) + output = self.engine.render_to_string('widthratio16', {'a': 50, 'b': 100}) self.assertEqual(output, '-50-') @setup({'widthratio17': '{% widthratio a b 100 as variable %}-{{ variable }}-'}) def test_widthratio17(self): - output = render('widthratio17', {'a': 100, 'b': 100}) + output = self.engine.render_to_string('widthratio17', {'a': 100, 'b': 100}) self.assertEqual(output, '-100-') @setup({'widthratio18': '{% widthratio a b 100 as %}'}) def test_widthratio18(self): with self.assertRaises(TemplateSyntaxError): - get_template('widthratio18') + self.engine.get_template('widthratio18') @setup({'widthratio19': '{% widthratio a b 100 not_as variable %}'}) def test_widthratio19(self): with self.assertRaises(TemplateSyntaxError): - get_template('widthratio19') + self.engine.get_template('widthratio19') @setup({'widthratio20': '{% widthratio a b 100 %}'}) def test_widthratio20(self): - output = render('widthratio20', {'a': float('inf'), 'b': float('inf')}) + output = self.engine.render_to_string('widthratio20', {'a': float('inf'), 'b': float('inf')}) self.assertEqual(output, '') @setup({'widthratio21': '{% widthratio a b 100 %}'}) def test_widthratio21(self): - output = render('widthratio21', {'a': float('inf'), 'b': 2}) + output = self.engine.render_to_string('widthratio21', {'a': float('inf'), 'b': 2}) self.assertEqual(output, '') diff --git a/tests/template_tests/syntax_tests/test_with.py b/tests/template_tests/syntax_tests/test_with.py index 571ea7f1c1..ba1875af21 100644 --- a/tests/template_tests/syntax_tests/test_with.py +++ b/tests/template_tests/syntax_tests/test_with.py @@ -1,28 +1,27 @@ -from django.conf import settings -from django.template.base import TemplateSyntaxError +from django.template import TemplateSyntaxError from django.test import SimpleTestCase -from ..utils import render, setup +from ..utils import setup class WithTagTests(SimpleTestCase): @setup({'with01': '{% with key=dict.key %}{{ key }}{% endwith %}'}) def test_with01(self): - output = render('with01', {'dict': {'key': 50}}) + output = self.engine.render_to_string('with01', {'dict': {'key': 50}}) self.assertEqual(output, '50') @setup({'legacywith01': '{% with dict.key as key %}{{ key }}{% endwith %}'}) def test_legacywith01(self): - output = render('legacywith01', {'dict': {'key': 50}}) + output = self.engine.render_to_string('legacywith01', {'dict': {'key': 50}}) self.assertEqual(output, '50') @setup({'with02': '{{ key }}{% with key=dict.key %}' '{{ key }}-{{ dict.key }}-{{ key }}' '{% endwith %}{{ key }}'}) def test_with02(self): - output = render('with02', {'dict': {'key': 50}}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('with02', {'dict': {'key': 50}}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID50-50-50INVALID') else: self.assertEqual(output, '50-50-50') @@ -31,23 +30,23 @@ class WithTagTests(SimpleTestCase): '{{ key }}-{{ dict.key }}-{{ key }}' '{% endwith %}{{ key }}'}) def test_legacywith02(self): - output = render('legacywith02', {'dict': {'key': 50}}) - if settings.TEMPLATE_STRING_IF_INVALID: + output = self.engine.render_to_string('legacywith02', {'dict': {'key': 50}}) + if self.engine.string_if_invalid: self.assertEqual(output, 'INVALID50-50-50INVALID') else: self.assertEqual(output, '50-50-50') @setup({'with03': '{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}'}) def test_with03(self): - output = render('with03', {'alpha': 'A', 'beta': 'B'}) + output = self.engine.render_to_string('with03', {'alpha': 'A', 'beta': 'B'}) self.assertEqual(output, 'AB') @setup({'with-error01': '{% with dict.key xx key %}{{ key }}{% endwith %}'}) def test_with_error01(self): with self.assertRaises(TemplateSyntaxError): - render('with-error01', {'dict': {'key': 50}}) + self.engine.render_to_string('with-error01', {'dict': {'key': 50}}) @setup({'with-error02': '{% with dict.key as %}{{ key }}{% endwith %}'}) def test_with_error02(self): with self.assertRaises(TemplateSyntaxError): - render('with-error02', {'dict': {'key': 50}}) + self.engine.render_to_string('with-error02', {'dict': {'key': 50}}) |