diff options
Diffstat (limited to 'parts/django/tests/regressiontests/templates')
21 files changed, 0 insertions, 2161 deletions
diff --git a/parts/django/tests/regressiontests/templates/__init__.py b/parts/django/tests/regressiontests/templates/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/parts/django/tests/regressiontests/templates/__init__.py +++ /dev/null diff --git a/parts/django/tests/regressiontests/templates/context.py b/parts/django/tests/regressiontests/templates/context.py deleted file mode 100644 index 394de94..0000000 --- a/parts/django/tests/regressiontests/templates/context.py +++ /dev/null @@ -1,17 +0,0 @@ -# coding: utf-8 -from unittest import TestCase - -from django.template import Context - - -class ContextTests(TestCase): - def test_context(self): - c = Context({"a": 1, "b": "xyzzy"}) - self.assertEqual(c["a"], 1) - self.assertEqual(c.push(), {}) - c["a"] = 2 - self.assertEqual(c["a"], 2) - self.assertEqual(c.get("a"), 2) - self.assertEqual(c.pop(), {"a": 2}) - self.assertEqual(c["a"], 1) - self.assertEqual(c.get("foo", 42), 42) diff --git a/parts/django/tests/regressiontests/templates/custom.py b/parts/django/tests/regressiontests/templates/custom.py deleted file mode 100644 index b346198..0000000 --- a/parts/django/tests/regressiontests/templates/custom.py +++ /dev/null @@ -1,12 +0,0 @@ -from unittest import TestCase - -from django import template - - -class CustomTests(TestCase): - def test_filter(self): - t = template.Template("{% load custom %}{{ string|trim:5 }}") - self.assertEqual( - t.render(template.Context({"string": "abcdefghijklmnopqrstuvwxyz"})), - u"abcde" - ) diff --git a/parts/django/tests/regressiontests/templates/eggs/tagsegg.egg b/parts/django/tests/regressiontests/templates/eggs/tagsegg.egg Binary files differdeleted file mode 100755 index 3941914..0000000 --- a/parts/django/tests/regressiontests/templates/eggs/tagsegg.egg +++ /dev/null diff --git a/parts/django/tests/regressiontests/templates/filters.py b/parts/django/tests/regressiontests/templates/filters.py deleted file mode 100644 index af34c58..0000000 --- a/parts/django/tests/regressiontests/templates/filters.py +++ /dev/null @@ -1,350 +0,0 @@ -# coding: utf-8 -""" -Tests for template filters (as opposed to template tags). - -The tests are hidden inside a function so that things like timestamps and -timezones are only evaluated at the moment of execution and will therefore be -consistent. -""" - -from datetime import date, datetime, timedelta - -from django.utils.tzinfo import LocalTimezone, FixedOffset -from django.utils.safestring import mark_safe - -# These two classes are used to test auto-escaping of __unicode__ output. -class UnsafeClass: - def __unicode__(self): - return u'you & me' - -class SafeClass: - def __unicode__(self): - return mark_safe(u'you > me') - -# RESULT SYNTAX -- -# 'template_name': ('template contents', 'context dict', -# 'expected string output' or Exception class) -def get_filter_tests(): - now = datetime.now() - now_tz = datetime.now(LocalTimezone(now)) - now_tz_i = datetime.now(FixedOffset((3 * 60) + 15)) # imaginary time zone - today = date.today() - - return { - # Default compare with datetime.now() - 'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1 minute'), - 'filter-timesince02' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(days=1, minutes = 1)}, '1 day'), - 'filter-timesince03' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds = 10)}, '1 hour, 25 minutes'), - - # Compare to a given parameter - 'filter-timesince04' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=1)}, '1 day'), - 'filter-timesince05' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2, minutes=1), 'b':now - timedelta(days=2)}, '1 minute'), - - # Check that timezone is respected - 'filter-timesince06' : ('{{ a|timesince:b }}', {'a':now_tz - timedelta(hours=8), 'b':now_tz}, '8 hours'), - - # Regression for #7443 - 'filter-timesince07': ('{{ earlier|timesince }}', { 'earlier': now - timedelta(days=7) }, '1 week'), - 'filter-timesince08': ('{{ earlier|timesince:now }}', { 'now': now, 'earlier': now - timedelta(days=7) }, '1 week'), - 'filter-timesince09': ('{{ later|timesince }}', { 'later': now + timedelta(days=7) }, '0 minutes'), - 'filter-timesince10': ('{{ later|timesince:now }}', { 'now': now, 'later': now + timedelta(days=7) }, '0 minutes'), - - # Ensures that differing timezones are calculated correctly - 'filter-timesince11' : ('{{ a|timesince }}', {'a': now}, '0 minutes'), - 'filter-timesince12' : ('{{ a|timesince }}', {'a': now_tz}, '0 minutes'), - 'filter-timesince13' : ('{{ a|timesince }}', {'a': now_tz_i}, '0 minutes'), - 'filter-timesince14' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0 minutes'), - 'filter-timesince15' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''), - 'filter-timesince16' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''), - - # Regression for #9065 (two date objects). - 'filter-timesince17' : ('{{ a|timesince:b }}', {'a': today, 'b': today}, '0 minutes'), - 'filter-timesince18' : ('{{ a|timesince:b }}', {'a': today, 'b': today + timedelta(hours=24)}, '1 day'), - - # Default compare with datetime.now() - 'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2 minutes'), - 'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1 day'), - 'filter-timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8 hours, 10 minutes'), - - # Compare to a given parameter - 'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=1), 'b':now - timedelta(days=2)}, '1 day'), - 'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=2, minutes=1)}, '1 minute'), - - # Regression for #7443 - 'filter-timeuntil06': ('{{ earlier|timeuntil }}', { 'earlier': now - timedelta(days=7) }, '0 minutes'), - 'filter-timeuntil07': ('{{ earlier|timeuntil:now }}', { 'now': now, 'earlier': now - timedelta(days=7) }, '0 minutes'), - 'filter-timeuntil08': ('{{ later|timeuntil }}', { 'later': now + timedelta(days=7, hours=1) }, '1 week'), - 'filter-timeuntil09': ('{{ later|timeuntil:now }}', { 'now': now, 'later': now + timedelta(days=7) }, '1 week'), - - # Ensures that differing timezones are calculated correctly - 'filter-timeuntil10' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0 minutes'), - 'filter-timeuntil11' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0 minutes'), - - # Regression for #9065 (two date objects). - 'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0 minutes'), - 'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1 day'), - - 'filter-addslash01': ("{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}", {"a": "<a>'", "b": mark_safe("<a>'")}, ur"<a>\' <a>\'"), - 'filter-addslash02': ("{{ a|addslashes }} {{ b|addslashes }}", {"a": "<a>'", "b": mark_safe("<a>'")}, ur"<a>\' <a>\'"), - - 'filter-capfirst01': ("{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}", {"a": "fred>", "b": mark_safe("fred>")}, u"Fred> Fred>"), - 'filter-capfirst02': ("{{ a|capfirst }} {{ b|capfirst }}", {"a": "fred>", "b": mark_safe("fred>")}, u"Fred> Fred>"), - - # Note that applying fix_ampsersands in autoescape mode leads to - # double escaping. - 'filter-fix_ampersands01': ("{% autoescape off %}{{ a|fix_ampersands }} {{ b|fix_ampersands }}{% endautoescape %}", {"a": "a&b", "b": mark_safe("a&b")}, u"a&b a&b"), - 'filter-fix_ampersands02': ("{{ a|fix_ampersands }} {{ b|fix_ampersands }}", {"a": "a&b", "b": mark_safe("a&b")}, u"a&amp;b a&b"), - - 'filter-floatformat01': ("{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}", {"a": "1.42", "b": mark_safe("1.42")}, u"1.4 1.4"), - 'filter-floatformat02': ("{{ a|floatformat }} {{ b|floatformat }}", {"a": "1.42", "b": mark_safe("1.42")}, u"1.4 1.4"), - - # The contents of "linenumbers" is escaped according to the current - # autoescape setting. - 'filter-linenumbers01': ("{{ a|linenumbers }} {{ b|linenumbers }}", {"a": "one\n<two>\nthree", "b": mark_safe("one\n<two>\nthree")}, u"1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three"), - 'filter-linenumbers02': ("{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}", {"a": "one\n<two>\nthree", "b": mark_safe("one\n<two>\nthree")}, u"1. one\n2. <two>\n3. three 1. one\n2. <two>\n3. three"), - - 'filter-lower01': ("{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}", {"a": "Apple & banana", "b": mark_safe("Apple & banana")}, u"apple & banana apple & banana"), - 'filter-lower02': ("{{ a|lower }} {{ b|lower }}", {"a": "Apple & banana", "b": mark_safe("Apple & banana")}, u"apple & banana apple & banana"), - - # The make_list filter can destroy existing escaping, so the results are - # escaped. - 'filter-make_list01': ("{% autoescape off %}{{ a|make_list }}{% endautoescape %}", {"a": mark_safe("&")}, u"[u'&']"), - 'filter-make_list02': ("{{ a|make_list }}", {"a": mark_safe("&")}, u"[u'&']"), - 'filter-make_list03': ('{% autoescape off %}{{ a|make_list|stringformat:"s"|safe }}{% endautoescape %}', {"a": mark_safe("&")}, u"[u'&']"), - 'filter-make_list04': ('{{ a|make_list|stringformat:"s"|safe }}', {"a": mark_safe("&")}, u"[u'&']"), - - # Running slugify on a pre-escaped string leads to odd behaviour, - # but the result is still safe. - 'filter-slugify01': ("{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}", {"a": "a & b", "b": mark_safe("a & b")}, u"a-b a-amp-b"), - 'filter-slugify02': ("{{ a|slugify }} {{ b|slugify }}", {"a": "a & b", "b": mark_safe("a & b")}, u"a-b a-amp-b"), - - # Notice that escaping is applied *after* any filters, so the string - # formatting here only needs to deal with pre-escaped characters. - 'filter-stringformat01': ('{% autoescape off %}.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.{% endautoescape %}', - {"a": "a<b", "b": mark_safe("a<b")}, u". a<b. . a<b."), - 'filter-stringformat02': ('.{{ a|stringformat:"5s" }}. .{{ b|stringformat:"5s" }}.', {"a": "a<b", "b": mark_safe("a<b")}, - u". a<b. . a<b."), - - # Test the title filter - 'filter-title1' : ('{{ a|title }}', {'a' : 'JOE\'S CRAB SHACK'}, u'Joe's Crab Shack'), - 'filter-title2' : ('{{ a|title }}', {'a' : '555 WEST 53RD STREET'}, u'555 West 53rd Street'), - - 'filter-truncatewords01': ('{% autoescape off %}{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}{% endautoescape %}', - {"a": "alpha & bravo", "b": mark_safe("alpha & bravo")}, u"alpha & ... alpha & ..."), - 'filter-truncatewords02': ('{{ a|truncatewords:"2" }} {{ b|truncatewords:"2"}}', - {"a": "alpha & bravo", "b": mark_safe("alpha & bravo")}, u"alpha & ... alpha & ..."), - - # The "upper" filter messes up entities (which are case-sensitive), - # so it's not safe for non-escaping purposes. - 'filter-upper01': ('{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}', {"a": "a & b", "b": mark_safe("a & b")}, u"A & B A & B"), - 'filter-upper02': ('{{ a|upper }} {{ b|upper }}', {"a": "a & b", "b": mark_safe("a & b")}, u"A & B A &AMP; B"), - - 'filter-urlize01': ('{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}', {"a": "http://example.com/?x=&y=", "b": mark_safe("http://example.com?x=&y=")}, u'<a href="http://example.com/?x=&y=" rel="nofollow">http://example.com/?x=&y=</a> <a href="http://example.com?x=&y=" rel="nofollow">http://example.com?x=&y=</a>'), - 'filter-urlize02': ('{{ a|urlize }} {{ b|urlize }}', {"a": "http://example.com/?x=&y=", "b": mark_safe("http://example.com?x=&y=")}, u'<a href="http://example.com/?x=&y=" rel="nofollow">http://example.com/?x=&y=</a> <a href="http://example.com?x=&y=" rel="nofollow">http://example.com?x=&y=</a>'), - 'filter-urlize03': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {"a": mark_safe("a & b")}, 'a & b'), - 'filter-urlize04': ('{{ a|urlize }}', {"a": mark_safe("a & b")}, 'a & b'), - - # This will lead to a nonsense result, but at least it won't be - # exploitable for XSS purposes when auto-escaping is on. - 'filter-urlize05': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {"a": "<script>alert('foo')</script>"}, "<script>alert('foo')</script>"), - 'filter-urlize06': ('{{ a|urlize }}', {"a": "<script>alert('foo')</script>"}, '<script>alert('foo')</script>'), - - # mailto: testing for urlize - 'filter-urlize07': ('{{ a|urlize }}', {"a": "Email me at me@example.com"}, 'Email me at <a href="mailto:me@example.com">me@example.com</a>'), - 'filter-urlize08': ('{{ a|urlize }}', {"a": "Email me at <me@example.com>"}, 'Email me at <<a href="mailto:me@example.com">me@example.com</a>>'), - - 'filter-urlizetrunc01': ('{% autoescape off %}{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}{% endautoescape %}', {"a": '"Unsafe" http://example.com/x=&y=', "b": mark_safe('"Safe" http://example.com?x=&y=')}, u'"Unsafe" <a href="http://example.com/x=&y=" rel="nofollow">http:...</a> "Safe" <a href="http://example.com?x=&y=" rel="nofollow">http:...</a>'), - 'filter-urlizetrunc02': ('{{ a|urlizetrunc:"8" }} {{ b|urlizetrunc:"8" }}', {"a": '"Unsafe" http://example.com/x=&y=', "b": mark_safe('"Safe" http://example.com?x=&y=')}, u'"Unsafe" <a href="http://example.com/x=&y=" rel="nofollow">http:...</a> "Safe" <a href="http://example.com?x=&y=" rel="nofollow">http:...</a>'), - - 'filter-wordcount01': ('{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}', {"a": "a & b", "b": mark_safe("a & b")}, "3 3"), - 'filter-wordcount02': ('{{ a|wordcount }} {{ b|wordcount }}', {"a": "a & b", "b": mark_safe("a & b")}, "3 3"), - - 'filter-wordwrap01': ('{% autoescape off %}{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}{% endautoescape %}', {"a": "a & b", "b": mark_safe("a & b")}, u"a &\nb a &\nb"), - 'filter-wordwrap02': ('{{ a|wordwrap:"3" }} {{ b|wordwrap:"3" }}', {"a": "a & b", "b": mark_safe("a & b")}, u"a &\nb a &\nb"), - - 'filter-ljust01': ('{% autoescape off %}.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, u".a&b . .a&b ."), - 'filter-ljust02': ('.{{ a|ljust:"5" }}. .{{ b|ljust:"5" }}.', {"a": "a&b", "b": mark_safe("a&b")}, u".a&b . .a&b ."), - - 'filter-rjust01': ('{% autoescape off %}.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, u". a&b. . a&b."), - 'filter-rjust02': ('.{{ a|rjust:"5" }}. .{{ b|rjust:"5" }}.', {"a": "a&b", "b": mark_safe("a&b")}, u". a&b. . a&b."), - - 'filter-center01': ('{% autoescape off %}.{{ a|center:"5" }}. .{{ b|center:"5" }}.{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, u". a&b . . a&b ."), - 'filter-center02': ('.{{ a|center:"5" }}. .{{ b|center:"5" }}.', {"a": "a&b", "b": mark_safe("a&b")}, u". a&b . . a&b ."), - - 'filter-cut01': ('{% autoescape off %}{{ a|cut:"x" }} {{ b|cut:"x" }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, u"&y &y"), - 'filter-cut02': ('{{ a|cut:"x" }} {{ b|cut:"x" }}', {"a": "x&y", "b": mark_safe("x&y")}, u"&y &y"), - 'filter-cut03': ('{% autoescape off %}{{ a|cut:"&" }} {{ b|cut:"&" }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, u"xy xamp;y"), - 'filter-cut04': ('{{ a|cut:"&" }} {{ b|cut:"&" }}', {"a": "x&y", "b": mark_safe("x&y")}, u"xy xamp;y"), - # Passing ';' to cut can break existing HTML entities, so those strings - # are auto-escaped. - 'filter-cut05': ('{% autoescape off %}{{ a|cut:";" }} {{ b|cut:";" }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, u"x&y x&y"), - 'filter-cut06': ('{{ a|cut:";" }} {{ b|cut:";" }}', {"a": "x&y", "b": mark_safe("x&y")}, u"x&y x&ampy"), - - # The "escape" filter works the same whether autoescape is on or off, - # but it has no effect on strings already marked as safe. - 'filter-escape01': ('{{ a|escape }} {{ b|escape }}', {"a": "x&y", "b": mark_safe("x&y")}, u"x&y x&y"), - 'filter-escape02': ('{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}', {"a": "x&y", "b": mark_safe("x&y")}, "x&y x&y"), - - # It is only applied once, regardless of the number of times it - # appears in a chain. - 'filter-escape03': ('{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}', {"a": "x&y"}, u"x&y"), - 'filter-escape04': ('{{ a|escape|escape }}', {"a": "x&y"}, u"x&y"), - - # Force_escape is applied immediately. It can be used to provide - # double-escaping, for example. - 'filter-force-escape01': ('{% autoescape off %}{{ a|force_escape }}{% endautoescape %}', {"a": "x&y"}, u"x&y"), - 'filter-force-escape02': ('{{ a|force_escape }}', {"a": "x&y"}, u"x&y"), - 'filter-force-escape03': ('{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}', {"a": "x&y"}, u"x&amp;y"), - 'filter-force-escape04': ('{{ a|force_escape|force_escape }}', {"a": "x&y"}, u"x&amp;y"), - - # Because the result of force_escape is "safe", an additional - # escape filter has no effect. - 'filter-force-escape05': ('{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}', {"a": "x&y"}, u"x&y"), - 'filter-force-escape06': ('{{ a|force_escape|escape }}', {"a": "x&y"}, u"x&y"), - 'filter-force-escape07': ('{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}', {"a": "x&y"}, u"x&y"), - 'filter-force-escape08': ('{{ a|escape|force_escape }}', {"a": "x&y"}, u"x&y"), - - # The contents in "linebreaks" and "linebreaksbr" are escaped - # according to the current autoescape setting. - 'filter-linebreaks01': ('{{ a|linebreaks }} {{ b|linebreaks }}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, u"<p>x&<br />y</p> <p>x&<br />y</p>"), - 'filter-linebreaks02': ('{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, u"<p>x&<br />y</p> <p>x&<br />y</p>"), - - 'filter-linebreaksbr01': ('{{ a|linebreaksbr }} {{ b|linebreaksbr }}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, u"x&<br />y x&<br />y"), - 'filter-linebreaksbr02': ('{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}', {"a": "x&\ny", "b": mark_safe("x&\ny")}, u"x&<br />y x&<br />y"), - - 'filter-safe01': ("{{ a }} -- {{ a|safe }}", {"a": u"<b>hello</b>"}, "<b>hello</b> -- <b>hello</b>"), - 'filter-safe02': ("{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}", {"a": "<b>hello</b>"}, u"<b>hello</b> -- <b>hello</b>"), - - 'filter-safeseq01': ('{{ a|join:", " }} -- {{ a|safeseq|join:", " }}', {"a": ["&", "<"]}, "&, < -- &, <"), - 'filter-safeseq02': ('{% autoescape off %}{{ a|join:", " }} -- {{ a|safeseq|join:", " }}{% endautoescape %}', {"a": ["&", "<"]}, "&, < -- &, <"), - - 'filter-removetags01': ('{{ a|removetags:"a b" }} {{ b|removetags:"a b" }}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, u"x <p>y</p> x <p>y</p>"), - 'filter-removetags02': ('{% autoescape off %}{{ a|removetags:"a b" }} {{ b|removetags:"a b" }}{% endautoescape %}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, u"x <p>y</p> x <p>y</p>"), - - 'filter-striptags01': ('{{ a|striptags }} {{ b|striptags }}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, "x y x y"), - 'filter-striptags02': ('{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}', {"a": "<a>x</a> <p><b>y</b></p>", "b": mark_safe("<a>x</a> <p><b>y</b></p>")}, "x y x y"), - - 'filter-first01': ('{{ a|first }} {{ b|first }}', {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}, "a&b a&b"), - 'filter-first02': ('{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}', {"a": ["a&b", "x"], "b": [mark_safe("a&b"), "x"]}, "a&b a&b"), - - 'filter-last01': ('{{ a|last }} {{ b|last }}', {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}, "a&b a&b"), - 'filter-last02': ('{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}', {"a": ["x", "a&b"], "b": ["x", mark_safe("a&b")]}, "a&b a&b"), - - 'filter-random01': ('{{ a|random }} {{ b|random }}', {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]}, "a&b a&b"), - 'filter-random02': ('{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}', {"a": ["a&b", "a&b"], "b": [mark_safe("a&b"), mark_safe("a&b")]}, "a&b a&b"), - - 'filter-slice01': ('{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}', {"a": "a&b", "b": mark_safe("a&b")}, "&b &b"), - 'filter-slice02': ('{% autoescape off %}{{ a|slice:"1:3" }} {{ b|slice:"1:3" }}{% endautoescape %}', {"a": "a&b", "b": mark_safe("a&b")}, "&b &b"), - - 'filter-unordered_list01': ('{{ a|unordered_list }}', {"a": ["x>", [["<y", []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), - 'filter-unordered_list02': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {"a": ["x>", [["<y", []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), - 'filter-unordered_list03': ('{{ a|unordered_list }}', {"a": ["x>", [[mark_safe("<y"), []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), - 'filter-unordered_list04': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {"a": ["x>", [[mark_safe("<y"), []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), - 'filter-unordered_list05': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {"a": ["x>", [["<y", []]]]}, "\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>"), - - # Literal string arguments to the default filter are always treated as - # safe strings, regardless of the auto-escaping state. - # - # Note: we have to use {"a": ""} here, otherwise the invalid template - # variable string interferes with the test result. - 'filter-default01': ('{{ a|default:"x<" }}', {"a": ""}, "x<"), - 'filter-default02': ('{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}', {"a": ""}, "x<"), - 'filter-default03': ('{{ a|default:"x<" }}', {"a": mark_safe("x>")}, "x>"), - 'filter-default04': ('{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}', {"a": mark_safe("x>")}, "x>"), - - 'filter-default_if_none01': ('{{ a|default:"x<" }}', {"a": None}, "x<"), - 'filter-default_if_none02': ('{% autoescape off %}{{ a|default:"x<" }}{% endautoescape %}', {"a": None}, "x<"), - - 'filter-phone2numeric01': ('{{ a|phone2numeric }} {{ b|phone2numeric }}', {"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>") }, "<1-800-2255-63> <1-800-2255-63>"), - 'filter-phone2numeric02': ('{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}', {"a": "<1-800-call-me>", "b": mark_safe("<1-800-call-me>") }, "<1-800-2255-63> <1-800-2255-63>"), - 'filter-phone2numeric03': ('{{ a|phone2numeric }}', {"a": "How razorback-jumping frogs can level six piqued gymnasts!"}, "469 729672225-5867464 37647 226 53835 749 747833 49662787!"), - - # Ensure iriencode keeps safe strings: - 'filter-iriencode01': ('{{ url|iriencode }}', {'url': '?test=1&me=2'}, '?test=1&me=2'), - 'filter-iriencode02': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': '?test=1&me=2'}, '?test=1&me=2'), - 'filter-iriencode03': ('{{ url|iriencode }}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'), - 'filter-iriencode04': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'), - - # Chaining a bunch of safeness-preserving filters should not alter - # the safe status either way. - 'chaining01': ('{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}', {"a": "a < b", "b": mark_safe("a < b")}, " A < b . A < b "), - 'chaining02': ('{% autoescape off %}{{ a|capfirst|center:"7" }}.{{ b|capfirst|center:"7" }}{% endautoescape %}', {"a": "a < b", "b": mark_safe("a < b")}, " A < b . A < b "), - - # Using a filter that forces a string back to unsafe: - 'chaining03': ('{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}', {"a": "a < b", "b": mark_safe("a < b")}, "A < .A < "), - 'chaining04': ('{% autoescape off %}{{ a|cut:"b"|capfirst }}.{{ b|cut:"b"|capfirst }}{% endautoescape %}', {"a": "a < b", "b": mark_safe("a < b")}, "A < .A < "), - - # Using a filter that forces safeness does not lead to double-escaping - 'chaining05': ('{{ a|escape|capfirst }}', {"a": "a < b"}, "A < b"), - 'chaining06': ('{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}', {"a": "a < b"}, "A < b"), - - # Force to safe, then back (also showing why using force_escape too - # early in a chain can lead to unexpected results). - 'chaining07': ('{{ a|force_escape|cut:";" }}', {"a": "a < b"}, "a &lt b"), - 'chaining08': ('{% autoescape off %}{{ a|force_escape|cut:";" }}{% endautoescape %}', {"a": "a < b"}, "a < b"), - 'chaining09': ('{{ a|cut:";"|force_escape }}', {"a": "a < b"}, "a < b"), - 'chaining10': ('{% autoescape off %}{{ a|cut:";"|force_escape }}{% endautoescape %}', {"a": "a < b"}, "a < b"), - 'chaining11': ('{{ a|cut:"b"|safe }}', {"a": "a < b"}, "a < "), - 'chaining12': ('{% autoescape off %}{{ a|cut:"b"|safe }}{% endautoescape %}', {"a": "a < b"}, "a < "), - 'chaining13': ('{{ a|safe|force_escape }}', {"a": "a < b"}, "a < b"), - 'chaining14': ('{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}', {"a": "a < b"}, "a < b"), - - # Filters decorated with stringfilter still respect is_safe. - 'autoescape-stringfilter01': (r'{{ unsafe|capfirst }}', {'unsafe': UnsafeClass()}, 'You & me'), - 'autoescape-stringfilter02': (r'{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}', {'unsafe': UnsafeClass()}, 'You & me'), - 'autoescape-stringfilter03': (r'{{ safe|capfirst }}', {'safe': SafeClass()}, 'You > me'), - 'autoescape-stringfilter04': (r'{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}', {'safe': SafeClass()}, 'You > me'), - - 'escapejs01': (r'{{ a|escapejs }}', {'a': 'testing\r\njavascript \'string" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'), - 'escapejs02': (r'{% autoescape off %}{{ a|escapejs }}{% endautoescape %}', {'a': 'testing\r\njavascript \'string" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'), - - - # length filter. - 'length01': ('{{ list|length }}', {'list': ['4', None, True, {}]}, '4'), - 'length02': ('{{ list|length }}', {'list': []}, '0'), - 'length03': ('{{ string|length }}', {'string': ''}, '0'), - 'length04': ('{{ string|length }}', {'string': 'django'}, '6'), - # Invalid uses that should fail silently. - 'length05': ('{{ int|length }}', {'int': 7}, ''), - 'length06': ('{{ None|length }}', {'None': None}, ''), - - # length_is filter. - 'length_is01': ('{% if some_list|length_is:"4" %}Four{% endif %}', {'some_list': ['4', None, True, {}]}, 'Four'), - 'length_is02': ('{% if some_list|length_is:"4" %}Four{% else %}Not Four{% endif %}', {'some_list': ['4', None, True, {}, 17]}, 'Not Four'), - 'length_is03': ('{% if mystring|length_is:"4" %}Four{% endif %}', {'mystring': 'word'}, 'Four'), - 'length_is04': ('{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}', {'mystring': 'Python'}, 'Not Four'), - 'length_is05': ('{% if mystring|length_is:"4" %}Four{% else %}Not Four{% endif %}', {'mystring': ''}, 'Not Four'), - 'length_is06': ('{% with var|length as my_length %}{{ my_length }}{% endwith %}', {'var': 'django'}, '6'), - # Boolean return value from length_is should not be coerced to a string - 'length_is07': (r'{% if "X"|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}', {}, 'Length not 0'), - 'length_is08': (r'{% if "X"|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}', {}, 'Length is 1'), - # Invalid uses that should fail silently. - 'length_is09': ('{{ var|length_is:"fish" }}', {'var': 'django'}, ''), - 'length_is10': ('{{ int|length_is:"1" }}', {'int': 7}, ''), - 'length_is11': ('{{ none|length_is:"1" }}', {'none': None}, ''), - - 'join01': (r'{{ a|join:", " }}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'), - 'join02': (r'{% autoescape off %}{{ a|join:", " }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'), - 'join03': (r'{{ a|join:" & " }}', {'a': ['alpha', 'beta & me']}, 'alpha & beta & me'), - 'join04': (r'{% autoescape off %}{{ a|join:" & " }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha & beta & me'), - - # Test that joining with unsafe joiners don't result in unsafe strings (#11377) - 'join05': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': ' & '}, 'alpha & beta & me'), - 'join06': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta & me'), - 'join07': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': ' & ' }, 'alpha & beta & me'), - 'join08': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta & me'), - - 'date01': (r'{{ d|date:"m" }}', {'d': datetime(2008, 1, 1)}, '01'), - 'date02': (r'{{ d|date }}', {'d': datetime(2008, 1, 1)}, 'Jan. 1, 2008'), - #Ticket 9520: Make sure |date doesn't blow up on non-dates - 'date03': (r'{{ d|date:"m" }}', {'d': 'fail_string'}, ''), - - # Tests for #11687 - 'add01': (r'{{ i|add:"5" }}', {'i': 2000}, '2005'), - 'add02': (r'{{ i|add:"napis" }}', {'i': 2000}, '2000'), - 'add03': (r'{{ i|add:16 }}', {'i': 'not_an_int'}, 'not_an_int'), - 'add04': (r'{{ i|add:"16" }}', {'i': 'not_an_int'}, 'not_an_int16'), - 'add05': (r'{{ l1|add:l2 }}', {'l1': [1, 2], 'l2': [3, 4]}, '[1, 2, 3, 4]'), - 'add06': (r'{{ t1|add:t2 }}', {'t1': (3, 4), 't2': (1, 2)}, '(3, 4, 1, 2)'), - 'add07': (r'{{ d|add:t }}', {'d': date(2000, 1, 1), 't': timedelta(10)}, 'Jan. 11, 2000'), - } diff --git a/parts/django/tests/regressiontests/templates/loaders.py b/parts/django/tests/regressiontests/templates/loaders.py deleted file mode 100644 index 47cd18a..0000000 --- a/parts/django/tests/regressiontests/templates/loaders.py +++ /dev/null @@ -1,150 +0,0 @@ -""" -Test cases for the template loaders - -Note: This test requires setuptools! -""" - -from django.conf import settings - -if __name__ == '__main__': - settings.configure() - -import unittest -import sys -import pkg_resources -import imp -import StringIO -import os.path -import warnings - -from django.template import TemplateDoesNotExist, Context -from django.template.loaders.eggs import load_template_source as lts_egg -from django.template.loaders.eggs import Loader as EggLoader -from django.template import loader -from django.test.utils import get_warnings_state, restore_warnings_state - -# Mock classes and objects for pkg_resources functions. -class MockProvider(pkg_resources.NullProvider): - def __init__(self, module): - pkg_resources.NullProvider.__init__(self, module) - self.module = module - - def _has(self, path): - return path in self.module._resources - - def _isdir(self,path): - return False - - def get_resource_stream(self, manager, resource_name): - return self.module._resources[resource_name] - - def _get(self, path): - return self.module._resources[path].read() - -class MockLoader(object): - pass - -def create_egg(name, resources): - """ - Creates a mock egg with a list of resources. - - name: The name of the module. - resources: A dictionary of resources. Keys are the names and values the data. - """ - egg = imp.new_module(name) - egg.__loader__ = MockLoader() - egg._resources = resources - sys.modules[name] = egg - -class DeprecatedEggLoaderTest(unittest.TestCase): - "Test the deprecated load_template_source interface to the egg loader" - def setUp(self): - pkg_resources._provider_factories[MockLoader] = MockProvider - - self.empty_egg = create_egg("egg_empty", {}) - self.egg_1 = create_egg("egg_1", { - os.path.normcase('templates/y.html') : StringIO.StringIO("y"), - os.path.normcase('templates/x.txt') : StringIO.StringIO("x"), - }) - self._old_installed_apps = settings.INSTALLED_APPS - settings.INSTALLED_APPS = [] - self._warnings_state = get_warnings_state() - warnings.simplefilter("ignore", PendingDeprecationWarning) - - def tearDown(self): - settings.INSTALLED_APPS = self._old_installed_apps - restore_warnings_state(self._warnings_state) - - def test_existing(self): - "A template can be loaded from an egg" - settings.INSTALLED_APPS = ['egg_1'] - contents, template_name = lts_egg("y.html") - self.assertEqual(contents, "y") - self.assertEqual(template_name, "egg:egg_1:templates/y.html") - - -class EggLoaderTest(unittest.TestCase): - def setUp(self): - pkg_resources._provider_factories[MockLoader] = MockProvider - - self.empty_egg = create_egg("egg_empty", {}) - self.egg_1 = create_egg("egg_1", { - os.path.normcase('templates/y.html') : StringIO.StringIO("y"), - os.path.normcase('templates/x.txt') : StringIO.StringIO("x"), - }) - self._old_installed_apps = settings.INSTALLED_APPS - settings.INSTALLED_APPS = [] - - def tearDown(self): - settings.INSTALLED_APPS = self._old_installed_apps - - def test_empty(self): - "Loading any template on an empty egg should fail" - settings.INSTALLED_APPS = ['egg_empty'] - egg_loader = EggLoader() - self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "not-existing.html") - - def test_non_existing(self): - "Template loading fails if the template is not in the egg" - settings.INSTALLED_APPS = ['egg_1'] - egg_loader = EggLoader() - self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "not-existing.html") - - def test_existing(self): - "A template can be loaded from an egg" - settings.INSTALLED_APPS = ['egg_1'] - egg_loader = EggLoader() - contents, template_name = egg_loader.load_template_source("y.html") - self.assertEqual(contents, "y") - self.assertEqual(template_name, "egg:egg_1:templates/y.html") - - def test_not_installed(self): - "Loading an existent template from an egg not included in INSTALLED_APPS should fail" - settings.INSTALLED_APPS = [] - egg_loader = EggLoader() - self.assertRaises(TemplateDoesNotExist, egg_loader.load_template_source, "y.html") - -class CachedLoader(unittest.TestCase): - def setUp(self): - self.old_TEMPLATE_LOADERS = settings.TEMPLATE_LOADERS - settings.TEMPLATE_LOADERS = ( - ('django.template.loaders.cached.Loader', ( - 'django.template.loaders.filesystem.Loader', - ) - ), - ) - def tearDown(self): - settings.TEMPLATE_LOADERS = self.old_TEMPLATE_LOADERS - - def test_templatedir_caching(self): - "Check that the template directories form part of the template cache key. Refs #13573" - # Retrive a template specifying a template directory to check - t1, name = loader.find_template('test.html', (os.path.join(os.path.dirname(__file__), 'templates', 'first'),)) - # Now retrieve the same template name, but from a different directory - t2, name = loader.find_template('test.html', (os.path.join(os.path.dirname(__file__), 'templates', 'second'),)) - - # The two templates should not have the same content - self.assertNotEqual(t1.render(Context({})), t2.render(Context({}))) - -if __name__ == "__main__": - unittest.main() diff --git a/parts/django/tests/regressiontests/templates/models.py b/parts/django/tests/regressiontests/templates/models.py deleted file mode 100644 index e69de29..0000000 --- a/parts/django/tests/regressiontests/templates/models.py +++ /dev/null diff --git a/parts/django/tests/regressiontests/templates/nodelist.py b/parts/django/tests/regressiontests/templates/nodelist.py deleted file mode 100644 index 89fac97..0000000 --- a/parts/django/tests/regressiontests/templates/nodelist.py +++ /dev/null @@ -1,30 +0,0 @@ -from unittest import TestCase -from django.template.loader import get_template_from_string -from django.template import VariableNode - - -class NodelistTest(TestCase): - - def test_for(self): - source = '{% for i in 1 %}{{ a }}{% endfor %}' - template = get_template_from_string(source) - vars = template.nodelist.get_nodes_by_type(VariableNode) - self.assertEqual(len(vars), 1) - - def test_if(self): - source = '{% if x %}{{ a }}{% endif %}' - template = get_template_from_string(source) - vars = template.nodelist.get_nodes_by_type(VariableNode) - self.assertEqual(len(vars), 1) - - def test_ifequal(self): - source = '{% ifequal x y %}{{ a }}{% endifequal %}' - template = get_template_from_string(source) - vars = template.nodelist.get_nodes_by_type(VariableNode) - self.assertEqual(len(vars), 1) - - def test_ifchanged(self): - source = '{% ifchanged x %}{{ a }}{% endifchanged %}' - template = get_template_from_string(source) - vars = template.nodelist.get_nodes_by_type(VariableNode) - self.assertEqual(len(vars), 1) diff --git a/parts/django/tests/regressiontests/templates/parser.py b/parts/django/tests/regressiontests/templates/parser.py deleted file mode 100644 index 93e8118..0000000 --- a/parts/django/tests/regressiontests/templates/parser.py +++ /dev/null @@ -1,84 +0,0 @@ -""" -Testing some internals of the template processing. These are *not* examples to be copied in user code. -""" -from unittest import TestCase - -from django.template import (TokenParser, FilterExpression, Parser, Variable, - TemplateSyntaxError) - - -class ParserTests(TestCase): - def test_token_parsing(self): - # Tests for TokenParser behavior in the face of quoted strings with - # spaces. - - p = TokenParser("tag thevar|filter sometag") - self.assertEqual(p.tagname, "tag") - self.assertEqual(p.value(), "thevar|filter") - self.assertTrue(p.more()) - self.assertEqual(p.tag(), "sometag") - self.assertFalse(p.more()) - - p = TokenParser('tag "a value"|filter sometag') - self.assertEqual(p.tagname, "tag") - self.assertEqual(p.value(), '"a value"|filter') - self.assertTrue(p.more()) - self.assertEqual(p.tag(), "sometag") - self.assertFalse(p.more()) - - p = TokenParser("tag 'a value'|filter sometag") - self.assertEqual(p.tagname, "tag") - self.assertEqual(p.value(), "'a value'|filter") - self.assertTrue(p.more()) - self.assertEqual(p.tag(), "sometag") - self.assertFalse(p.more()) - - def test_filter_parsing(self): - c = {"article": {"section": u"News"}} - p = Parser("") - - def fe_test(s, val): - self.assertEqual(FilterExpression(s, p).resolve(c), val) - - fe_test("article.section", u"News") - fe_test("article.section|upper", u"NEWS") - fe_test(u'"News"', u"News") - fe_test(u"'News'", u"News") - fe_test(ur'"Some \"Good\" News"', u'Some "Good" News') - fe_test(ur'"Some \"Good\" News"', u'Some "Good" News') - fe_test(ur"'Some \'Bad\' News'", u"Some 'Bad' News") - - fe = FilterExpression(ur'"Some \"Good\" News"', p) - self.assertEqual(fe.filters, []) - self.assertEqual(fe.var, u'Some "Good" News') - - # Filtered variables should reject access of attributes beginning with - # underscores. - self.assertRaises(TemplateSyntaxError, - FilterExpression, "article._hidden|upper", p - ) - - def test_variable_parsing(self): - c = {"article": {"section": u"News"}} - self.assertEqual(Variable("article.section").resolve(c), "News") - self.assertEqual(Variable(u'"News"').resolve(c), "News") - self.assertEqual(Variable(u"'News'").resolve(c), "News") - - # Translated strings are handled correctly. - self.assertEqual(Variable("_(article.section)").resolve(c), "News") - self.assertEqual(Variable('_("Good News")').resolve(c), "Good News") - self.assertEqual(Variable("_('Better News')").resolve(c), "Better News") - - # Escaped quotes work correctly as well. - self.assertEqual( - Variable(ur'"Some \"Good\" News"').resolve(c), 'Some "Good" News' - ) - self.assertEqual( - Variable(ur"'Some \'Better\' News'").resolve(c), "Some 'Better' News" - ) - - # Variables should reject access of attributes beginning with - # underscores. - self.assertRaises(TemplateSyntaxError, - Variable, "article._hidden" - ) diff --git a/parts/django/tests/regressiontests/templates/smartif.py b/parts/django/tests/regressiontests/templates/smartif.py deleted file mode 100644 index 5e5d770..0000000 --- a/parts/django/tests/regressiontests/templates/smartif.py +++ /dev/null @@ -1,53 +0,0 @@ -import unittest -from django.template.smartif import IfParser, Literal - -class SmartIfTests(unittest.TestCase): - - def assertCalcEqual(self, expected, tokens): - self.assertEqual(expected, IfParser(tokens).parse().eval({})) - - # We only test things here that are difficult to test elsewhere - # Many other tests are found in the main tests for builtin template tags - # Test parsing via the printed parse tree - def test_not(self): - var = IfParser(["not", False]).parse() - self.assertEqual("(not (literal False))", repr(var)) - self.assert_(var.eval({})) - - self.assertFalse(IfParser(["not", True]).parse().eval({})) - - def test_or(self): - var = IfParser([True, "or", False]).parse() - self.assertEqual("(or (literal True) (literal False))", repr(var)) - self.assert_(var.eval({})) - - def test_in(self): - list_ = [1,2,3] - self.assertCalcEqual(True, [1, 'in', list_]) - self.assertCalcEqual(False, [1, 'in', None]) - self.assertCalcEqual(False, [None, 'in', list_]) - - def test_not_in(self): - list_ = [1,2,3] - self.assertCalcEqual(False, [1, 'not', 'in', list_]) - self.assertCalcEqual(True, [4, 'not', 'in', list_]) - self.assertCalcEqual(False, [1, 'not', 'in', None]) - self.assertCalcEqual(True, [None, 'not', 'in', list_]) - - def test_precedence(self): - # (False and False) or True == True <- we want this one, like Python - # False and (False or True) == False - self.assertCalcEqual(True, [False, 'and', False, 'or', True]) - - # True or (False and False) == True <- we want this one, like Python - # (True or False) and False == False - self.assertCalcEqual(True, [True, 'or', False, 'and', False]) - - # (1 or 1) == 2 -> False - # 1 or (1 == 2) -> True <- we want this one - self.assertCalcEqual(True, [1, 'or', 1, '==', 2]) - - self.assertCalcEqual(True, [True, '==', True, 'or', True, '==', False]) - - self.assertEqual("(or (and (== (literal 1) (literal 2)) (literal 3)) (literal 4))", - repr(IfParser([1, '==', 2, 'and', 3, 'or', 4]).parse())) diff --git a/parts/django/tests/regressiontests/templates/templates/broken_base.html b/parts/django/tests/regressiontests/templates/templates/broken_base.html deleted file mode 100644 index aa41f44..0000000 --- a/parts/django/tests/regressiontests/templates/templates/broken_base.html +++ /dev/null @@ -1 +0,0 @@ -{% include "missing.html" %} diff --git a/parts/django/tests/regressiontests/templates/templates/first/test.html b/parts/django/tests/regressiontests/templates/templates/first/test.html deleted file mode 100644 index 6029fe5..0000000 --- a/parts/django/tests/regressiontests/templates/templates/first/test.html +++ /dev/null @@ -1 +0,0 @@ -First template diff --git a/parts/django/tests/regressiontests/templates/templates/second/test.html b/parts/django/tests/regressiontests/templates/templates/second/test.html deleted file mode 100644 index d9b316f..0000000 --- a/parts/django/tests/regressiontests/templates/templates/second/test.html +++ /dev/null @@ -1 +0,0 @@ -Second template diff --git a/parts/django/tests/regressiontests/templates/templates/test_extends_error.html b/parts/django/tests/regressiontests/templates/templates/test_extends_error.html deleted file mode 100755 index fc74690..0000000 --- a/parts/django/tests/regressiontests/templates/templates/test_extends_error.html +++ /dev/null @@ -1 +0,0 @@ -{% extends "broken_base.html" %} diff --git a/parts/django/tests/regressiontests/templates/templatetags/__init__.py b/parts/django/tests/regressiontests/templates/templatetags/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/parts/django/tests/regressiontests/templates/templatetags/__init__.py +++ /dev/null diff --git a/parts/django/tests/regressiontests/templates/templatetags/broken_tag.py b/parts/django/tests/regressiontests/templates/templatetags/broken_tag.py deleted file mode 100644 index c70e183..0000000 --- a/parts/django/tests/regressiontests/templates/templatetags/broken_tag.py +++ /dev/null @@ -1 +0,0 @@ -from django import Xtemplate diff --git a/parts/django/tests/regressiontests/templates/templatetags/custom.py b/parts/django/tests/regressiontests/templates/templatetags/custom.py deleted file mode 100644 index fdf8d10..0000000 --- a/parts/django/tests/regressiontests/templates/templatetags/custom.py +++ /dev/null @@ -1,11 +0,0 @@ -from django import template -from django.template.defaultfilters import stringfilter - -register = template.Library() - -def trim(value, num): - return value[:num] -trim = stringfilter(trim) - -register.filter(trim) - diff --git a/parts/django/tests/regressiontests/templates/tests.py b/parts/django/tests/regressiontests/templates/tests.py deleted file mode 100644 index 62b2237..0000000 --- a/parts/django/tests/regressiontests/templates/tests.py +++ /dev/null @@ -1,1389 +0,0 @@ -# -*- coding: utf-8 -*- -from django.conf import settings - -if __name__ == '__main__': - # When running this file in isolation, we need to set up the configuration - # before importing 'template'. - settings.configure() - -from datetime import datetime, timedelta -import time -import os -import sys -import traceback -import unittest - -from django import template -from django.core import urlresolvers -from django.template import loader -from django.template.loaders import app_directories, filesystem, cached -from django.utils.translation import activate, deactivate, ugettext as _ -from django.utils.safestring import mark_safe -from django.utils.tzinfo import LocalTimezone - -from context import ContextTests -from custom import CustomTests -from parser import ParserTests -from unicode import UnicodeTests -from nodelist import NodelistTest -from smartif import * - -try: - from loaders import * -except ImportError: - pass # If setuptools isn't installed, that's fine. Just move on. - -import filters - -################################# -# Custom template tag for tests # -################################# - -register = template.Library() - -class EchoNode(template.Node): - def __init__(self, contents): - self.contents = contents - - def render(self, context): - return " ".join(self.contents) - -def do_echo(parser, token): - return EchoNode(token.contents.split()[1:]) - -register.tag("echo", do_echo) - -template.libraries['testtags'] = register - -##################################### -# Helper objects for template tests # -##################################### - -class SomeException(Exception): - silent_variable_failure = True - -class SomeOtherException(Exception): - pass - -class ContextStackException(Exception): - pass - -class SomeClass: - def __init__(self): - self.otherclass = OtherClass() - - def method(self): - return "SomeClass.method" - - def method2(self, o): - return o - - def method3(self): - raise SomeException - - def method4(self): - raise SomeOtherException - -class OtherClass: - def method(self): - return "OtherClass.method" - -class TestObj(object): - def is_true(self): - return True - - def is_false(self): - return False - - def is_bad(self): - time.sleep(0.3) - return True - -class SilentGetItemClass(object): - def __getitem__(self, key): - raise SomeException - -class SilentAttrClass(object): - def b(self): - raise SomeException - b = property(b) - -class UTF8Class: - "Class whose __str__ returns non-ASCII data" - def __str__(self): - return u'ŠĐĆŽćžšđ'.encode('utf-8') - -class Templates(unittest.TestCase): - def test_loaders_security(self): - ad_loader = app_directories.Loader() - fs_loader = filesystem.Loader() - def test_template_sources(path, template_dirs, expected_sources): - if isinstance(expected_sources, list): - # Fix expected sources so they are normcased and abspathed - expected_sources = [os.path.normcase(os.path.abspath(s)) for s in expected_sources] - # Test the two loaders (app_directores and filesystem). - func1 = lambda p, t: list(ad_loader.get_template_sources(p, t)) - func2 = lambda p, t: list(fs_loader.get_template_sources(p, t)) - for func in (func1, func2): - if isinstance(expected_sources, list): - self.assertEqual(func(path, template_dirs), expected_sources) - else: - self.assertRaises(expected_sources, func, path, template_dirs) - - template_dirs = ['/dir1', '/dir2'] - test_template_sources('index.html', template_dirs, - ['/dir1/index.html', '/dir2/index.html']) - test_template_sources('/etc/passwd', template_dirs, []) - test_template_sources('etc/passwd', template_dirs, - ['/dir1/etc/passwd', '/dir2/etc/passwd']) - test_template_sources('../etc/passwd', template_dirs, []) - test_template_sources('../../../etc/passwd', template_dirs, []) - test_template_sources('/dir1/index.html', template_dirs, - ['/dir1/index.html']) - test_template_sources('../dir2/index.html', template_dirs, - ['/dir2/index.html']) - test_template_sources('/dir1blah', template_dirs, []) - test_template_sources('../dir1blah', template_dirs, []) - - # UTF-8 bytestrings are permitted. - test_template_sources('\xc3\x85ngstr\xc3\xb6m', template_dirs, - [u'/dir1/Ångström', u'/dir2/Ångström']) - # Unicode strings are permitted. - test_template_sources(u'Ångström', template_dirs, - [u'/dir1/Ångström', u'/dir2/Ångström']) - test_template_sources(u'Ångström', ['/Straße'], [u'/Straße/Ångström']) - test_template_sources('\xc3\x85ngstr\xc3\xb6m', ['/Straße'], - [u'/Straße/Ångström']) - # Invalid UTF-8 encoding in bytestrings is not. Should raise a - # semi-useful error message. - test_template_sources('\xc3\xc3', template_dirs, UnicodeDecodeError) - - # Case insensitive tests (for win32). Not run unless we're on - # a case insensitive operating system. - if os.path.normcase('/TEST') == os.path.normpath('/test'): - template_dirs = ['/dir1', '/DIR2'] - test_template_sources('index.html', template_dirs, - ['/dir1/index.html', '/dir2/index.html']) - test_template_sources('/DIR1/index.HTML', template_dirs, - ['/dir1/index.html']) - - def test_loader_debug_origin(self): - # Turn TEMPLATE_DEBUG on, so that the origin file name will be kept with - # the compiled templates. - old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True - old_loaders = loader.template_source_loaders - - try: - loader.template_source_loaders = (filesystem.Loader(),) - - # We rely on the fact that runtests.py sets up TEMPLATE_DIRS to - # point to a directory containing a 404.html file. Also that - # the file system and app directories loaders both inherit the - # load_template method from the BaseLoader class, so we only need - # to test one of them. - load_name = '404.html' - template = loader.get_template(load_name) - template_name = template.nodelist[0].source[0].name - self.assertTrue(template_name.endswith(load_name), - 'Template loaded by filesystem loader has incorrect name for debug page: %s' % template_name) - - # Aso test the cached loader, since it overrides load_template - cache_loader = cached.Loader(('',)) - cache_loader._cached_loaders = loader.template_source_loaders - loader.template_source_loaders = (cache_loader,) - - template = loader.get_template(load_name) - template_name = template.nodelist[0].source[0].name - self.assertTrue(template_name.endswith(load_name), - 'Template loaded through cached loader has incorrect name for debug page: %s' % template_name) - - template = loader.get_template(load_name) - template_name = template.nodelist[0].source[0].name - self.assertTrue(template_name.endswith(load_name), - 'Cached template loaded through cached loader has incorrect name for debug page: %s' % template_name) - finally: - loader.template_source_loaders = old_loaders - settings.TEMPLATE_DEBUG = old_td - - def test_extends_include_missing_baseloader(self): - """ - Tests that the correct template is identified as not existing - when {% extends %} specifies a template that does exist, but - that template has an {% include %} of something that does not - exist. See #12787. - """ - - # TEMPLATE_DEBUG must be true, otherwise the exception raised - # during {% include %} processing will be suppressed. - old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True - old_loaders = loader.template_source_loaders - - try: - # Test the base loader class via the app loader. load_template - # from base is used by all shipped loaders excepting cached, - # which has its own test. - loader.template_source_loaders = (app_directories.Loader(),) - - load_name = 'test_extends_error.html' - tmpl = loader.get_template(load_name) - r = None - try: - r = tmpl.render(template.Context({})) - except template.TemplateSyntaxError, e: - settings.TEMPLATE_DEBUG = old_td - self.assertEqual(e.args[0], 'Caught TemplateDoesNotExist while rendering: missing.html') - self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) - finally: - loader.template_source_loaders = old_loaders - settings.TEMPLATE_DEBUG = old_td - - def test_extends_include_missing_cachedloader(self): - """ - Same as test_extends_include_missing_baseloader, only tests - behavior of the cached loader instead of BaseLoader. - """ - - old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True - old_loaders = loader.template_source_loaders - - try: - cache_loader = cached.Loader(('',)) - cache_loader._cached_loaders = (app_directories.Loader(),) - loader.template_source_loaders = (cache_loader,) - - load_name = 'test_extends_error.html' - tmpl = loader.get_template(load_name) - r = None - try: - r = tmpl.render(template.Context({})) - except template.TemplateSyntaxError, e: - self.assertEqual(e.args[0], 'Caught TemplateDoesNotExist while rendering: missing.html') - self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) - - # For the cached loader, repeat the test, to ensure the first attempt did not cache a - # result that behaves incorrectly on subsequent attempts. - tmpl = loader.get_template(load_name) - try: - tmpl.render(template.Context({})) - except template.TemplateSyntaxError, e: - self.assertEqual(e.args[0], 'Caught TemplateDoesNotExist while rendering: missing.html') - self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r) - finally: - loader.template_source_loaders = old_loaders - settings.TEMPLATE_DEBUG = old_td - - def test_token_smart_split(self): - # Regression test for #7027 - token = template.Token(template.TOKEN_BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")') - split = token.split_contents() - self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")']) - - def test_url_reverse_no_settings_module(self): - # Regression test for #9005 - from django.template import Template, Context, TemplateSyntaxError - - old_settings_module = settings.SETTINGS_MODULE - old_template_debug = settings.TEMPLATE_DEBUG - - settings.SETTINGS_MODULE = None - settings.TEMPLATE_DEBUG = True - - t = Template('{% url will_not_match %}') - c = Context() - try: - rendered = t.render(c) - except TemplateSyntaxError, e: - # Assert that we are getting the template syntax error and not the - # string encoding error. - self.assertEquals(e.args[0], "Caught NoReverseMatch while rendering: Reverse for 'will_not_match' with arguments '()' and keyword arguments '{}' not found.") - - settings.SETTINGS_MODULE = old_settings_module - settings.TEMPLATE_DEBUG = old_template_debug - - def test_invalid_block_suggestion(self): - # See #7876 - from django.template import Template, TemplateSyntaxError - try: - t = Template("{% if 1 %}lala{% endblock %}{% endif %}") - except TemplateSyntaxError, e: - self.assertEquals(e.args[0], "Invalid block tag: 'endblock', expected 'else' or 'endif'") - - def test_templates(self): - template_tests = self.get_template_tests() - filter_tests = filters.get_filter_tests() - - # Quickly check that we aren't accidentally using a name in both - # template and filter tests. - overlapping_names = [name for name in filter_tests if name in template_tests] - assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names) - - template_tests.update(filter_tests) - - # Register our custom template loader. - def test_template_loader(template_name, template_dirs=None): - "A custom template loader that loads the unit-test templates." - try: - return (template_tests[template_name][0] , "test:%s" % template_name) - except KeyError: - raise template.TemplateDoesNotExist, template_name - - cache_loader = cached.Loader(('test_template_loader',)) - cache_loader._cached_loaders = (test_template_loader,) - - old_template_loaders = loader.template_source_loaders - loader.template_source_loaders = [cache_loader] - - failures = [] - tests = template_tests.items() - tests.sort() - - # Turn TEMPLATE_DEBUG off, because tests assume that. - old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False - - # Set TEMPLATE_STRING_IF_INVALID to a known string. - old_invalid = settings.TEMPLATE_STRING_IF_INVALID - expected_invalid_str = 'INVALID' - - # Warm the URL reversing cache. This ensures we don't pay the cost - # warming the cache during one of the tests. - urlresolvers.reverse('regressiontests.templates.views.client_action', - kwargs={'id':0,'action':"update"}) - - for name, vals in tests: - if isinstance(vals[2], tuple): - normal_string_result = vals[2][0] - invalid_string_result = vals[2][1] - if isinstance(invalid_string_result, basestring) and '%s' in invalid_string_result: - expected_invalid_str = 'INVALID %s' - invalid_string_result = invalid_string_result % vals[2][2] - template.invalid_var_format_string = True - else: - normal_string_result = vals[2] - invalid_string_result = vals[2] - - if 'LANGUAGE_CODE' in vals[1]: - activate(vals[1]['LANGUAGE_CODE']) - else: - activate('en-us') - - for invalid_str, result in [('', normal_string_result), - (expected_invalid_str, invalid_string_result)]: - settings.TEMPLATE_STRING_IF_INVALID = invalid_str - for is_cached in (False, True): - try: - start = datetime.now() - test_template = loader.get_template(name) - end = datetime.now() - if end-start > timedelta(seconds=0.2): - failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Took too long to parse test" % (is_cached, invalid_str, name)) - - start = datetime.now() - output = self.render(test_template, vals) - end = datetime.now() - if end-start > timedelta(seconds=0.2): - failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Took too long to render test" % (is_cached, invalid_str, name)) - except ContextStackException: - failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Context stack was left imbalanced" % (is_cached, invalid_str, name)) - continue - except Exception: - exc_type, exc_value, exc_tb = sys.exc_info() - if exc_type != result: - tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb)) - failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Got %s, exception: %s\n%s" % (is_cached, invalid_str, name, exc_type, exc_value, tb)) - continue - if output != result: - failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Expected %r, got %r" % (is_cached, invalid_str, name, result, output)) - cache_loader.reset() - - if 'LANGUAGE_CODE' in vals[1]: - deactivate() - - if template.invalid_var_format_string: - expected_invalid_str = 'INVALID' - template.invalid_var_format_string = False - - loader.template_source_loaders = old_template_loaders - deactivate() - settings.TEMPLATE_DEBUG = old_td - settings.TEMPLATE_STRING_IF_INVALID = old_invalid - - self.assertEqual(failures, [], "Tests failed:\n%s\n%s" % - ('-'*70, ("\n%s\n" % ('-'*70)).join(failures))) - - def render(self, test_template, vals): - context = template.Context(vals[1]) - before_stack_size = len(context.dicts) - output = test_template.render(context) - if len(context.dicts) != before_stack_size: - raise ContextStackException - return output - - def get_template_tests(self): - # SYNTAX -- - # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class) - return { - ### BASIC SYNTAX ################################################ - - # Plain text should go through the template parser untouched - 'basic-syntax01': ("something cool", {}, "something cool"), - - # Variables should be replaced with their value in the current - # context - 'basic-syntax02': ("{{ headline }}", {'headline':'Success'}, "Success"), - - # More than one replacement variable is allowed in a template - 'basic-syntax03': ("{{ first }} --- {{ second }}", {"first" : 1, "second" : 2}, "1 --- 2"), - - # Fail silently when a variable is not found in the current context - 'basic-syntax04': ("as{{ missing }}df", {}, ("asdf","asINVALIDdf")), - - # A variable may not contain more than one word - 'basic-syntax06': ("{{ multi word variable }}", {}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError for empty variable tags - 'basic-syntax07': ("{{ }}", {}, template.TemplateSyntaxError), - 'basic-syntax08': ("{{ }}", {}, template.TemplateSyntaxError), - - # Attribute syntax allows a template to call an object's attribute - 'basic-syntax09': ("{{ var.method }}", {"var": SomeClass()}, "SomeClass.method"), - - # Multiple levels of attribute access are allowed - 'basic-syntax10': ("{{ var.otherclass.method }}", {"var": SomeClass()}, "OtherClass.method"), - - # Fail silently when a variable's attribute isn't found - 'basic-syntax11': ("{{ var.blech }}", {"var": SomeClass()}, ("","INVALID")), - - # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore - 'basic-syntax12': ("{{ var.__dict__ }}", {"var": SomeClass()}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError when trying to access a variable containing an illegal character - 'basic-syntax13': ("{{ va>r }}", {}, template.TemplateSyntaxError), - 'basic-syntax14': ("{{ (var.r) }}", {}, template.TemplateSyntaxError), - 'basic-syntax15': ("{{ sp%am }}", {}, template.TemplateSyntaxError), - 'basic-syntax16': ("{{ eggs! }}", {}, template.TemplateSyntaxError), - 'basic-syntax17': ("{{ moo? }}", {}, template.TemplateSyntaxError), - - # Attribute syntax allows a template to call a dictionary key's value - 'basic-syntax18': ("{{ foo.bar }}", {"foo" : {"bar" : "baz"}}, "baz"), - - # Fail silently when a variable's dictionary key isn't found - 'basic-syntax19': ("{{ foo.spam }}", {"foo" : {"bar" : "baz"}}, ("","INVALID")), - - # Fail silently when accessing a non-simple method - 'basic-syntax20': ("{{ var.method2 }}", {"var": SomeClass()}, ("","INVALID")), - - # Don't get confused when parsing something that is almost, but not - # quite, a template tag. - 'basic-syntax21': ("a {{ moo %} b", {}, "a {{ moo %} b"), - 'basic-syntax22': ("{{ moo #}", {}, "{{ moo #}"), - - # Will try to treat "moo #} {{ cow" as the variable. Not ideal, but - # costly to work around, so this triggers an error. - 'basic-syntax23': ("{{ moo #} {{ cow }}", {"cow": "cow"}, template.TemplateSyntaxError), - - # Embedded newlines make it not-a-tag. - 'basic-syntax24': ("{{ moo\n }}", {}, "{{ moo\n }}"), - - # Literal strings are permitted inside variables, mostly for i18n - # purposes. - 'basic-syntax25': ('{{ "fred" }}', {}, "fred"), - 'basic-syntax26': (r'{{ "\"fred\"" }}', {}, "\"fred\""), - 'basic-syntax27': (r'{{ _("\"fred\"") }}', {}, "\"fred\""), - - # regression test for ticket #12554 - # make sure a silent_variable_failure Exception is supressed - # on dictionary and attribute lookup - 'basic-syntax28': ("{{ a.b }}", {'a': SilentGetItemClass()}, ('', 'INVALID')), - 'basic-syntax29': ("{{ a.b }}", {'a': SilentAttrClass()}, ('', 'INVALID')), - - # Something that starts like a number but has an extra lookup works as a lookup. - 'basic-syntax30': ("{{ 1.2.3 }}", {"1": {"2": {"3": "d"}}}, "d"), - 'basic-syntax31': ("{{ 1.2.3 }}", {"1": {"2": ("a", "b", "c", "d")}}, "d"), - 'basic-syntax32': ("{{ 1.2.3 }}", {"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))}, "d"), - 'basic-syntax33': ("{{ 1.2.3 }}", {"1": ("xxxx", "yyyy", "abcd")}, "d"), - 'basic-syntax34': ("{{ 1.2.3 }}", {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})}, "d"), - - # Numbers are numbers even if their digits are in the context. - 'basic-syntax35': ("{{ 1 }}", {"1": "abc"}, "1"), - 'basic-syntax36': ("{{ 1.2 }}", {"1": "abc"}, "1.2"), - - # List-index syntax allows a template to access a certain item of a subscriptable object. - 'list-index01': ("{{ var.1 }}", {"var": ["first item", "second item"]}, "second item"), - - # Fail silently when the list index is out of range. - 'list-index02': ("{{ var.5 }}", {"var": ["first item", "second item"]}, ("", "INVALID")), - - # Fail silently when the variable is not a subscriptable object. - 'list-index03': ("{{ var.1 }}", {"var": None}, ("", "INVALID")), - - # Fail silently when variable is a dict without the specified key. - 'list-index04': ("{{ var.1 }}", {"var": {}}, ("", "INVALID")), - - # Dictionary lookup wins out when dict's key is a string. - 'list-index05': ("{{ var.1 }}", {"var": {'1': "hello"}}, "hello"), - - # But list-index lookup wins out when dict's key is an int, which - # behind the scenes is really a dictionary lookup (for a dict) - # after converting the key to an int. - 'list-index06': ("{{ var.1 }}", {"var": {1: "hello"}}, "hello"), - - # Dictionary lookup wins out when there is a string and int version of the key. - 'list-index07': ("{{ var.1 }}", {"var": {'1': "hello", 1: "world"}}, "hello"), - - # Basic filter usage - 'filter-syntax01': ("{{ var|upper }}", {"var": "Django is the greatest!"}, "DJANGO IS THE GREATEST!"), - - # Chained filters - 'filter-syntax02': ("{{ var|upper|lower }}", {"var": "Django is the greatest!"}, "django is the greatest!"), - - # Raise TemplateSyntaxError for space between a variable and filter pipe - 'filter-syntax03': ("{{ var |upper }}", {}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError for space after a filter pipe - 'filter-syntax04': ("{{ var| upper }}", {}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError for a nonexistent filter - 'filter-syntax05': ("{{ var|does_not_exist }}", {}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError when trying to access a filter containing an illegal character - 'filter-syntax06': ("{{ var|fil(ter) }}", {}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError for invalid block tags - 'filter-syntax07': ("{% nothing_to_see_here %}", {}, template.TemplateSyntaxError), - - # Raise TemplateSyntaxError for empty block tags - 'filter-syntax08': ("{% %}", {}, template.TemplateSyntaxError), - - # Chained filters, with an argument to the first one - 'filter-syntax09': ('{{ var|removetags:"b i"|upper|lower }}', {"var": "<b><i>Yes</i></b>"}, "yes"), - - # Literal string as argument is always "safe" from auto-escaping.. - 'filter-syntax10': (r'{{ var|default_if_none:" endquote\" hah" }}', - {"var": None}, ' endquote" hah'), - - # Variable as argument - 'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {"var": None, "var2": "happy"}, 'happy'), - - # Default argument testing - 'filter-syntax12': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'), - - # Fail silently for methods that raise an exception with a - # "silent_variable_failure" attribute - 'filter-syntax13': (r'1{{ var.method3 }}2', {"var": SomeClass()}, ("12", "1INVALID2")), - - # In methods that raise an exception without a - # "silent_variable_attribute" set to True, the exception propagates - 'filter-syntax14': (r'1{{ var.method4 }}2', {"var": SomeClass()}, SomeOtherException), - - # Escaped backslash in argument - 'filter-syntax15': (r'{{ var|default_if_none:"foo\bar" }}', {"var": None}, r'foo\bar'), - - # Escaped backslash using known escape char - 'filter-syntax16': (r'{{ var|default_if_none:"foo\now" }}', {"var": None}, r'foo\now'), - - # Empty strings can be passed as arguments to filters - 'filter-syntax17': (r'{{ var|join:"" }}', {'var': ['a', 'b', 'c']}, 'abc'), - - # Make sure that any unicode strings are converted to bytestrings - # in the final output. - 'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'), - - # Numbers as filter arguments should work - 'filter-syntax19': ('{{ var|truncatewords:1 }}', {"var": "hello world"}, "hello ..."), - - #filters should accept empty string constants - 'filter-syntax20': ('{{ ""|default_if_none:"was none" }}', {}, ""), - - ### COMMENT SYNTAX ######################################################## - 'comment-syntax01': ("{# this is hidden #}hello", {}, "hello"), - 'comment-syntax02': ("{# this is hidden #}hello{# foo #}", {}, "hello"), - - # Comments can contain invalid stuff. - 'comment-syntax03': ("foo{# {% if %} #}", {}, "foo"), - 'comment-syntax04': ("foo{# {% endblock %} #}", {}, "foo"), - 'comment-syntax05': ("foo{# {% somerandomtag %} #}", {}, "foo"), - 'comment-syntax06': ("foo{# {% #}", {}, "foo"), - 'comment-syntax07': ("foo{# %} #}", {}, "foo"), - 'comment-syntax08': ("foo{# %} #}bar", {}, "foobar"), - 'comment-syntax09': ("foo{# {{ #}", {}, "foo"), - 'comment-syntax10': ("foo{# }} #}", {}, "foo"), - 'comment-syntax11': ("foo{# { #}", {}, "foo"), - 'comment-syntax12': ("foo{# } #}", {}, "foo"), - - ### COMMENT TAG ########################################################### - 'comment-tag01': ("{% comment %}this is hidden{% endcomment %}hello", {}, "hello"), - 'comment-tag02': ("{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}", {}, "hello"), - - # Comment tag can contain invalid stuff. - 'comment-tag03': ("foo{% comment %} {% if %} {% endcomment %}", {}, "foo"), - 'comment-tag04': ("foo{% comment %} {% endblock %} {% endcomment %}", {}, "foo"), - 'comment-tag05': ("foo{% comment %} {% somerandomtag %} {% endcomment %}", {}, "foo"), - - ### CYCLE TAG ############################################################# - 'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError), - 'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'), - 'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'), - 'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'), - 'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError), - 'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError), - 'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError), - 'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'), - 'cycle09': ("{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}", {'test': range(5)}, 'a0,b1,a2,b3,a4,'), - 'cycle10': ("{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}", {}, 'ab'), - 'cycle11': ("{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}", {}, 'abc'), - 'cycle12': ("{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}", {}, 'abca'), - 'cycle13': ("{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}", {'test': range(5)}, 'a0,b1,a2,b3,a4,'), - 'cycle14': ("{% cycle one two as foo %}{% cycle foo %}", {'one': '1','two': '2'}, '12'), - 'cycle15': ("{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'), - 'cycle16': ("{% cycle one|lower two as foo %}{% cycle foo %}", {'one': 'A','two': '2'}, 'a2'), - - ### EXCEPTIONS ############################################################ - - # Raise exception for invalid template name - 'exception01': ("{% extends 'nonexistent' %}", {}, template.TemplateDoesNotExist), - - # Raise exception for invalid template name (in variable) - 'exception02': ("{% extends nonexistent %}", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)), - - # Raise exception for extra {% extends %} tags - 'exception03': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}", {}, template.TemplateSyntaxError), - - # Raise exception for custom tags used in child with {% load %} tag in parent, not in child - 'exception04': ("{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}", {}, template.TemplateSyntaxError), - - ### FILTER TAG ############################################################ - 'filter01': ('{% filter upper %}{% endfilter %}', {}, ''), - 'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'), - 'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'), - 'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'), - - ### FIRSTOF TAG ########################################################### - 'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''), - 'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'), - 'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'), - 'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'), - 'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'), - 'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'), - 'firstof07': ('{% firstof a b "c" %}', {'a':0}, 'c'), - 'firstof08': ('{% firstof a b "c and d" %}', {'a':0,'b':0}, 'c and d'), - 'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError), - - ### FOR TAG ############################################################### - 'for-tag01': ("{% for val in values %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "123"), - 'for-tag02': ("{% for val in values reversed %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "321"), - 'for-tag-vars01': ("{% for val in values %}{{ forloop.counter }}{% endfor %}", {"values": [6, 6, 6]}, "123"), - 'for-tag-vars02': ("{% for val in values %}{{ forloop.counter0 }}{% endfor %}", {"values": [6, 6, 6]}, "012"), - 'for-tag-vars03': ("{% for val in values %}{{ forloop.revcounter }}{% endfor %}", {"values": [6, 6, 6]}, "321"), - 'for-tag-vars04': ("{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}", {"values": [6, 6, 6]}, "210"), - 'for-tag-vars05': ("{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}", {"values": [6, 6, 6]}, "fxx"), - 'for-tag-vars06': ("{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}", {"values": [6, 6, 6]}, "xxl"), - 'for-tag-unpack01': ("{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), - 'for-tag-unpack03': ("{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), - 'for-tag-unpack04': ("{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), - 'for-tag-unpack05': ("{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), - 'for-tag-unpack06': ("{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, template.TemplateSyntaxError), - 'for-tag-unpack07': ("{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, template.TemplateSyntaxError), - 'for-tag-unpack08': ("{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, template.TemplateSyntaxError), - # Ensure that a single loopvar doesn't truncate the list in val. - 'for-tag-unpack09': ("{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, "one:1/two:2/"), - # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items. - 'for-tag-unpack10': ("{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}", {"items": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, "one:1/two:2/"), - 'for-tag-unpack11': ("{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}", {"items": (('one', 1), ('two', 2))}, ("one:1,/two:2,/", "one:1,INVALID/two:2,INVALID/")), - 'for-tag-unpack12': ("{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}", {"items": (('one', 1, 'carrot'), ('two', 2))}, ("one:1,carrot/two:2,/", "one:1,carrot/two:2,INVALID/")), - 'for-tag-unpack13': ("{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}", {"items": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, ("one:1,carrot/two:2,cheese/", "one:1,carrot/two:2,cheese/")), - 'for-tag-unpack14': ("{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}", {"items": (1, 2)}, (":/:/", "INVALID:INVALID/INVALID:INVALID/")), - 'for-tag-empty01': ("{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}", {"values": [1, 2, 3]}, "123"), - 'for-tag-empty02': ("{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}", {"values": []}, "values array empty"), - 'for-tag-empty03': ("{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}", {}, "values array not found"), - - ### IF TAG ################################################################ - 'if-tag01': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": True}, "yes"), - 'if-tag02': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": False}, "no"), - 'if-tag03': ("{% if foo %}yes{% else %}no{% endif %}", {}, "no"), - - # Filters - 'if-tag-filter01': ("{% if foo|length == 5 %}yes{% else %}no{% endif %}", {'foo': 'abcde'}, "yes"), - 'if-tag-filter02': ("{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}", {}, "no"), - - # Equality - 'if-tag-eq01': ("{% if foo == bar %}yes{% else %}no{% endif %}", {}, "yes"), - 'if-tag-eq02': ("{% if foo == bar %}yes{% else %}no{% endif %}", {'foo': 1}, "no"), - 'if-tag-eq03': ("{% if foo == bar %}yes{% else %}no{% endif %}", {'foo': 1, 'bar': 1}, "yes"), - 'if-tag-eq04': ("{% if foo == bar %}yes{% else %}no{% endif %}", {'foo': 1, 'bar': 2}, "no"), - 'if-tag-eq05': ("{% if foo == '' %}yes{% else %}no{% endif %}", {}, "no"), - - # Comparison - 'if-tag-gt-01': ("{% if 2 > 1 %}yes{% else %}no{% endif %}", {}, "yes"), - 'if-tag-gt-02': ("{% if 1 > 1 %}yes{% else %}no{% endif %}", {}, "no"), - 'if-tag-gte-01': ("{% if 1 >= 1 %}yes{% else %}no{% endif %}", {}, "yes"), - 'if-tag-gte-02': ("{% if 1 >= 2 %}yes{% else %}no{% endif %}", {}, "no"), - 'if-tag-lt-01': ("{% if 1 < 2 %}yes{% else %}no{% endif %}", {}, "yes"), - 'if-tag-lt-02': ("{% if 1 < 1 %}yes{% else %}no{% endif %}", {}, "no"), - 'if-tag-lte-01': ("{% if 1 <= 1 %}yes{% else %}no{% endif %}", {}, "yes"), - 'if-tag-lte-02': ("{% if 2 <= 1 %}yes{% else %}no{% endif %}", {}, "no"), - - # Contains - 'if-tag-in-01': ("{% if 1 in x %}yes{% else %}no{% endif %}", {'x':[1]}, "yes"), - 'if-tag-in-02': ("{% if 2 in x %}yes{% else %}no{% endif %}", {'x':[1]}, "no"), - 'if-tag-not-in-01': ("{% if 1 not in x %}yes{% else %}no{% endif %}", {'x':[1]}, "no"), - 'if-tag-not-in-02': ("{% if 2 not in x %}yes{% else %}no{% endif %}", {'x':[1]}, "yes"), - - # AND - 'if-tag-and01': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), - 'if-tag-and02': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), - 'if-tag-and03': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), - 'if-tag-and04': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), - 'if-tag-and05': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'), - 'if-tag-and06': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'), - 'if-tag-and07': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True}, 'no'), - 'if-tag-and08': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': True}, 'no'), - - # OR - 'if-tag-or01': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), - 'if-tag-or02': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), - 'if-tag-or03': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), - 'if-tag-or04': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), - 'if-tag-or05': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'), - 'if-tag-or06': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'), - 'if-tag-or07': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True}, 'yes'), - 'if-tag-or08': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': True}, 'yes'), - - # multiple ORs - 'if-tag-or09': ("{% if foo or bar or baz %}yes{% else %}no{% endif %}", {'baz': True}, 'yes'), - - # NOT - 'if-tag-not01': ("{% if not foo %}no{% else %}yes{% endif %}", {'foo': True}, 'yes'), - 'if-tag-not02': ("{% if not not foo %}no{% else %}yes{% endif %}", {'foo': True}, 'no'), - # not03 to not05 removed, now TemplateSyntaxErrors - - 'if-tag-not06': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {}, 'no'), - 'if-tag-not07': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), - 'if-tag-not08': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), - 'if-tag-not09': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), - 'if-tag-not10': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), - - 'if-tag-not11': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {}, 'no'), - 'if-tag-not12': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), - 'if-tag-not13': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), - 'if-tag-not14': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), - 'if-tag-not15': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'), - - 'if-tag-not16': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'), - 'if-tag-not17': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), - 'if-tag-not18': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), - 'if-tag-not19': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), - 'if-tag-not20': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), - - 'if-tag-not21': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {}, 'yes'), - 'if-tag-not22': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'), - 'if-tag-not23': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), - 'if-tag-not24': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), - 'if-tag-not25': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), - - 'if-tag-not26': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {}, 'yes'), - 'if-tag-not27': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), - 'if-tag-not28': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'), - 'if-tag-not29': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'), - 'if-tag-not30': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), - - 'if-tag-not31': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'), - 'if-tag-not32': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'), - 'if-tag-not33': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'), - 'if-tag-not34': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'), - 'if-tag-not35': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'), - - # Various syntax errors - 'if-tag-error01': ("{% if %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error02': ("{% if foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), - 'if-tag-error03': ("{% if foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), - 'if-tag-error04': ("{% if not foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), - 'if-tag-error05': ("{% if not foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError), - 'if-tag-error06': ("{% if abc def %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error07': ("{% if not %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error08': ("{% if and %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error09': ("{% if or %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error10': ("{% if == %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error11': ("{% if 1 == %}yes{% endif %}", {}, template.TemplateSyntaxError), - 'if-tag-error12': ("{% if a not b %}yes{% endif %}", {}, template.TemplateSyntaxError), - - # If evaluations are shortcircuited where possible - # These tests will fail by taking too long to run. When the if clause - # is shortcircuiting correctly, the is_bad() function shouldn't be - # evaluated, and the deliberate sleep won't happen. - 'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, "yes"), - 'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, "no"), - - # Non-existent args - 'if-tag-badarg01':("{% if x|default_if_none:y %}yes{% endif %}", {}, ''), - 'if-tag-badarg02':("{% if x|default_if_none:y %}yes{% endif %}", {'y': 0}, ''), - 'if-tag-badarg03':("{% if x|default_if_none:y %}yes{% endif %}", {'y': 1}, 'yes'), - 'if-tag-badarg04':("{% if x|default_if_none:y %}yes{% else %}no{% endif %}", {}, 'no'), - - # Additional, more precise parsing tests are in SmartIfTests - - ### IFCHANGED TAG ######################################################### - 'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'), - 'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'), - 'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'), - 'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'), - 'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'), - 'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'), - 'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'), - 'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'), - - # Test one parameter given to ifchanged. - 'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'), - 'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'), - - # Test multiple parameters to ifchanged. - 'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'), - - # 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. - 'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'), - - # Logically the same as above, just written with explicit - # ifchanged for the day. - 'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'), - - # Test the else clause of ifchanged. - 'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'), - - 'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'), - 'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'), - - 'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'), - - ### IFEQUAL TAG ########################################################### - 'ifequal01': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 2}, ""), - 'ifequal02': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 1}, "yes"), - 'ifequal03': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 2}, "no"), - 'ifequal04': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 1}, "yes"), - 'ifequal05': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "test"}, "yes"), - 'ifequal06': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "no"}, "no"), - 'ifequal07': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "test"}, "yes"), - 'ifequal08': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "no"}, "no"), - 'ifequal09': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {}, "no"), - 'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, "yes"), - - # SMART SPLITTING - 'ifequal-split01': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {}, "no"), - 'ifequal-split02': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, "no"), - 'ifequal-split03': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, "yes"), - 'ifequal-split04': ("{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}", {'a': 'test man'}, "yes"), - 'ifequal-split05': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': ''}, "no"), - 'ifequal-split06': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i "love" you'}, "yes"), - 'ifequal-split07': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i love you'}, "no"), - 'ifequal-split08': (r"{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}", {'a': "I'm happy"}, "yes"), - 'ifequal-split09': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slash\man"}, "yes"), - 'ifequal-split10': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slashman"}, "no"), - - # NUMERIC RESOLUTION - 'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''), - 'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'), - 'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''), - 'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'), - 'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'), - 'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'), - 'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''), - 'ifequal-numeric08': ('{% ifequal x "5" %}yes{% endifequal %}', {'x': 5}, ''), - 'ifequal-numeric09': ('{% ifequal x "5" %}yes{% endifequal %}', {'x': '5'}, 'yes'), - 'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'), - 'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'), - 'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'), - - # FILTER EXPRESSIONS AS ARGUMENTS - 'ifequal-filter01': ('{% ifequal a|upper "A" %}x{% endifequal %}', {'a': 'a'}, 'x'), - 'ifequal-filter02': ('{% ifequal "A" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'), - 'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'), - 'ifequal-filter04': ('{% ifequal x|slice:"1" "a" %}x{% endifequal %}', {'x': 'aaa'}, 'x'), - 'ifequal-filter05': ('{% ifequal x|slice:"1"|upper "A" %}x{% endifequal %}', {'x': 'aaa'}, 'x'), - - ### IFNOTEQUAL TAG ######################################################## - 'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"), - 'ifnotequal02': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 1}, ""), - 'ifnotequal03': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 2}, "yes"), - 'ifnotequal04': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 1}, "no"), - - ### INCLUDE TAG ########################################################### - 'include01': ('{% include "basic-syntax01" %}', {}, "something cool"), - 'include02': ('{% include "basic-syntax02" %}', {'headline': 'Included'}, "Included"), - 'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, "Included"), - 'include04': ('a{% include "nonexistent" %}b', {}, "ab"), - 'include 05': ('template with a space', {}, 'template with a space'), - 'include06': ('{% include "include 05"%}', {}, 'template with a space'), - - ### NAMED ENDBLOCKS ####################################################### - - # Basic test - 'namedendblocks01': ("1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3", {}, '1_2_3'), - - # Unbalanced blocks - 'namedendblocks02': ("1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3", {}, template.TemplateSyntaxError), - 'namedendblocks03': ("1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3", {}, template.TemplateSyntaxError), - 'namedendblocks04': ("1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3", {}, template.TemplateSyntaxError), - 'namedendblocks05': ("1{% block first %}_{% block second %}2{% endblock first %}", {}, template.TemplateSyntaxError), - - # Mixed named and unnamed endblocks - 'namedendblocks06': ("1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3", {}, '1_2_3'), - 'namedendblocks07': ("1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3", {}, '1_2_3'), - - ### INHERITANCE ########################################################### - - # Standard template with no inheritance - 'inheritance01': ("1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}", {}, '1&3_'), - - # Standard two-level inheritance - 'inheritance02': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'), - - # Three-level with no redefinitions on third level - 'inheritance03': ("{% extends 'inheritance02' %}", {}, '1234'), - - # Two-level with no redefinitions on second level - 'inheritance04': ("{% extends 'inheritance01' %}", {}, '1&3_'), - - # Two-level with double quotes instead of single quotes - 'inheritance05': ('{% extends "inheritance02" %}', {}, '1234'), - - # Three-level with variable parent-template name - 'inheritance06': ("{% extends foo %}", {'foo': 'inheritance02'}, '1234'), - - # Two-level with one block defined, one block not defined - 'inheritance07': ("{% extends 'inheritance01' %}{% block second %}5{% endblock %}", {}, '1&35'), - - # Three-level with one block defined on this level, two blocks defined next level - 'inheritance08': ("{% extends 'inheritance02' %}{% block second %}5{% endblock %}", {}, '1235'), - - # Three-level with second and third levels blank - 'inheritance09': ("{% extends 'inheritance04' %}", {}, '1&3_'), - - # Three-level with space NOT in a block -- should be ignored - 'inheritance10': ("{% extends 'inheritance04' %} ", {}, '1&3_'), - - # Three-level with both blocks defined on this level, but none on second level - 'inheritance11': ("{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'), - - # Three-level with this level providing one and second level providing the other - 'inheritance12': ("{% extends 'inheritance07' %}{% block first %}2{% endblock %}", {}, '1235'), - - # Three-level with this level overriding second level - 'inheritance13': ("{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}", {}, '1a3b'), - - # A block defined only in a child template shouldn't be displayed - 'inheritance14': ("{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}", {}, '1&3_'), - - # A block within another block - 'inheritance15': ("{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}", {}, '12inner3_'), - - # A block within another block (level 2) - 'inheritance16': ("{% extends 'inheritance15' %}{% block inner %}out{% endblock %}", {}, '12out3_'), - - # {% load %} tag (parent -- setup for exception04) - 'inheritance17': ("{% load testtags %}{% block first %}1234{% endblock %}", {}, '1234'), - - # {% load %} tag (standard usage, without inheritance) - 'inheritance18': ("{% load testtags %}{% echo this that theother %}5678", {}, 'this that theother5678'), - - # {% load %} tag (within a child template) - 'inheritance19': ("{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}", {}, '140056783_'), - - # Two-level inheritance with {{ block.super }} - 'inheritance20': ("{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1&a3_'), - - # Three-level inheritance with {{ block.super }} from parent - 'inheritance21': ("{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '12a34'), - - # Three-level inheritance with {{ block.super }} from grandparent - 'inheritance22': ("{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1&a3_'), - - # Three-level inheritance with {{ block.super }} from parent and grandparent - 'inheritance23': ("{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}", {}, '1&ab3_'), - - # Inheritance from local context without use of template loader - 'inheritance24': ("{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")}, '1234'), - - # Inheritance from local context with variable parent template - 'inheritance25': ("{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': [template.Template("Wrong"), template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")]}, '1234'), - - # Set up a base template to extend - 'inheritance26': ("no tags", {}, 'no tags'), - - # Inheritance from a template that doesn't have any blocks - 'inheritance27': ("{% extends 'inheritance26' %}", {}, 'no tags'), - - # Set up a base template with a space in it. - 'inheritance 28': ("{% block first %}!{% endblock %}", {}, '!'), - - # Inheritance from a template with a space in its name should work. - 'inheritance29': ("{% extends 'inheritance 28' %}", {}, '!'), - - # Base template, putting block in a conditional {% if %} tag - 'inheritance30': ("1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3", {'optional': True}, '123'), - - # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden - 'inheritance31': ("{% extends 'inheritance30' %}{% block opt %}two{% endblock %}", {'optional': True}, '1two3'), - 'inheritance32': ("{% extends 'inheritance30' %}{% block opt %}two{% endblock %}", {}, '13'), - - # Base template, putting block in a conditional {% ifequal %} tag - 'inheritance33': ("1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3", {'optional': 1}, '123'), - - # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden - 'inheritance34': ("{% extends 'inheritance33' %}{% block opt %}two{% endblock %}", {'optional': 1}, '1two3'), - 'inheritance35': ("{% extends 'inheritance33' %}{% block opt %}two{% endblock %}", {'optional': 2}, '13'), - - # Base template, putting block in a {% for %} tag - 'inheritance36': ("{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_", {'numbers': '123'}, '_1_2_3_'), - - # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden - 'inheritance37': ("{% extends 'inheritance36' %}{% block opt %}X{% endblock %}", {'numbers': '123'}, '_X_X_X_'), - 'inheritance38': ("{% extends 'inheritance36' %}{% block opt %}X{% endblock %}", {}, '_'), - - # The super block will still be found. - 'inheritance39': ("{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}", {'optional': True}, '1new23'), - 'inheritance40': ("{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}", {'optional': 1}, '1new23'), - 'inheritance41': ("{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}", {'numbers': '123'}, '_new1_new2_new3_'), - - ### I18N ################################################################## - - # {% spaceless %} tag - 'spaceless01': ("{% spaceless %} <b> <i> text </i> </b> {% endspaceless %}", {}, "<b><i> text </i></b>"), - 'spaceless02': ("{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}", {}, "<b><i> text </i></b>"), - 'spaceless03': ("{% spaceless %}<b><i>text</i></b>{% endspaceless %}", {}, "<b><i>text</i></b>"), - - # simple translation of a string delimited by ' - 'i18n01': ("{% load i18n %}{% trans 'xxxyyyxxx' %}", {}, "xxxyyyxxx"), - - # simple translation of a string delimited by " - 'i18n02': ('{% load i18n %}{% trans "xxxyyyxxx" %}', {}, "xxxyyyxxx"), - - # simple translation of a variable - 'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': '\xc3\x85'}, u"Å"), - - # simple translation of a variable and filter - 'i18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': '\xc3\x85'}, u'å'), - - # simple translation of a string with interpolation - 'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, "xxxyyyxxx"), - - # simple translation of a string to german - 'i18n06': ('{% load i18n %}{% trans "Page not found" %}', {'LANGUAGE_CODE': 'de'}, "Seite nicht gefunden"), - - # translation of singular form - 'i18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, "singular"), - - # translation of plural form - 'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, "2 plural"), - - # simple non-translation (only marking) of a string to german - 'i18n09': ('{% load i18n %}{% trans "Page not found" noop %}', {'LANGUAGE_CODE': 'de'}, "Page not found"), - - # translation of a variable with a translated filter - 'i18n10': ('{{ bool|yesno:_("yes,no,maybe") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'), - - # translation of a variable with a non-translated filter - 'i18n11': ('{{ bool|yesno:"ja,nein" }}', {'bool': True}, 'ja'), - - # usage of the get_available_languages tag - 'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 "de" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'), - - # translation of constant strings - 'i18n13': ('{{ _("Password") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'), - 'i18n14': ('{% cycle "foo" _("Password") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'), - 'i18n15': ('{{ absent|default:_("Password") }}', {'LANGUAGE_CODE': 'de', 'absent': ""}, 'Passwort'), - 'i18n16': ('{{ _("<") }}', {'LANGUAGE_CODE': 'de'}, '<'), - - # Escaping inside blocktrans and trans works as if it was directly in the - # template. - 'i18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, u'α & β'), - 'i18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, u'α & β'), - 'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, u'a & b'), - 'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, u'a & b'), - 'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, u'a & b'), - 'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, u'a & b'), - - # Use filters with the {% trans %} tag, #5972 - 'i18n23': ('{% load i18n %}{% trans "Page not found"|capfirst|slice:"6:" %}', {'LANGUAGE_CODE': 'de'}, u'nicht gefunden'), - 'i18n24': ("{% load i18n %}{% trans 'Page not found'|upper %}", {'LANGUAGE_CODE': 'de'}, u'SEITE NICHT GEFUNDEN'), - 'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, u'SEITE NICHT GEFUNDEN'), - - # translation of plural form with extra field in singular form (#13568) - 'i18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, "singular test"), - - # translation of singular form in russian (#14126) - 'i18n27': ('{% load i18n %}{% blocktrans count number as counter %}1 result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, u'1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'), - - ### HANDLING OF TEMPLATE_STRING_IF_INVALID ################################### - - 'invalidstr01': ('{{ var|default:"Foo" }}', {}, ('Foo','INVALID')), - 'invalidstr02': ('{{ var|default_if_none:"Foo" }}', {}, ('','INVALID')), - 'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''), - 'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'), - 'invalidstr04': ('{% if var|default:"Foo" %}Yes{% else %}No{% endif %}', {}, 'Yes'), - 'invalidstr05': ('{{ var }}', {}, ('', 'INVALID %s', 'var')), - 'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', 'INVALID %s', 'var.prop')), - - ### MULTILINE ############################################################# - - 'multiline01': (""" - Hello, - boys. - How - are - you - gentlemen. - """, - {}, - """ - Hello, - boys. - How - are - you - gentlemen. - """), - - ### REGROUP TAG ########################################################### - 'regroup01': ('{% regroup data by bar as grouped %}' + \ - '{% for group in grouped %}' + \ - '{{ group.grouper }}:' + \ - '{% for item in group.list %}' + \ - '{{ item.foo }}' + \ - '{% endfor %},' + \ - '{% endfor %}', - {'data': [ {'foo':'c', 'bar':1}, - {'foo':'d', 'bar':1}, - {'foo':'a', 'bar':2}, - {'foo':'b', 'bar':2}, - {'foo':'x', 'bar':3} ]}, - '1:cd,2:ab,3:x,'), - - # Test for silent failure when target variable isn't found - 'regroup02': ('{% regroup data by bar as grouped %}' + \ - '{% for group in grouped %}' + \ - '{{ group.grouper }}:' + \ - '{% for item in group.list %}' + \ - '{{ item.foo }}' + \ - '{% endfor %},' + \ - '{% endfor %}', - {}, ''), - - ### TEMPLATETAG TAG ####################################################### - 'templatetag01': ('{% templatetag openblock %}', {}, '{%'), - 'templatetag02': ('{% templatetag closeblock %}', {}, '%}'), - 'templatetag03': ('{% templatetag openvariable %}', {}, '{{'), - 'templatetag04': ('{% templatetag closevariable %}', {}, '}}'), - 'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError), - 'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError), - 'templatetag07': ('{% templatetag openbrace %}', {}, '{'), - 'templatetag08': ('{% templatetag closebrace %}', {}, '}'), - 'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'), - 'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'), - 'templatetag11': ('{% templatetag opencomment %}', {}, '{#'), - 'templatetag12': ('{% templatetag closecomment %}', {}, '#}'), - - ### WIDTHRATIO TAG ######################################################## - 'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'), - 'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, ''), - 'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'), - 'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'), - 'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'), - - # 62.5 should round to 63 - 'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '63'), - - # 71.4 should round to 71 - 'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'), - - # Raise exception if we don't have 3 args, last one an integer - 'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError), - 'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError), - 'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'), - - # #10043: widthratio should allow max_width to be a variable - 'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'), - - ### WITH TAG ######################################################## - 'with01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key':50}}, '50'), - 'with02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key':50}}, ('50-50-50', 'INVALID50-50-50INVALID')), - - 'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key':50}}, template.TemplateSyntaxError), - 'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key':50}}, template.TemplateSyntaxError), - - ### NOW TAG ######################################################## - # Simple case - 'now01': ('{% now "j n Y"%}', {}, str(datetime.now().day) + ' ' + str(datetime.now().month) + ' ' + str(datetime.now().year)), - - # Check parsing of escaped and special characters - 'now02': ('{% now "j "n" Y"%}', {}, template.TemplateSyntaxError), - # 'now03': ('{% now "j \"n\" Y"%}', {}, str(datetime.now().day) + '"' + str(datetime.now().month) + '"' + str(datetime.now().year)), - # 'now04': ('{% now "j \nn\n Y"%}', {}, str(datetime.now().day) + '\n' + str(datetime.now().month) + '\n' + str(datetime.now().year)) - - ### URL TAG ######################################################## - # Successes - 'legacyurl02': ('{% url regressiontests.templates.views.client_action id=client.id,action="update" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'legacyurl02a': ('{% url regressiontests.templates.views.client_action client.id,"update" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'legacyurl02b': ("{% url regressiontests.templates.views.client_action id=client.id,action='update' %}", {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'legacyurl02c': ("{% url regressiontests.templates.views.client_action client.id,'update' %}", {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'legacyurl10': ('{% url regressiontests.templates.views.client_action id=client.id,action="two words" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'), - 'legacyurl13': ('{% url regressiontests.templates.views.client_action id=client.id, action=arg|join:"-" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'), - 'legacyurl14': ('{% url regressiontests.templates.views.client_action client.id, arg|join:"-" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'), - 'legacyurl16': ('{% url regressiontests.templates.views.client_action action="update",id="1" %}', {}, '/url_tag/client/1/update/'), - 'legacyurl16a': ("{% url regressiontests.templates.views.client_action action='update',id='1' %}", {}, '/url_tag/client/1/update/'), - 'legacyurl17': ('{% url regressiontests.templates.views.client_action client_id=client.my_id,action=action %}', {'client': {'my_id': 1}, 'action': 'update'}, '/url_tag/client/1/update/'), - - 'url01': ('{% url regressiontests.templates.views.client client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'), - 'url02': ('{% url regressiontests.templates.views.client_action id=client.id action="update" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'url02a': ('{% url regressiontests.templates.views.client_action client.id "update" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'url02b': ("{% url regressiontests.templates.views.client_action id=client.id action='update' %}", {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'url02c': ("{% url regressiontests.templates.views.client_action client.id 'update' %}", {'client': {'id': 1}}, '/url_tag/client/1/update/'), - 'url03': ('{% url regressiontests.templates.views.index %}', {}, '/url_tag/'), - 'url04': ('{% url named.client client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'), - 'url05': (u'{% url метка_оператора v %}', {'v': u'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), - 'url06': (u'{% url метка_оператора_2 tag=v %}', {'v': u'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), - 'url07': (u'{% url regressiontests.templates.views.client2 tag=v %}', {'v': u'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), - 'url08': (u'{% url метка_оператора v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), - 'url09': (u'{% url метка_оператора_2 tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), - 'url10': ('{% url regressiontests.templates.views.client_action id=client.id action="two words" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'), - 'url11': ('{% url regressiontests.templates.views.client_action id=client.id action="==" %}', {'client': {'id': 1}}, '/url_tag/client/1/==/'), - 'url12': ('{% url regressiontests.templates.views.client_action id=client.id action="," %}', {'client': {'id': 1}}, '/url_tag/client/1/,/'), - 'url13': ('{% url regressiontests.templates.views.client_action id=client.id action=arg|join:"-" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'), - 'url14': ('{% url regressiontests.templates.views.client_action client.id arg|join:"-" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'), - 'url15': ('{% url regressiontests.templates.views.client_action 12 "test" %}', {}, '/url_tag/client/12/test/'), - 'url18': ('{% url regressiontests.templates.views.client "1,2" %}', {}, '/url_tag/client/1,2/'), - - # Failures - 'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError), - 'url-fail02': ('{% url no_such_view %}', {}, urlresolvers.NoReverseMatch), - 'url-fail03': ('{% url regressiontests.templates.views.client %}', {}, urlresolvers.NoReverseMatch), - 'url-fail04': ('{% url view id, %}', {}, template.TemplateSyntaxError), - 'url-fail05': ('{% url view id= %}', {}, template.TemplateSyntaxError), - 'url-fail06': ('{% url view a.id=id %}', {}, template.TemplateSyntaxError), - 'url-fail07': ('{% url view a.id!id %}', {}, template.TemplateSyntaxError), - 'url-fail08': ('{% url view id="unterminatedstring %}', {}, template.TemplateSyntaxError), - 'url-fail09': ('{% url view id=", %}', {}, template.TemplateSyntaxError), - - # {% url ... as var %} - 'url-asvar01': ('{% url regressiontests.templates.views.index as url %}', {}, ''), - 'url-asvar02': ('{% url regressiontests.templates.views.index as url %}{{ url }}', {}, '/url_tag/'), - 'url-asvar03': ('{% url no_such_view as url %}{{ url }}', {}, ''), - - ### CACHE TAG ###################################################### - 'cache01': ('{% load cache %}{% cache -1 test %}cache01{% endcache %}', {}, 'cache01'), - 'cache02': ('{% load cache %}{% cache -1 test %}cache02{% endcache %}', {}, 'cache02'), - 'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'), - 'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'), - 'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'), - 'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'), - 'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'), - - # Allow first argument to be a variable. - 'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'), - 'cache09': ('{% load cache %}{% cache time test foo %}cache09{% endcache %}', {'foo': 3, 'time': -1}, 'cache09'), - 'cache10': ('{% load cache %}{% cache time test foo %}cache10{% endcache %}', {'foo': 3, 'time': -1}, 'cache10'), - - # Raise exception if we don't have at least 2 args, first one integer. - 'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError), - 'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError), - 'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError), - 'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError), - 'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError), - - # Regression test for #7460. - 'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''), - - # Regression test for #11270. - 'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'), - - - ### AUTOESCAPE TAG ############################################## - 'autoescape-tag01': ("{% autoescape off %}hello{% endautoescape %}", {}, "hello"), - 'autoescape-tag02': ("{% autoescape off %}{{ first }}{% endautoescape %}", {"first": "<b>hello</b>"}, "<b>hello</b>"), - 'autoescape-tag03': ("{% autoescape on %}{{ first }}{% endautoescape %}", {"first": "<b>hello</b>"}, "<b>hello</b>"), - - # Autoescape disabling and enabling nest in a predictable way. - 'autoescape-tag04': ("{% autoescape off %}{{ first }} {% autoescape on%}{{ first }}{% endautoescape %}{% endautoescape %}", {"first": "<a>"}, "<a> <a>"), - - 'autoescape-tag05': ("{% autoescape on %}{{ first }}{% endautoescape %}", {"first": "<b>first</b>"}, "<b>first</b>"), - - # Strings (ASCII or unicode) already marked as "safe" are not - # auto-escaped - 'autoescape-tag06': ("{{ first }}", {"first": mark_safe("<b>first</b>")}, "<b>first</b>"), - 'autoescape-tag07': ("{% autoescape on %}{{ first }}{% endautoescape %}", {"first": mark_safe(u"<b>Apple</b>")}, u"<b>Apple</b>"), - - # Literal string arguments to filters, if used in the result, are - # safe. - 'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}', {"var": None}, ' endquote" hah'), - - # Objects which return safe strings as their __unicode__ method - # won't get double-escaped. - 'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you & me'), - 'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you > me'), - - # The "safe" and "escape" filters cannot work due to internal - # implementation details (fortunately, the (no)autoescape block - # tags can be used in those cases) - 'autoescape-filtertag01': ("{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}", {"first": "<a>"}, template.TemplateSyntaxError), - - # ifqeual compares unescaped vales. - 'autoescape-ifequal01': ('{% ifequal var "this & that" %}yes{% endifequal %}', { "var": "this & that" }, "yes" ), - - # Arguments to filters are 'safe' and manipulate their input unescaped. - 'autoescape-filters01': ('{{ var|cut:"&" }}', { "var": "this & that" }, "this that" ), - 'autoescape-filters02': ('{{ var|join:" & \" }}', { "var": ("Tom", "Dick", "Harry") }, "Tom & Dick & Harry" ), - - # Literal strings are safe. - 'autoescape-literals01': ('{{ "this & that" }}',{}, "this & that" ), - - # Iterating over strings outputs safe characters. - 'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, "K,&,R," ), - - # Escape requirement survives lookup. - 'autoescape-lookup01': ('{{ var.key }}', { "var": {"key": "this & that" }}, "this & that" ), - - } - - -class TemplateTagLoading(unittest.TestCase): - - def setUp(self): - self.old_path = sys.path[:] - self.old_apps = settings.INSTALLED_APPS - self.egg_dir = '%s/eggs' % os.path.dirname(__file__) - self.old_tag_modules = template.templatetags_modules - template.templatetags_modules = [] - - def tearDown(self): - settings.INSTALLED_APPS = self.old_apps - sys.path = self.old_path - template.templatetags_modules = self.old_tag_modules - - def test_load_error(self): - ttext = "{% load broken_tag %}" - self.assertRaises(template.TemplateSyntaxError, template.Template, ttext) - try: - template.Template(ttext) - except template.TemplateSyntaxError, e: - self.assertTrue('ImportError' in e.args[0]) - self.assertTrue('Xtemplate' in e.args[0]) - - def test_load_error_egg(self): - ttext = "{% load broken_egg %}" - egg_name = '%s/tagsegg.egg' % self.egg_dir - sys.path.append(egg_name) - settings.INSTALLED_APPS = ('tagsegg',) - self.assertRaises(template.TemplateSyntaxError, template.Template, ttext) - try: - template.Template(ttext) - except template.TemplateSyntaxError, e: - self.assertTrue('ImportError' in e.args[0]) - self.assertTrue('Xtemplate' in e.args[0]) - - def test_load_working_egg(self): - ttext = "{% load working_egg %}" - egg_name = '%s/tagsegg.egg' % self.egg_dir - sys.path.append(egg_name) - settings.INSTALLED_APPS = ('tagsegg',) - t = template.Template(ttext) - -if __name__ == "__main__": - unittest.main() diff --git a/parts/django/tests/regressiontests/templates/unicode.py b/parts/django/tests/regressiontests/templates/unicode.py deleted file mode 100644 index 05b0e22..0000000 --- a/parts/django/tests/regressiontests/templates/unicode.py +++ /dev/null @@ -1,30 +0,0 @@ -# -*- coding: utf-8 -*- -from unittest import TestCase - -from django.template import Template, TemplateEncodingError, Context -from django.utils.safestring import SafeData - - -class UnicodeTests(TestCase): - def test_template(self): - # Templates can be created from unicode strings. - t1 = Template(u'ŠĐĆŽćžšđ {{ var }}') - # Templates can also be created from bytestrings. These are assumed to - # be encoded using UTF-8. - s = '\xc5\xa0\xc4\x90\xc4\x86\xc5\xbd\xc4\x87\xc5\xbe\xc5\xa1\xc4\x91 {{ var }}' - t2 = Template(s) - s = '\x80\xc5\xc0' - self.assertRaises(TemplateEncodingError, Template, s) - - # Contexts can be constructed from unicode or UTF-8 bytestrings. - c1 = Context({"var": "foo"}) - c2 = Context({u"var": "foo"}) - c3 = Context({"var": u"Đđ"}) - c4 = Context({u"var": "\xc4\x90\xc4\x91"}) - - # Since both templates and all four contexts represent the same thing, - # they all render the same (and are returned as unicode objects and - # "safe" objects as well, for auto-escaping purposes). - self.assertEqual(t1.render(c3), t2.render(c3)) - self.assertTrue(isinstance(t1.render(c3), unicode)) - self.assertTrue(isinstance(t1.render(c3), SafeData)) diff --git a/parts/django/tests/regressiontests/templates/urls.py b/parts/django/tests/regressiontests/templates/urls.py deleted file mode 100644 index 28d4133..0000000 --- a/parts/django/tests/regressiontests/templates/urls.py +++ /dev/null @@ -1,17 +0,0 @@ -# coding: utf-8 -from django.conf.urls.defaults import * -from regressiontests.templates import views - -urlpatterns = patterns('', - - # Test urls for testing reverse lookups - (r'^$', views.index), - (r'^client/([\d,]+)/$', views.client), - (r'^client/(?P<id>\d+)/(?P<action>[^/]+)/$', views.client_action), - (r'^client/(?P<client_id>\d+)/(?P<action>[^/]+)/$', views.client_action), - url(r'^named-client/(\d+)/$', views.client2, name="named.client"), - - # Unicode strings are permitted everywhere. - url(ur'^Юникод/(\w+)/$', views.client2, name=u"метка_оператора"), - url(ur'^Юникод/(?P<tag>\S+)/$', 'regressiontests.templates.views.client2', name=u"метка_оператора_2"), -) diff --git a/parts/django/tests/regressiontests/templates/views.py b/parts/django/tests/regressiontests/templates/views.py deleted file mode 100644 index ca3cecd..0000000 --- a/parts/django/tests/regressiontests/templates/views.py +++ /dev/null @@ -1,13 +0,0 @@ -# Fake views for testing url reverse lookup - -def index(request): - pass - -def client(request, id): - pass - -def client_action(request, id, action): - pass - -def client2(request, tag): - pass |