Source

fastpt / kajiki / tests / test_ir.py

Full commit
from unittest import TestCase, main

import kajiki
from kajiki import ir

class TestBasic(TestCase):

    def setUp(self):
        self.tpl = ir.TemplateNode(
            defs=[ir.DefNode(
                '__main__()',
                ir.TextNode('Hello, '),
                ir.ExprNode('name'),
                ir.TextNode('\n'))])

    def test(self):
        tpl = kajiki.template.from_ir(self.tpl)
        rsp = tpl(dict(name='Rick')).render() 
        assert rsp == 'Hello, Rick\n', rsp

class TestSwitch(TestCase):

    def setUp(self):
        self.tpl = ir.TemplateNode(
            defs=[ir.DefNode(
                    '__main__()',
                    ir.ForNode(
                        'i in range(2)',
                        ir.ExprNode('i'),
                        ir.TextNode(' is '),
                        ir.SwitchNode(
                            'i % 2',
                            ir.CaseNode(
                                '0',
                                ir.TextNode('even\n')),
                            ir.ElseNode(
                                ir.TextNode('odd\n')))))])
            
    def test_basic(self):
        tpl = kajiki.template.from_ir(self.tpl)
        rsp = tpl(dict()).render() 
        assert rsp == '0 is even\n1 is odd\n', rsp

class TestFunction(TestCase):

    def setUp(self):
        self.tpl = ir.TemplateNode(
            defs=[ir.DefNode(
                    'evenness(n)',
                    ir.IfNode(
                        'n % 2 == 0',
                        ir.TextNode('even')),
                    ir.ElseNode(
                        ir.TextNode('odd'))),
                  ir.DefNode(
                    '__main__()',
                    ir.ForNode(
                        'i in range(2)',
                        ir.ExprNode('i'),
                        ir.TextNode(' is '),
                        ir.ExprNode('evenness(i)'),
                        ir.TextNode('\n')))])

    def test_basic(self):
        tpl = kajiki.template.from_ir(self.tpl)
        rsp = tpl(dict(name='Rick')).render()
        assert rsp == '0 is even\n1 is odd\n', rsp

class TestCall(TestCase):
    
    def setUp(self):
        self.tpl = ir.TemplateNode(
            defs=[ir.DefNode(
                    'quote(caller, speaker)',
                    ir.ForNode(
                        'i in range(2)',
                        ir.TextNode('Quoth '),
                        ir.ExprNode('speaker'),
                        ir.TextNode(', "'),
                        ir.ExprNode('caller(i)'),
                        ir.TextNode('."\n'))),
                  ir.DefNode(
                    '__main__()',
                    ir.CallNode(
                        '$caller(n)',
                        "quote($caller, 'the raven')",
                        ir.TextNode('Nevermore '),
                        ir.ExprNode('n')))])
            
    def test_basic(self):
        tpl = kajiki.template.from_ir(self.tpl)
        rsp = tpl(dict(name='Rick')).render()
        assert (
            rsp == 'Quoth the raven, "Nevermore 0."\n'
            'Quoth the raven, "Nevermore 1."\n'), rsp

class TestImport(TestCase):
    
    def setUp(self):
        lib = ir.TemplateNode(
            defs=[ir.DefNode(
                    'evenness(n)',
                    ir.IfNode(
                        'n % 2 == 0',
                        ir.TextNode('even')),
                    ir.ElseNode(
                        ir.TextNode('odd'))),
                  ir.DefNode(
                    'half_evenness(n)',
                    ir.TextNode(' half of '),
                    ir.ExprNode('n'),
                    ir.TextNode(' is '),
                    ir.ExprNode('evenness(n/2)'))])
        tpl = ir.TemplateNode(
            defs=[ir.DefNode(
                    '__main__()',
                    ir.ImportNode(
                        'lib.txt',
                        'simple_function'),
                    ir.ForNode(
                        'i in range(4)',
                        ir.ExprNode('i'),
                        ir.TextNode(' is '),
                        ir.ExprNode('simple_function.evenness(i)'),
                        ir.ExprNode('simple_function.half_evenness(i)'),
                        ir.TextNode('\n')))])
        loader = kajiki.loader.MockLoader({
            'lib.txt':kajiki.template.from_ir(lib),
            'tpl.txt':kajiki.template.from_ir(tpl)})
        self.tpl = loader.import_('tpl.txt')

    def test_import(self):
        rsp = self.tpl(dict(name='Rick')).render()
        assert (rsp=='0 is even half of 0 is even\n'
                '1 is odd half of 1 is even\n'
                '2 is even half of 2 is odd\n'
                '3 is odd half of 3 is odd\n'), rsp

