#!/usr/bin/env python import os import sys import traceback import xml.dom.minidom from io import BytesIO from unittest import TestCase, main import kajiki from kajiki import FileLoader, MockLoader, PackageLoader, XMLTemplate, i18n from kajiki.ir import TranslatableTextNode from kajiki.template import KajikiSyntaxError from kajiki.xml_template import ( XMLTemplateCompileError, XMLTemplateParseError, _Compiler, _Parser, ) DATA = os.path.join(os.path.dirname(__file__), "data") class TestParser(TestCase): def test_parser(self): doc = kajiki.xml_template._Parser( "", """
Hello, $name < > $x
""", ).parse() xml.dom.minidom.parseString(doc.toxml().encode("utf-8")) class TestExpand(TestCase): def test_expand(self): doc = kajiki.xml_template._Parser( "", """
Foo
""", ).parse() doc = kajiki.xml_template._DomTransformer(doc).transform() node = doc.childNodes[0] for tagname, attr in kajiki.markup_template.QDIRECTIVES: if node.tagName == "div": node = node.childNodes[0] continue assert node.tagName == tagname, "%s != %s" % (node.tagName, tagname) if attr: assert len(node.attributes) == 1 assert node.hasAttribute(attr) assert node.getAttribute(attr) == tagname.split(":")[-1] else: assert len(node.attributes) == 0 assert len(node.childNodes) == 1 node = node.childNodes[0] def perform(source, expected_output, context=dict(name="Rick"), **options): tpl = XMLTemplate(source, **options) try: rsp = tpl(context).render() assert isinstance(rsp, str), "render() must return a unicode string." assert rsp == expected_output, (rsp, expected_output) except Exception as e: print("\n" + tpl.py_text) raise e else: return tpl class TestSimple(TestCase): def test_empty_attr(self): perform( source='', mode="html", expected_output='', ) def test_pre_whitespace(self): src = '
\nHey there.  \n\n    I am indented.\n' "
" perform(src, src, mode="html") perform(src, src, mode="xml") def test_textarea_whitespace(self): src = ( '" ) perform(src, src, mode="html") perform(src, src, mode="xml") def test_script(self): "Always close script tags, even in xml mode." source = '' perform(source, output, mode="html") perform(source, output, mode="xml") def test_script_escaping(self): """In HTML script and style tags are automatically CDATA; in XML they must be explicitly be made so. """ script = 'if (1 < 2) { doc.write("

Offen bach

"); }\n' src = "".format(script) perform( src, mode="html", expected_output="".format(script) ) perform( src, "".format(script), mode="xml" ) def test_style_escaping(self): style = "html > body { display: none; }\n" src = "".format(style) perform( src, "".format(style), mode="xml" ) perform(src, "".format(style), mode="html") def test_script_variable(self): """Interpolate variables inside " perform(src, "", mode="xml") perform(src, "", mode="html") def test_CDATA_disabled(self): src = "" perform(src, "", mode="xml", cdata_scripts=False) perform(src, "", mode="html", cdata_scripts=False) def test_CDATA_escaping(self): src = """""" perform( src, "", mode="xml" ) perform( src, "", mode="html" ) def test_CDATA_escaping_mixed(self): src = """ >""" perform( src, " >", mode="xml", ) perform( src, " >", mode="html", ) def test_script_commented_CDATA(self): script = 'if (1 < 2) { doc.write("

Offen bach

"); }\n' src = "".format(script) perform( src, mode="html", expected_output="".format(script), ) perform( src, "".format(script), mode="xml", ) def test_escape_dollar(self): perform("
$$
", "
$
") def test_escape_dollar_followed_by_dollar(self): perform("
$$$
", "
$$
") def test_double_escape_dollar(self): perform("
$$$$
", "
$$
") def test_preserve_dollar_not_variable_brace(self): perform("
$(
", "
$(
") perform("
$.
", "
$.
") def test_expr_name(self): perform("
Hello, $name
", "
Hello, Rick
") def test_expr_braced(self): perform("
Hello, ${name}
", "
Hello, Rick
") def test_expr_brace_complex(self): perform("
Hello, ${{'name':name}['name']}
", "
Hello, Rick
") def test_expr_multiline(self): perform( """
Hello, ${{'name': 'Rick', 'age': 26}['name']}
""", "
Hello, Rick
", ) def test_expr_multiline_and_IndentationError(self): try: XMLTemplate( """
Hello, ${ 'pippo' + 'baudo'}
""" )().render() except XMLTemplateCompileError as e: assert "`'pippo' +\n 'baudo'`" in str(e), str(e) assert "Hello" in str(e) assert "baudo" in str(e) def test_expr_multiline_cdata(self): perform( """""", "", ) def test_jquery_call_is_not_expr(self): """Ensure we handle '$(' as a text literal, since it cannot be a valid variable sequence. This simplifies, for example, templates containing inline scripts with jQuery calls which otherwise have to be written '$$(...' """ js = "$(function () { alert('.ready()'); });" src = "
" + js + "
" out = ( "
"
            + js
            + "
" ) perform(src, out) def test_jquery_shortcut_is_not_expr(self): """Ensure we handle '$.' as a text literal in script blocks""" js = "$.extend({}, {foo: 'bar'})" src = "
" + js + "
" out = ( "
"
            + js
            + "
" ) perform(src, out) def test_xml_entities(self): source = "
Cookies & Cream
" perform(source, source) def test_html_entities(self): source = "
Spam Spam < Spam > Spam …
" output = "
Spam Spam < Spam > Spam \u2026
" assert chr(32) in output # normal space assert chr(160) in output # non breaking space perform(source, output) class TestSwitch(TestCase): def test_switch(self): perform( """
$i is even odd
""", """
0 is even
1 is odd
""", ) def test_switch_multi(self): perform( """
$i is ok nearly nope
""", """
0 is ok
1 is nearly
2 is nope
3 is nope
4 is ok
5 is nearly
6 is nope
7 is nope
""", ) def test_case_elem(self): perform( """
0 1 2
""", "
\n 1\n
", ) def test_switch_div(self): try: perform( """

