Cheetah/Tests/Template.py

   1 #!/usr/bin/env python
   2 # $Id: Template.py,v 1.16 2006/02/03 21:05:50 tavis_rudd Exp $
   3 """Tests of the Template class API
   4
   5 Meta-Data
   6 ================================================================================
   7 Author: Tavis Rudd <tavis@damnsimple.com>,
   8 Version: $Revision: 1.16 $
   9 Start Date: 2001/10/01
  10 Last Revision Date: $Date: 2006/02/03 21:05:50 $
  11 """
  12 __author__ = "Tavis Rudd <tavis@damnsimple.com>"
  13 __revision__ = "$Revision: 1.16 $"[11:-2]
  14
  15
  16 ##################################################
  17 ## DEPENDENCIES ##
  18
  19 import sys
  20 import types
  21 import os
  22 import os.path
  23 import tempfile
  24 import shutil
  25 import unittest_local_copy as unittest
  26 from Cheetah.Template import Template
  27
  28 ##################################################
  29 ## CONSTANTS & GLOBALS ##
  30
  31 majorVer, minorVer = sys.version_info[0], sys.version_info[1]
  32 versionTuple = (majorVer, minorVer)
  33
  34 try:
  35     True,False
  36 except NameError:
  37     True, False = (1==1),(1==0)
  38
  39 ##################################################
  40 ## TEST DATA FOR USE IN THE TEMPLATES ##
  41
  42 ##################################################
  43 ## TEST BASE CLASSES
  44
  45 class TemplateTest(unittest.TestCase):
  46     pass
  47
  48 ##################################################
  49 ## TEST CASE CLASSES
  50
  51 class ClassMethods_compile(TemplateTest):
  52     """I am using the same Cheetah source for each test to root out clashes
  53     caused by the compile caching in Template.compile().
  54     """
  55
  56     def test_basicUsage(self):
  57         klass = Template.compile(source='$foo')
  58         t = klass(namespaces={'foo':1234})
  59         assert str(t)=='1234'
  60
  61     def test_baseclassArg(self):
  62         klass = Template.compile(source='$foo', baseclass=dict)
  63         t = klass({'foo':1234})
  64         assert str(t)=='1234'
  65
  66         klass2 = Template.compile(source='$foo', baseclass=klass)
  67         t = klass2({'foo':1234})
  68         assert str(t)=='1234'
  69
  70         klass3 = Template.compile(source='#implements dummy\n$bar', baseclass=klass2)
  71         t = klass3({'foo':1234})
  72         assert str(t)=='1234'
  73
  74         klass4 = Template.compile(source='$foo', baseclass='dict')
  75         t = klass4({'foo':1234})
  76         assert str(t)=='1234'
  77
  78     def test_moduleFileCaching(self):
  79         if versionTuple < (2,3):
  80             return
  81         tmpDir = tempfile.mkdtemp()
  82         try:
  83             #print tmpDir
  84             assert os.path.exists(tmpDir)
  85             klass = Template.compile(source='$foo',
  86                                      cacheModuleFilesForTracebacks=True,
  87                                      cacheDirForModuleFiles=tmpDir)
  88             mod = sys.modules[klass.__module__]
  89             #print mod.__file__
  90             assert os.path.exists(mod.__file__)
  91             assert os.path.dirname(mod.__file__)==tmpDir
  92         finally:
  93             shutil.rmtree(tmpDir, True)
  94
  95     def test_classNameArg(self):
  96         klass = Template.compile(source='$foo', className='foo123')
  97         assert klass.__name__=='foo123'
  98         t = klass(namespaces={'foo':1234})
  99         assert str(t)=='1234'
 100
 101     def test_moduleNameArg(self):
 102         klass = Template.compile(source='$foo', moduleName='foo99')
 103         mod = sys.modules['foo99']
 104         assert klass.__name__=='foo99'
 105         t = klass(namespaces={'foo':1234})
 106         assert str(t)=='1234'
 107
 108
 109         klass = Template.compile(source='$foo',
 110                                  moduleName='foo1',
 111                                  className='foo2')
 112         mod = sys.modules['foo1']
 113         assert klass.__name__=='foo2'
 114         t = klass(namespaces={'foo':1234})
 115         assert str(t)=='1234'
 116
 117
 118     def test_mainMethodNameArg(self):
 119         klass = Template.compile(source='$foo',
 120                                  className='foo123',
 121                                  mainMethodName='testMeth')
 122         assert klass.__name__=='foo123'
 123         t = klass(namespaces={'foo':1234})
 124         #print t.generatedClassCode()
 125         assert str(t)=='1234'
 126         assert t.testMeth()=='1234'
 127
 128         klass = Template.compile(source='$foo',
 129                                  moduleName='fooXXX',
 130                                  className='foo123',
 131                                  mainMethodName='testMeth',
 132                                  baseclass=dict)
 133         assert klass.__name__=='foo123'
 134         t = klass({'foo':1234})
 135         #print t.generatedClassCode()
 136         assert str(t)=='1234'
 137         assert t.testMeth()=='1234'
 138
 139
 140
 141     def test_moduleGlobalsArg(self):
 142         klass = Template.compile(source='$foo',
 143                                  moduleGlobals={'foo':1234})
 144         t = klass()
 145         assert str(t)=='1234'
 146
 147         klass2 = Template.compile(source='$foo', baseclass='Test1',
 148                                   moduleGlobals={'Test1':dict})
 149         t = klass2({'foo':1234})
 150         assert str(t)=='1234'
 151
 152         klass3 = Template.compile(source='$foo', baseclass='Test1',
 153                                   moduleGlobals={'Test1':dict, 'foo':1234})
 154         t = klass3()
 155         assert str(t)=='1234'
 156
 157
 158     def test_keepRefToGeneratedCodeArg(self):
 159         klass = Template.compile(source='$foo',
 160                                  className='unique58',
 161                                  cacheCompilationResults=False,
 162                                  keepRefToGeneratedCode=False)
 163         t = klass(namespaces={'foo':1234})
 164         assert str(t)=='1234'
 165         assert not t.generatedModuleCode()
 166
 167
 168         klass2 = Template.compile(source='$foo',
 169                                  className='unique58',
 170                                  keepRefToGeneratedCode=True)
 171         t = klass2(namespaces={'foo':1234})
 172         assert str(t)=='1234'
 173         assert t.generatedModuleCode()
 174
 175         klass3 = Template.compile(source='$foo',
 176                                  className='unique58',
 177                                  keepRefToGeneratedCode=False)
 178         t = klass3(namespaces={'foo':1234})
 179         assert str(t)=='1234'
 180         # still there as this class came from the cache
 181         assert t.generatedModuleCode()
 182
 183
 184     def test_compilationCache(self):
 185         klass = Template.compile(source='$foo',
 186                                  className='unique111',
 187                                  cacheCompilationResults=False)
 188         t = klass(namespaces={'foo':1234})
 189         assert str(t)=='1234'
 190         assert not klass._CHEETAH_isInCompilationCache
 191
 192
 193         # this time it will place it in the cache
 194         klass = Template.compile(source='$foo',
 195                                  className='unique111',
 196                                  cacheCompilationResults=True)
 197         t = klass(namespaces={'foo':1234})
 198         assert str(t)=='1234'
 199         assert klass._CHEETAH_isInCompilationCache
 200
 201         # by default it will be in the cache
 202         klass = Template.compile(source='$foo',
 203                                  className='unique999099')
 204         t = klass(namespaces={'foo':1234})
 205         assert str(t)=='1234'
 206         assert klass._CHEETAH_isInCompilationCache
 207
 208
 209 class ClassMethods_subclass(TemplateTest):
 210
 211     def test_basicUsage(self):
 212         klass = Template.compile(source='$foo', baseclass=dict)
 213         t = klass({'foo':1234})
 214         assert str(t)=='1234'
 215
 216         klass2 = klass.subclass(source='$foo')
 217         t = klass2({'foo':1234})
 218         assert str(t)=='1234'
 219
 220         klass3 = klass2.subclass(source='#implements dummy\n$bar')
 221         t = klass3({'foo':1234})
 222         assert str(t)=='1234'
 223
 224
 225 class Preprocessors(TemplateTest):
 226
 227     def test_basicUsage1(self):
 228         src='''\
 229         %set foo = @a
 230         $(@foo*10)
 231         @a'''
 232         src = '\n'.join([ln.strip() for ln in src.splitlines()])
 233         preprocessors = {'tokens':'@ %',
 234                          'namespaces':{'a':99}
 235                          }
 236         klass = Template.compile(src, preprocessors=preprocessors)
 237         assert str(klass())=='990\n99'
 238
 239     def test_normalizePreprocessorArgVariants(self):
 240         src='%set foo = 12\n%%comment\n$(@foo*10)'
 241
 242         class Settings1: tokens = '@ %'
 243         Settings1 = Settings1()
 244
 245         from Cheetah.Template import TemplatePreprocessor
 246         settings = Template._normalizePreprocessorSettings(Settings1)
 247         preprocObj = TemplatePreprocessor(settings)
 248
 249         def preprocFunc(source, file):
 250             return '$(12*10)', None
 251
 252         class TemplateSubclass(Template):
 253             pass
 254
 255         compilerSettings = {'cheetahVarStartToken':'@',
 256                             'directiveStartToken':'%',
 257                             'commentStartToken':'%%',
 258                             }
 259
 260         for arg in ['@ %',
 261                     {'tokens':'@ %'},
 262                     {'compilerSettings':compilerSettings},
 263                     {'compilerSettings':compilerSettings,
 264                      'templateInitArgs':{}},
 265                     {'tokens':'@ %',
 266                      'templateAPIClass':TemplateSubclass},
 267                     Settings1,
 268                     preprocObj,
 269                     preprocFunc,
 270                     ]:
 271
 272             klass = Template.compile(src, preprocessors=arg)
 273             assert str(klass())=='120'
 274
 275
 276     def test_complexUsage(self):
 277         src='''\
 278         %set foo = @a
 279         %def func1: #def func(arg): $arg("***")
 280         %% comment
 281         $(@foo*10)
 282         @func1
 283         $func(lambda x:c"--$x--@a")'''
 284         src = '\n'.join([ln.strip() for ln in src.splitlines()])
 285
 286
 287         for arg in [{'tokens':'@ %', 'namespaces':{'a':99} },
 288                     {'tokens':'@ %', 'namespaces':{'a':99} },
 289                     ]:
 290             klass = Template.compile(src, preprocessors=arg)
 291             t = klass()
 292             assert str(t)=='990\n--***--99'
 293
 294
 295
 296     def test_i18n(self):
 297         src='''\
 298         %i18n: This is a $string that needs translation
 299         %i18n id="foo", domain="root": This is a $string that needs translation
 300         '''
 301         src = '\n'.join([ln.strip() for ln in src.splitlines()])
 302         klass = Template.compile(src, preprocessors='@ %', baseclass=dict)
 303         t = klass({'string':'bit of text'})
 304         #print str(t), repr(str(t))
 305         assert str(t)==('This is a bit of text that needs translation\n'*2)[:-1]
 306
 307
 308 ##################################################
 309 ## if run from the command line ##
 310
 311 if __name__ == '__main__':
 312     unittest.main()