Python Engine Exemples

Exemple #1

Fichier : test_template_base.py Projet : johnmahugu/fiole

class EngineTestCase(unittest.TestCase):
    """Test the ``Engine``."""
    def setUp(self):
        from fiole import Engine
        self.engine = Engine()

    def test_template_not_found(self):
        """Raises."""
        self.assertRaises(Exception, self.engine.get_template, 'x')

    def test_import_not_found(self):
        """Raises."""
        self.assertRaises(Exception, self.engine.import_name, 'x')

    def test_remove_unknown_name(self):
        """Invalidate name that is not known to engine."""
        self.assertNotIn('x', self.engine.templates)
        self.assertNotIn('x', self.engine.renders)
        self.assertNotIn('x', self.engine.modules)
        self.engine.remove('x')

    def test_remove_name(self):
        """Invalidate name that is known to engine."""
        self.engine.templates['x'] = 'x'
        self.engine.renders['x'] = 'x'
        self.engine.modules['x'] = 'x'
        self.assertIn('x', self.engine.templates)
        self.assertIn('x', self.engine.renders)
        self.assertIn('x', self.engine.modules)
        self.engine.remove('x')
        self.assertNotIn('x', self.engine.templates)
        self.assertNotIn('x', self.engine.renders)
        self.assertNotIn('x', self.engine.modules)

Exemple #2

Fichier : test_template_base.py Projet : florentx/fiole

class EngineTestCase(unittest.TestCase):
    """Test the ``Engine``."""

    def setUp(self):
        from fiole import Engine
        self.engine = Engine()

    def test_template_not_found(self):
        """Raises."""
        self.assertRaises(Exception, self.engine.get_template, 'x')

    def test_import_not_found(self):
        """Raises."""
        self.assertRaises(Exception, self.engine.import_name, 'x')

    def test_remove_unknown_name(self):
        """Invalidate name that is not known to engine."""
        self.assertNotIn('x', self.engine.templates)
        self.assertNotIn('x', self.engine.renders)
        self.assertNotIn('x', self.engine.modules)
        self.engine.remove('x')

    def test_remove_name(self):
        """Invalidate name that is known to engine."""
        self.engine.templates['x'] = 'x'
        self.engine.renders['x'] = 'x'
        self.engine.modules['x'] = 'x'
        self.assertIn('x', self.engine.templates)
        self.assertIn('x', self.engine.renders)
        self.assertIn('x', self.engine.modules)
        self.engine.remove('x')
        self.assertNotIn('x', self.engine.templates)
        self.assertNotIn('x', self.engine.renders)
        self.assertNotIn('x', self.engine.modules)

Exemple #3

Fichier : test_template_base.py Projet : florentx/fiole

 def setUp(self):
     from fiole import Engine
     self.engine = Engine()

Exemple #4

Fichier : test_template_parse.py Projet : johnmahugu/fiole

 def setUp(self):
     from fiole import Engine
     self.engine = Engine()

Exemple #5

Fichier : test_template_render.py Projet : florentx/fiole

 def setUp(self):
     from fiole import Engine, Loader
     self.templates = {}
     self.engine = Engine(loader=Loader(templates=self.templates))

Exemple #6

Fichier : test_template_render.py Projet : florentx/fiole