True

False

""", "
False
", ) except XMLTemplateCompileError as e: self.assertTrue( "py:switch directive can only contain py:case and py:else nodes" in str(e) ) else: self.assertTrue(False, msg="Should have raised XMLTemplateParseError") class TestElse(TestCase): def test_pyif_pyelse(self): try: perform( """
True
False
""", """
False
""", ) except XMLTemplateCompileError as e: self.assertTrue( "py:else directive must be inside a py:switch or directly after py:if" in str(e) ) else: self.assertTrue(False, msg="Should have raised XMLTemplateParseError") def test_pyiftag_pyelse_continuation(self): perform( """
True
False
""", """
False
""", ) def test_pyif_pyelse_continuation(self): perform( """
TrueFalse
""", """
False
""", ) class TestWith(TestCase): def test_with(self): perform( """
$a
$a
$a
""", """
foo
5
foo
""", ) def test_with_multiple(self): perform( """
$a - $b
$a - $b
$a - $b
""", """
foo - 3
5 - 1
foo - 3
""", ) def test_with_multiple_and_whitespace(self): perform( """
$a - $b
""", "
foo - 3
", ) def test_with_trailing_semicolon(self): perform("""
$a
""", "
foo
") def test_with_ordered_multiple(self): perform( """
""" """$a $b $c $d
""", "
foo foofoo oofoof oof
", ) def test_with_multiple_with_embedded_semicolons(self): perform("""
$a$b
""", "
;-)
") def test_standalone(self): perform( """
$a$b
""", "
;-)
", ) class TestFunction(TestCase): def test_function(self): perform( """
evenodd
$i is ${evenness(i)}
""", """
0 is
even
1 is
odd
""", ) def test_empty_function(self): """Do not crash if a function has no content.""" perform('
', "
") def test_function_in_attr(self): """Attribute value with a function call.""" perform( """
text/$sz/$n
""", '
', ) class TestCall(TestCase): def test_call(self): perform( """
  • Quoth $speaker, ${caller(i)}
Nevermore $n
""", """
  • Quoth the raven, Nevermore 0
  • Quoth the raven, Nevermore 1
