Lib/test/test_pep292.py

   1 # Copyright (C) 2004 Python Software Foundation
   2 # Author: barry@python.org (Barry Warsaw)
   3 # License: http://www.opensource.org/licenses/PythonSoftFoundation.php
   4
   5 import unittest
   6 from string import Template
   7
   8
   9 class Bag:
  10     pass
  11
  12 class Mapping:
  13     def __getitem__(self, name):
  14         obj = self
  15         for part in name.split('.'):
  16             try:
  17                 obj = getattr(obj, part)
  18             except AttributeError:
  19                 raise KeyError(name)
  20         return obj
  21
  22
  23 class TestTemplate(unittest.TestCase):
  24     def test_regular_templates(self):
  25         s = Template('$who likes to eat a bag of $what worth $$100')
  26         self.assertEqual(s.substitute(dict(who='tim', what='ham')),
  27                          'tim likes to eat a bag of ham worth $100')
  28         self.assertRaises(KeyError, s.substitute, dict(who='tim'))
  29
  30     def test_regular_templates_with_braces(self):
  31         s = Template('$who likes ${what} for ${meal}')
  32         d = dict(who='tim', what='ham', meal='dinner')
  33         self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
  34         self.assertRaises(KeyError, s.substitute,
  35                           dict(who='tim', what='ham'))
  36
  37     def test_escapes(self):
  38         eq = self.assertEqual
  39         s = Template('$who likes to eat a bag of $$what worth $$100')
  40         eq(s.substitute(dict(who='tim', what='ham')),
  41            'tim likes to eat a bag of $what worth $100')
  42         s = Template('$who likes $$')
  43         eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $')
  44
  45     def test_percents(self):
  46         eq = self.assertEqual
  47         s = Template('%(foo)s $foo ${foo}')
  48         d = dict(foo='baz')
  49         eq(s.substitute(d), '%(foo)s baz baz')
  50         eq(s.safe_substitute(d), '%(foo)s baz baz')
  51
  52     def test_stringification(self):
  53         eq = self.assertEqual
  54         s = Template('tim has eaten $count bags of ham today')
  55         d = dict(count=7)
  56         eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
  57         eq(s.safe_substitute(d), 'tim has eaten 7 bags of ham today')
  58         s = Template('tim has eaten ${count} bags of ham today')
  59         eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
  60
  61     def test_tupleargs(self):
  62         eq = self.assertEqual
  63         s = Template('$who ate ${meal}')
  64         d = dict(who=('tim', 'fred'), meal=('ham', 'kung pao'))
  65         eq(s.substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
  66         eq(s.safe_substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
  67
  68     def test_SafeTemplate(self):
  69         eq = self.assertEqual
  70         s = Template('$who likes ${what} for ${meal}')
  71         eq(s.safe_substitute(dict(who='tim')), 'tim likes ${what} for ${meal}')
  72         eq(s.safe_substitute(dict(what='ham')), '$who likes ham for ${meal}')
  73         eq(s.safe_substitute(dict(what='ham', meal='dinner')),
  74            '$who likes ham for dinner')
  75         eq(s.safe_substitute(dict(who='tim', what='ham')),
  76            'tim likes ham for ${meal}')
  77         eq(s.safe_substitute(dict(who='tim', what='ham', meal='dinner')),
  78            'tim likes ham for dinner')
  79
  80     def test_invalid_placeholders(self):
  81         raises = self.assertRaises
  82         s = Template('$who likes $')
  83         raises(ValueError, s.substitute, dict(who='tim'))
  84         s = Template('$who likes ${what)')
  85         raises(ValueError, s.substitute, dict(who='tim'))
  86         s = Template('$who likes $100')
  87         raises(ValueError, s.substitute, dict(who='tim'))
  88
  89     def test_delimiter_override(self):
  90         class PieDelims(Template):
  91             delimiter = '@'
  92         s = PieDelims('@who likes to eat a bag of @{what} worth $100')
  93         self.assertEqual(s.substitute(dict(who='tim', what='ham')),
  94                          'tim likes to eat a bag of ham worth $100')
  95
  96     def test_idpattern_override(self):
  97         class PathPattern(Template):
  98             idpattern = r'[_a-z][._a-z0-9]*'
  99         m = Mapping()
 100         m.bag = Bag()
 101         m.bag.foo = Bag()
 102         m.bag.foo.who = 'tim'
 103         m.bag.what = 'ham'
 104         s = PathPattern('$bag.foo.who likes to eat a bag of $bag.what')
 105         self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
 106
 107     def test_pattern_override(self):
 108         class MyPattern(Template):
 109             pattern = r"""
 110             (?P<escaped>@{2})                   |
 111             @(?P<named>[_a-z][._a-z0-9]*)       |
 112             @{(?P<braced>[_a-z][._a-z0-9]*)}    |
 113             (?P<invalid>@)
 114             """
 115         m = Mapping()
 116         m.bag = Bag()
 117         m.bag.foo = Bag()
 118         m.bag.foo.who = 'tim'
 119         m.bag.what = 'ham'
 120         s = MyPattern('@bag.foo.who likes to eat a bag of @bag.what')
 121         self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
 122
 123         class BadPattern(Template):
 124             pattern = r"""
 125             (?P<badname>.*)                     |
 126             (?P<escaped>@{2})                   |
 127             @(?P<named>[_a-z][._a-z0-9]*)       |
 128             @{(?P<braced>[_a-z][._a-z0-9]*)}    |
 129             (?P<invalid>@)                      |
 130             """
 131         s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
 132         self.assertRaises(ValueError, s.substitute, {})
 133         self.assertRaises(ValueError, s.safe_substitute, {})
 134
 135     def test_unicode_values(self):
 136         s = Template('$who likes $what')
 137         d = dict(who=u't\xffm', what=u'f\xfe\fed')
 138         self.assertEqual(s.substitute(d), u't\xffm likes f\xfe\x0ced')
 139
 140     def test_keyword_arguments(self):
 141         eq = self.assertEqual
 142         s = Template('$who likes $what')
 143         eq(s.substitute(who='tim', what='ham'), 'tim likes ham')
 144         eq(s.substitute(dict(who='tim'), what='ham'), 'tim likes ham')
 145         eq(s.substitute(dict(who='fred', what='kung pao'),
 146                         who='tim', what='ham'),
 147            'tim likes ham')
 148         s = Template('the mapping is $mapping')
 149         eq(s.substitute(dict(foo='none'), mapping='bozo'),
 150            'the mapping is bozo')
 151         eq(s.substitute(dict(mapping='one'), mapping='two'),
 152            'the mapping is two')
 153
 154     def test_keyword_arguments_safe(self):
 155         eq = self.assertEqual
 156         raises = self.assertRaises
 157         s = Template('$who likes $what')
 158         eq(s.safe_substitute(who='tim', what='ham'), 'tim likes ham')
 159         eq(s.safe_substitute(dict(who='tim'), what='ham'), 'tim likes ham')
 160         eq(s.safe_substitute(dict(who='fred', what='kung pao'),
 161                         who='tim', what='ham'),
 162            'tim likes ham')
 163         s = Template('the mapping is $mapping')
 164         eq(s.safe_substitute(dict(foo='none'), mapping='bozo'),
 165            'the mapping is bozo')
 166         eq(s.safe_substitute(dict(mapping='one'), mapping='two'),
 167            'the mapping is two')
 168         d = dict(mapping='one')
 169         raises(TypeError, s.substitute, d, {})
 170         raises(TypeError, s.safe_substitute, d, {})
 171
 172     def test_delimiter_override(self):
 173         eq = self.assertEqual
 174         raises = self.assertRaises
 175         class AmpersandTemplate(Template):
 176             delimiter = '&'
 177         s = AmpersandTemplate('this &gift is for &{who} &&')
 178         eq(s.substitute(gift='bud', who='you'), 'this bud is for you &')
 179         raises(KeyError, s.substitute)
 180         eq(s.safe_substitute(gift='bud', who='you'), 'this bud is for you &')
 181         eq(s.safe_substitute(), 'this &gift is for &{who} &')
 182         s = AmpersandTemplate('this &gift is for &{who} &')
 183         raises(ValueError, s.substitute, dict(gift='bud', who='you'))
 184         eq(s.safe_substitute(), 'this &gift is for &{who} &')
 185
 186
 187 def test_main():
 188     from test import test_support
 189     test_classes = [TestTemplate,]
 190     test_support.run_unittest(*test_classes)
 191
 192
 193 if __name__ == '__main__':
 194     test_main()