Cheetah/Tests/NameMapper.py

   1 #!/usr/bin/env python
   2 # $Id: NameMapper.py,v 1.11 2006/01/15 20:45:22 tavis_rudd Exp $
   3 """NameMapper Tests
   4
   5 Meta-Data
   6 ================================================================================
   7 Author: Tavis Rudd <tavis@damnsimple.com>,
   8 Version: $Revision: 1.11 $
   9 Start Date: 2001/10/01
  10 Last Revision Date: $Date: 2006/01/15 20:45:22 $
  11 """
  12 from __future__ import generators
  13 __author__ = "Tavis Rudd <tavis@damnsimple.com>"
  14 __revision__ = "$Revision: 1.11 $"[11:-2]
  15 import sys
  16 import types
  17 import os
  18 import os.path
  19
  20 import unittest_local_copy as unittest
  21 from Cheetah.NameMapper import NotFound, valueForKey, \
  22      valueForName, valueFromSearchList, valueFromFrame, valueFromFrameOrSearchList
  23
  24
  25 ##################################################
  26 ## TEST DATA FOR USE IN THE TEMPLATES ##
  27
  28 class DummyClass:
  29     classVar1 = 123
  30
  31     def __init__(self):
  32         self.instanceVar1 = 123
  33
  34     def __str__(self):
  35         return 'object'
  36
  37     def meth(self, arg="arff"):
  38         return str(arg)
  39
  40     def meth1(self, arg="doo"):
  41         return arg
  42
  43     def meth2(self, arg1="a1", arg2="a2"):
  44         raise ValueError
  45
  46     def meth3(self):
  47         """Tests a bug that Jeff Johnson reported on Oct 1, 2001"""
  48
  49         x = 'A string'
  50         try:
  51             for i in [1,2,3,4]:
  52                 if x == 2:
  53                     pass
  54
  55                 if x == 'xx':
  56                     pass
  57             return x
  58         except:
  59             raise
  60
  61
  62 def dummyFunc(arg="Scooby"):
  63     return arg
  64
  65 def funcThatRaises():
  66     raise ValueError
  67
  68
  69 testNamespace = {
  70     'aStr':'blarg',
  71     'anInt':1,
  72     'aFloat':1.5,
  73     'aDict': {'one':'item1',
  74               'two':'item2',
  75               'nestedDict':{'one':'nestedItem1',
  76                             'two':'nestedItem2',
  77                             'funcThatRaises':funcThatRaises,
  78                             'aClass': DummyClass,
  79                             },
  80               'nestedFunc':dummyFunc,
  81               },
  82     'aClass': DummyClass,
  83     'aFunc': dummyFunc,
  84     'anObj': DummyClass(),
  85     'aMeth': DummyClass().meth1,
  86     'none' : None,
  87     'emptyString':'',
  88     'funcThatRaises':funcThatRaises,
  89     }
  90
  91 autoCallResults = {'aFunc':'Scooby',
  92                    'aMeth':'doo',
  93                    }
  94
  95 results = testNamespace.copy()
  96 results.update({'anObj.meth1':'doo',
  97                 'aDict.one':'item1',
  98                 'aDict.nestedDict':testNamespace['aDict']['nestedDict'],
  99                 'aDict.nestedDict.one':'nestedItem1',
 100                 'aDict.nestedDict.aClass':DummyClass,
 101                 'aDict.nestedFunc':'Scooby',
 102                 'aClass.classVar1':123,
 103                 'anObj.instanceVar1':123,
 104                 'anObj.meth3':'A string',
 105                 })
 106
 107 for k in testNamespace.keys():
 108     # put them in the globals for the valueFromFrame tests
 109     exec '%s = testNamespace[k]'%k
 110
 111 ##################################################
 112 ## TEST BASE CLASSES
 113
 114 class NameMapperTest(unittest.TestCase):
 115     failureException = (NotFound,AssertionError)
 116     _testNamespace = testNamespace
 117     _results = results
 118
 119     def namespace(self):
 120         return self._testNamespace
 121
 122     def VFN(self, name, autocall=True):
 123         return valueForName(self.namespace(), name, autocall)
 124
 125     def VFS(self, searchList, name, autocall=True):
 126         return valueFromSearchList(searchList, name, autocall)
 127
 128
 129     # alias to be overriden later
 130     get = VFN
 131
 132     def check(self, name):
 133         got = self.get(name)
 134         if autoCallResults.has_key(name):
 135             expected = autoCallResults[name]
 136         else:
 137             expected = self._results[name]
 138         assert got == expected
 139
 140
 141 ##################################################
 142 ## TEST CASE CLASSES
 143
 144 class VFN(NameMapperTest):
 145
 146     def test1(self):
 147         """string in dict lookup"""
 148         self.check('aStr')
 149
 150     def test2(self):
 151         """string in dict lookup in a loop"""
 152         for i in range(10):
 153             self.check('aStr')
 154
 155     def test3(self):
 156         """int in dict lookup"""
 157         self.check('anInt')
 158
 159     def test4(self):
 160         """int in dict lookup in a loop"""
 161         for i in range(10):
 162             self.check('anInt')
 163
 164     def test5(self):
 165         """float in dict lookup"""
 166         self.check('aFloat')
 167
 168     def test6(self):
 169         """float in dict lookup in a loop"""
 170         for i in range(10):
 171             self.check('aFloat')
 172
 173     def test7(self):
 174         """class in dict lookup"""
 175         self.check('aClass')
 176
 177     def test8(self):
 178         """class in dict lookup in a loop"""
 179         for i in range(10):
 180             self.check('aClass')
 181
 182     def test9(self):
 183         """aFunc in dict lookup"""
 184         self.check('aFunc')
 185
 186     def test10(self):
 187         """aFunc in dict lookup in a loop"""
 188         for i in range(10):
 189             self.check('aFunc')
 190
 191     def test11(self):
 192         """aMeth in dict lookup"""
 193         self.check('aMeth')
 194
 195     def test12(self):
 196         """aMeth in dict lookup in a loop"""
 197         for i in range(10):
 198             self.check('aMeth')
 199
 200     def test13(self):
 201         """aMeth in dict lookup"""
 202         self.check('aMeth')
 203
 204     def test14(self):
 205         """aMeth in dict lookup in a loop"""
 206         for i in range(10):
 207             self.check('aMeth')
 208
 209     def test15(self):
 210         """anObj in dict lookup"""
 211         self.check('anObj')
 212
 213     def test16(self):
 214         """anObj in dict lookup in a loop"""
 215         for i in range(10):
 216             self.check('anObj')
 217
 218     def test17(self):
 219         """aDict in dict lookup"""
 220         self.check('aDict')
 221
 222     def test18(self):
 223         """aDict in dict lookup in a loop"""
 224         for i in range(10):
 225             self.check('aDict')
 226
 227     def test17(self):
 228         """aDict in dict lookup"""
 229         self.check('aDict')
 230
 231     def test18(self):
 232         """aDict in dict lookup in a loop"""
 233         for i in range(10):
 234             self.check('aDict')
 235
 236     def test19(self):
 237         """aClass.classVar1 in dict lookup"""
 238         self.check('aClass.classVar1')
 239
 240     def test20(self):
 241         """aClass.classVar1 in dict lookup in a loop"""
 242         for i in range(10):
 243             self.check('aClass.classVar1')
 244
 245
 246     def test23(self):
 247         """anObj.instanceVar1 in dict lookup"""
 248         self.check('anObj.instanceVar1')
 249
 250     def test24(self):
 251         """anObj.instanceVar1 in dict lookup in a loop"""
 252         for i in range(10):
 253             self.check('anObj.instanceVar1')
 254
 255     ## tests 22, 25, and 26 removed when the underscored lookup was removed
 256
 257     def test27(self):
 258         """anObj.meth1 in dict lookup"""
 259         self.check('anObj.meth1')
 260
 261     def test28(self):
 262         """anObj.meth1 in dict lookup in a loop"""
 263         for i in range(10):
 264             self.check('anObj.meth1')
 265
 266     def test29(self):
 267         """aDict.one in dict lookup"""
 268         self.check('aDict.one')
 269
 270     def test30(self):
 271         """aDict.one in dict lookup in a loop"""
 272         for i in range(10):
 273             self.check('aDict.one')
 274
 275     def test31(self):
 276         """aDict.nestedDict in dict lookup"""
 277         self.check('aDict.nestedDict')
 278
 279     def test32(self):
 280         """aDict.nestedDict in dict lookup in a loop"""
 281         for i in range(10):
 282             self.check('aDict.nestedDict')
 283
 284     def test33(self):
 285         """aDict.nestedDict.one in dict lookup"""
 286         self.check('aDict.nestedDict.one')
 287
 288     def test34(self):
 289         """aDict.nestedDict.one in dict lookup in a loop"""
 290         for i in range(10):
 291             self.check('aDict.nestedDict.one')
 292
 293     def test35(self):
 294         """aDict.nestedFunc in dict lookup"""
 295         self.check('aDict.nestedFunc')
 296
 297     def test36(self):
 298         """aDict.nestedFunc in dict lookup in a loop"""
 299         for i in range(10):
 300             self.check('aDict.nestedFunc')
 301
 302     def test37(self):
 303         """aDict.nestedFunc in dict lookup - without autocalling"""
 304         assert self.get('aDict.nestedFunc', False) == dummyFunc
 305
 306     def test38(self):
 307         """aDict.nestedFunc in dict lookup in a loop - without autocalling"""
 308         for i in range(10):
 309             assert self.get('aDict.nestedFunc', False) == dummyFunc
 310
 311     def test39(self):
 312         """aMeth in dict lookup - without autocalling"""
 313         assert self.get('aMeth', False) == self.namespace()['aMeth']
 314
 315     def test40(self):
 316         """aMeth in dict lookup in a loop - without autocalling"""
 317         for i in range(10):
 318             assert self.get('aMeth', False) == self.namespace()['aMeth']
 319
 320     def test41(self):
 321         """anObj.meth3 in dict lookup"""
 322         self.check('anObj.meth3')
 323
 324     def test42(self):
 325         """aMeth in dict lookup in a loop"""
 326         for i in range(10):
 327             self.check('anObj.meth3')
 328
 329     def test43(self):
 330         """NotFound test"""
 331
 332         def test(self=self):
 333             self.get('anObj.methX')
 334         self.assertRaises(NotFound,test)
 335
 336     def test44(self):
 337         """NotFound test in a loop"""
 338         def test(self=self):
 339             self.get('anObj.methX')
 340
 341         for i in range(10):
 342             self.assertRaises(NotFound,test)
 343
 344     def test45(self):
 345         """Other exception from meth test"""
 346
 347         def test(self=self):
 348             self.get('anObj.meth2')
 349         self.assertRaises(ValueError, test)
 350
 351     def test46(self):
 352         """Other exception from meth test in a loop"""
 353         def test(self=self):
 354             self.get('anObj.meth2')
 355
 356         for i in range(10):
 357             self.assertRaises(ValueError,test)
 358
 359     def test47(self):
 360         """None in dict lookup"""
 361         self.check('none')
 362
 363     def test48(self):
 364         """None in dict lookup in a loop"""
 365         for i in range(10):
 366             self.check('none')
 367
 368     def test49(self):
 369         """EmptyString in dict lookup"""
 370         self.check('emptyString')
 371
 372     def test50(self):
 373         """EmptyString in dict lookup in a loop"""
 374         for i in range(10):
 375             self.check('emptyString')
 376
 377     def test51(self):
 378         """Other exception from func test"""
 379
 380         def test(self=self):
 381             self.get('funcThatRaises')
 382         self.assertRaises(ValueError, test)
 383
 384     def test52(self):
 385         """Other exception from func test in a loop"""
 386         def test(self=self):
 387             self.get('funcThatRaises')
 388
 389         for i in range(10):
 390             self.assertRaises(ValueError,test)
 391
 392
 393     def test53(self):
 394         """Other exception from func test"""
 395
 396         def test(self=self):
 397             self.get('aDict.nestedDict.funcThatRaises')
 398         self.assertRaises(ValueError, test)
 399
 400     def test54(self):
 401         """Other exception from func test in a loop"""
 402         def test(self=self):
 403             self.get('aDict.nestedDict.funcThatRaises')
 404
 405         for i in range(10):
 406             self.assertRaises(ValueError,test)
 407
 408     def test55(self):
 409         """aDict.nestedDict.aClass in dict lookup"""
 410         self.check('aDict.nestedDict.aClass')
 411
 412     def test56(self):
 413         """aDict.nestedDict.aClass in dict lookup in a loop"""
 414         for i in range(10):
 415             self.check('aDict.nestedDict.aClass')
 416
 417     def test57(self):
 418         """aDict.nestedDict.aClass in dict lookup - without autocalling"""
 419         assert self.get('aDict.nestedDict.aClass', False) == DummyClass
 420
 421     def test58(self):
 422         """aDict.nestedDict.aClass in dict lookup in a loop - without autocalling"""
 423         for i in range(10):
 424             assert self.get('aDict.nestedDict.aClass', False) == DummyClass
 425
 426     def test59(self):
 427         """Other exception from func test -- but without autocalling shouldn't raise"""
 428
 429         self.get('aDict.nestedDict.funcThatRaises', False)
 430
 431     def test60(self):
 432         """Other exception from func test in a loop -- but without autocalling shouldn't raise"""
 433
 434         for i in range(10):
 435             self.get('aDict.nestedDict.funcThatRaises', False)
 436
 437 class VFS(VFN):
 438     _searchListLength = 1
 439
 440     def searchList(self):
 441         lng = self._searchListLength
 442         if lng == 1:
 443             return [self.namespace()]
 444         elif lng == 2:
 445             return [self.namespace(),{'dummy':1234}]
 446         elif lng == 3:
 447             # a tuple for kicks
 448             return ({'dummy':1234}, self.namespace(),{'dummy':1234})
 449         elif lng == 4:
 450             # a generator for more kicks
 451             return self.searchListGenerator()
 452
 453     def searchListGenerator(self):
 454         class Test:
 455             pass
 456         for i in [Test(),{'dummy':1234}, self.namespace(),{'dummy':1234}]:
 457             yield i
 458
 459     def get(self, name, autocall=True):
 460         return self.VFS(self.searchList(), name, autocall)
 461
 462 class VFS_2namespaces(VFS):
 463     _searchListLength = 2
 464
 465 class VFS_3namespaces(VFS):
 466     _searchListLength = 3
 467
 468 class VFS_4namespaces(VFS):
 469     _searchListLength = 4
 470
 471 class VFF(VFN):
 472     def get(self, name, autocall=True):
 473         ns = self._testNamespace
 474         aStr = ns['aStr']
 475         aFloat = ns['aFloat']
 476         none = 'some'
 477         return valueFromFrame(name, autocall)
 478
 479     def setUp(self):
 480         """Mod some of the data
 481         """
 482         self._testNamespace = ns = self._testNamespace.copy()
 483         self._results = res = self._results.copy()
 484         ns['aStr'] = res['aStr'] = 'BLARG'
 485         ns['aFloat'] = res['aFloat'] = 0.1234
 486         res['none'] = 'some'
 487         res['True'] = True
 488         res['False'] = False
 489         res['None'] = None
 490         res['eval'] = eval
 491
 492     def test_VFF_1(self):
 493         """Builtins"""
 494         self.check('True')
 495         self.check('None')
 496         self.check('False')
 497         assert self.get('eval', False)==eval
 498         assert self.get('range', False)==range
 499
 500 class VFFSL(VFS):
 501     _searchListLength = 1
 502
 503     def setUp(self):
 504         """Mod some of the data
 505         """
 506         self._testNamespace = ns = self._testNamespace.copy()
 507         self._results = res = self._results.copy()
 508         ns['aStr'] = res['aStr'] = 'BLARG'
 509         ns['aFloat'] = res['aFloat'] = 0.1234
 510         res['none'] = 'some'
 511
 512         del ns['anInt'] # will be picked up by globals
 513
 514     def VFFSL(self, searchList, name, autocall=True):
 515         anInt = 1
 516         none = 'some'
 517         return valueFromFrameOrSearchList(searchList, name, autocall)
 518
 519     def get(self, name, autocall=True):
 520         return self.VFFSL(self.searchList(), name, autocall)
 521
 522 class VFFSL_2(VFFSL):
 523     _searchListLength = 2
 524
 525 class VFFSL_3(VFFSL):
 526     _searchListLength = 3
 527
 528 class VFFSL_4(VFFSL):
 529     _searchListLength = 4
 530
 531 if sys.platform.startswith('java'):
 532     del VFF, VFFSL, VFFSL_2, VFFSL_3, VFFSL_4
 533
 534
 535 ##################################################
 536 ## if run from the command line ##
 537
 538 if __name__ == '__main__':
 539     unittest.main()