Viewing github.com/django/django-stable-4.1.x/tests/template_tests/syntax_tests/test

from django.template import NodeList, TemplateSyntaxError

```
from django.template.base import Node
```

from django.template.loader_tags import ExtendsNode

```
from django.test import SimpleTestCase
```
```
from ..utils import setup
```
```
inheritance_templates = {
```
```
    "inheritance01": (
```

        "1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"

```
    ),
```

    "inheritance02": "{% extends 'inheritance01' %}"

    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",

    "inheritance03": "{% extends 'inheritance02' %}",

    "inheritance04": "{% extends 'inheritance01' %}",

    "inheritance05": "{% extends 'inheritance02' %}",

    "inheritance06": "{% extends foo %}",

    "inheritance07": "{% extends 'inheritance01' %}{% block second %}5{% endblock %}",

    "inheritance08": "{% extends 'inheritance02' %}{% block second %}5{% endblock %}",

    "inheritance09": "{% extends 'inheritance04' %}",

    "inheritance10": "{% extends 'inheritance04' %}      ",

    "inheritance11": "{% extends 'inheritance04' %}"

    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",

    "inheritance12": "{% extends 'inheritance07' %}{% block first %}2{% endblock %}",

    "inheritance13": "{% extends 'inheritance02' %}"

    "{% block first %}a{% endblock %}{% block second %}b{% endblock %}",

```
    "inheritance14": (
```

        "{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"

```
    ),
```

    "inheritance15": "{% extends 'inheritance01' %}"

    "{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}",

    "inheritance16": "{% extends 'inheritance15' %}{% block inner %}out{% endblock %}",

    "inheritance17": "{% load testtags %}{% block first %}1234{% endblock %}",

    "inheritance18": "{% load testtags %}{% echo this that theother %}5678",

    "inheritance19": "{% extends 'inheritance01' %}"

    "{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}",

```
    "inheritance20": (
```

        "{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"

```
    ),
```
```
    "inheritance21": (
```

        "{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"

```
    ),
```
```
    "inheritance22": (
```

        "{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"

```
    ),
```
```
    "inheritance23": (
```

        "{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"

```
    ),
```

    "inheritance24": "{% extends context_template %}"

    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",

    "inheritance25": "{% extends context_template.1 %}"

    "{% block first %}2{% endblock %}{% block second %}4{% endblock %}",

```
    "inheritance26": "no tags",
```

    "inheritance27": "{% extends 'inheritance26' %}",

    "inheritance 28": "{% block first %}!{% endblock %}",

    "inheritance29": "{% extends 'inheritance 28' %}",

    "inheritance30": "1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3",

    "inheritance31": "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",

    "inheritance32": "{% extends 'inheritance30' %}{% block opt %}two{% endblock %}",

```
    "inheritance33": (
```

        "1{% if optional == 1 %}{% block opt %}2{% endblock %}{% endif %}3"

```
    ),
```

    "inheritance34": "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",

    "inheritance35": "{% extends 'inheritance33' %}{% block opt %}two{% endblock %}",

```
    "inheritance36": (
```

        "{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"

```
    ),
```

    "inheritance37": "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",

    "inheritance38": "{% extends 'inheritance36' %}{% block opt %}X{% endblock %}",

```
    "inheritance39": (
```

        "{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"

```
    ),
```
```
    "inheritance40": (
```

        "{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"

```
    ),
```
```
    "inheritance41": (
```

        "{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"

```
    ),
```

    "inheritance42": "{% extends 'inheritance02'|cut:' ' %}",

    "inheritance_empty": "{% extends %}",

    "extends_duplicate": "{% extends 'base.html' %}{% extends 'base.html' %}",

```
    "duplicate_block": (
```

        "{% extends 'base.html' %}{% block content %}2{% endblock %}{% block content %}"

```
        "4{% endblock %}"
```
```
    ),
```
```
}
```

class InheritanceTests(SimpleTestCase):

    libraries = {"testtags": "template_tests.templatetags.testtags"}

```
    @setup(inheritance_templates)
```
```
    def test_inheritance01(self):
```
```
        """
```

        Standard template with no inheritance