""", ) class TestImport(TestCase): def test_import(self): loader = MockLoader( { "lib.html": XMLTemplate( source="""
evenodd half of $n is ${evenness(n/2)}
""" ), "tpl.html": XMLTemplate( source="""
  • $i is ${simple_function.evenness(i)} ${simple_function.half_evenness(i)}
""" ), } ) tpl = loader.import_("tpl.html") rsp = tpl(dict(name="Rick")).render() assert ( rsp == """
  • 0 is even half of 0 is even
  • 1 is odd half of 1 is odd
  • 2 is even half of 2 is odd
  • 3 is odd half of 3 is odd
""" ), rsp def test_import_auto(self): loader = MockLoader( { "lib.html": XMLTemplate( source="""
evenodd half of $n is ${evenness(n/2)}
""" ), "tpl.html": XMLTemplate( source="""
  • $i is ${lib.evenness(i)} ${lib.half_evenness(i)}
""" ), } ) tpl = loader.import_("tpl.html") rsp = tpl(dict(name="Rick")).render() assert ( rsp == """
  • 0 is even half of 0 is even
  • 1 is odd half of 1 is odd
  • 2 is even half of 2 is odd
  • 3 is odd half of 3 is odd
""" ), rsp def test_include(self): """Must NOT result in: NameError: global name 'name' is not defined""" loader = MockLoader( { "included.html": XMLTemplate( "

The included template must also " "access Kajiki globals and the template context: " '${value_of("name")}

\n' ), "tpl.html": XMLTemplate( "

This is the body

\n" '' ), } ) tpl = loader.import_("tpl.html") rsp = tpl(dict(name="Rick")).render() assert ( "

This is the body

\n" "

The included template must also access Kajiki globals and " "the template context: Rick

" == rsp ) def test_include_html5(self): """Should not have DOCTYPE""" class XMLSourceLoader(MockLoader): """Fakes a FileLoader, but with source in a lookup table. It differs from MockLoader because MockLoader doesn't create the template on load, it's already pre-instantiated by the user of the MockLoader """ def __init__(self, sources): self.sources = sources super().__init__({}) def _load(self, name, encoding="utf-8", *args, **kwargs): return XMLTemplate( source=self.sources[name], mode="html5", *args, **kwargs ) loader = XMLSourceLoader( { "included.html": "

The included template must also " "access Kajiki globals and the template context: " '${value_of("name")}

\n', "tpl.html": "

This is the body

\n" '', } ) tpl = loader.import_("tpl.html") rsp = tpl(dict(name="Rick")).render() assert ( "\n

This is the body

\n" "

The included template must also access Kajiki globals and " "the template context: Rick

" == rsp ), rsp class TestExtends(TestCase): def test_basic(self): loader = MockLoader( { "parent.html": XMLTemplate( """

Header name=$name

Footer
id() = ${id()} local.id() = ${local.id()} self.id() = ${self.id()} child.id() = ${child.id()}
parent ${header()} ${body()} ${footer()}
""" ), "mid.html": XMLTemplate( """mid""" ), "child.html": XMLTemplate( """child

Child Body

${parent.body()}
""" ), } ) tpl = loader.import_("child.html") rsp = tpl(dict(name="Rick")).render() assert ( rsp == """

Header name=Rick

Child Body

id() = child local.id() = parent self.id() = child child.id() = mid
Footer
""" ), rsp def test_dynamic(self): loader = MockLoader( { "parent0.html": XMLTemplate("Parent 0"), "parent1.html": XMLTemplate("Parent 1"), "child.html": XMLTemplate( """
""" ), } ) tpl = loader.import_("child.html") rsp = tpl(dict(p=0)).render() assert rsp == "
Parent 0
", rsp rsp = tpl(dict(p=1)).render() assert rsp == "
Parent 1
", rsp def test_block(self): loader = MockLoader( { "parent.html": XMLTemplate( """
Hello, $name!Sincerely,
$name${greet(to)}

It was good seeing you last Friday. Thanks for the gift!

${sign(from_)}
""" ), "child.html": XMLTemplate( """Dear $name:${parent_block()}

And don't forget you owe me money!

 """ ), } ) parent = loader.import_("parent.html") rsp = parent({"to": "Mark", "from_": "Rick"}).render() assert ( rsp == """