class TemplateTestCase(unittest.TestCase):
    """Test the compiled templates."""

    def setUp(self):
        from fiole import Engine, Loader
        self.templates = {}
        self.engine = Engine(loader=Loader(templates=self.templates))

    def render(self, ctx, source):
        self.templates['test.html'] = source
        template = self.engine.get_template('test.html')
        self.engine.remove('test.html')
        return template.render(ctx)

    def test_markup(self):
        ctx = {}
        self.assertEqual(self.render(ctx, 'Hello'), 'Hello')

    def test_comment(self):
        self.assertEqual(self.render({}, """\
Hello\\
%# comment
 World"""),
                         'Hello World')
        self.assertEqual(self.render({}, """\
Hello\\
% # comment
 World"""),
                         'Hello World')

    def test_import(self):
        self.assertEqual(self.render({}, """\
% from math import pi
Pi = {{ '%.9f' % pi }}"""),
                         'Pi = 3.141592654')
        self.assertEqual(self.render({}, """\
% import  math \n\
Pi = {{ '%.9f' % math.pi }}"""),
                         'Pi = 3.141592654')
        self.assertEqual(self.render({}, """\
%# import  this \n\
% import  itertools
# {{ 42 }} {{ locals()|sorted }}"""),
                         """\
# 42 ['_b', 'ctx', 'itertools', 'local_defs', 'super_defs', 'w']""")

    def test_var(self):
        ctx = {'username': '******'}
        self.assertEqual(self.render(ctx, """\
%require(username)
Welcome, {{username}}!"""), 'Welcome, John!')

    def test_if(self):
        template = """\
%require(n)
%if n > 0:
    Positive\\
%elif n == 0:
    Zero\\
%else:
    Negative\\
%end
"""
        self.assertEqual(self.render({'n': +1}, template), '    Positive')
        self.assertEqual(self.render({'n': +0}, template), '    Zero')
        self.assertEqual(self.render({'n': -1}, template), '    Negative')

    def test_for(self):
        ctx = {'colors': ['red', 'yellow']}
        self.assertEqual(self.render(ctx, """\
%require(colors)
%for color in colors:
    {{color}}
%end
"""),
                         '    red\n    yellow\n')

    def test_def(self):
        self.assertEqual(self.render({}, """\
%def welcome(name):
Welcome, {{name}}!\\
%end
{{welcome('John')}}"""),
                         'Welcome, John!')

    def test_def_empty(self):
        self.assertEqual(self.render({}, """\
%def title():
%end
{{title()}}."""),
                         '.')

    def test_def_syntax_error_compound(self):
        self.assertRaises(SyntaxError, self.render, {}, """\
%def welcome(name):
%if name:
Welcome, {{name}}!\\
%end
%end
{{welcome('John')}}""")

    def test_def_no_syntax_error(self):
        self.assertEqual(self.render({}, """\
%def welcome(name):
%#ignore
%if name:
Welcome, {{name}}!\\
%end
%end
{{welcome('John')}}"""),
                         'Welcome, John!')

    def test_backslash(self):
        self.assertRaises(SyntaxError, self.render, {}, """\
  %def say_hi(name):
Hi, {{name}}\
  %end
{{ say_hi('Noël')}}""")

    def test_return_early(self):
        template = """\
%require(magic)
    First Line\\
% if magic == 987:
%     return 'Moar Lines'
% elif magic == 42:
%     return
% end
    Second Line\\
"""
        self.assertEqual(self.render({'magic': 27}, template),
                         '    First Line    Second Line')
        self.assertEqual(self.render({'magic': 42}, template),
                         '    First Line')
        self.assertEqual(self.render({'magic': 987}, template), 'Moar Lines')

Exemple #7

