Isolated template tests from Django settings.

Author: aaugustin

tests/template_tests/filter_tests/test_add.py

@@ -3,7 +3,7 @@
 from django.template.defaultfilters import add
 from django.test import SimpleTestCase
 
-from ..utils import render, setup
+from ..utils import setup
 
 
 class AddTests(SimpleTestCase):
@@ -13,37 +13,37 @@ class AddTests(SimpleTestCase):
 
     @setup({'add01': '{{ i|add:"5" }}'})
     def test_add01(self):
-        output = render('add01', {'i': 2000})
+        output = self.engine.render_to_string('add01', {'i': 2000})
         self.assertEqual(output, '2005')
 
     @setup({'add02': '{{ i|add:"napis" }}'})
     def test_add02(self):
-        output = render('add02', {'i': 2000})
+        output = self.engine.render_to_string('add02', {'i': 2000})
         self.assertEqual(output, '')
 
     @setup({'add03': '{{ i|add:16 }}'})
     def test_add03(self):
-        output = render('add03', {'i': 'not_an_int'})
+        output = self.engine.render_to_string('add03', {'i': 'not_an_int'})
         self.assertEqual(output, '')
 
     @setup({'add04': '{{ i|add:"16" }}'})
     def test_add04(self):
-        output = render('add04', {'i': 'not_an_int'})
+        output = self.engine.render_to_string('add04', {'i': 'not_an_int'})
         self.assertEqual(output, 'not_an_int16')
 
     @setup({'add05': '{{ l1|add:l2 }}'})
     def test_add05(self):
-        output = render('add05', {'l1': [1, 2], 'l2': [3, 4]})
+        output = self.engine.render_to_string('add05', {'l1': [1, 2], 'l2': [3, 4]})
         self.assertEqual(output, '[1, 2, 3, 4]')
 
     @setup({'add06': '{{ t1|add:t2 }}'})
     def test_add06(self):
-        output = render('add06', {'t1': (3, 4), 't2': (1, 2)})
+        output = self.engine.render_to_string('add06', {'t1': (3, 4), 't2': (1, 2)})
         self.assertEqual(output, '(3, 4, 1, 2)')
 
     @setup({'add07': '{{ d|add:t }}'})
     def test_add07(self):
-        output = render('add07', {'d': date(2000, 1, 1), 't': timedelta(10)})
+        output = self.engine.render_to_string('add07', {'d': date(2000, 1, 1), 't': timedelta(10)})
         self.assertEqual(output, 'Jan. 11, 2000')
 
 

tests/template_tests/filter_tests/test_addslashes.py

@@ -2,19 +2,19 @@
 from django.test import SimpleTestCase
 from django.utils.safestring import mark_safe
 
-from ..utils import render, setup
+from ..utils import setup
 
 
 class AddslashesTests(SimpleTestCase):
 
     @setup({'addslashes01': '{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}'})
     def test_addslashes01(self):
-        output = render('addslashes01', {"a": "<a>'", "b": mark_safe("<a>'")})
+        output = self.engine.render_to_string('addslashes01', {"a": "<a>'", "b": mark_safe("<a>'")})
         self.assertEqual(output, r"<a>\' <a>\'")
 
     @setup({'addslashes02': '{{ a|addslashes }} {{ b|addslashes }}'})
     def test_addslashes02(self):
-        output = render('addslashes02', {"a": "<a>'", "b": mark_safe("<a>'")})
+        output = self.engine.render_to_string('addslashes02', {"a": "<a>'", "b": mark_safe("<a>'")})
         self.assertEqual(output, r"&lt;a&gt;\&#39; <a>\'")
 
 

tests/template_tests/filter_tests/test_autoescape.py

@@ -1,6 +1,6 @@
 from django.test import SimpleTestCase
 
-from ..utils import render, setup, SafeClass, UnsafeClass
+from ..utils import setup, SafeClass, UnsafeClass
 
 
 class AutoescapeStringfilterTests(SimpleTestCase):
@@ -10,20 +10,20 @@ class AutoescapeStringfilterTests(SimpleTestCase):
 
     @setup({'autoescape-stringfilter01': '{{ unsafe|capfirst }}'})
     def test_autoescape_stringfilter01(self):
-        output = render('autoescape-stringfilter01', {'unsafe': UnsafeClass()})
+        output = self.engine.render_to_string('autoescape-stringfilter01', {'unsafe': UnsafeClass()})
         self.assertEqual(output, 'You & me')
 
     @setup({'autoescape-stringfilter02': '{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}'})
     def test_autoescape_stringfilter02(self):
