Lib/bsddb/test/test_associate.py

   1 """
   2 TestCases for DB.associate.
   3 """
   4
   5 import sys, os, string
   6 import tempfile
   7 import time
   8 from pprint import pprint
   9
  10 try:
  11     from threading import Thread, currentThread
  12     have_threads = 1
  13 except ImportError:
  14     have_threads = 0
  15
  16 import unittest
  17 from test_all import verbose
  18
  19 try:
  20     # For Pythons w/distutils pybsddb
  21     from bsddb3 import db, dbshelve
  22 except ImportError:
  23     # For Python 2.3
  24     from bsddb import db, dbshelve
  25
  26
  27 #----------------------------------------------------------------------
  28
  29
  30 musicdata = {
  31 1 : ("Bad English", "The Price Of Love", "Rock"),
  32 2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"),
  33 3 : ("George Michael", "Praying For Time", "Rock"),
  34 4 : ("Gloria Estefan", "Here We Are", "Rock"),
  35 5 : ("Linda Ronstadt", "Don't Know Much", "Rock"),
  36 6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"),
  37 7 : ("Paul Young", "Oh Girl", "Rock"),
  38 8 : ("Paula Abdul", "Opposites Attract", "Rock"),
  39 9 : ("Richard Marx", "Should've Known Better", "Rock"),
  40 10: ("Rod Stewart", "Forever Young", "Rock"),
  41 11: ("Roxette", "Dangerous", "Rock"),
  42 12: ("Sheena Easton", "The Lover In Me", "Rock"),
  43 13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"),
  44 14: ("Stevie B.", "Because I Love You", "Rock"),
  45 15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"),
  46 16: ("The Bangles", "Eternal Flame", "Rock"),
  47 17: ("Wilson Phillips", "Release Me", "Rock"),
  48 18: ("Billy Joel", "Blonde Over Blue", "Rock"),
  49 19: ("Billy Joel", "Famous Last Words", "Rock"),
  50 20: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"),
  51 21: ("Billy Joel", "The River Of Dreams", "Rock"),
  52 22: ("Billy Joel", "Two Thousand Years", "Rock"),
  53 23: ("Janet Jackson", "Alright", "Rock"),
  54 24: ("Janet Jackson", "Black Cat", "Rock"),
  55 25: ("Janet Jackson", "Come Back To Me", "Rock"),
  56 26: ("Janet Jackson", "Escapade", "Rock"),
  57 27: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"),
  58 28: ("Janet Jackson", "Miss You Much", "Rock"),
  59 29: ("Janet Jackson", "Rhythm Nation", "Rock"),
  60 30: ("Janet Jackson", "State Of The World", "Rock"),
  61 31: ("Janet Jackson", "The Knowledge", "Rock"),
  62 32: ("Spyro Gyra", "End of Romanticism", "Jazz"),
  63 33: ("Spyro Gyra", "Heliopolis", "Jazz"),
  64 34: ("Spyro Gyra", "Jubilee", "Jazz"),
  65 35: ("Spyro Gyra", "Little Linda", "Jazz"),
  66 36: ("Spyro Gyra", "Morning Dance", "Jazz"),
  67 37: ("Spyro Gyra", "Song for Lorraine", "Jazz"),
  68 38: ("Yes", "Owner Of A Lonely Heart", "Rock"),
  69 39: ("Yes", "Rhythm Of Love", "Rock"),
  70 40: ("Cusco", "Dream Catcher", "New Age"),
  71 41: ("Cusco", "Geronimos Laughter", "New Age"),
  72 42: ("Cusco", "Ghost Dance", "New Age"),
  73 43: ("Blue Man Group", "Drumbone", "New Age"),
  74 44: ("Blue Man Group", "Endless Column", "New Age"),
  75 45: ("Blue Man Group", "Klein Mandelbrot", "New Age"),
  76 46: ("Kenny G", "Silhouette", "Jazz"),
  77 47: ("Sade", "Smooth Operator", "Jazz"),
  78 48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)",
  79      "New Age"),
  80 49: ("David Arkenstone", "Stepping Stars", "New Age"),
  81 50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"),
  82 51: ("David Lanz", "Behind The Waterfall", "New Age"),
  83 52: ("David Lanz", "Cristofori's Dream", "New Age"),
  84 53: ("David Lanz", "Heartsounds", "New Age"),
  85 54: ("David Lanz", "Leaves on the Seine", "New Age"),
  86 99: ("unknown artist", "Unnamed song", "Unknown"),
  87 }
  88
  89 #----------------------------------------------------------------------
  90
  91
  92 class AssociateTestCase(unittest.TestCase):
  93     keytype = ''
  94
  95     def setUp(self):
  96         self.filename = self.__class__.__name__ + '.db'
  97         homeDir = os.path.join(os.path.dirname(sys.argv[0]), 'db_home')
  98         self.homeDir = homeDir
  99         try: os.mkdir(homeDir)
 100         except os.error: pass
 101         self.env = db.DBEnv()
 102         self.env.open(homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
 103                                db.DB_INIT_LOCK | db.DB_THREAD)
 104
 105     def tearDown(self):
 106         self.closeDB()
 107         self.env.close()
 108         import glob
 109         files = glob.glob(os.path.join(self.homeDir, '*'))
 110         for file in files:
 111             os.remove(file)
 112
 113     def addDataToDB(self, d):
 114         for key, value in musicdata.items():
 115             if type(self.keytype) == type(''):
 116                 key = "%02d" % key
 117             d.put(key, string.join(value, '|'))
 118
 119     def createDB(self):
 120         self.primary = db.DB(self.env)
 121         self.primary.set_get_returns_none(2)
 122         self.primary.open(self.filename, "primary", self.dbtype,
 123                           db.DB_CREATE | db.DB_THREAD)
 124
 125     def closeDB(self):
 126         self.primary.close()
 127
 128     def getDB(self):
 129         return self.primary
 130
 131     def test01_associateWithDB(self):
 132         if verbose:
 133             print '\n', '-=' * 30
 134             print "Running %s.test01_associateWithDB..." % \
 135                   self.__class__.__name__
 136
 137         self.createDB()
 138
 139         secDB = db.DB(self.env)
 140         secDB.set_flags(db.DB_DUP)
 141         secDB.set_get_returns_none(2)
 142         secDB.open(self.filename, "secondary", db.DB_BTREE,
 143                    db.DB_CREATE | db.DB_THREAD)
 144         self.getDB().associate(secDB, self.getGenre)
 145
 146         self.addDataToDB(self.getDB())
 147
 148         self.finish_test(secDB)
 149
 150
 151     def test02_associateAfterDB(self):
 152         if verbose:
 153             print '\n', '-=' * 30
 154             print "Running %s.test02_associateAfterDB..." % \
 155                   self.__class__.__name__
 156
 157         self.createDB()
 158         self.addDataToDB(self.getDB())
 159
 160         secDB = db.DB(self.env)
 161         secDB.set_flags(db.DB_DUP)
 162         secDB.open(self.filename, "secondary", db.DB_BTREE,
 163                    db.DB_CREATE | db.DB_THREAD)
 164
 165         # adding the DB_CREATE flag will cause it to index existing records
 166         self.getDB().associate(secDB, self.getGenre, db.DB_CREATE)
 167
 168         self.finish_test(secDB)
 169
 170
 171     def finish_test(self, secDB):
 172         # 'Blues' should not be in the secondary database
 173         vals = secDB.pget('Blues')
 174         assert vals == None, vals
 175
 176         vals = secDB.pget('Unknown')
 177         assert vals[0] == 99 or vals[0] == '99', vals
 178         vals[1].index('Unknown')
 179         vals[1].index('Unnamed')
 180         vals[1].index('unknown')
 181
 182         if verbose:
 183             print "Primary key traversal:"
 184         c = self.getDB().cursor()
 185         count = 0
 186         rec = c.first()
 187         while rec is not None:
 188             if type(self.keytype) == type(''):
 189                 assert string.atoi(rec[0])  # for primary db, key is a number
 190             else:
 191                 assert rec[0] and type(rec[0]) == type(0)
 192             count = count + 1
 193             if verbose:
 194                 print rec
 195             rec = c.next()
 196         assert count == len(musicdata) # all items accounted for
 197
 198
 199         if verbose:
 200             print "Secondary key traversal:"
 201         c = secDB.cursor()
 202         count = 0
 203
 204         # test cursor pget
 205         vals = c.pget('Unknown', flags=db.DB_LAST)
 206         assert vals[1] == 99 or vals[1] == '99', vals
 207         assert vals[0] == 'Unknown'
 208         vals[2].index('Unknown')
 209         vals[2].index('Unnamed')
 210         vals[2].index('unknown')
 211
 212         vals = c.pget('Unknown', data='wrong value', flags=db.DB_GET_BOTH)
 213         assert vals == None, vals
 214
 215         rec = c.first()
 216         assert rec[0] == "Jazz"
 217         while rec is not None:
 218             count = count + 1
 219             if verbose:
 220                 print rec
 221             rec = c.next()
 222         # all items accounted for EXCEPT for 1 with "Blues" genre
 223         assert count == len(musicdata)-1
 224
 225     def getGenre(self, priKey, priData):
 226         assert type(priData) == type("")
 227         if verbose:
 228             print 'getGenre key: %r data: %r' % (priKey, priData)
 229         genre = string.split(priData, '|')[2]
 230         if genre == 'Blues':
 231             return db.DB_DONOTINDEX
 232         else:
 233             return genre
 234
 235
 236 #----------------------------------------------------------------------
 237
 238
 239 class AssociateHashTestCase(AssociateTestCase):
 240     dbtype = db.DB_HASH
 241
 242 class AssociateBTreeTestCase(AssociateTestCase):
 243     dbtype = db.DB_BTREE
 244
 245 class AssociateRecnoTestCase(AssociateTestCase):
 246     dbtype = db.DB_RECNO
 247     keytype = 0
 248
 249
 250 #----------------------------------------------------------------------
 251
 252 class ShelveAssociateTestCase(AssociateTestCase):
 253
 254     def createDB(self):
 255         self.primary = dbshelve.open(self.filename,
 256                                      dbname="primary",
 257                                      dbenv=self.env,
 258                                      filetype=self.dbtype)
 259
 260     def addDataToDB(self, d):
 261         for key, value in musicdata.items():
 262             if type(self.keytype) == type(''):
 263                 key = "%02d" % key
 264             d.put(key, value)    # save the value as is this time
 265
 266
 267     def getGenre(self, priKey, priData):
 268         assert type(priData) == type(())
 269         if verbose:
 270             print 'getGenre key: %r data: %r' % (priKey, priData)
 271         genre = priData[2]
 272         if genre == 'Blues':
 273             return db.DB_DONOTINDEX
 274         else:
 275             return genre
 276
 277
 278 class ShelveAssociateHashTestCase(ShelveAssociateTestCase):
 279     dbtype = db.DB_HASH
 280
 281 class ShelveAssociateBTreeTestCase(ShelveAssociateTestCase):
 282     dbtype = db.DB_BTREE
 283
 284 class ShelveAssociateRecnoTestCase(ShelveAssociateTestCase):
 285     dbtype = db.DB_RECNO
 286     keytype = 0
 287
 288
 289 #----------------------------------------------------------------------
 290
 291 class ThreadedAssociateTestCase(AssociateTestCase):
 292
 293     def addDataToDB(self, d):
 294         t1 = Thread(target = self.writer1,
 295                     args = (d, ))
 296         t2 = Thread(target = self.writer2,
 297                     args = (d, ))
 298
 299         t1.start()
 300         t2.start()
 301         t1.join()
 302         t2.join()
 303
 304     def writer1(self, d):
 305         for key, value in musicdata.items():
 306             if type(self.keytype) == type(''):
 307                 key = "%02d" % key
 308             d.put(key, string.join(value, '|'))
 309
 310     def writer2(self, d):
 311         for x in range(100, 600):
 312             key = 'z%2d' % x
 313             value = [key] * 4
 314             d.put(key, string.join(value, '|'))
 315
 316
 317 class ThreadedAssociateHashTestCase(ShelveAssociateTestCase):
 318     dbtype = db.DB_HASH
 319
 320 class ThreadedAssociateBTreeTestCase(ShelveAssociateTestCase):
 321     dbtype = db.DB_BTREE
 322
 323 class ThreadedAssociateRecnoTestCase(ShelveAssociateTestCase):
 324     dbtype = db.DB_RECNO
 325     keytype = 0
 326
 327
 328 #----------------------------------------------------------------------
 329
 330 def test_suite():
 331     suite = unittest.TestSuite()
 332
 333     if db.version() >= (3, 3, 11):
 334         suite.addTest(unittest.makeSuite(AssociateHashTestCase))
 335         suite.addTest(unittest.makeSuite(AssociateBTreeTestCase))
 336         suite.addTest(unittest.makeSuite(AssociateRecnoTestCase))
 337
 338         suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase))
 339         suite.addTest(unittest.makeSuite(ShelveAssociateBTreeTestCase))
 340         suite.addTest(unittest.makeSuite(ShelveAssociateRecnoTestCase))
 341
 342         if have_threads:
 343             suite.addTest(unittest.makeSuite(ThreadedAssociateHashTestCase))
 344             suite.addTest(unittest.makeSuite(ThreadedAssociateBTreeTestCase))
 345             suite.addTest(unittest.makeSuite(ThreadedAssociateRecnoTestCase))
 346
 347     return suite
 348
 349
 350 if __name__ == '__main__':
 351     unittest.main(defaultTest='test_suite')