Hello, Mark!

It was good seeing you last Friday. Thanks for the gift!

Sincerely,
Rick
""" ), rsp child = loader.import_("child.html") rsp = child({"to": "Mark", "from_": "Rick"}).render() assert ( rsp == """
Dear Mark:

It was good seeing you last Friday. Thanks for the gift!

And don't forget you owe me money!

Sincerely,
Rick
""" ), rsp def test_autoblocks(self): loader = MockLoader( { "parent.html": XMLTemplate( """

It was good seeing you last Friday. Thanks for the gift!

""" ), "child.html": XMLTemplate( """ Great conference this weekend! """, autoblocks=["body"], ), } ) parent = loader.import_("parent.html") rsp = parent().render() assert ( rsp == """

It was good seeing you last Friday. Thanks for the gift!

""" ), rsp child = loader.import_("child.html") rsp = child().render() assert ( rsp == """ Great conference this weekend! """ ), rsp def test_autoblocks_disabling(self): loader = MockLoader( { "parent.html": XMLTemplate( """

It was good seeing you last Friday. Thanks for the gift!

""", autoblocks=["body"], ), "child.html": XMLTemplate( """ Great conference this weekend! """, autoblocks=["body"], ), } ) parent = loader.import_("parent.html") rsp = parent().render() assert ( rsp == """

It was good seeing you last Friday. Thanks for the gift!

""" ), rsp child = loader.import_("child.html") rsp = child().render() assert ( rsp == """ Great conference this weekend! """ ), rsp class TestClosure(TestCase): def test(self): perform( """
${x+y}${inner(x*2)}${add(5)}
""", "
15
", ) class TestPython(TestCase): def test_basic(self): perform( """
${os.path.join('a', 'b', 'c')}
""", "
a/b/c
", ) def test_indent(self): perform( """
${os.path.join('a','b','c')}
""", "
a/b/c
", ) def test_short(self): perform( """
${os.path.join('a', 'b', 'c')}
""", "
a/b/c
", ) def test_mod(self): perform( """
${os.path.join('a', 'b', 'c')}${test()}
""", "
a/b/c
", ) class TestComment(TestCase): def test_basic(self): perform( "
" "
", "
", ) class TestAttributes(TestCase): def test_basic(self): perform("""
""", '
') def test_content(self): perform("""
""", "
foo
") def test_replace(self): perform("""
""", "foo") def test_attrs(self): perform('
', '
') perform("""
""", """
""") perform('
', "
") perform('
', '
') perform('
', "
") perform('
', "
") def test_strip(self): TPL = '

Header

' perform(TPL, "
Header
", context=dict(header=True)) perform(TPL, "

Header

", context=dict(header=False)) TPL = """

It's...

""" perform(TPL, "
It's...
") def test_html_attrs(self): TPL = '' context0 = dict(checked=None) context1 = dict(checked=True) perform(TPL, '', context0, mode="xml") perform(TPL, '', context1, mode="xml") perform(TPL, '', context0, mode="html") perform(TPL, '', context1, mode="html") perform( TPL, '\n', context1, mode="html5", is_fragment=False, ) perform( "\n" + TPL, '\n', context1, mode=None, is_fragment=False, ) def test_xml_namespaces(self): """Namespaced attributes pass through.""" TPL = '

English text

' perform(TPL, TPL, mode="xml") perform(TPL, TPL, mode="html") def test_escape_attr_values(self): """Escape static and dynamic attribute values.""" context = dict(url="https://domain.com/path?a=1&b=2") source = """Link""" output = ( 'Link' ) perform(source, output, context, mode="html") perform(source, output, context, mode="xml") class TestDebug(TestCase): def test_debug(self): loader = FileLoader(path=os.path.join(os.path.dirname(__file__), "data")) tpl = loader.import_("debug.html") try: tpl().render() assert False, "Should have raised ValueError" except ValueError: exc_info = sys.exc_info() stack = traceback.extract_tb(exc_info[2]) # Verify we have stack trace entries in the template for fn, lno, func, line in stack: if fn.endswith("debug.html"): break else: assert False, "Stacktrace is all python" class TestPackageLoader(TestCase): def test_pkg_loader(self): loader = PackageLoader() loader.import_("kajiki_test_data.debug") class TestBuiltinFunctions(TestCase): def test_defined(self): perform( """
\
$albatross
\