class MultiTemplateTestCase(unittest.TestCase):
    """Test the compiled templates."""
    def setUp(self):
        from fiole import Engine, Loader
        self.templates = {}
        self.engine = Engine(loader=Loader(templates=self.templates))

    def render(self, name, ctx):
        template = self.engine.get_template(name)
        self.engine.remove('test.html')
        return template.render(ctx)

    def test_extends(self):
        self.templates.update({
            'master.html':
            """\
%def say_hi(name):
    Hello, {{name}}!
%end
{{say_hi('John')}}""",
            'tmpl.html':
            """\
%extends('master.html')
%def say_hi(name):
    Hi, {{name}}!
%end
"""
        })
        self.assertEqual(self.render('tmpl.html', {}), '    Hi, John!\n')
        self.assertEqual(self.render('master.html', {}), '    Hello, John!\n')
        self.assertEqual(self.render('tmpl.html', {}), '    Hi, John!\n')
        self.assertEqual(self.render('master.html', {}), '    Hello, John!\n')

    def test_super(self):
        self.templates.update({
            'master.html':
            """\
%def say_hi(name):
    Hello, {{name}}!\\
%end
{{say_hi('John')}}""",
            'tmpl.html':
            """\
%extends('master.html')
%def say_hi(name):
    {{super_defs['say_hi'](name)}}!!\\
%end
"""
        })
        self.assertEqual(self.render('tmpl.html', {}),
                         '        Hello, John!!!')

    def test_include(self):
        self.templates.update({
            'footer.html':
            """\
%require(name)
Thanks, {{name}}""",
            'tmpl.html':
            """\
Welcome to my site.
%include('footer.html')
"""
        })
        ctx = {'name': 'John'}
        self.assertEqual(self.render('tmpl.html', ctx), """\
Welcome to my site.
Thanks, John""")
        self.assertEqual(self.render('footer.html', ctx), 'Thanks, John')

    def test_import(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\\
%end""",
            'tmpl.html':
            """\
%import 'helpers.html' as helpers
{{helpers.say_hi('John')}}"""
        })
        self.assertEqual(self.render('tmpl.html', {}), "Hi, John")

    def test_import_dynamic(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\\
%end""",
            'tmpl.html':
            """\
%require(helpers_impl)
%import helpers_impl as helpers
{{helpers.say_hi('John')}}"""
        })
        self.assertEqual(
            self.render('tmpl.html', {'helpers_impl': 'helpers.html'}),
            "Hi, John")

    def test_from_import(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\\
%end""",
            'tmpl.html':
            """\
%from 'helpers.html' import say_hi
{{say_hi('John')}}"""
        })
        self.assertEqual(self.render('tmpl.html', {}), "Hi, John")

    def test_from_import_dynamic(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\\
%end""",
            'tmpl.html':
            """\
%require(helpers_impl)
%from helpers_impl import say_hi
{{say_hi('John')}}"""
        })
        self.assertEqual(
            self.render('tmpl.html', {'helpers_impl': 'helpers.html'}),
            "Hi, John")

    def test_from_import_as(self):
        self.templates.update({
            'share/helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\\
%end""",
            'tmpl.html':
            """\
%from 'share/helpers.html' import say_hi as hi
{{hi('John')}}"""
        })
        self.assertEqual(self.render('tmpl.html', {}), "Hi, John")

    def test_import_syntax_error(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\
%end""",
            'tmpl.html':
            """\
%import 'helpers.html' as helpers
{{helpers.say_hi('John')}}"""
        })
        self.assertRaises(SyntaxError, self.render, 'tmpl.html', {})

    def test_import_dynamic_syntax_error(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\
%end""",
            'tmpl.html':
            """\
%require(helpers_impl)
%import helpers_impl as helpers
{{helpers.say_hi('John')}}"""
        })
        self.assertRaises(SyntaxError, self.render, 'tmpl.html',
                          {'helpers_impl': 'helpers.html'})

    def test_from_import_syntax_error(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\
%end""",
            'tmpl.html':
            """\
%from 'helpers.html' import say_hi
{{say_hi('John')}}"""
        })
        self.assertRaises(SyntaxError, self.render, 'tmpl.html', {})

    def test_from_import_dynamic_syntax_error(self):
        self.templates.update({
            'helpers.html':
            """\
%def say_hi(name):
Hi, {{name}}\
%end""",
            'tmpl.html':
            """\
%require(helpers_impl)
%from helpers_impl import say_hi
{{say_hi('John')}}"""
        })
        self.assertRaises(SyntaxError, self.render, 'tmpl.html',
                          {'helpers_impl': 'helpers.html'})

    def test_from_import_as_syntax_error(self):
        self.templates.update({
            'share/helpers.html':
            """\
% def say_hi( name ):
Hi, {{name}}\
% end""",
            'tmpl.html':
            """\
%  from  "share/helpers.html" import  say_hi  as  hi
{{hi('John')}}"""
        })
        self.assertRaises(SyntaxError, self.render, 'tmpl.html', {})

Exemple #8

 def setUp(self):
     from fiole import Engine, Loader
     self.templates = {}
     self.engine = Engine(loader=Loader(templates=self.templates))

