Commit | Line | Data |
---|---|---|
86530b38 AT |
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') |