-        output = render('autoescape-stringfilter02', {'unsafe': UnsafeClass()})
+        output = self.engine.render_to_string('autoescape-stringfilter02', {'unsafe': UnsafeClass()})
         self.assertEqual(output, 'You & me')
 
     @setup({'autoescape-stringfilter03': '{{ safe|capfirst }}'})
     def test_autoescape_stringfilter03(self):
-        output = render('autoescape-stringfilter03', {'safe': SafeClass()})
+        output = self.engine.render_to_string('autoescape-stringfilter03', {'safe': SafeClass()})
         self.assertEqual(output, 'You > me')
 
     @setup({'autoescape-stringfilter04': '{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}'})
     def test_autoescape_stringfilter04(self):
-        output = render('autoescape-stringfilter04', {'safe': SafeClass()})
+        output = self.engine.render_to_string('autoescape-stringfilter04', {'safe': SafeClass()})
         self.assertEqual(output, 'You > me')

tests/template_tests/filter_tests/test_capfirst.py

@@ -2,19 +2,19 @@
 from django.test import SimpleTestCase
 from django.utils.safestring import mark_safe
 
-from ..utils import render, setup
+from ..utils import setup
 
 
 class CapfirstTests(SimpleTestCase):
 
     @setup({'capfirst01': '{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}'})
     def test_capfirst01(self):
-        output = render('capfirst01', {'a': 'fred>', 'b': mark_safe('fred>')})
+        output = self.engine.render_to_string('capfirst01', {'a': 'fred>', 'b': mark_safe('fred>')})
         self.assertEqual(output, 'Fred> Fred>')
 
     @setup({'capfirst02': '{{ a|capfirst }} {{ b|capfirst }}'})
     def test_capfirst02(self):
-        output = render('capfirst02', {'a': 'fred>', 'b': mark_safe('fred>')})
+        output = self.engine.render_to_string('capfirst02', {'a': 'fred>', 'b': mark_safe('fred>')})
         self.assertEqual(output, 'Fred> Fred>')
 
 

tests/template_tests/filter_tests/test_center.py

@@ -2,20 +2,20 @@
 from django.test import SimpleTestCase
 from django.utils.safestring import mark_safe
 
-from ..utils import render, setup
+from ..utils import setup
 
 
 class CenterTests(SimpleTestCase):
 
     @setup({'center01':
         '{% autoescape off %}.{{ a|center:"5" }}. .{{ b|center:"5" }}.{% endautoescape %}'})
     def test_center01(self):
-        output = render('center01', {"a": "a&b", "b": mark_safe("a&b")})
+        output = self.engine.render_to_string('center01', {"a": "a&b", "b": mark_safe("a&b")})
         self.assertEqual(output, ". a&b . . a&b .")
 
     @setup({'center02': '.{{ a|center:"5" }}. .{{ b|center:"5" }}.'})
     def test_center02(self):
-        output = render('center02', {"a": "a&b", "b": mark_safe("a&b")})
+        output = self.engine.render_to_string('center02', {"a": "a&b", "b": mark_safe("a&b")})
         self.assertEqual(output, ". a&b . . a&b .")
 
 

tests/template_tests/filter_tests/test_chaining.py

@@ -1,7 +1,7 @@
 from django.test import SimpleTestCase
 from django.utils.safestring import mark_safe
 
-from ..utils import render, setup
+from ..utils import setup
 
 
 class ChainingTests(SimpleTestCase):
@@ -11,76 +11,76 @@ class ChainingTests(SimpleTestCase):
 
     @setup({'chaining01': '{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}'})
     def test_chaining01(self):
-        output = render('chaining01', {'a': 'a < b', 'b': mark_safe('a < b')})
+        output = self.engine.render_to_string('chaining01', {'a': 'a < b', 'b': mark_safe('a < b')})
         self.assertEqual(output, ' A &lt; b . A < b ')
 
     @setup({'chaining02':
         '{% autoescape off %}{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}{% endautoescape %}'})
     def test_chaining02(self):
-        output = render('chaining02', {'a': 'a < b', 'b': mark_safe('a < b')})
+        output = self.engine.render_to_string('chaining02', {'a': 'a < b', 'b': mark_safe('a < b')})
         self.assertEqual(output, ' A < b . A < b ')
 
     # Using a filter that forces a string back to unsafe:
     @setup({'chaining03': '{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}'})
     def test_chaining03(self):