Exemple #9

Fichier : test_template_render.py Projet : johnmahugu/fiole

class TemplateTestCase(unittest.TestCase):
    """Test the compiled templates."""
    def setUp(self):
        from fiole import Engine, Loader
        self.templates = {}
        self.engine = Engine(loader=Loader(templates=self.templates))

    def render(self, ctx, source):
        self.templates['test.html'] = source
        template = self.engine.get_template('test.html')
        self.engine.remove('test.html')
        return template.render(ctx)

    def test_markup(self):
        ctx = {}
        self.assertEqual(self.render(ctx, 'Hello'), 'Hello')

    def test_comment(self):
        self.assertEqual(self.render({}, """\
Hello\\
%# comment
 World"""), 'Hello World')
        self.assertEqual(self.render({}, """\
Hello\\
% # comment
 World"""), 'Hello World')

    def test_import(self):
        self.assertEqual(
            self.render({}, """\
% from math import pi
Pi = {{ '%.9f' % pi }}"""), 'Pi = 3.141592654')
        self.assertEqual(
            self.render({}, """\
% import  math \n\
Pi = {{ '%.9f' % math.pi }}"""), 'Pi = 3.141592654')
        self.assertEqual(
            self.render({}, """\
%# import  this \n\
% import  itertools
# {{ 42 }} {{ locals()|sorted }}"""), """\
# 42 ['_b', 'ctx', 'itertools', 'local_defs', 'super_defs', 'w']""")

    def test_var(self):
        ctx = {'username': '******'}
        self.assertEqual(
            self.render(ctx, """\
%require(username)
Welcome, {{username}}!"""), 'Welcome, John!')

    def test_if(self):
        template = """\
%require(n)
%if n > 0:
    Positive\\
%elif n == 0:
    Zero\\
%else:
    Negative\\
%end
"""
        self.assertEqual(self.render({'n': +1}, template), '    Positive')
        self.assertEqual(self.render({'n': +0}, template), '    Zero')
        self.assertEqual(self.render({'n': -1}, template), '    Negative')

    def test_for(self):
        ctx = {'colors': ['red', 'yellow']}
        self.assertEqual(
            self.render(
                ctx, """\
%require(colors)
%for color in colors:
    {{color}}
%end
"""), '    red\n    yellow\n')

    def test_def(self):
        self.assertEqual(
            self.render({}, """\
%def welcome(name):
Welcome, {{name}}!\\
%end
{{welcome('John')}}"""), 'Welcome, John!')

    def test_def_empty(self):
        self.assertEqual(
            self.render({}, """\
%def title():
%end
{{title()}}."""), '.')

    def test_def_syntax_error_compound(self):
        self.assertRaises(
            SyntaxError, self.render, {}, """\
%def welcome(name):
%if name:
Welcome, {{name}}!\\
%end
%end
{{welcome('John')}}""")

    def test_def_no_syntax_error(self):
        self.assertEqual(
            self.render({}, """\
%def welcome(name):
%#ignore
%if name:
Welcome, {{name}}!\\
%end
%end
{{welcome('John')}}"""), 'Welcome, John!')

    def test_backslash(self):
        self.assertRaises(
            SyntaxError, self.render, {}, """\
  %def say_hi(name):
Hi, {{name}}\
  %end
{{ say_hi('Noël')}}""")

    def test_return_early(self):
        template = """\
%require(magic)
    First Line\\
% if magic == 987:
%     return 'Moar Lines'
% elif magic == 42:
%     return
% end
    Second Line\\
"""
        self.assertEqual(self.render({'magic': 27}, template),
                         '    First Line    Second Line')
        self.assertEqual(self.render({'magic': 42}, template),
                         '    First Line')
        self.assertEqual(self.render({'magic': 987}, template), 'Moar Lines')

Exemple #10

Fichier : test_template_render.py Projet : johnmahugu/fiole

 def setUp(self):
     import fiole
     from fiole import Engine, Loader
     self.get_template = fiole.get_template
     fiole.engine = Engine(loader=Loader(templates={}))