$parrot

""", expected_output="

Bereft of life, it rests in peace

", context=dict(parrot="Bereft of life, it rests in peace"), ) def test_value_of(self): TPL = "

${value_of('albatross', 'Albatross!!!')}

" perform(TPL, expected_output="

It's

", context=dict(albatross="It's")) perform(TPL, expected_output="

Albatross!!!

") def test_literal(self): """Escape by default; literal() marks as safe.""" context = dict(albatross="Albatross!!!") expected_output = "

Albatross!!!

" perform("

${literal(albatross)}

", expected_output, context) perform("

${Markup(albatross)}

", expected_output, context) perform( "

$albatross

", "

<em>Albatross!!!</em>

", context ) from kajiki.util import literal markup = '"&"' assert "".join(list(literal(markup))) == markup class TestTranslation(TestCase): def test_scripts_non_translatable(self): src = ( "
Hi
" "" ) doc = _Parser("", src).parse() for n in _Compiler("", doc).compile(): text = getattr(n, "text", "") if text in ("hello world", "hello style"): self.assertFalse(isinstance(n, TranslatableTextNode)) for n in _Compiler("", doc, cdata_scripts=False).compile(): text = getattr(n, "text", "") if text in ("hello world", "hello style"): self.assertFalse(isinstance(n, TranslatableTextNode)) def test_extract_translate(self): src = """
Hi

Hello World

""" expected = { False: """
TRANSLATED(Hi)

\n\n TRANSLATED(Hello World)

""", True: """
TRANSLATED(Hi)

TRANSLATED(Hello World)

""", } for strip_text in (False, True): # Build translation table messages = {} for _, _, msgid, _ in i18n.extract( BytesIO(src.encode("utf-8")), None, None, {"strip_text": strip_text} ): messages[msgid] = "TRANSLATED(%s)" % msgid # Provide a fake translation function default_gettext = i18n.gettext i18n.gettext = lambda s: messages[s] try: perform(src, expected[strip_text], strip_text=strip_text) finally: i18n.gettext = default_gettext def test_extract_python_inside(self): src = """
${_('hi')}

Hello World

""" expected = """
xi

\n\n TRANSLATED(Hello World)