-        output = render('chaining03', {'a': 'a < b', 'b': mark_safe('a < b')})
+        output = self.engine.render_to_string('chaining03', {'a': 'a < b', 'b': mark_safe('a < b')})
         self.assertEqual(output, 'A &lt; .A < ')
 
     @setup({'chaining04':
         '{% autoescape off %}{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}{% endautoescape %}'})
     def test_chaining04(self):
-        output = render('chaining04', {'a': 'a < b', 'b': mark_safe('a < b')})
+        output = self.engine.render_to_string('chaining04', {'a': 'a < b', 'b': mark_safe('a < b')})
         self.assertEqual(output, 'A < .A < ')
 
     # Using a filter that forces safeness does not lead to double-escaping
     @setup({'chaining05': '{{ a|escape|capfirst }}'})
     def test_chaining05(self):
-        output = render('chaining05', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining05', {'a': 'a < b'})
         self.assertEqual(output, 'A &lt; b')
 
     @setup({'chaining06': '{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}'})
     def test_chaining06(self):
-        output = render('chaining06', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining06', {'a': 'a < b'})
         self.assertEqual(output, 'A &lt; b')
 
     # Force to safe, then back (also showing why using force_escape too
     # early in a chain can lead to unexpected results).
     @setup({'chaining07': '{{ a|force_escape|cut:";" }}'})
     def test_chaining07(self):
-        output = render('chaining07', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining07', {'a': 'a < b'})
         self.assertEqual(output, 'a &amp;lt b')
 
     @setup({'chaining08': '{% autoescape off %}{{ a|force_escape|cut:";" }}{% endautoescape %}'})
     def test_chaining08(self):
-        output = render('chaining08', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining08', {'a': 'a < b'})
         self.assertEqual(output, 'a &lt b')
 
     @setup({'chaining09': '{{ a|cut:";"|force_escape }}'})
     def test_chaining09(self):
-        output = render('chaining09', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining09', {'a': 'a < b'})
         self.assertEqual(output, 'a &lt; b')
 
     @setup({'chaining10': '{% autoescape off %}{{ a|cut:";"|force_escape }}{% endautoescape %}'})
     def test_chaining10(self):
-        output = render('chaining10', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining10', {'a': 'a < b'})
         self.assertEqual(output, 'a &lt; b')
 
     @setup({'chaining11': '{{ a|cut:"b"|safe }}'})
     def test_chaining11(self):
-        output = render('chaining11', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining11', {'a': 'a < b'})
         self.assertEqual(output, 'a < ')
 
     @setup({'chaining12': '{% autoescape off %}{{ a|cut:"b"|safe }}{% endautoescape %}'})
     def test_chaining12(self):
-        output = render('chaining12', {'a': 'a < b'})
+        output = self.engine.render_to_string('chaining12', {'a': 'a < b'})
         self.assertEqual(output, 'a < ')
 
     @setup({'chaining13': '{{ a|safe|force_escape }}'})
     def test_chaining13(self):
-        output = render('chaining13', {"a": "a < b"})
+        output = self.engine.render_to_string('chaining13', {"a": "a < b"})
         self.assertEqual(output, 'a &lt; b')
 
     @setup({'chaining14': '{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}'})
     def test_chaining14(self):
-        output = render('chaining14', {"a": "a < b"})
+        output = self.engine.render_to_string('chaining14', {"a": "a < b"})
         self.assertEqual(output, 'a &lt; b')

tests/template_tests/filter_tests/test_cut.py

@@ -2,41 +2,41 @@
 from django.test import SimpleTestCase
 from django.utils.safestring import mark_safe
 
-from ..utils import render, setup
+from ..utils import setup
 
 
 class CutTests(SimpleTestCase):
 
     @setup({'cut01': '{% autoescape off %}{{ a|cut:"x" }} {{ b|cut:"x" }}{% endautoescape %}'})
     def test_cut01(self):
-        output = render('cut01', {"a": "x&y", "b": mark_safe("x&y")})
+        output = self.engine.render_to_string('cut01', {"a": "x&y", "b": mark_safe("x&y")})
         self.assertEqual(output, "&y &y")
 
     @setup({'cut02': '{{ a|cut:"x" }} {{ b|cut:"x" }}'})
     def test_cut02(self):
-        output = render('cut02', {"a": "x&y", "b": mark_safe("x&y")})
+        output = self.engine.render_to_string('cut02', {"a": "x&y", "b": mark_safe("x&y")})
         self.assertEqual(output, "&y &y")
 
     @setup({'cut03': '{% autoescape off %}{{ a|cut:"&" }} {{ b|cut:"&" }}{% endautoescape %}'})
     def test_cut03(self):
-        output = render('cut03', {"a": "x&y", "b": mark_safe("x&y")})
+        output = self.engine.render_to_string('cut03', {"a": "x&y", "b": mark_safe("x&y")})
         self.assertEqual(output, "xy xamp;y")
 
     @setup({'cut04': '{{ a|cut:"&" }} {{ b|cut:"&" }}'})
     def test_cut04(self):
-        output = render('cut04', {"a": "x&y", "b": mark_safe("x&y")})
+        output = self.engine.render_to_string('cut04', {"a": "x&y", "b": mark_safe("x&y")})
         self.assertEqual(output, "xy xamp;y")
 
     # Passing ';' to cut can break existing HTML entities, so those strings
     # are auto-escaped.
     @setup({'cut05': '{% autoescape off %}{{ a|cut:";" }} {{ b|cut:";" }}{% endautoescape %}'})
     def test_cut05(self):
-        output = render('cut05', {"a": "x&y", "b": mark_safe("x&y")})
+        output = self.engine.render_to_string('cut05', {"a": "x&y", "b": mark_safe("x&y")})
         self.assertEqual(output, "x&y x&ampy")
 
     @setup({'cut06': '{{ a|cut:";" }} {{ b|cut:";" }}'})
     def test_cut06(self):
-        output = render('cut06', {"a": "x&y", "b": mark_safe("x&y")})
+        output = self.engine.render_to_string('cut06', {"a": "x&y", "b": mark_safe("x&y")})
         self.assertEqual(output, "x&y x&ampy")
 
 

tests/template_tests/filter_tests/test_date.py

@@ -5,60 +5,60 @@
 from django.utils import timezone
 
 from .timezone_utils import TimezoneTestCase
-from ..utils import render, setup
+from ..utils import setup
 
 
 class DateTests(TimezoneTestCase):
 
     @setup({'date01': '{{ d|date:"m" }}'})
     def test_date01(self):
-        output = render('date01', {'d': datetime(2008, 1, 1)})
+        output = self.engine.render_to_string('date01', {'d': datetime(2008, 1, 1)})
         self.assertEqual(output, '01')
 
     @setup({'date02': '{{ d|date }}'})
     def test_date02(self):
-        output = render('date02', {'d': datetime(2008, 1, 1)})
+        output = self.engine.render_to_string('date02', {'d': datetime(2008, 1, 1)})
         self.assertEqual(output, 'Jan. 1, 2008')
 
     @setup({'date03': '{{ d|date:"m" }}'})
     def test_date03(self):
         """
         #9520: Make sure |date doesn't blow up on non-dates
         """
-        output = render('date03', {'d': 'fail_string'})
+        output = self.engine.render_to_string('date03', {'d': 'fail_string'})
         self.assertEqual(output, '')
 
     # ISO date formats
     @setup({'date04': '{{ d|date:"o" }}'})
     def test_date04(self):
-        output = render('date04', {'d': datetime(2008, 12, 29)})
+        output = self.engine.render_to_string('date04', {'d': datetime(2008, 12, 29)})
         self.assertEqual(output, '2009')
 
     @setup({'date05': '{{ d|date:"o" }}'})
     def test_date05(self):
-        output = render('date05', {'d': datetime(2010, 1, 3)})
+        output = self.engine.render_to_string('date05', {'d': datetime(2010, 1, 3)})
         self.assertEqual(output, '2009')
 
     # Timezone name
     @setup({'date06': '{{ d|date:"e" }}'})
     def test_date06(self):
-        output = render('date06', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))})
+        output = self.engine.render_to_string('date06', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))})
         self.assertEqual(output, '+0030')
 
     @setup({'date07': '{{ d|date:"e" }}'})
     def test_date07(self):
-        output = render('date07', {'d': datetime(2009, 3, 12)})
+        output = self.engine.render_to_string('date07', {'d': datetime(2009, 3, 12)})
         self.assertEqual(output, '')
 
     # #19370: Make sure |date doesn't blow up on a midnight time object
     @setup({'date08': '{{ t|date:"H:i" }}'})
     def test_date08(self):
-        output = render('date08', {'t': time(0, 1)})
+        output = self.engine.render_to_string('date08', {'t': time(0, 1)})
         self.assertEqual(output, '00:01')
 
     @setup({'date09': '{{ t|date:"H:i" }}'})
     def test_date09(self):
-        output = render('date09', {'t': time(0, 0)})
+        output = self.engine.render_to_string('date09', {'t': time(0, 0)})
         self.assertEqual(output, '00:00')