```
        """
```

        output = self.engine.render_to_string("inheritance01")

        self.assertEqual(output, "1&3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance02(self):
```
```
        """
```
```
        Standard two-level inheritance
```
```
        """
```

        output = self.engine.render_to_string("inheritance02")

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance03(self):
```
```
        """
```

        Three-level with no redefinitions on third level

```
        """
```

        output = self.engine.render_to_string("inheritance03")

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance04(self):
```
```
        """
```

        Two-level with no redefinitions on second level

```
        """
```

        output = self.engine.render_to_string("inheritance04")

        self.assertEqual(output, "1&3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance05(self):
```
```
        """
```

        Two-level with double quotes instead of single quotes

```
        """
```

        output = self.engine.render_to_string("inheritance05")

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance06(self):
```
```
        """
```

        Three-level with variable parent-template name

```
        """
```

        output = self.engine.render_to_string("inheritance06", {"foo": "inheritance02"})

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance07(self):
```
```
        """
```

        Two-level with one block defined, one block not defined

```
        """
```

        output = self.engine.render_to_string("inheritance07")

        self.assertEqual(output, "1&35")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance08(self):
```
```
        """
```

        Three-level with one block defined on this level, two blocks

```
        defined next level
```
```
        """
```

        output = self.engine.render_to_string("inheritance08")

        self.assertEqual(output, "1235")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance09(self):
```
```
        """
```

        Three-level with second and third levels blank

```
        """
```

        output = self.engine.render_to_string("inheritance09")

        self.assertEqual(output, "1&3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance10(self):
```
```
        """
```

        Three-level with space NOT in a block -- should be ignored

```
        """
```

        output = self.engine.render_to_string("inheritance10")

        self.assertEqual(output, "1&3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance11(self):
```
```
        """
```

        Three-level with both blocks defined on this level, but none on

```
        second level
```
```
        """
```

        output = self.engine.render_to_string("inheritance11")

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance12(self):
```
```
        """
```

        Three-level with this level providing one and second level

```
        providing the other
```
```
        """
```

        output = self.engine.render_to_string("inheritance12")

        self.assertEqual(output, "1235")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance13(self):
```
```
        """
```

        Three-level with this level overriding second level

```
        """
```

        output = self.engine.render_to_string("inheritance13")

        self.assertEqual(output, "1a3b")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance14(self):
```
```
        """
```

        A block defined only in a child template shouldn't be displayed

```
        """
```

        output = self.engine.render_to_string("inheritance14")

        self.assertEqual(output, "1&3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance15(self):
```
```
        """
```
```
        A block within another block
```
```
        """
```

        output = self.engine.render_to_string("inheritance15")

        self.assertEqual(output, "12inner3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance16(self):
```
```
        """
```

        A block within another block (level 2)

```
        """
```

        output = self.engine.render_to_string("inheritance16")

        self.assertEqual(output, "12out3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance17(self):
```
```
        """
```

        {% load %} tag (parent -- setup for exception04)

```
        """
```

        output = self.engine.render_to_string("inheritance17")

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance18(self):
```
```
        """
```

        {% load %} tag (standard usage, without inheritance)

```
        """
```

        output = self.engine.render_to_string("inheritance18")

        self.assertEqual(output, "this that theother5678")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance19(self):
```
```
        """
```

        {% load %} tag (within a child template)

```
        """
```

        output = self.engine.render_to_string("inheritance19")

        self.assertEqual(output, "140056783_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance20(self):
```
```
        """
```

        Two-level inheritance with {{ block.super }}

```
        """
```

        output = self.engine.render_to_string("inheritance20")

        self.assertEqual(output, "1&a3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance21(self):
```
```
        """
```

        Three-level inheritance with {{ block.super }} from parent

```
        """
```

        output = self.engine.render_to_string("inheritance21")

        self.assertEqual(output, "12a34")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance22(self):
```
```
        """
```

        Three-level inheritance with {{ block.super }} from grandparent

```
        """
```

        output = self.engine.render_to_string("inheritance22")

        self.assertEqual(output, "1&a3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance23(self):
```
```
        """
```

        Three-level inheritance with {{ block.super }} from parent and

```
        grandparent
```
```
        """
```

        output = self.engine.render_to_string("inheritance23")

        self.assertEqual(output, "1&ab3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance24(self):
```
```
        """
```

        Inheritance from local context without use of template loader

```
        """
```

        context_template = self.engine.from_string(

            "1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"

```
        )
```

        output = self.engine.render_to_string(

            "inheritance24", {"context_template": context_template}

```
        )
```

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance25(self):
```
```
        """
```

        Inheritance from local context with variable parent template

```
        """
```
```
        context_template = [
```

            self.engine.from_string("Wrong"),

```
            self.engine.from_string(
```

                "1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"

```
            ),
```
```
        ]
```

        output = self.engine.render_to_string(

            "inheritance25", {"context_template": context_template}

```
        )
```

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance26(self):
```
```
        """
```

        Set up a base template to extend

```
        """
```

        output = self.engine.render_to_string("inheritance26")

        self.assertEqual(output, "no tags")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance27(self):
```
```
        """
```

        Inheritance from a template that doesn't have any blocks

```
        """
```

        output = self.engine.render_to_string("inheritance27")

        self.assertEqual(output, "no tags")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance_28(self):
```
```
        """
```

        Set up a base template with a space in it.

```
        """
```

        output = self.engine.render_to_string("inheritance 28")

```
        self.assertEqual(output, "!")
```
```
    @setup(inheritance_templates)
```
```
    def test_inheritance29(self):
```
```
        """
```

        Inheritance from a template with a space in its name should work.

```
        """
```

        output = self.engine.render_to_string("inheritance29")

```
        self.assertEqual(output, "!")
```
```
    @setup(inheritance_templates)
```
```
    def test_inheritance30(self):
```
```
        """
```

        Base template, putting block in a conditional {% if %} tag

```
        """
```

        output = self.engine.render_to_string("inheritance30", {"optional": True})

        self.assertEqual(output, "123")

    # Inherit from a template with block wrapped in an {% if %} tag

    # (in parent), still gets overridden

```
    @setup(inheritance_templates)
```
```
    def test_inheritance31(self):
```

        output = self.engine.render_to_string("inheritance31", {"optional": True})

        self.assertEqual(output, "1two3")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance32(self):
```

        output = self.engine.render_to_string("inheritance32")

```
        self.assertEqual(output, "13")
```
```
    @setup(inheritance_templates)
```
```
    def test_inheritance33(self):
```
```
        """
```

        Base template, putting block in a conditional {% if %} tag

```
        """
```

        output = self.engine.render_to_string("inheritance33", {"optional": 1})

        self.assertEqual(output, "123")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance34(self):
```
```
        """
```

        Inherit from a template with block wrapped in an {% if %} tag

        (in parent), still gets overridden

```
        """
```

        output = self.engine.render_to_string("inheritance34", {"optional": 1})

        self.assertEqual(output, "1two3")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance35(self):
```
```
        """
```

        Inherit from a template with block wrapped in an {% if %} tag

        (in parent), still gets overridden

```
        """
```

        output = self.engine.render_to_string("inheritance35", {"optional": 2})

```
        self.assertEqual(output, "13")
```
```
    @setup(inheritance_templates)
```
```
    def test_inheritance36(self):
```
```
        """
```

        Base template, putting block in a {% for %} tag

```
        """
```

        output = self.engine.render_to_string("inheritance36", {"numbers": "123"})

        self.assertEqual(output, "_1_2_3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance37(self):
```
```
        """
```

        Inherit from a template with block wrapped in an {% for %} tag

        (in parent), still gets overridden

```
        """
```

        output = self.engine.render_to_string("inheritance37", {"numbers": "123"})

        self.assertEqual(output, "_X_X_X_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance38(self):
```
```
        """
```

        Inherit from a template with block wrapped in an {% for %} tag

        (in parent), still gets overridden

```
        """
```

        output = self.engine.render_to_string("inheritance38")

```
        self.assertEqual(output, "_")
```

    # The super block will still be found.

```
    @setup(inheritance_templates)
```
```
    def test_inheritance39(self):
```

        output = self.engine.render_to_string("inheritance39", {"optional": True})

        self.assertEqual(output, "1new23")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance40(self):
```

        output = self.engine.render_to_string("inheritance40", {"optional": 1})

        self.assertEqual(output, "1new23")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance41(self):
```

        output = self.engine.render_to_string("inheritance41", {"numbers": "123"})

        self.assertEqual(output, "_new1_new2_new3_")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance42(self):
```
```
        """
```

        Expression starting and ending with a quote

```
        """
```

        output = self.engine.render_to_string("inheritance42")

        self.assertEqual(output, "1234")

```
    @setup(inheritance_templates)
```
```
    def test_inheritance_empty(self):
```
```
        with self.assertRaisesMessage(
```

            TemplateSyntaxError, "'extends' takes one argument"

```
        ):
```

            self.engine.render_to_string("inheritance_empty")

```
    @setup(inheritance_templates)
```
```
    def test_extends_duplicate(self):
```

        msg = "'extends' cannot appear more than once in the same template"

        with self.assertRaisesMessage(TemplateSyntaxError, msg):

            self.engine.render_to_string("extends_duplicate")

```
    @setup(inheritance_templates)
```
```
    def test_duplicate_block(self):
```

        msg = "'block' tag with name 'content' appears more than once"

        with self.assertRaisesMessage(TemplateSyntaxError, msg):

            self.engine.render_to_string("duplicate_block")

class ExtendsNodeTests(SimpleTestCase):

```
    def test_extends_node_repr(self):
```
```
        extends_node = ExtendsNode(
```
```
            nodelist=NodeList([]),
```
```
            parent_name=Node(),
```
```
            template_dirs=[],
```
```
        )
```

        self.assertEqual(repr(extends_node), "<ExtendsNode: extends None>")