""" # Build translation table messages = {"hi": "xi"} for _, _, msgid, _ in i18n.extract( BytesIO(src.encode("utf-8")), [], None, {"extract_python": True} ): messages[msgid] = "TRANSLATED(%s)" % msgid # Provide a fake translation function default_gettext = i18n.gettext i18n.gettext = lambda s: messages[s] try: perform(src, expected) finally: i18n.gettext = default_gettext def test_extract_python_inside_invalid(self): src = """
${_('hi' +)}
""" try: list( i18n.extract( BytesIO(src.encode("utf-8")), [], None, {"extract_python": True} ) ) except XMLTemplateCompileError as e: assert "_('hi' +)" in str(e) else: assert False, "Should have raised" def test_substituting_gettext_with_lambda(self): src = """hi""" expected = """spam""" perform(src, expected, context=dict(gettext=lambda x: "spam")) def test_substituting_gettext_with_lambda_extending(self): loader = MockLoader( { "parent.html": XMLTemplate("""
parent
"""), "child.html": XMLTemplate( """
child
""" ), } ) tpl = loader.import_("child.html") rsp = tpl(dict(gettext=lambda _: "egg")).render() assert rsp == """
egg
egg
""", rsp def test_substituting_gettext_with_lambda_extending_twice(self): loader = MockLoader( { "parent.html": XMLTemplate("
parent
"), "mid.html": XMLTemplate( '
${variable}
' ), "child.html": XMLTemplate( '
child
' ), } ) tpl = loader.import_("child.html") rsp = tpl(dict(variable="spam", gettext=lambda _: "egg")).render() # variables must not be translated assert rsp == """
egg
spam
egg
""", rsp def test_substituting_gettext_with_lambda_extending_file(self): loader = FileLoader( path=os.path.join(os.path.dirname(__file__), "data"), base_globals=dict(gettext=lambda x: "egg"), ) tpl = loader.import_("file_child.html") rsp = tpl(dict()).render() assert rsp == """
egg
egg
""", rsp def test_without_substituting_gettext_with_lambda_extending_file(self): # this should use i18n.gettext loader = FileLoader(path=os.path.join(os.path.dirname(__file__), "data")) tpl = loader.import_("file_child.html") rsp = tpl(dict()).render() assert rsp == """
parent
child
""", rsp class TestDOMTransformations(TestCase): def test_empty_text_extraction(self): doc = kajiki.xml_template._Parser( "", """ text """ ).parse() doc = kajiki.xml_template._DomTransformer(doc, strip_text=False).transform() text_data = [n.data for n in doc.firstChild.childNodes] self.assertEqual([" ", "text", " "], text_data) def test_empty_text_extraction_lineno(self): doc = kajiki.xml_template._Parser( "", """ text """, ).parse() doc = kajiki.xml_template._DomTransformer(doc, strip_text=False).transform() linenos = [n.lineno for n in doc.firstChild.childNodes] self.assertEqual( [1, 3, 3], linenos ) # Last node starts on same line as it starts with \n class TestErrorReporting(TestCase): def test_syntax_error(self): for strip_text in (False, True): try: perform( '
${i}
', "", strip_text=strip_text, ) except KajikiSyntaxError as exc: assert "--> for i i range(1, 2):" in str(exc), exc else: assert False def test_code_error(self): for strip_text in (False, True): try: child = FileLoader( os.path.join(os.path.dirname(__file__), "data") ).load("error.html", strip_text=strip_text) child().render() except ZeroDivisionError: exn_info = traceback.format_exception(*sys.exc_info()) last_line = exn_info[-2] assert "${3/0}" in last_line else: assert False class TestBracketsInExpression(TestCase): def test_simple(self): perform("${'ok'}", "ok") def test_some_brackets(self): perform("${'{ok}'}", "{ok}") def test_brackets_asymmetric(self): perform("${'{o{k}k { '}", "{o{k}k { ") def test_complex(self): perform( "
${'ciao { } {' + \"a {} b {{{{} w}}rar\"}${'sd{}'}" " ${1+1}
", "
ciao { } {a {} b {{{{} w}}rarsd{} 2
", ) def test_with_padding_space(self): perform( ' ${ "hello" + "world" } ', ' helloworld ', ) def test_raise_unclosed_string(self): try: XMLTemplate('${"ciao}') assert False, "must raise" except XMLTemplateCompileError as e: # assert "can't compile" in str(e), e # different between pypy and cpython assert '"ciao' in str(e), e def test_raise_plus_with_an_operand(self): try: XMLTemplate('${"ciao" + }') assert False, "must raise" except XMLTemplateCompileError as e: assert "detected an invalid python expression" in str(e), e assert '"ciao" +' in str(e), e def test_unclosed_braced(self): try: XMLTemplate('${"ciao"') assert False, "must raise" except XMLTemplateCompileError as e: assert "Braced expression not terminated" in str(e), e def test_leading_opening_brace(self): try: XMLTemplate('${{"a", "b"}') assert False, "must raise" except XMLTemplateCompileError as e: assert "Braced expression not terminated" in str(e), e class TestMultipleChildrenInDOM(TestCase): def test_ok(self): XMLTemplate("${1+1}") def test_comment(self): res = XMLTemplate("${1+1}")().render() assert res == "2" def test_multiple_nodes(self): try: XMLTemplate("${1+1}${1+1}") except XMLTemplateParseError as e: assert "junk after document element" in str(e), e else: assert False, "should have raised" def test_only_comment(self): try: XMLTemplate("") except XMLTemplateParseError as e: assert "no element found" in str(e), e else: assert False, "should have raised" class TestSyntaxErrorCallingWithTrailingParenthesis(TestCase): def test_raise(self): try: XMLTemplate( """
$x${echo('hello'))}
""" ) assert False, "should raise" except XMLTemplateCompileError: pass if __name__ == "__main__": main()