class TestInclude(TestCase):
    
    def setUp(self):
        hdr = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.TextNode('# header\n'))])
        tpl = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.TextNode('a\n'),
                    ir.IncludeNode('hdr.txt'),
                    ir.TextNode('b\n'))])
        loader = kajiki.loader.MockLoader({
            'hdr.txt':kajiki.template.from_ir(hdr),
            'tpl.txt':kajiki.template.from_ir(tpl)})
        self.tpl = loader.import_('tpl.txt')

    def test_include(self):
        rsp = self.tpl(dict(name='Rick')).render()
        assert rsp == 'a\n# header\nb\n', rsp

class TestExtends(TestCase):

    def setUp(self):
        parent_tpl = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.ExprNode('header()'),
                    ir.ExprNode('body()'),
                    ir.ExprNode('footer()')),
                ir.DefNode(
                    'header()',
                    ir.TextNode('# Header name='),
                    ir.ExprNode('name'),
                    ir.TextNode('\n')),
                ir.DefNode(
                    'body()',
                    ir.TextNode('## Parent Body\n'),
                    ir.TextNode('local.id() = '),
                    ir.ExprNode('local.id()'),
                    ir.TextNode('\n'),
                    ir.TextNode('self.id() = '),
                    ir.ExprNode('self.id()'),
                    ir.TextNode('\n'),
                    ir.TextNode('child.id() = '),
                    ir.ExprNode('child.id()'),
                    ir.TextNode('\n')),
                ir.DefNode(
                    'footer()',
                    ir.TextNode('# Footer\n')),
                ir.DefNode(
                    'id()',
                    ir.TextNode('parent'))])
        mid_tpl = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.ExtendNode('parent.txt')),
                ir.DefNode(
                    'id()',
                    ir.TextNode('mid'))])
        child_tpl = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.ExtendNode('mid.txt')),
                ir.DefNode(
                    'body()',
                    ir.TextNode('## Child Body\n'),
                    ir.ExprNode('parent.body()')),
                ir.DefNode(
                    'id()',
                    ir.TextNode('child'))])
        loader = kajiki.loader.MockLoader({
            'parent.txt':kajiki.template.from_ir(parent_tpl),
            'mid.txt':kajiki.template.from_ir(mid_tpl),
            'child.txt':kajiki.template.from_ir(child_tpl)})
        self.loader = loader
        self.tpl = loader.import_('child.txt')
        
    def test_extends(self):
        rsp = self.tpl(dict(name='Rick')).render()
        assert (rsp == '# Header name=Rick\n'
                '## Child Body\n'
                '## Parent Body\n'
                'local.id() = parent\n'
                'self.id() = child\n'
                'child.id() = mid\n'
                '# Footer\n'), rsp

class TestDynamicExtends(TestCase):
    def setUp(self):
        p0 = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.TextNode('Parent 0'))])
        p1 = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.TextNode('Parent 1'))])
        child = ir.TemplateNode(
            defs=[
                ir.DefNode(
                    '__main__()',
                    ir.IfNode(
                        'p==0',
                        ir.ExtendNode('parent0.txt')),
                    ir.ElseNode(
                        ir.ExtendNode('parent1.txt')))])
        loader = kajiki.loader.MockLoader({
            'parent0.txt':kajiki.template.from_ir(p0),
            'parent1.txt':kajiki.template.from_ir(p1),
            'child.txt':kajiki.template.from_ir(child)})
        self.loader = loader
        self.tpl = loader.import_('child.txt')

    def test_extends(self):
        rsp = self.tpl(dict(p=0)).render()
        assert rsp == 'Parent 0', rsp
        rsp = self.tpl(dict(p=1)).render()
        assert rsp == 'Parent 1', rsp

if __name__ == '__main__':
    main()