Isolated template tests from Django settings.

1 files changed, 31 insertions, 32 deletions

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, ':/:/')