Python template.DictLoader类代码示例

 def test_include(self):
     loader = DictLoader({
         "index.html": '{% include "header.html" %}\nbody text',
         "header.html": "header text",
     })
     self.assertEqual(loader.load("index.html").generate(),
                      b"header text\nbody text")

 def test_details(self):
     loader = DictLoader({"foo.html": "\n\n{{"})
     with self.assertRaises(ParseError) as cm:
         loader.load("foo.html")
     self.assertEqual("Missing end expression }} at foo.html:3", str(cm.exception))
     self.assertEqual("foo.html", cm.exception.filename)
     self.assertEqual(3, cm.exception.lineno)

 def test_error_line_number_include(self):
     loader = DictLoader({"base.html": "{% include 'sub.html' %}", "sub.html": "{{1/0}}"})
     try:
         loader.load("base.html").generate()
         self.fail("did not get expected exception")
     except ZeroDivisionError:
         self.assertTrue("# sub.html:1 (via base.html:1)" in traceback.format_exc())

 def test_unextended_block(self):
     loader = DictLoader(self.templates)
     name = "<script>"
     self.assertEqual(loader.load("escaped_block.html").generate(name=name),
                      b"base: &lt;script&gt;")
     self.assertEqual(loader.load("unescaped_block.html").generate(name=name),
                      b"base: <script>")

 def test_non_ascii_name(self):
     if PY3 and is_coverage_running():
         try:
             os.fsencode(u"t\u00e9st.html")
         except UnicodeEncodeError:
             self.skipTest("coverage tries to access unencodable filename")
     loader = DictLoader({u"t\u00e9st.html": "hello"})
     self.assertEqual(loader.load(u"t\u00e9st.html").generate(), b"hello")

 def test_error_line_number_extends_base_error(self):
     loader = DictLoader({"base.html": "{{1/0}}", "sub.html": "{% extends 'base.html' %}"})
     try:
         loader.load("sub.html").generate()
         self.fail("did not get expected exception")
     except ZeroDivisionError:
         exc_stack = traceback.format_exc()
     self.assertTrue("# base.html:1" in exc_stack)

 def test_relative_load(self):
     loader = DictLoader({
         "a/1.html": "{% include '2.html' %}",
         "a/2.html": "{% include '../b/3.html' %}",
         "b/3.html": "ok",
     })
     self.assertEqual(loader.load("a/1.html").generate(),
                      b"ok")

 def test_multi_includes(self):
     loader = DictLoader(
         {"a.html": "{% include 'b.html' %}", "b.html": "{% include 'c.html' %}", "c.html": "{{1/0}}"}
     )
     try:
         loader.load("a.html").generate()
         self.fail("did not get expected exception")
     except ZeroDivisionError:
         self.assertTrue("# c.html:1 (via b.html:1, a.html:1)" in traceback.format_exc())

    def test_error_line_number_directive(self):
        loader = DictLoader({"test.html": """one
two{%if 1/0%}
three{%end%}
        """})
        try:
            loader.load("test.html").generate()
        except ZeroDivisionError:
            self.assertTrue("# test.html:2" in traceback.format_exc())

    def test_error_line_number_expression(self):
        loader = DictLoader({"test.html": """one
two{{1/0}}
three
        """})
        try:
            loader.load("test.html").generate()
        except ZeroDivisionError:
            self.assertTrue("# test.html:2" in traceback.format_exc())

 def test_error_line_number_module(self):
     loader = DictLoader({
         "base.html": "{% module Template('sub.html') %}",
         "sub.html": "{{1/0}}",
     }, namespace={"_modules": ObjectDict({"Template": lambda path, **kwargs: loader.load(path).generate(**kwargs)})})
     try:
         loader.load("base.html").generate()
     except ZeroDivisionError:
         exc_stack = traceback.format_exc()
         self.assertTrue('# base.html:1' in exc_stack)
         self.assertTrue('# sub.html:1' in exc_stack)

    def test_default_on(self):
        loader = DictLoader(self.templates, autoescape="xhtml_escape")
        name = "Bobby <table>s"
        self.assertEqual(loader.load("escaped.html").generate(name=name), b"Bobby &lt;table&gt;s")
        self.assertEqual(loader.load("unescaped.html").generate(name=name), b"Bobby <table>s")
        self.assertEqual(loader.load("default.html").generate(name=name), b"Bobby &lt;table&gt;s")

        self.assertEqual(
            loader.load("include.html").generate(name=name),
            b"escaped: Bobby &lt;table&gt;s\n" b"unescaped: Bobby <table>s\n" b"default: Bobby &lt;table&gt;s\n",
        )

 def test_error_line_number_module(self):
     loader = DictLoader(
         {"base.html": "{% module Template('sub.html') %}", "sub.html": "{{1/0}}"},
         namespace={"_tt_modules": ObjectDict(Template=lambda path, **kwargs: loader.load(path).generate(**kwargs))},
     )
     try:
         loader.load("base.html").generate()
         self.fail("did not get expected exception")
     except ZeroDivisionError:
         exc_stack = traceback.format_exc()
         self.assertTrue("# base.html:1" in exc_stack)
         self.assertTrue("# sub.html:1" in exc_stack)

    def test_whitespace_directive(self):
        loader = DictLoader({
            "foo.html": """\
{% whitespace oneline %}
    {% for i in range(3) %}
        {{ i }}
    {% end %}
{% whitespace all %}
    pre\tformatted
"""})
        self.assertEqual(loader.load("foo.html").generate(),
                         b"  0  1  2  \n    pre\tformatted\n")

    def test_manual_minimize_whitespace(self):
        # Whitespace including newlines is allowed within template tags
        # and directives, and this is one way to avoid long lines while
        # keeping extra whitespace out of the rendered output.
        loader = DictLoader({'foo.txt': """\
{% for i in items
  %}{% if i > 0 %}, {% end %}{#
  #}{{i
  }}{% end
%}""",
                             })
        self.assertEqual(loader.load("foo.txt").generate(items=range(5)),
                         b"0, 1, 2, 3, 4")