Python test__compiler.render函数代码示例

 def test_block_helper_inverted_sections(self):
     def list(this, options, context):
         if len(context):
             out = "<ul>"
             for thing in context:
                 out += "<li>"
                 out += str_class(options['fn'](thing))
                 out += "</li>"
             out += "</ul>"
             return out
         else:
             return "<p>" + str_class(options['inverse'](this)) + "</p>"
     context = {'people': [{'name': "Alan"}, {'name': "Yehuda"}]}
     empty = {'people': []}
     rootMessage = {'people': [], 'message': "Nobody's here"}
     src1 = u"{{#list people}}{{name}}{{^}}<em>Nobody's here</em>{{/list}}"
     src2 = u"{{#list people}}Hello{{^}}{{message}}{{/list}}"
     src3 = u"{{#list people}}{{name}}{{else}}<em>Nobody's here</em>{{/list}}"
     helpers = {'list': list}
     # inverse not executed by helper:
     self.assertEqual("<ul><li>Alan</li><li>Yehuda</li></ul>",
         render(src1, context, helpers))
     # inverse can be called by a helper
     self.assertEqual("<p><em>Nobody's here</em></p>",
         render(src1, empty, helpers))
     # the expected context of the inverse is the this parameter to block
     # helpers.
     self.assertEqual("<p>Nobody&#x27;s here</p>",
         render(src2, rootMessage, helpers=helpers))
     # inverse can also be denoted by 'else':
     self.assertEqual("<ul><li>Alan</li><li>Yehuda</li></ul>",
         render(src3, context, helpers))
     self.assertEqual("<p><em>Nobody's here</em></p>",
         render(src3, empty, helpers))

 def test_zeros(self):
     self.assertEqual("num1: 42, num2: 0",
         render(u"num1: {{num1}}, num2: {{num2}}", {'num1': 42, 'num2': 0}))
     self.assertEqual("num: 0",
         render(u"num: {{.}}", 0))
     self.assertEqual("num: 0",
         render(u"num: {{num1/num2}}", {'num1': {'num2': 0}}))

 def test_negative_int_literal(self):
     self.assertEqual("str int int",
         render(u"{{type \"string\"}} {{type 1}} {{type -1}}", None,
         helpers={'type': lambda s, v: type(v).__name__}))
     self.assertEqual("string 1 -1",
         render(u"{{echo \"string\"}} {{echo 1}} {{echo -1}}", None,
         helpers={'echo': lambda s, v: str(v)}))

 def test_escaping_expressions(self):
     self.assertEqual('&\"\\<>',
         render(u"{{{awesome}}}", {'awesome': "&\"\\<>"}))
     self.assertEqual('&\"\\<>',
         render(u"{{&awesome}}", {'awesome': "&\"\\<>"}))
     self.assertEqual(u'&amp;&quot;&#x27;&#x60;\\&lt;&gt;',
         render(u"{{awesome}}", {'awesome': "&\"'`\\<>"}))

 def test_providing_a_helpers_hash(self):
     self.assertEqual("Goodbye cruel world!",
         render(u"Goodbye {{cruel}} {{world}}!", {'cruel': "cruel"},
             helpers={'world': "world"}))
     self.assertEqual("Goodbye cruel world!",
         render(u"Goodbye {{#iter}}{{cruel}} {{world}}{{/iter}}!",
             {'iter': [{'cruel': "cruel"}]},
             helpers={'world': "world"}))

 def test_booleans(self):
     template = u"{{#goodbye}}GOODBYE {{/goodbye}}cruel {{world}}!"
     self.assertEqual(
         "GOODBYE cruel world!",
         render(template, {'goodbye': True, 'world': 'world'}))
     self.assertEqual(
         "cruel world!",
         render(template, {'goodbye': False, 'world': 'world'}))

 def test_functions_can_take_context_arguments(self):
     def awesome(this, context):
         return context
     self.assertEqual("Frank",
         render(u"{{awesome frank}}",
             {'awesome': awesome, 'frank': 'Frank'}))
     self.assertEqual("Frank",
         render(u"{{{awesome frank}}}",
             {'awesome': awesome, 'frank': 'Frank'}))

 def test_each(self):
     source = u"{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!"
     context = {'goodbyes':
         [{'text': "goodbye"}, {'text': "Goodbye"}, {'text': "GOODBYE"}],
         'world': "world"}
     self.assertEqual("goodbye! Goodbye! GOODBYE! cruel world!",
         render(source, context))
     self.assertEqual("cruel world!",
         render(source, {'goodbyes': [], 'world': "world"}))

 def test_empty_block(self):
     source = u"{{#goodbyes}}{{/goodbyes}}cruel {{world}}!"
     context = {
         'goodbyes': [
             {'text': "goodbye"}, {'text': "Goodbye"}, {'text': "GOODBYE"}],
         'world': "world"}
     self.assertEqual("cruel world!", render(source, context))
     self.assertEqual("cruel world!",
         render(source, {'goodbyes': [], 'world': "world"}))

 def test_in_cases_of_conflict_helpers_before_context(self):
     self.assertEqual("helpers",
         render(u"{{lookup}}", {'lookup': 'Explicit'},
             helpers={'lookup': 'helpers'}))
     self.assertEqual("helpers",
         render(u"{{{lookup}}}", {'lookup': 'Explicit'},
             helpers={'lookup': 'helpers'}))
     self.assertEqual("Explicit",
         render(u"{{#lookup}}Explicit{{/lookup}}", {'lookup': []},
             helpers={'lookup': [{}]}))

 def test_inverted_sections(self):
     source = (
         u"{{#goodbyes}}{{this}}{{/goodbyes}}"
         u"{{^goodbyes}}Right On!{{/goodbyes}}")
     # Unset value
     self.assertEqual("Right On!", render(source, {}))
     # False value
     self.assertEqual("Right On!", render(source, {'goodbyes': False}))
     # Empty list
     self.assertEqual("Right On!", render(source, {'goodbyes': []}))

 def test_if_with_function_argument(self):
     source = u"{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!"
     self.assertEqual(u"GOODBYE cruel world!",
         render(source, {'goodbye': lambda this: True, 'world': "world"}))
     self.assertEqual(u"GOODBYE cruel world!",
         render(source,
             {'goodbye': lambda this: this['world'], 'world': "world"}))
     self.assertEqual(u"cruel world!",
         render(source, {'goodbye': lambda this: False, 'world': "world"}))
     self.assertEqual(u"cruel world!",
         render(source, {'goodbye': lambda this: None, 'world': "world"}))

 def test_block_helpers_can_take_an_optional_hash_with_booleans(self):
     def goodbye(this, options, cruel, _print):
         if _print is True:
             return "GOODBYE " + cruel + " " + str_class(options['fn'](this))
         elif _print is False:
             return "NOT PRINTING"
         else:
             return "THIS SHOULD NOT HAPPEN"
     helpers = {'goodbye': goodbye}
     self.assertEqual("GOODBYE CRUEL world",
         render(u'{{#goodbye cruel="CRUEL" _print=true}}world{{/goodbye}}',
             {}, helpers=helpers))
     self.assertEqual("NOT PRINTING",
         render(u'{{#goodbye cruel="CRUEL" _print=false}}world{{/goodbye}}',
             {}, helpers=helpers))

 def test_helpers_can_take_an_optional_hash_with_booleans(self):
     def goodbye(this, cruel, world, _print):
         if _print is True:
             return "GOODBYE " + cruel + " " + world
         elif _print is False:
             return "NOT PRINTING"
         else:
             return "THIS SHOULD NOT HAPPEN"
     helpers = {'goodbye': goodbye}
     self.assertEqual("GOODBYE CRUEL WORLD",
         render(u'{{goodbye cruel="CRUEL" world="WORLD" _print=true}}',
             {}, helpers=helpers))
     self.assertEqual("NOT PRINTING",
         render(u'{{goodbye cruel="CRUEL" world="WORLD" _print=false}}',
             {}, helpers=helpers))

 def test_block_helpers_can_take_an_optional_hash(self):
     source = u'{{#goodbye cruel="CRUEL" times=12}}world{{/goodbye}}'
     def goodbye(this, options, times, cruel):
         return "GOODBYE " + cruel + " " + str_class(options['fn'](this)) + " " + str(times) + " TIMES"
     helpers = {'goodbye': goodbye}
     self.assertEqual("GOODBYE CRUEL world 12 TIMES",
         render(source, {}, helpers=helpers))