1
=== modified file '.pylintrc'
2
--- .pylintrc	2011-04-20 05:14:30 +0000
3
+++ .pylintrc	2011-08-16 21:02:23 +0000
4
@@ -1,5 +1,10 @@
5
1
[Basic]
6
2
method-rgx=([a-z_][a-z0-9_]{2,30}$)|setUp|tearDown
7
3
no-docstring-rgx=(__.*__)|(test_.*)
8
4
9
1
[Design]
5
[Design]
10
2
min-public-methods=0
6
min-public-methods=0
11
7
max-public-methods=80
12
3
8
13
4
[Messages Control]
9
[Messages Control]
14
5
# W0142: Allow use of *args and **kwargs
10
# W0142: Allow use of *args and **kwargs
15
6
11
16
=== modified file 'test/__init__.py'
17
--- test/__init__.py	2011-03-17 23:42:41 +0000
18
+++ test/__init__.py	2011-08-16 21:02:23 +0000
19
@@ -0,0 +1,15 @@
20
1
# Copyright (C) 2011 OpenStack LLC.
21
2
#
22
3
# Licensed under the Apache License, Version 2.0 (the "License");
23
4
# you may not use this file except in compliance with the License.
24
5
# You may obtain a copy of the License at
25
6
#
26
7
#     http://www.apache.org/licenses/LICENSE-2.0
27
8
#
28
9
# Unless required by applicable law or agreed to in writing, software
29
10
# distributed under the License is distributed on an "AS IS" BASIS,
30
11
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31
12
# See the License for the specific language governing permissions and
32
13
# limitations under the License.
33
14
34
15
'''Unittests for burrow.'''
35
0
16
36
=== modified file 'test/backend/__init__.py'
37
--- test/backend/__init__.py	2011-06-10 21:36:49 +0000
38
+++ test/backend/__init__.py	2011-08-16 21:02:23 +0000
39
@@ -0,0 +1,963 @@
40
1
# Copyright (C) 2011 OpenStack LLC.
41
2
#
42
3
# Licensed under the Apache License, Version 2.0 (the "License");
43
4
# you may not use this file except in compliance with the License.
44
5
# You may obtain a copy of the License at
45
6
#
46
7
#     http://www.apache.org/licenses/LICENSE-2.0
47
8
#
48
9
# Unless required by applicable law or agreed to in writing, software
49
10
# distributed under the License is distributed on an "AS IS" BASIS,
50
11
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
51
12
# See the License for the specific language governing permissions and
52
13
# limitations under the License.
53
14
54
15
'''Unittests for burrow backends.'''
55
16
56
17
import time
57
18
import unittest
58
19
59
20
import eventlet
60
21
eventlet.monkey_patch(socket=True)
61
22
62
23
import burrow.backend
63
24
64
25
65
26
class Base(unittest.TestCase):
66
27
    '''Base test case.'''
67
28
68
29
    def __init__(self, *args, **kwargs):
69
30
        super(Base, self).__init__(*args, **kwargs)
70
31
        self.backend = None
71
32
        self.success = False
72
33
73
34
    def setUp(self):
74
35
        self.check_empty()
75
36
76
37
    def tearDown(self):
77
38
        self.check_empty()
78
39
79
40
    def check_empty(self):
80
41
        '''Ensure the backend is empty before, used before and after
81
42
        each test.'''
82
43
        accounts = self.backend.get_accounts()
83
44
        self.assertRaises(burrow.backend.NotFound, list, accounts)
84
45
        queues = self.backend.get_queues('a')
85
46
        self.assertRaises(burrow.backend.NotFound, list, queues)
86
47
        filters = dict(match_hidden=True)
87
48
        messages = self.backend.get_messages('a', 'q', filters)
88
49
        self.assertRaises(burrow.backend.NotFound, list, messages)
89
50
90
51
    def delete_messages(self):
91
52
        '''Delete messages, including those that are hidden. Use
92
53
        after tests that don't need to delete.'''
93
54
        filters = dict(match_hidden=True)
94
55
        messages = list(self.backend.delete_messages('a', 'q', filters))
95
56
        self.assertEquals([], messages)
96
57
97
58
    def get_messages(self):
98
59
        '''Get messages and ensure it is correct. Used for concurrent
99
60
        tests as an eventlet thread.'''
100
61
        message = dict(id='m', ttl=0, hide=0, body='test')
101
62
        filters = dict(wait=2)
102
63
        messages = list(self.backend.get_messages('a', 'q', filters))
103
64
        self.assertEquals([message], messages)
104
65
        self.success = True
105
66
106
67
107
68
class TestAccounts(Base):
108
69
    '''Test case for accounts.'''
109
70
110
71
    def test_basic(self):
111
72
        self.backend.create_message('a', 'q', 'm', 'test')
112
73
        self.assertEquals(['a'], list(self.backend.get_accounts()))
113
74
        self.assertEquals([], list(self.backend.delete_accounts()))
114
75
        accounts = self.backend.delete_accounts()
115
76
        self.assertRaises(burrow.backend.NotFound, list, accounts)
116
77
117
78
    def test_large(self):
118
79
        for name in xrange(0, 1000):
119
80
            name = str(name)
120
81
            self.backend.create_message(name, name, name, name)
121
82
        filters = dict(marker='unknown')
122
83
        self.assertEquals([], list(self.backend.delete_accounts(filters)))
123
84
124
85
    def test_delete_detail_all(self):
125
86
        self.backend.create_message('a', 'q', 'm', 'test')
126
87
        filters = dict(detail='all')
127
88
        accounts = list(self.backend.delete_accounts(filters))
128
89
        self.assertEquals([dict(id='a')], accounts)
129
90
130
91
    def test_delete_detail_id(self):
131
92
        self.backend.create_message('a', 'q', 'm', 'test')
132
93
        filters = dict(detail='id')
133
94
        accounts = list(self.backend.delete_accounts(filters))
134
95
        self.assertEquals(['a'], accounts)
135
96
136
97
    def test_delete_detail_none(self):
137
98
        self.backend.create_message('a', 'q', 'm', 'test')
138
99
        filters = dict(detail='none')
139
100
        accounts = list(self.backend.delete_accounts(filters))
140
101
        self.assertEquals([], accounts)
141
102
142
103
    def test_delete_detail_bad(self):
143
104
        self.backend.create_message('a', 'q', 'm', 'test')
144
105
        filters = dict(detail='bad')
145
106
        accounts = self.backend.delete_accounts(filters)
146
107
        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
147
108
        self.assertEquals([], list(self.backend.delete_accounts()))
148
109
149
110
    def test_delete_marker(self):
150
111
        self.backend.create_message('a1', 'q', 'm', 'test')
151
112
        self.backend.create_message('a2', 'q', 'm', 'test')
152
113
        self.backend.create_message('a3', 'q', 'm', 'test')
153
114
        accounts = list(self.backend.get_accounts())
154
115
        self.assertEquals(3, len(accounts))
155
116
        filters = dict(detail='id', marker=accounts[0])
156
117
        accounts2 = list(self.backend.delete_accounts(filters))
157
118
        self.assertEquals(accounts[1:], accounts2)
158
119
        accounts2 = list(self.backend.get_accounts())
159
120
        self.assertEquals(accounts[:1], accounts2)
160
121
        filters = dict(detail='id', marker='unknown')
161
122
        accounts2 = list(self.backend.delete_accounts(filters))
162
123
        self.assertEquals(accounts[:1], accounts2)
163
124
164
125
    def test_delete_limit(self):
165
126
        self.backend.create_message('a1', 'q', 'm', 'test')
166
127
        self.backend.create_message('a2', 'q', 'm', 'test')
167
128
        self.backend.create_message('a3', 'q', 'm', 'test')
168
129
        accounts = list(self.backend.get_accounts())
169
130
        self.assertEquals(3, len(accounts))
170
131
        filters = dict(detail='id', limit=1)
171
132
        accounts2 = list(self.backend.delete_accounts(filters))
172
133
        self.assertEquals(accounts[:1], accounts2)
173
134
        filters = dict(detail='id', limit=2)
174
135
        accounts2 = list(self.backend.delete_accounts(filters))
175
136
        self.assertEquals(accounts[1:3], accounts2)
176
137
177
138
    def test_delete_marker_limit(self):
178
139
        self.backend.create_message('a1', 'q', 'm', 'test')
179
140
        self.backend.create_message('a2', 'q', 'm', 'test')
180
141
        self.backend.create_message('a3', 'q', 'm', 'test')
181
142
        accounts = list(self.backend.get_accounts())
182
143
        self.assertEquals(3, len(accounts))
183
144
        filters = dict(detail='id', marker=accounts[1], limit=1)
184
145
        accounts2 = list(self.backend.delete_accounts(filters))
185
146
        self.assertEquals(accounts[2:3], accounts2)
186
147
        filters = dict(detail='id', marker=accounts[0], limit=2)
187
148
        accounts2 = list(self.backend.delete_accounts(filters))
188
149
        self.assertEquals(accounts[1:2], accounts2)
189
150
        self.assertEquals([], list(self.backend.delete_accounts()))
190
151
191
152
    def test_get_detail_all(self):
192
153
        self.backend.create_message('a', 'q', 'm', 'test')
193
154
        filters = dict(detail='all')
194
155
        accounts = list(self.backend.get_accounts(filters))
195
156
        self.assertEquals([dict(id='a')], accounts)
196
157
        self.assertEquals([], list(self.backend.delete_accounts()))
197
158
198
159
    def test_get_detail_id(self):
199
160
        self.backend.create_message('a', 'q', 'm', 'test')
200
161
        filters = dict(detail='id')
201
162
        accounts = list(self.backend.get_accounts(filters))
202
163
        self.assertEquals(['a'], accounts)
203
164
        self.assertEquals([], list(self.backend.delete_accounts()))
204
165
205
166
    def test_get_detail_none(self):
206
167
        self.backend.create_message('a', 'q', 'm', 'test')
207
168
        filters = dict(detail='none')
208
169
        accounts = list(self.backend.get_accounts(filters))
209
170
        self.assertEquals([], accounts)
210
171
        self.assertEquals([], list(self.backend.delete_accounts()))
211
172
212
173
    def test_get_detail_bad(self):
213
174
        self.backend.create_message('a', 'q', 'm', 'test')
214
175
        filters = dict(detail='bad')
215
176
        accounts = self.backend.get_accounts(filters)
216
177
        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
217
178
        self.assertEquals([], list(self.backend.delete_accounts()))
218
179
219
180
    def test_get_marker(self):
220
181
        self.backend.create_message('a1', 'q', 'm', 'test')
221
182
        self.backend.create_message('a2', 'q', 'm', 'test')
222
183
        self.backend.create_message('a3', 'q', 'm', 'test')
223
184
        accounts = list(self.backend.get_accounts())
224
185
        self.assertEquals(3, len(accounts))
225
186
        filters = dict(marker=accounts[0])
226
187
        accounts2 = list(self.backend.get_accounts(filters))
227
188
        self.assertEquals(accounts[1:], accounts2)
228
189
        filters = dict(marker=accounts[1])
229
190
        accounts2 = list(self.backend.get_accounts(filters))
230
191
        self.assertEquals(accounts[2:], accounts2)
231
192
        filters = dict(marker=accounts[2])
232
193
        accounts2 = self.backend.get_accounts(filters)
233
194
        self.assertRaises(burrow.backend.NotFound, list, accounts2)
234
195
        filters = dict(marker='unknown')
235
196
        accounts2 = list(self.backend.get_accounts(filters))
236
197
        self.assertEquals(accounts, accounts2)
237
198
        self.assertEquals([], list(self.backend.delete_accounts()))
238
199
239
200
    def test_get_limit(self):
240
201
        self.backend.create_message('a1', 'q', 'm', 'test')
241
202
        self.backend.create_message('a2', 'q', 'm', 'test')
242
203
        self.backend.create_message('a3', 'q', 'm', 'test')
243
204
        accounts = list(self.backend.get_accounts())
244
205
        self.assertEquals(3, len(accounts))
245
206
        filters = dict(limit=1)
246
207
        accounts2 = list(self.backend.get_accounts(filters))
247
208
        self.assertEquals(accounts[:1], accounts2)
248
209
        filters = dict(limit=2)
249
210
        accounts2 = list(self.backend.get_accounts(filters))
250
211
        self.assertEquals(accounts[:2], accounts2)
251
212
        filters = dict(limit=3)
252
213
        accounts2 = list(self.backend.get_accounts(filters))
253
214
        self.assertEquals(accounts, accounts2)
254
215
        filters = dict(limit=100)
255
216
        accounts2 = list(self.backend.get_accounts(filters))
256
217
        self.assertEquals(accounts, accounts2)
257
218
        self.assertEquals([], list(self.backend.delete_accounts()))
258
219
259
220
    def test_get_marker_limit(self):
260
221
        self.backend.create_message('a1', 'q', 'm', 'test')
261
222
        self.backend.create_message('a2', 'q', 'm', 'test')
262
223
        self.backend.create_message('a3', 'q', 'm', 'test')
263
224
        accounts = list(self.backend.get_accounts())
264
225
        self.assertEquals(3, len(accounts))
265
226
        filters = dict(marker=accounts[1], limit=1)
266
227
        accounts2 = list(self.backend.get_accounts(filters))
267
228
        self.assertEquals(accounts[2:3], accounts2)
268
229
        filters = dict(marker=accounts[0], limit=2)
269
230
        accounts2 = list(self.backend.get_accounts(filters))
270
231
        self.assertEquals(accounts[1:3], accounts2)
271
232
        self.assertEquals([], list(self.backend.delete_accounts()))
272
233
273
234
274
235
class TestQueues(Base):
275
236
    '''Test case for queues.'''
276
237
277
238
    def test_basic(self):
278
239
        self.backend.create_message('a', 'q', 'm', 'test')
279
240
        self.assertEquals(['q'], list(self.backend.get_queues('a')))
280
241
        self.assertEquals([], list(self.backend.delete_queues('a')))
281
242
        queues = self.backend.delete_queues('a')
282
243
        self.assertRaises(burrow.backend.NotFound, list, queues)
283
244
284
245
    def test_large(self):
285
246
        for name in xrange(0, 1000):
286
247
            name = str(name)
287
248
            self.backend.create_message('a', name, name, name)
288
249
        filters = dict(marker='unknown')
289
250
        self.assertEquals([], list(self.backend.delete_queues('a', filters)))
290
251
291
252
    def test_delete_detail_all(self):
292
253
        self.backend.create_message('a', 'q', 'm', 'test')
293
254
        filters = dict(detail='all')
294
255
        queues = list(self.backend.delete_queues('a', filters))
295
256
        self.assertEquals([dict(id='q')], queues)
296
257
297
258
    def test_delete_detail_id(self):
298
259
        self.backend.create_message('a', 'q', 'm', 'test')
299
260
        filters = dict(detail='id')
300
261
        queues = list(self.backend.delete_queues('a', filters))
301
262
        self.assertEquals(['q'], queues)
302
263
303
264
    def test_delete_detail_none(self):
304
265
        self.backend.create_message('a', 'q', 'm', 'test')
305
266
        filters = dict(detail='none')
306
267
        queues = list(self.backend.delete_queues('a', filters))
307
268
        self.assertEquals([], queues)
308
269
309
270
    def test_delete_detail_bad(self):
310
271
        self.backend.create_message('a', 'q', 'm', 'test')
311
272
        filters = dict(detail='bad')
312
273
        queues = self.backend.delete_queues('a', filters)
313
274
        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
314
275
        self.assertEquals([], list(self.backend.delete_queues('a')))
315
276
316
277
    def test_delete_marker(self):
317
278
        self.backend.create_message('a', 'q1', 'm', 'test')
318
279
        self.backend.create_message('a', 'q2', 'm', 'test')
319
280
        self.backend.create_message('a', 'q3', 'm', 'test')
320
281
        queues = list(self.backend.get_queues('a'))
321
282
        self.assertEquals(3, len(queues))
322
283
        filters = dict(detail='id', marker=queues[0])
323
284
        queues2 = list(self.backend.delete_queues('a', filters))
324
285
        self.assertEquals(queues[1:], queues2)
325
286
        queues2 = list(self.backend.get_queues('a'))
326
287
        self.assertEquals(queues[:1], queues2)
327
288
        filters = dict(detail='id', marker='unknown')
328
289
        queues2 = list(self.backend.delete_queues('a', filters))
329
290
        self.assertEquals(queues[:1], queues2)
330
291
331
292
    def test_delete_limit(self):
332
293
        self.backend.create_message('a', 'q1', 'm', 'test')
333
294
        self.backend.create_message('a', 'q2', 'm', 'test')
334
295
        self.backend.create_message('a', 'q3', 'm', 'test')
335
296
        queues = list(self.backend.get_queues('a'))
336
297
        self.assertEquals(3, len(queues))
337
298
        filters = dict(detail='id', limit=1)
338
299
        queues2 = list(self.backend.delete_queues('a', filters))
339
300
        self.assertEquals(queues[:1], queues2)
340
301
        filters = dict(detail='id', limit=2)
341
302
        queues2 = list(self.backend.delete_queues('a', filters))
342
303
        self.assertEquals(queues[1:3], queues2)
343
304
344
305
    def test_delete_marker_limit(self):
345
306
        self.backend.create_message('a', 'q1', 'm', 'test')
346
307
        self.backend.create_message('a', 'q2', 'm', 'test')
347
308
        self.backend.create_message('a', 'q3', 'm', 'test')
348
309
        queues = list(self.backend.get_queues('a'))
349
310
        self.assertEquals(3, len(queues))
350
311
        filters = dict(detail='id', marker=queues[1], limit=1)
351
312
        queues2 = list(self.backend.delete_queues('a', filters))
352
313
        self.assertEquals(queues[2:3], queues2)
353
314
        filters = dict(detail='id', marker=queues[0], limit=2)
354
315
        queues2 = list(self.backend.delete_queues('a', filters))
355
316
        self.assertEquals(queues[1:2], queues2)
356
317
        self.assertEquals([], list(self.backend.delete_queues('a')))
357
318
358
319
    def test_get_detail_all(self):
359
320
        self.backend.create_message('a', 'q', 'm', 'test')
360
321
        filters = dict(detail='all')
361
322
        queues = list(self.backend.get_queues('a', filters))
362
323
        self.assertEquals([dict(id='q')], queues)
363
324
        self.assertEquals([], list(self.backend.delete_queues('a')))
364
325
365
326
    def test_get_detail_id(self):
366
327
        self.backend.create_message('a', 'q', 'm', 'test')
367
328
        filters = dict(detail='id')
368
329
        queues = list(self.backend.get_queues('a', filters))
369
330
        self.assertEquals(['q'], queues)
370
331
        self.assertEquals([], list(self.backend.delete_queues('a')))
371
332
372
333
    def test_get_detail_none(self):
373
334
        self.backend.create_message('a', 'q', 'm', 'test')
374
335
        filters = dict(detail='none')
375
336
        queues = list(self.backend.get_queues('a', filters))
376
337
        self.assertEquals([], queues)
377
338
        self.assertEquals([], list(self.backend.delete_queues('a')))
378
339
379
340
    def test_get_detail_bad(self):
380
341
        self.backend.create_message('a', 'q', 'm', 'test')
381
342
        filters = dict(detail='bad')
382
343
        queues = self.backend.get_queues('a', filters)
383
344
        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
384
345
        self.assertEquals([], list(self.backend.delete_queues('a')))
385
346
386
347
    def test_get_marker(self):
387
348
        self.backend.create_message('a', 'q1', 'm', 'test')
388
349
        self.backend.create_message('a', 'q2', 'm', 'test')
389
350
        self.backend.create_message('a', 'q3', 'm', 'test')
390
351
        queues = list(self.backend.get_queues('a'))
391
352
        self.assertEquals(3, len(queues))
392
353
        filters = dict(marker=queues[0])
393
354
        queues2 = list(self.backend.get_queues('a', filters))
394
355
        self.assertEquals(queues[1:], queues2)
395
356
        filters = dict(marker=queues[1])
396
357
        queues2 = list(self.backend.get_queues('a', filters))
397
358
        self.assertEquals(queues[2:], queues2)
398
359
        filters = dict(marker=queues[2])
399
360
        queues2 = self.backend.get_queues('a', filters)
400
361
        self.assertRaises(burrow.backend.NotFound, list, queues2)
401
362
        filters = dict(marker='unknown')
402
363
        queues2 = list(self.backend.get_queues('a', filters))
403
364
        self.assertEquals(queues, queues2)
404
365
        self.assertEquals([], list(self.backend.delete_queues('a')))
405
366
406
367
    def test_get_limit(self):
407
368
        self.backend.create_message('a', 'q1', 'm', 'test')
408
369
        self.backend.create_message('a', 'q2', 'm', 'test')
409
370
        self.backend.create_message('a', 'q3', 'm', 'test')
410
371
        queues = list(self.backend.get_queues('a'))
411
372
        self.assertEquals(3, len(queues))
412
373
        filters = dict(limit=1)
413
374
        queues2 = list(self.backend.get_queues('a', filters))
414
375
        self.assertEquals(queues[:1], queues2)
415
376
        filters = dict(limit=2)
416
377
        queues2 = list(self.backend.get_queues('a', filters))
417
378
        self.assertEquals(queues[:2], queues2)
418
379
        filters = dict(limit=3)
419
380
        queues2 = list(self.backend.get_queues('a', filters))
420
381
        self.assertEquals(queues, queues2)
421
382
        filters = dict(limit=100)
422
383
        queues2 = list(self.backend.get_queues('a', filters))
423
384
        self.assertEquals(queues, queues2)
424
385
        self.assertEquals([], list(self.backend.delete_queues('a')))
425
386
426
387
    def test_get_marker_limit(self):
427
388
        self.backend.create_message('a', 'q1', 'm', 'test')
428
389
        self.backend.create_message('a', 'q2', 'm', 'test')
429
390
        self.backend.create_message('a', 'q3', 'm', 'test')
430
391
        queues = list(self.backend.get_queues('a'))
431
392
        self.assertEquals(3, len(queues))
432
393
        filters = dict(marker=queues[1], limit=1)
433
394
        queues2 = list(self.backend.get_queues('a', filters))
434
395
        self.assertEquals(queues[2:3], queues2)
435
396
        filters = dict(marker=queues[0], limit=2)
436
397
        queues2 = list(self.backend.get_queues('a', filters))
437
398
        self.assertEquals(queues[1:3], queues2)
438
399
        self.assertEquals([], list(self.backend.delete_queues('a')))
439
400
440
401
441
402
class TestMessages(Base):
442
403
    '''Test case for messages.'''
443
404
444
405
    def test_basic(self):
445
406
        self.backend.create_message('a', 'q', 'm', 'test')
446
407
        message = dict(id='m', ttl=0, hide=0, body='test')
447
408
        messages = list(self.backend.get_messages('a', 'q'))
448
409
        self.assertEquals([message], messages)
449
410
        attributes = dict(ttl=100, hide=200)
450
411
        messages = list(self.backend.update_messages('a', 'q', attributes))
451
412
        self.assertEquals([], messages)
452
413
        attributes = dict(ttl=0, hide=0)
453
414
        filters = dict(match_hidden=True)
454
415
        messages = self.backend.update_messages('a', 'q', attributes, filters)
455
416
        self.assertEquals([], list(messages))
456
417
        messages = self.backend.update_messages('a', 'q', dict(), filters)
457
418
        self.assertEquals([], list(messages))
458
419
        self.delete_messages()
459
420
        messages = self.backend.delete_messages('a', 'q')
460
421
        self.assertRaises(burrow.backend.NotFound, list, messages)
461
422
        messages = self.backend.update_messages('a', 'q', attributes)
462
423
        self.assertRaises(burrow.backend.NotFound, list, messages)
463
424
464
425
    def test_large(self):
465
426
        for name in xrange(0, 1000):
466
427
            name = str(name)
467
428
            self.backend.create_message('a', 'q', name, name)
468
429
        attributes = dict(ttl=100, hide=200)
469
430
        messages = self.backend.update_messages('a', 'q', attributes)
470
431
        self.assertEquals([], list(messages))
471
432
        self.delete_messages()
472
433
473
434
    def test_delete_detail_all(self):
474
435
        self.backend.create_message('a', 'q', 'm', 'test')
475
436
        message = dict(id='m', ttl=0, hide=0, body='test')
476
437
        filters = dict(detail='all')
477
438
        messages = list(self.backend.delete_messages('a', 'q', filters))
478
439
        self.assertEquals([message], messages)
479
440
480
441
    def test_delete_detail_attributes(self):
481
442
        self.backend.create_message('a', 'q', 'm', 'test')
482
443
        message = dict(id='m', ttl=0, hide=0)
483
444
        filters = dict(detail='attributes')
484
445
        messages = list(self.backend.delete_messages('a', 'q', filters))
485
446
        self.assertEquals([message], messages)
486
447
487
448
    def test_delete_detail_body(self):
488
449
        self.backend.create_message('a', 'q', 'm', 'test')
489
450
        filters = dict(detail='body')
490
451
        messages = list(self.backend.delete_messages('a', 'q', filters))
491
452
        self.assertEquals(['test'], messages)
492
453
493
454
    def test_delete_detail_id(self):
494
455
        self.backend.create_message('a', 'q', 'm', 'test')
495
456
        filters = dict(detail='id')
496
457
        messages = list(self.backend.delete_messages('a', 'q', filters))
497
458
        self.assertEquals(['m'], messages)
498
459
499
460
    def test_delete_detail_none(self):
500
461
        self.backend.create_message('a', 'q', 'm', 'test')
501
462
        filters = dict(detail='none')
502
463
        messages = list(self.backend.delete_messages('a', 'q', filters))
503
464
        self.assertEquals([], messages)
504
465
505
466
    def test_delete_detail_bad(self):
506
467
        self.backend.create_message('a', 'q', 'm', 'test')
507
468
        filters = dict(detail='bad')
508
469
        messages = self.backend.delete_messages('a', 'q', filters)
509
470
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
510
471
        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
511
472
512
473
    def test_delete_marker(self):
513
474
        self.backend.create_message('a', 'q', 'm1', 'test')
514
475
        self.backend.create_message('a', 'q', 'm2', 'test')
515
476
        self.backend.create_message('a', 'q', 'm3', 'test')
516
477
        messages = list(self.backend.get_messages('a', 'q'))
517
478
        self.assertEquals(3, len(messages))
518
479
        filters = dict(detail='all', marker=messages[0]['id'])
519
480
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
520
481
        self.assertEquals(messages[1:], messages2)
521
482
        messages2 = list(self.backend.get_messages('a', 'q'))
522
483
        self.assertEquals(messages[:1], messages2)
523
484
        filters = dict(detail='all', marker='unknown')
524
485
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
525
486
        self.assertEquals(messages[:1], messages2)
526
487
527
488
    def test_delete_limit(self):
528
489
        self.backend.create_message('a', 'q', 'm1', 'test')
529
490
        self.backend.create_message('a', 'q', 'm2', 'test')
530
491
        self.backend.create_message('a', 'q', 'm3', 'test')
531
492
        messages = list(self.backend.get_messages('a', 'q'))
532
493
        self.assertEquals(3, len(messages))
533
494
        filters = dict(detail='all', limit=1)
534
495
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
535
496
        self.assertEquals(messages[:1], messages2)
536
497
        filters = dict(detail='all', limit=2)
537
498
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
538
499
        self.assertEquals(messages[1:3], messages2)
539
500
540
501
    def test_delete_marker_limit(self):
541
502
        self.backend.create_message('a', 'q', 'm1', 'test')
542
503
        self.backend.create_message('a', 'q', 'm2', 'test')
543
504
        self.backend.create_message('a', 'q', 'm3', 'test')
544
505
        messages = list(self.backend.get_messages('a', 'q'))
545
506
        self.assertEquals(3, len(messages))
546
507
        filters = dict(detail='all', marker=messages[1]['id'], limit=1)
547
508
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
548
509
        self.assertEquals(messages[2:3], messages2)
549
510
        filters = dict(detail='all', marker=messages[0]['id'], limit=2)
550
511
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
551
512
        self.assertEquals(messages[1:2], messages2)
552
513
        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
553
514
554
515
    def test_get_detail_all(self):
555
516
        self.backend.create_message('a', 'q', 'm', 'test')
556
517
        message = dict(id='m', ttl=0, hide=0, body='test')
557
518
        filters = dict(detail='all')
558
519
        messages = list(self.backend.get_messages('a', 'q', filters))
559
520
        self.assertEquals([message], messages)
560
521
        self.delete_messages()
561
522
562
523
    def test_get_detail_attributes(self):
563
524
        self.backend.create_message('a', 'q', 'm', 'test')
564
525
        message = dict(id='m', ttl=0, hide=0)
565
526
        filters = dict(detail='attributes')
566
527
        messages = list(self.backend.get_messages('a', 'q', filters))
567
528
        self.assertEquals([message], messages)
568
529
        self.delete_messages()
569
530
570
531
    def test_get_detail_body(self):
571
532
        self.backend.create_message('a', 'q', 'm', 'test')
572
533
        filters = dict(detail='body')
573
534
        messages = list(self.backend.get_messages('a', 'q', filters))
574
535
        self.assertEquals(['test'], messages)
575
536
        self.delete_messages()
576
537
577
538
    def test_get_detail_id(self):
578
539
        self.backend.create_message('a', 'q', 'm', 'test')
579
540
        filters = dict(detail='id')
580
541
        messages = list(self.backend.get_messages('a', 'q', filters))
581
542
        self.assertEquals(['m'], messages)
582
543
        self.delete_messages()
583
544
584
545
    def test_get_detail_none(self):
585
546
        self.backend.create_message('a', 'q', 'm', 'test')
586
547
        filters = dict(detail='none')
587
548
        messages = list(self.backend.get_messages('a', 'q', filters))
588
549
        self.assertEquals([], messages)
589
550
        self.delete_messages()
590
551
591
552
    def test_get_detail_bad(self):
592
553
        self.backend.create_message('a', 'q', 'm', 'test')
593
554
        filters = dict(detail='bad')
594
555
        messages = self.backend.get_messages('a', 'q', filters)
595
556
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
596
557
        self.delete_messages()
597
558
598
559
    def test_get_marker(self):
599
560
        self.backend.create_message('a', 'q', 'm1', 'test')
600
561
        self.backend.create_message('a', 'q', 'm2', 'test')
601
562
        self.backend.create_message('a', 'q', 'm3', 'test')
602
563
        messages = list(self.backend.get_messages('a', 'q'))
603
564
        self.assertEquals(3, len(messages))
604
565
        filters = dict(marker=messages[0]['id'])
605
566
        messages2 = list(self.backend.get_messages('a', 'q', filters))
606
567
        self.assertEquals(messages[1:], messages2)
607
568
        filters = dict(marker=messages[1]['id'])
608
569
        messages2 = list(self.backend.get_messages('a', 'q', filters))
609
570
        self.assertEquals(messages[2:], messages2)
610
571
        filters = dict(marker=messages[2]['id'])
611
572
        messages2 = self.backend.get_messages('a', 'q', filters)
612
573
        self.assertRaises(burrow.backend.NotFound, list, messages2)
613
574
        filters = dict(marker='unknown')
614
575
        messages2 = list(self.backend.get_messages('a', 'q', filters))
615
576
        self.assertEquals(messages, messages2)
616
577
        self.delete_messages()
617
578
618
579
    def test_get_limit(self):
619
580
        self.backend.create_message('a', 'q', 'm1', 'test')
620
581
        self.backend.create_message('a', 'q', 'm2', 'test')
621
582
        self.backend.create_message('a', 'q', 'm3', 'test')
622
583
        messages = list(self.backend.get_messages('a', 'q'))
623
584
        self.assertEquals(3, len(messages))
624
585
        filters = dict(limit=1)
625
586
        messages2 = list(self.backend.get_messages('a', 'q', filters))
626
587
        self.assertEquals(messages[:1], messages2)
627
588
        filters = dict(limit=2)
628
589
        messages2 = list(self.backend.get_messages('a', 'q', filters))
629
590
        self.assertEquals(messages[:2], messages2)
630
591
        filters = dict(limit=3)
631
592
        messages2 = list(self.backend.get_messages('a', 'q', filters))
632
593
        self.assertEquals(messages, messages2)
633
594
        filters = dict(limit=100)
634
595
        messages2 = list(self.backend.get_messages('a', 'q', filters))
635
596
        self.assertEquals(messages, messages2)
636
597
        self.delete_messages()
637
598
638
599
    def test_get_marker_limit(self):
639
600
        self.backend.create_message('a', 'q', 'm1', 'test')
640
601
        self.backend.create_message('a', 'q', 'm2', 'test')
641
602
        self.backend.create_message('a', 'q', 'm3', 'test')
642
603
        messages = list(self.backend.get_messages('a', 'q'))
643
604
        self.assertEquals(3, len(messages))
644
605
        filters = dict(marker=messages[1]['id'], limit=1)
645
606
        messages2 = list(self.backend.get_messages('a', 'q', filters))
646
607
        self.assertEquals(messages[2:3], messages2)
647
608
        filters = dict(marker=messages[0]['id'], limit=2)
648
609
        messages2 = list(self.backend.get_messages('a', 'q', filters))
649
610
        self.assertEquals(messages[1:3], messages2)
650
611
        self.delete_messages()
651
612
652
613
    def test_update_detail_all(self):
653
614
        self.backend.create_message('a', 'q', 'm', 'test')
654
615
        message = dict(id='m', ttl=100, hide=200, body='test')
655
616
        attributes = dict(ttl=100, hide=200)
656
617
        filters = dict(detail='all')
657
618
        messages = self.backend.update_messages('a', 'q', attributes, filters)
658
619
        self.assertEquals([message], list(messages))
659
620
        self.delete_messages()
660
621
661
622
    def test_update_detail_attributes(self):
662
623
        self.backend.create_message('a', 'q', 'm', 'test')
663
624
        message = dict(id='m', ttl=100, hide=200)
664
625
        attributes = dict(ttl=100, hide=200)
665
626
        filters = dict(detail='attributes')
666
627
        messages = self.backend.update_messages('a', 'q', attributes, filters)
667
628
        self.assertEquals([message], list(messages))
668
629
        self.delete_messages()
669
630
670
631
    def test_update_detail_body(self):
671
632
        self.backend.create_message('a', 'q', 'm', 'test')
672
633
        attributes = dict(ttl=100, hide=200)
673
634
        filters = dict(detail='body')
674
635
        messages = self.backend.update_messages('a', 'q', attributes, filters)
675
636
        self.assertEquals(['test'], list(messages))
676
637
        self.delete_messages()
677
638
678
639
    def test_update_detail_id(self):
679
640
        self.backend.create_message('a', 'q', 'm', 'test')
680
641
        attributes = dict(ttl=100, hide=200)
681
642
        filters = dict(detail='id')
682
643
        messages = self.backend.update_messages('a', 'q', attributes, filters)
683
644
        self.assertEquals(['m'], list(messages))
684
645
        self.delete_messages()
685
646
686
647
    def test_update_detail_none(self):
687
648
        self.backend.create_message('a', 'q', 'm', 'test')
688
649
        attributes = dict(ttl=100, hide=200)
689
650
        filters = dict(detail='none')
690
651
        messages = self.backend.update_messages('a', 'q', attributes, filters)
691
652
        self.assertEquals([], list(messages))
692
653
        self.delete_messages()
693
654
694
655
    def test_update_detail_bad(self):
695
656
        self.backend.create_message('a', 'q', 'm', 'test')
696
657
        attributes = dict(ttl=100, hide=200)
697
658
        filters = dict(detail='bad')
698
659
        messages = self.backend.update_messages('a', 'q', attributes, filters)
699
660
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
700
661
        self.delete_messages()
701
662
702
663
    def test_update_marker(self):
703
664
        self.backend.create_message('a', 'q', 'm1', 'test')
704
665
        self.backend.create_message('a', 'q', 'm2', 'test')
705
666
        self.backend.create_message('a', 'q', 'm3', 'test')
706
667
        attributes = dict(ttl=100, hide=200)
707
668
        filters = dict(detail='all', match_hidden=True)
708
669
        messages = self.backend.update_messages('a', 'q', attributes, filters)
709
670
        messages = list(messages)
710
671
        self.assertEquals(3, len(messages))
711
672
        filters.update(marker=messages[0]['id'])
712
673
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
713
674
        self.assertEquals(messages[1:], list(messages2))
714
675
        filters.update(marker=messages[1]['id'])
715
676
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
716
677
        self.assertEquals(messages[2:], list(messages2))
717
678
        filters.update(marker=messages[2]['id'])
718
679
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
719
680
        self.assertRaises(burrow.backend.NotFound, list, messages2)
720
681
        filters = dict(detail='all', marker='unknown', match_hidden=True)
721
682
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
722
683
        self.assertEquals(messages, list(messages2))
723
684
        self.delete_messages()
724
685
725
686
    def test_update_limit(self):
726
687
        self.backend.create_message('a', 'q', 'm1', 'test')
727
688
        self.backend.create_message('a', 'q', 'm2', 'test')
728
689
        self.backend.create_message('a', 'q', 'm3', 'test')
729
690
        attributes = dict(ttl=100, hide=200)
730
691
        filters = dict(detail='all', match_hidden=True)
731
692
        messages = self.backend.update_messages('a', 'q', attributes, filters)
732
693
        messages = list(messages)
733
694
        self.assertEquals(3, len(messages))
734
695
        filters.update(limit=1)
735
696
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
736
697
        self.assertEquals(messages[:1], list(messages2))
737
698
        filters.update(limit=2)
738
699
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
739
700
        self.assertEquals(messages[:2], list(messages2))
740
701
        filters.update(limit=3)
741
702
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
742
703
        self.assertEquals(messages, list(messages2))
743
704
        filters.update(limit=100)
744
705
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
745
706
        self.assertEquals(messages, list(messages2))
746
707
        self.delete_messages()
747
708
748
709
    def test_update_marker_limit(self):
749
710
        self.backend.create_message('a', 'q', 'm1', 'test')
750
711
        self.backend.create_message('a', 'q', 'm2', 'test')
751
712
        self.backend.create_message('a', 'q', 'm3', 'test')
752
713
        attributes = dict(ttl=100, hide=200)
753
714
        filters = dict(detail='all', match_hidden=True)
754
715
        messages = self.backend.update_messages('a', 'q', attributes, filters)
755
716
        messages = list(messages)
756
717
        self.assertEquals(3, len(messages))
757
718
        filters.update(marker=messages[1]['id'], limit=1)
758
719
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
759
720
        self.assertEquals(messages[2:3], list(messages2))
760
721
        filters.update(marker=messages[0]['id'], limit=2)
761
722
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
762
723
        self.assertEquals(messages[1:3], list(messages2))
763
724
        self.delete_messages()
764
725
765
726
    def test_update_wait(self):
766
727
        attributes = dict(hide=100)
767
728
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
768
729
        self.success = False
769
730
        thread = eventlet.spawn(self.get_messages)
770
731
        attributes = dict(hide=0)
771
732
        filters = dict(match_hidden=True)
772
733
        messages = self.backend.update_messages('a', 'q', attributes, filters)
773
734
        eventlet.spawn_after(0.2, list, messages)
774
735
        thread.wait()
775
736
        self.assertTrue(self.success)
776
737
        self.delete_messages()
777
738
778
739
779
740
class TestMessage(Base):
780
741
    '''Test case for message.'''
781
742
782
743
    def test_basic(self):
783
744
        self.backend.create_message('a', 'q', 'm', 'test')
784
745
        message = self.backend.get_message('a', 'q', 'm')
785
746
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
786
747
        attributes = dict(ttl=100, hide=200)
787
748
        message = self.backend.update_message('a', 'q', 'm', attributes)
788
749
        attributes = dict(ttl=0, hide=0)
789
750
        message = self.backend.update_message('a', 'q', 'm', attributes)
790
751
        self.assertEquals(None, message)
791
752
        message = self.backend.update_message('a', 'q', 'm', dict())
792
753
        self.assertEquals(None, message)
793
754
        message = self.backend.delete_message('a', 'q', 'm')
794
755
        self.assertEquals(None, message)
795
756
796
757
    def test_create(self):
797
758
        created = self.backend.create_message('a', 'q', 'm', 'test1')
798
759
        self.assertEquals(created, True)
799
760
        message = self.backend.get_message('a', 'q', 'm')
800
761
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test1'), message)
801
762
        attributes = dict(ttl=100, hide=200)
802
763
        created = self.backend.create_message('a', 'q', 'm', 'test2',
803
764
            attributes)
804
765
        self.assertEquals(created, False)
805
766
        message = self.backend.get_message('a', 'q', 'm')
806
767
        self.assertEquals(dict(id='m', ttl=100, hide=200, body='test2'),
807
768
            message)
808
769
        attributes = dict(ttl=0, hide=0)
809
770
        created = self.backend.create_message('a', 'q', 'm', 'test3',
810
771
            attributes)
811
772
        self.assertEquals(created, False)
812
773
        message = self.backend.get_message('a', 'q', 'm')
813
774
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test3'), message)
814
775
        self.delete_messages()
815
776
816
777
    def test_delete_detail_all(self):
817
778
        self.backend.create_message('a', 'q', 'm', 'test')
818
779
        filters = dict(detail='all')
819
780
        message = self.backend.delete_message('a', 'q', 'm', filters)
820
781
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
821
782
822
783
    def test_delete_detail_attributes(self):
823
784
        self.backend.create_message('a', 'q', 'm', 'test')
824
785
        filters = dict(detail='attributes')
825
786
        message = self.backend.delete_message('a', 'q', 'm', filters)
826
787
        self.assertEquals(dict(id='m', ttl=0, hide=0), message)
827
788
828
789
    def test_delete_detail_body(self):
829
790
        self.backend.create_message('a', 'q', 'm', 'test')
830
791
        filters = dict(detail='body')
831
792
        message = self.backend.delete_message('a', 'q', 'm', filters)
832
793
        self.assertEquals('test', message)
833
794
834
795
    def test_delete_detail_id(self):
835
796
        self.backend.create_message('a', 'q', 'm', 'test')
836
797
        filters = dict(detail='id')
837
798
        message = self.backend.delete_message('a', 'q', 'm', filters)
838
799
        self.assertEquals('m', message)
839
800
840
801
    def test_delete_detail_none(self):
841
802
        self.backend.create_message('a', 'q', 'm', 'test')
842
803
        filters = dict(detail='none')
843
804
        message = self.backend.delete_message('a', 'q', 'm', filters)
844
805
        self.assertEquals(None, message)
845
806
846
807
    def test_delete_detail_bad(self):
847
808
        self.backend.create_message('a', 'q', 'm', 'test')
848
809
        filters = dict(detail='bad')
849
810
        self.assertRaises(burrow.backend.InvalidArguments,
850
811
            self.backend.delete_message, 'a', 'q', 'm', filters)
851
812
        self.delete_messages()
852
813
853
814
    def test_get_detail_all(self):
854
815
        self.backend.create_message('a', 'q', 'm', 'test')
855
816
        filters = dict(detail='all')
856
817
        message = self.backend.get_message('a', 'q', 'm', filters)
857
818
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
858
819
        self.delete_messages()
859
820
860
821
    def test_get_detail_attributes(self):
861
822
        self.backend.create_message('a', 'q', 'm', 'test')
862
823
        filters = dict(detail='attributes')
863
824
        message = self.backend.get_message('a', 'q', 'm', filters)
864
825
        self.assertEquals(dict(id='m', ttl=0, hide=0), message)
865
826
        self.delete_messages()
866
827
867
828
    def test_get_detail_body(self):
868
829
        self.backend.create_message('a', 'q', 'm', 'test')
869
830
        filters = dict(detail='body')
870
831
        message = self.backend.get_message('a', 'q', 'm', filters)
871
832
        self.assertEquals('test', message)
872
833
        self.delete_messages()
873
834
874
835
    def test_get_detail_id(self):
875
836
        self.backend.create_message('a', 'q', 'm', 'test')
876
837
        filters = dict(detail='id')
877
838
        message = self.backend.get_message('a', 'q', 'm', filters)
878
839
        self.assertEquals('m', message)
879
840
        self.delete_messages()
880
841
881
842
    def test_get_detail_none(self):
882
843
        self.backend.create_message('a', 'q', 'm', 'test')
883
844
        filters = dict(detail='none')
884
845
        message = self.backend.get_message('a', 'q', 'm', filters)
885
846
        self.assertEquals(None, message)
886
847
        self.delete_messages()
887
848
888
849
    def test_get_detail_bad(self):
889
850
        self.backend.create_message('a', 'q', 'm', 'test')
890
851
        filters = dict(detail='bad')
891
852
        self.assertRaises(burrow.backend.InvalidArguments,
892
853
            self.backend.get_message, 'a', 'q', 'm', filters)
893
854
        self.delete_messages()
894
855
895
856
    def test_update_detail_all(self):
896
857
        self.backend.create_message('a', 'q', 'm', 'test')
897
858
        attributes = dict(ttl=100, hide=200)
898
859
        filters = dict(detail='all')
899
860
        message = self.backend.update_message('a', 'q', 'm', attributes,
900
861
            filters)
901
862
        self.assertEquals(dict(id='m', ttl=100, hide=200, body='test'),
902
863
            message)
903
864
        self.delete_messages()
904
865
905
866
    def test_update_detail_attributes(self):
906
867
        self.backend.create_message('a', 'q', 'm', 'test')
907
868
        attributes = dict(ttl=100, hide=200)
908
869
        filters = dict(detail='attributes')
909
870
        message = self.backend.update_message('a', 'q', 'm', attributes,
910
871
            filters)
911
872
        self.assertEquals(dict(id='m', ttl=100, hide=200), message)
912
873
        self.delete_messages()
913
874
914
875
    def test_update_detail_body(self):
915
876
        self.backend.create_message('a', 'q', 'm', 'test')
916
877
        attributes = dict(ttl=100, hide=200)
917
878
        filters = dict(detail='body')
918
879
        message = self.backend.update_message('a', 'q', 'm', attributes,
919
880
            filters)
920
881
        self.assertEquals('test', message)
921
882
        self.delete_messages()
922
883
923
884
    def test_update_detail_id(self):
924
885
        self.backend.create_message('a', 'q', 'm', 'test')
925
886
        attributes = dict(ttl=100, hide=200)
926
887
        filters = dict(detail='id')
927
888
        message = self.backend.update_message('a', 'q', 'm', attributes,
928
889
            filters)
929
890
        self.assertEquals('m', message)
930
891
        self.delete_messages()
931
892
932
893
    def test_update_detail_none(self):
933
894
        self.backend.create_message('a', 'q', 'm', 'test')
934
895
        attributes = dict(ttl=100, hide=200)
935
896
        filters = dict(detail='none')
936
897
        message = self.backend.update_message('a', 'q', 'm', attributes,
937
898
            filters)
938
899
        self.assertEquals(None, message)
939
900
        self.delete_messages()
940
901
941
902
    def test_update_detail_bad(self):
942
903
        self.backend.create_message('a', 'q', 'm', 'test')
943
904
        attributes = dict(ttl=100, hide=200)
944
905
        filters = dict(detail='bad')
945
906
        self.assertRaises(burrow.backend.InvalidArguments,
946
907
            self.backend.update_message, 'a', 'q', 'm', attributes, filters)
947
908
        self.delete_messages()
948
909
949
910
    def test_ttl(self):
950
911
        attributes = dict(ttl=1)
951
912
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
952
913
        time.sleep(2)
953
914
        self.backend.clean()
954
915
955
916
    def test_ttl_large(self):
956
917
        attributes = dict(ttl=1)
957
918
        for name in xrange(0, 1000):
958
919
            name = str(name)
959
920
            self.backend.create_message('a', 'q', name, name, attributes)
960
921
        time.sleep(2)
961
922
        self.backend.clean()
962
923
963
924
    def test_hide(self):
964
925
        attributes = dict(hide=1)
965
926
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
966
927
        time.sleep(2)
967
928
        self.backend.clean()
968
929
        message = self.backend.get_message('a', 'q', 'm')
969
930
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
970
931
        self.delete_messages()
971
932
972
933
    def test_hide_large(self):
973
934
        attributes = dict(hide=1)
974
935
        for name in xrange(0, 1000):
975
936
            name = str(name)
976
937
            self.backend.create_message('a', 'q', name, name, attributes)
977
938
        time.sleep(2)
978
939
        self.backend.clean()
979
940
        message = self.backend.get_message('a', 'q', '0')
980
941
        self.assertEquals(dict(id='0', ttl=0, hide=0, body='0'), message)
981
942
        self.delete_messages()
982
943
983
944
    def test_create_wait(self):
984
945
        self.success = False
985
946
        thread = eventlet.spawn(self.get_messages)
986
947
        eventlet.spawn_after(0.2,
987
948
            self.backend.create_message, 'a', 'q', 'm', 'test')
988
949
        thread.wait()
989
950
        self.assertTrue(self.success)
990
951
        self.delete_messages()
991
952
992
953
    def test_update_wait(self):
993
954
        attributes = dict(hide=100)
994
955
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
995
956
        self.success = False
996
957
        thread = eventlet.spawn(self.get_messages)
997
958
        attributes = dict(hide=0)
998
959
        eventlet.spawn_after(0.2,
999
960
            self.backend.update_message, 'a', 'q', 'm', attributes)
1000
961
        thread.wait()
1001
962
        self.assertTrue(self.success)
1002
963
        self.delete_messages()
1003
0
964
1004
=== modified file 'test/backend/test_http.py'
1005
--- test/backend/test_http.py	2011-08-10 07:16:07 +0000
1006
+++ test/backend/test_http.py	2011-08-16 21:02:23 +0000
1007
@@ -12,19 +12,22 @@
1008
12
# See the License for the specific language governing permissions and
12
# See the License for the specific language governing permissions and
1009
13
# limitations under the License.
13
# limitations under the License.
1010
14
14
1011
15
'''Unittests for the HTTP backend. This starts the WSGI server so
1012
16
tests the WSGI frontend as well.'''
1013
17
1014
15
import atexit
18
import atexit
1015
16
import ConfigParser
19
import ConfigParser
1016
17
import os
20
import os
1017
18
import signal
21
import signal
1018
22
import sys
1019
19
import time
23
import time
1020
20
24
1021
21
import burrow.server
1022
22
import burrow.backend.http
25
import burrow.backend.http
1028
23
import test.backend.test_memory
26
import test.backend
1029
24
27
1030
25
28
1031
26
class TestHTTP(test.backend.test_memory.TestMemory):
29
class HTTPBase(test.backend.Base):
1032
27
    '''Unittests for the HTTP backend.'''
30
    '''Base test case for http backend.'''
1033
28
31
1034
29
    def setUp(self):
32
    def setUp(self):
1035
30
        config = (ConfigParser.ConfigParser(), 'test')
33
        config = (ConfigParser.ConfigParser(), 'test')
1036
@@ -32,23 +35,28 @@
1037
32
        self.check_empty()
35
        self.check_empty()
1038
33
36
1039
34
37
1054
35
def kill_server():
38
class TestHTTPAccounts(HTTPBase, test.backend.TestAccounts):
1055
36
    try:
39
    '''Test case for accounts with http backend.'''
1056
37
        pid_file = open('TestHTTP.pid', 'r')
40
    pass
1057
38
        pid = pid_file.read()
41
1058
39
        pid_file.close()
42
1059
40
        try:
43
class TestHTTPQueues(HTTPBase, test.backend.TestQueues):
1060
41
            os.kill(int(pid), signal.SIGUSR1)
44
    '''Test case for queues with http backend.'''
1061
42
            time.sleep(1)
45
    pass
1062
43
            os.kill(int(pid), signal.SIGTERM)
46
1063
44
        except OSError:
47
1064
45
            pass
48
class TestHTTPMessages(HTTPBase, test.backend.TestMessages):
1065
46
        os.unlink('TestHTTP.pid')
49
    '''Test case for messages with http backend.'''
1066
47
    except IOError:
50
    pass
1067
48
        pass
51
1068
52
1069
53
class TestHTTPMessage(HTTPBase, test.backend.TestMessage):
1070
54
    '''Test case for message with http backend.'''
1071
55
    pass
1072
49
56
1073
50
57
1074
51
def start_server():
58
def start_server():
1075
59
    '''Fork and start the server, saving the pid in a file.'''
1076
52
    kill_server()
60
    kill_server()
1077
53
    pid = os.fork()
61
    pid = os.fork()
1078
54
    if pid == 0:
62
    if pid == 0:
1079
@@ -57,16 +65,17 @@
1080
57
            cov = coverage.coverage(data_suffix=True)
65
            cov = coverage.coverage(data_suffix=True)
1081
58
            cov.start()
66
            cov.start()
1082
59
67
1084
60
            def save_coverage(signum, frame):
68
            def save_coverage(_signum, _frame):
1085
69
                '''Callback for signal to save coverage info to file.'''
1086
61
                cov.save()
70
                cov.save()
1087
62
71
1088
63
            signal.signal(signal.SIGUSR1, save_coverage)
72
            signal.signal(signal.SIGUSR1, save_coverage)
1090
64
        except:
73
        except ImportError:
1091
65
            pass
74
            pass
1093
66
        server = burrow.server.Server(add_default_log_handler=False)
75
        server = burrow.Server(add_default_log_handler=False)
1094
67
        server.frontends[0].default_ttl = 0
76
        server.frontends[0].default_ttl = 0
1095
68
        server.run()
77
        server.run()
1097
69
        os.exit(0)
78
        sys.exit(0)
1098
70
    pid_file = open('TestHTTP.pid', 'w')
79
    pid_file = open('TestHTTP.pid', 'w')
1099
71
    pid_file.write(str(pid))
80
    pid_file.write(str(pid))
1100
72
    pid_file.close()
81
    pid_file.close()
1101
@@ -74,4 +83,21 @@
1102
74
    time.sleep(1)
83
    time.sleep(1)
1103
75
84
1104
76
85
1105
86
def kill_server():
1106
87
    '''Try killing the server if the pid file exists.'''
1107
88
    try:
1108
89
        pid_file = open('TestHTTP.pid', 'r')
1109
90
        pid = pid_file.read()
1110
91
        pid_file.close()
1111
92
        try:
1112
93
            os.kill(int(pid), signal.SIGUSR1)
1113
94
            time.sleep(1)
1114
95
            os.kill(int(pid), signal.SIGTERM)
1115
96
        except OSError:
1116
97
            pass
1117
98
        os.unlink('TestHTTP.pid')
1118
99
    except IOError:
1119
100
        pass
1120
101
1121
102
1122
77
start_server()
103
start_server()
1123
78
104
1124
=== modified file 'test/backend/test_memory.py'
1125
--- test/backend/test_memory.py	2011-08-10 07:16:07 +0000
1126
+++ test/backend/test_memory.py	2011-08-16 21:02:23 +0000
1127
@@ -12,923 +12,38 @@
1128
12
# See the License for the specific language governing permissions and
12
# See the License for the specific language governing permissions and
1129
13
# limitations under the License.
13
# limitations under the License.
1130
14
14
1131
15
'''Unittests for the memory backend.'''
1132
16
1133
15
import ConfigParser
17
import ConfigParser
1141
16
import time
18
1135
17
import unittest
1136
18
1137
19
import eventlet
1138
20
eventlet.monkey_patch(socket=True)
1139
21
1140
22
import burrow.backend
1142
23
import burrow.backend.memory
19
import burrow.backend.memory
1147
24
20
import test.backend
1148
25
21
1149
26
class TestMemory(unittest.TestCase):
22
1150
27
    '''Unittests for the memory backend.'''
23
class MemoryBase(test.backend.Base):
1151
24
    '''Base test case for memory backend.'''
1152
28
25
1153
29
    def setUp(self):
26
    def setUp(self):
1154
30
        config = (ConfigParser.ConfigParser(), 'test')
27
        config = (ConfigParser.ConfigParser(), 'test')
1155
31
        self.backend = burrow.backend.memory.Backend(config)
28
        self.backend = burrow.backend.memory.Backend(config)
1156
32
        self.check_empty()
29
        self.check_empty()
1157
33
30
2059
34
    def tearDown(self):
31
2060
35
        self.check_empty()
32
class TestMemoryAccounts(MemoryBase, test.backend.TestAccounts):
2061
36
33
    '''Test case for accounts with memory backend.'''
2062
37
    def check_empty(self):
34
    pass
2063
38
        accounts = self.backend.get_accounts()
35
2064
39
        self.assertRaises(burrow.backend.NotFound, list, accounts)
36
2065
40
        queues = self.backend.get_queues('a')
37
class TestMemoryQueues(MemoryBase, test.backend.TestQueues):
2066
41
        self.assertRaises(burrow.backend.NotFound, list, queues)
38
    '''Test case for queues with memory backend.'''
2067
42
        filters = dict(match_hidden=True)
39
    pass
2068
43
        messages = self.backend.get_messages('a', 'q', filters)
40
2069
44
        self.assertRaises(burrow.backend.NotFound, list, messages)
41
2070
45
42
class TestMemoryMessages(MemoryBase, test.backend.TestMessages):
2071
46
    def test_accounts(self):
43
    '''Test case for messages with memory backend.'''
2072
47
        self.backend.create_message('a', 'q', 'm', 'test')
44
    pass
2073
48
        self.assertEquals(['a'], list(self.backend.get_accounts()))
45
2074
49
        self.assertEquals([], list(self.backend.delete_accounts()))
46
2075
50
        accounts = self.backend.delete_accounts()
47
class TestMemoryMessage(MemoryBase, test.backend.TestMessage):
2076
51
        self.assertRaises(burrow.backend.NotFound, list, accounts)
48
    '''Test case for message with memory backend.'''
2077
52
49
    pass
1177
53
    def test_accounts_large(self):
1178
54
        for x in xrange(0, 1000):
1179
55
            self.backend.create_message(str(x), str(x), str(x), str(x))
1180
56
        filters = dict(marker='unknown')
1181
57
        self.assertEquals([], list(self.backend.delete_accounts(filters)))
1182
58
1183
59
    def test_accounts_delete_detail_all(self):
1184
60
        self.backend.create_message('a', 'q', 'm', 'test')
1185
61
        filters = dict(detail='all')
1186
62
        accounts = list(self.backend.delete_accounts(filters))
1187
63
        self.assertEquals([dict(id='a')], accounts)
1188
64
1189
65
    def test_accounts_delete_detail_id(self):
1190
66
        self.backend.create_message('a', 'q', 'm', 'test')
1191
67
        filters = dict(detail='id')
1192
68
        accounts = list(self.backend.delete_accounts(filters))
1193
69
        self.assertEquals(['a'], accounts)
1194
70
1195
71
    def test_accounts_delete_detail_none(self):
1196
72
        self.backend.create_message('a', 'q', 'm', 'test')
1197
73
        filters = dict(detail='none')
1198
74
        accounts = list(self.backend.delete_accounts(filters))
1199
75
        self.assertEquals([], accounts)
1200
76
1201
77
    def test_accounts_delete_detail_bad(self):
1202
78
        self.backend.create_message('a', 'q', 'm', 'test')
1203
79
        filters = dict(detail='bad')
1204
80
        accounts = self.backend.delete_accounts(filters)
1205
81
        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
1206
82
        self.assertEquals([], list(self.backend.delete_accounts()))
1207
83
1208
84
    def test_accounts_delete_marker(self):
1209
85
        self.backend.create_message('a1', 'q', 'm', 'test')
1210
86
        self.backend.create_message('a2', 'q', 'm', 'test')
1211
87
        self.backend.create_message('a3', 'q', 'm', 'test')
1212
88
        accounts = list(self.backend.get_accounts())
1213
89
        self.assertEquals(3, len(accounts))
1214
90
        filters = dict(detail='id', marker=accounts[0])
1215
91
        accounts2 = list(self.backend.delete_accounts(filters))
1216
92
        self.assertEquals(accounts[1:], accounts2)
1217
93
        accounts2 = list(self.backend.get_accounts())
1218
94
        self.assertEquals(accounts[:1], accounts2)
1219
95
        filters = dict(detail='id', marker='unknown')
1220
96
        accounts2 = list(self.backend.delete_accounts(filters))
1221
97
        self.assertEquals(accounts[:1], accounts2)
1222
98
1223
99
    def test_accounts_delete_limit(self):
1224
100
        self.backend.create_message('a1', 'q', 'm', 'test')
1225
101
        self.backend.create_message('a2', 'q', 'm', 'test')
1226
102
        self.backend.create_message('a3', 'q', 'm', 'test')
1227
103
        accounts = list(self.backend.get_accounts())
1228
104
        self.assertEquals(3, len(accounts))
1229
105
        filters = dict(detail='id', limit=1)
1230
106
        accounts2 = list(self.backend.delete_accounts(filters))
1231
107
        self.assertEquals(accounts[:1], accounts2)
1232
108
        filters = dict(detail='id', limit=2)
1233
109
        accounts2 = list(self.backend.delete_accounts(filters))
1234
110
        self.assertEquals(accounts[1:3], accounts2)
1235
111
1236
112
    def test_accounts_delete_marker_limit(self):
1237
113
        self.backend.create_message('a1', 'q', 'm', 'test')
1238
114
        self.backend.create_message('a2', 'q', 'm', 'test')
1239
115
        self.backend.create_message('a3', 'q', 'm', 'test')
1240
116
        accounts = list(self.backend.get_accounts())
1241
117
        self.assertEquals(3, len(accounts))
1242
118
        filters = dict(detail='id', marker=accounts[1], limit=1)
1243
119
        accounts2 = list(self.backend.delete_accounts(filters))
1244
120
        self.assertEquals(accounts[2:3], accounts2)
1245
121
        filters = dict(detail='id', marker=accounts[0], limit=2)
1246
122
        accounts2 = list(self.backend.delete_accounts(filters))
1247
123
        self.assertEquals(accounts[1:2], accounts2)
1248
124
        self.assertEquals([], list(self.backend.delete_accounts()))
1249
125
1250
126
    def test_accounts_get_detail_all(self):
1251
127
        self.backend.create_message('a', 'q', 'm', 'test')
1252
128
        filters = dict(detail='all')
1253
129
        accounts = list(self.backend.get_accounts(filters))
1254
130
        self.assertEquals([dict(id='a')], accounts)
1255
131
        self.assertEquals([], list(self.backend.delete_accounts()))
1256
132
1257
133
    def test_accounts_get_detail_id(self):
1258
134
        self.backend.create_message('a', 'q', 'm', 'test')
1259
135
        filters = dict(detail='id')
1260
136
        accounts = list(self.backend.get_accounts(filters))
1261
137
        self.assertEquals(['a'], accounts)
1262
138
        self.assertEquals([], list(self.backend.delete_accounts()))
1263
139
1264
140
    def test_accounts_get_detail_none(self):
1265
141
        self.backend.create_message('a', 'q', 'm', 'test')
1266
142
        filters = dict(detail='none')
1267
143
        accounts = list(self.backend.get_accounts(filters))
1268
144
        self.assertEquals([], accounts)
1269
145
        self.assertEquals([], list(self.backend.delete_accounts()))
1270
146
1271
147
    def test_accounts_get_detail_bad(self):
1272
148
        self.backend.create_message('a', 'q', 'm', 'test')
1273
149
        filters = dict(detail='bad')
1274
150
        accounts = self.backend.get_accounts(filters)
1275
151
        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
1276
152
        self.assertEquals([], list(self.backend.delete_accounts()))
1277
153
1278
154
    def test_accounts_get_marker(self):
1279
155
        self.backend.create_message('a1', 'q', 'm', 'test')
1280
156
        self.backend.create_message('a2', 'q', 'm', 'test')
1281
157
        self.backend.create_message('a3', 'q', 'm', 'test')
1282
158
        accounts = list(self.backend.get_accounts())
1283
159
        self.assertEquals(3, len(accounts))
1284
160
        filters = dict(marker=accounts[0])
1285
161
        accounts2 = list(self.backend.get_accounts(filters))
1286
162
        self.assertEquals(accounts[1:], accounts2)
1287
163
        filters = dict(marker=accounts[1])
1288
164
        accounts2 = list(self.backend.get_accounts(filters))
1289
165
        self.assertEquals(accounts[2:], accounts2)
1290
166
        filters = dict(marker=accounts[2])
1291
167
        accounts2 = self.backend.get_accounts(filters)
1292
168
        self.assertRaises(burrow.backend.NotFound, list, accounts2)
1293
169
        filters = dict(marker='unknown')
1294
170
        accounts2 = list(self.backend.get_accounts(filters))
1295
171
        self.assertEquals(accounts, accounts2)
1296
172
        self.assertEquals([], list(self.backend.delete_accounts()))
1297
173
1298
174
    def test_accounts_get_limit(self):
1299
175
        self.backend.create_message('a1', 'q', 'm', 'test')
1300
176
        self.backend.create_message('a2', 'q', 'm', 'test')
1301
177
        self.backend.create_message('a3', 'q', 'm', 'test')
1302
178
        accounts = list(self.backend.get_accounts())
1303
179
        self.assertEquals(3, len(accounts))
1304
180
        filters = dict(limit=1)
1305
181
        accounts2 = list(self.backend.get_accounts(filters))
1306
182
        self.assertEquals(accounts[:1], accounts2)
1307
183
        filters = dict(limit=2)
1308
184
        accounts2 = list(self.backend.get_accounts(filters))
1309
185
        self.assertEquals(accounts[:2], accounts2)
1310
186
        filters = dict(limit=3)
1311
187
        accounts2 = list(self.backend.get_accounts(filters))
1312
188
        self.assertEquals(accounts, accounts2)
1313
189
        filters = dict(limit=100)
1314
190
        accounts2 = list(self.backend.get_accounts(filters))
1315
191
        self.assertEquals(accounts, accounts2)
1316
192
        self.assertEquals([], list(self.backend.delete_accounts()))
1317
193
1318
194
    def test_accounts_get_marker_limit(self):
1319
195
        self.backend.create_message('a1', 'q', 'm', 'test')
1320
196
        self.backend.create_message('a2', 'q', 'm', 'test')
1321
197
        self.backend.create_message('a3', 'q', 'm', 'test')
1322
198
        accounts = list(self.backend.get_accounts())
1323
199
        self.assertEquals(3, len(accounts))
1324
200
        filters = dict(marker=accounts[1], limit=1)
1325
201
        accounts2 = list(self.backend.get_accounts(filters))
1326
202
        self.assertEquals(accounts[2:3], accounts2)
1327
203
        filters = dict(marker=accounts[0], limit=2)
1328
204
        accounts2 = list(self.backend.get_accounts(filters))
1329
205
        self.assertEquals(accounts[1:3], accounts2)
1330
206
        self.assertEquals([], list(self.backend.delete_accounts()))
1331
207
1332
208
    def test_queues(self):
1333
209
        self.backend.create_message('a', 'q', 'm', 'test')
1334
210
        self.assertEquals(['q'], list(self.backend.get_queues('a')))
1335
211
        self.assertEquals([], list(self.backend.delete_queues('a')))
1336
212
        queues = self.backend.delete_queues('a')
1337
213
        self.assertRaises(burrow.backend.NotFound, list, queues)
1338
214
1339
215
    def test_queues_large(self):
1340
216
        for x in xrange(0, 1000):
1341
217
            self.backend.create_message('a', str(x), str(x), str(x))
1342
218
        filters = dict(marker='unknown')
1343
219
        self.assertEquals([], list(self.backend.delete_queues('a', filters)))
1344
220
1345
221
    def test_queues_delete_detail_all(self):
1346
222
        self.backend.create_message('a', 'q', 'm', 'test')
1347
223
        filters = dict(detail='all')
1348
224
        queues = list(self.backend.delete_queues('a', filters))
1349
225
        self.assertEquals([dict(id='q')], queues)
1350
226
1351
227
    def test_queues_delete_detail_id(self):
1352
228
        self.backend.create_message('a', 'q', 'm', 'test')
1353
229
        filters = dict(detail='id')
1354
230
        queues = list(self.backend.delete_queues('a', filters))
1355
231
        self.assertEquals(['q'], queues)
1356
232
1357
233
    def test_queues_delete_detail_none(self):
1358
234
        self.backend.create_message('a', 'q', 'm', 'test')
1359
235
        filters = dict(detail='none')
1360
236
        queues = list(self.backend.delete_queues('a', filters))
1361
237
        self.assertEquals([], queues)
1362
238
1363
239
    def test_queues_delete_detail_bad(self):
1364
240
        self.backend.create_message('a', 'q', 'm', 'test')
1365
241
        filters = dict(detail='bad')
1366
242
        queues = self.backend.delete_queues('a', filters)
1367
243
        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
1368
244
        self.assertEquals([], list(self.backend.delete_queues('a')))
1369
245
1370
246
    def test_queues_delete_marker(self):
1371
247
        self.backend.create_message('a', 'q1', 'm', 'test')
1372
248
        self.backend.create_message('a', 'q2', 'm', 'test')
1373
249
        self.backend.create_message('a', 'q3', 'm', 'test')
1374
250
        queues = list(self.backend.get_queues('a'))
1375
251
        self.assertEquals(3, len(queues))
1376
252
        filters = dict(detail='id', marker=queues[0])
1377
253
        queues2 = list(self.backend.delete_queues('a', filters))
1378
254
        self.assertEquals(queues[1:], queues2)
1379
255
        queues2 = list(self.backend.get_queues('a'))
1380
256
        self.assertEquals(queues[:1], queues2)
1381
257
        filters = dict(detail='id', marker='unknown')
1382
258
        queues2 = list(self.backend.delete_queues('a', filters))
1383
259
        self.assertEquals(queues[:1], queues2)
1384
260
1385
261
    def test_queues_delete_limit(self):
1386
262
        self.backend.create_message('a', 'q1', 'm', 'test')
1387
263
        self.backend.create_message('a', 'q2', 'm', 'test')
1388
264
        self.backend.create_message('a', 'q3', 'm', 'test')
1389
265
        queues = list(self.backend.get_queues('a'))
1390
266
        self.assertEquals(3, len(queues))
1391
267
        filters = dict(detail='id', limit=1)
1392
268
        queues2 = list(self.backend.delete_queues('a', filters))
1393
269
        self.assertEquals(queues[:1], queues2)
1394
270
        filters = dict(detail='id', limit=2)
1395
271
        queues2 = list(self.backend.delete_queues('a', filters))
1396
272
        self.assertEquals(queues[1:3], queues2)
1397
273
1398
274
    def test_queues_delete_marker_limit(self):
1399
275
        self.backend.create_message('a', 'q1', 'm', 'test')
1400
276
        self.backend.create_message('a', 'q2', 'm', 'test')
1401
277
        self.backend.create_message('a', 'q3', 'm', 'test')
1402
278
        queues = list(self.backend.get_queues('a'))
1403
279
        self.assertEquals(3, len(queues))
1404
280
        filters = dict(detail='id', marker=queues[1], limit=1)
1405
281
        queues2 = list(self.backend.delete_queues('a', filters))
1406
282
        self.assertEquals(queues[2:3], queues2)
1407
283
        filters = dict(detail='id', marker=queues[0], limit=2)
1408
284
        queues2 = list(self.backend.delete_queues('a', filters))
1409
285
        self.assertEquals(queues[1:2], queues2)
1410
286
        self.assertEquals([], list(self.backend.delete_queues('a')))
1411
287
1412
288
    def test_queues_get_detail_all(self):
1413
289
        self.backend.create_message('a', 'q', 'm', 'test')
1414
290
        filters = dict(detail='all')
1415
291
        queues = list(self.backend.get_queues('a', filters))
1416
292
        self.assertEquals([dict(id='q')], queues)
1417
293
        self.assertEquals([], list(self.backend.delete_queues('a')))
1418
294
1419
295
    def test_queues_get_detail_id(self):
1420
296
        self.backend.create_message('a', 'q', 'm', 'test')
1421
297
        filters = dict(detail='id')
1422
298
        queues = list(self.backend.get_queues('a', filters))
1423
299
        self.assertEquals(['q'], queues)
1424
300
        self.assertEquals([], list(self.backend.delete_queues('a')))
1425
301
1426
302
    def test_queues_get_detail_none(self):
1427
303
        self.backend.create_message('a', 'q', 'm', 'test')
1428
304
        filters = dict(detail='none')
1429
305
        queues = list(self.backend.get_queues('a', filters))
1430
306
        self.assertEquals([], queues)
1431
307
        self.assertEquals([], list(self.backend.delete_queues('a')))
1432
308
1433
309
    def test_queues_get_detail_bad(self):
1434
310
        self.backend.create_message('a', 'q', 'm', 'test')
1435
311
        filters = dict(detail='bad')
1436
312
        queues = self.backend.get_queues('a', filters)
1437
313
        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
1438
314
        self.assertEquals([], list(self.backend.delete_queues('a')))
1439
315
1440
316
    def test_queues_get_marker(self):
1441
317
        self.backend.create_message('a', 'q1', 'm', 'test')
1442
318
        self.backend.create_message('a', 'q2', 'm', 'test')
1443
319
        self.backend.create_message('a', 'q3', 'm', 'test')
1444
320
        queues = list(self.backend.get_queues('a'))
1445
321
        self.assertEquals(3, len(queues))
1446
322
        filters = dict(marker=queues[0])
1447
323
        queues2 = list(self.backend.get_queues('a', filters))
1448
324
        self.assertEquals(queues[1:], queues2)
1449
325
        filters = dict(marker=queues[1])
1450
326
        queues2 = list(self.backend.get_queues('a', filters))
1451
327
        self.assertEquals(queues[2:], queues2)
1452
328
        filters = dict(marker=queues[2])
1453
329
        queues2 = self.backend.get_queues('a', filters)
1454
330
        self.assertRaises(burrow.backend.NotFound, list, queues2)
1455
331
        filters = dict(marker='unknown')
1456
332
        queues2 = list(self.backend.get_queues('a', filters))
1457
333
        self.assertEquals(queues, queues2)
1458
334
        self.assertEquals([], list(self.backend.delete_queues('a')))
1459
335
1460
336
    def test_queues_get_limit(self):
1461
337
        self.backend.create_message('a', 'q1', 'm', 'test')
1462
338
        self.backend.create_message('a', 'q2', 'm', 'test')
1463
339
        self.backend.create_message('a', 'q3', 'm', 'test')
1464
340
        queues = list(self.backend.get_queues('a'))
1465
341
        self.assertEquals(3, len(queues))
1466
342
        filters = dict(limit=1)
1467
343
        queues2 = list(self.backend.get_queues('a', filters))
1468
344
        self.assertEquals(queues[:1], queues2)
1469
345
        filters = dict(limit=2)
1470
346
        queues2 = list(self.backend.get_queues('a', filters))
1471
347
        self.assertEquals(queues[:2], queues2)
1472
348
        filters = dict(limit=3)
1473
349
        queues2 = list(self.backend.get_queues('a', filters))
1474
350
        self.assertEquals(queues, queues2)
1475
351
        filters = dict(limit=100)
1476
352
        queues2 = list(self.backend.get_queues('a', filters))
1477
353
        self.assertEquals(queues, queues2)
1478
354
        self.assertEquals([], list(self.backend.delete_queues('a')))
1479
355
1480
356
    def test_queues_get_marker_limit(self):
1481
357
        self.backend.create_message('a', 'q1', 'm', 'test')
1482
358
        self.backend.create_message('a', 'q2', 'm', 'test')
1483
359
        self.backend.create_message('a', 'q3', 'm', 'test')
1484
360
        queues = list(self.backend.get_queues('a'))
1485
361
        self.assertEquals(3, len(queues))
1486
362
        filters = dict(marker=queues[1], limit=1)
1487
363
        queues2 = list(self.backend.get_queues('a', filters))
1488
364
        self.assertEquals(queues[2:3], queues2)
1489
365
        filters = dict(marker=queues[0], limit=2)
1490
366
        queues2 = list(self.backend.get_queues('a', filters))
1491
367
        self.assertEquals(queues[1:3], queues2)
1492
368
        self.assertEquals([], list(self.backend.delete_queues('a')))
1493
369
1494
370
    def test_messages(self):
1495
371
        self.backend.create_message('a', 'q', 'm', 'test')
1496
372
        message = dict(id='m', ttl=0, hide=0, body='test')
1497
373
        messages = list(self.backend.get_messages('a', 'q'))
1498
374
        self.assertEquals([message], messages)
1499
375
        attributes = dict(ttl=100, hide=200)
1500
376
        messages = list(self.backend.update_messages('a', 'q', attributes))
1501
377
        self.assertEquals([], messages)
1502
378
        attributes = dict(ttl=0, hide=0)
1503
379
        filters = dict(match_hidden=True)
1504
380
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1505
381
        self.assertEquals([], list(messages))
1506
382
        messages = self.backend.update_messages('a', 'q', dict(), filters)
1507
383
        self.assertEquals([], list(messages))
1508
384
        self.delete_messages()
1509
385
        messages = self.backend.delete_messages('a', 'q')
1510
386
        self.assertRaises(burrow.backend.NotFound, list, messages)
1511
387
        messages = self.backend.update_messages('a', 'q', attributes)
1512
388
        self.assertRaises(burrow.backend.NotFound, list, messages)
1513
389
1514
390
    def test_messages_large(self):
1515
391
        for x in xrange(0, 1000):
1516
392
            self.backend.create_message('a', 'q', str(x), str(x))
1517
393
        attributes = dict(ttl=100, hide=200)
1518
394
        messages = self.backend.update_messages('a', 'q', attributes)
1519
395
        self.assertEquals([], list(messages))
1520
396
        self.delete_messages()
1521
397
1522
398
    def test_messages_delete_detail_all(self):
1523
399
        self.backend.create_message('a', 'q', 'm', 'test')
1524
400
        message = dict(id='m', ttl=0, hide=0, body='test')
1525
401
        filters = dict(detail='all')
1526
402
        messages = list(self.backend.delete_messages('a', 'q', filters))
1527
403
        self.assertEquals([message], messages)
1528
404
1529
405
    def test_messages_delete_detail_attributes(self):
1530
406
        self.backend.create_message('a', 'q', 'm', 'test')
1531
407
        message = dict(id='m', ttl=0, hide=0)
1532
408
        filters = dict(detail='attributes')
1533
409
        messages = list(self.backend.delete_messages('a', 'q', filters))
1534
410
        self.assertEquals([message], messages)
1535
411
1536
412
    def test_messages_delete_detail_body(self):
1537
413
        self.backend.create_message('a', 'q', 'm', 'test')
1538
414
        filters = dict(detail='body')
1539
415
        messages = list(self.backend.delete_messages('a', 'q', filters))
1540
416
        self.assertEquals(['test'], messages)
1541
417
1542
418
    def test_messages_delete_detail_id(self):
1543
419
        self.backend.create_message('a', 'q', 'm', 'test')
1544
420
        filters = dict(detail='id')
1545
421
        messages = list(self.backend.delete_messages('a', 'q', filters))
1546
422
        self.assertEquals(['m'], messages)
1547
423
1548
424
    def test_messages_delete_detail_none(self):
1549
425
        self.backend.create_message('a', 'q', 'm', 'test')
1550
426
        filters = dict(detail='none')
1551
427
        messages = list(self.backend.delete_messages('a', 'q', filters))
1552
428
        self.assertEquals([], messages)
1553
429
1554
430
    def test_messages_delete_detail_bad(self):
1555
431
        self.backend.create_message('a', 'q', 'm', 'test')
1556
432
        filters = dict(detail='bad')
1557
433
        messages = self.backend.delete_messages('a', 'q', filters)
1558
434
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
1559
435
        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
1560
436
1561
437
    def test_messages_delete_marker(self):
1562
438
        self.backend.create_message('a', 'q', 'm1', 'test')
1563
439
        self.backend.create_message('a', 'q', 'm2', 'test')
1564
440
        self.backend.create_message('a', 'q', 'm3', 'test')
1565
441
        messages = list(self.backend.get_messages('a', 'q'))
1566
442
        self.assertEquals(3, len(messages))
1567
443
        filters = dict(detail='all', marker=messages[0]['id'])
1568
444
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
1569
445
        self.assertEquals(messages[1:], messages2)
1570
446
        messages2 = list(self.backend.get_messages('a', 'q'))
1571
447
        self.assertEquals(messages[:1], messages2)
1572
448
        filters = dict(detail='all', marker='unknown')
1573
449
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
1574
450
        self.assertEquals(messages[:1], messages2)
1575
451
1576
452
    def test_messages_delete_limit(self):
1577
453
        self.backend.create_message('a', 'q', 'm1', 'test')
1578
454
        self.backend.create_message('a', 'q', 'm2', 'test')
1579
455
        self.backend.create_message('a', 'q', 'm3', 'test')
1580
456
        messages = list(self.backend.get_messages('a', 'q'))
1581
457
        self.assertEquals(3, len(messages))
1582
458
        filters = dict(detail='all', limit=1)
1583
459
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
1584
460
        self.assertEquals(messages[:1], messages2)
1585
461
        filters = dict(detail='all', limit=2)
1586
462
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
1587
463
        self.assertEquals(messages[1:3], messages2)
1588
464
1589
465
    def test_messages_delete_marker_limit(self):
1590
466
        self.backend.create_message('a', 'q', 'm1', 'test')
1591
467
        self.backend.create_message('a', 'q', 'm2', 'test')
1592
468
        self.backend.create_message('a', 'q', 'm3', 'test')
1593
469
        messages = list(self.backend.get_messages('a', 'q'))
1594
470
        self.assertEquals(3, len(messages))
1595
471
        filters = dict(detail='all', marker=messages[1]['id'], limit=1)
1596
472
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
1597
473
        self.assertEquals(messages[2:3], messages2)
1598
474
        filters = dict(detail='all', marker=messages[0]['id'], limit=2)
1599
475
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
1600
476
        self.assertEquals(messages[1:2], messages2)
1601
477
        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
1602
478
1603
479
    def test_messages_get_detail_all(self):
1604
480
        self.backend.create_message('a', 'q', 'm', 'test')
1605
481
        message = dict(id='m', ttl=0, hide=0, body='test')
1606
482
        filters = dict(detail='all')
1607
483
        messages = list(self.backend.get_messages('a', 'q', filters))
1608
484
        self.assertEquals([message], messages)
1609
485
        self.delete_messages()
1610
486
1611
487
    def test_messages_get_detail_attributes(self):
1612
488
        self.backend.create_message('a', 'q', 'm', 'test')
1613
489
        message = dict(id='m', ttl=0, hide=0)
1614
490
        filters = dict(detail='attributes')
1615
491
        messages = list(self.backend.get_messages('a', 'q', filters))
1616
492
        self.assertEquals([message], messages)
1617
493
        self.delete_messages()
1618
494
1619
495
    def test_messages_get_detail_body(self):
1620
496
        self.backend.create_message('a', 'q', 'm', 'test')
1621
497
        filters = dict(detail='body')
1622
498
        messages = list(self.backend.get_messages('a', 'q', filters))
1623
499
        self.assertEquals(['test'], messages)
1624
500
        self.delete_messages()
1625
501
1626
502
    def test_messages_get_detail_id(self):
1627
503
        self.backend.create_message('a', 'q', 'm', 'test')
1628
504
        filters = dict(detail='id')
1629
505
        messages = list(self.backend.get_messages('a', 'q', filters))
1630
506
        self.assertEquals(['m'], messages)
1631
507
        self.delete_messages()
1632
508
1633
509
    def test_messages_get_detail_none(self):
1634
510
        self.backend.create_message('a', 'q', 'm', 'test')
1635
511
        filters = dict(detail='none')
1636
512
        messages = list(self.backend.get_messages('a', 'q', filters))
1637
513
        self.assertEquals([], messages)
1638
514
        self.delete_messages()
1639
515
1640
516
    def test_messages_get_detail_bad(self):
1641
517
        self.backend.create_message('a', 'q', 'm', 'test')
1642
518
        filters = dict(detail='bad')
1643
519
        messages = self.backend.get_messages('a', 'q', filters)
1644
520
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
1645
521
        self.delete_messages()
1646
522
1647
523
    def test_messages_get_marker(self):
1648
524
        self.backend.create_message('a', 'q', 'm1', 'test')
1649
525
        self.backend.create_message('a', 'q', 'm2', 'test')
1650
526
        self.backend.create_message('a', 'q', 'm3', 'test')
1651
527
        messages = list(self.backend.get_messages('a', 'q'))
1652
528
        self.assertEquals(3, len(messages))
1653
529
        filters = dict(marker=messages[0]['id'])
1654
530
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1655
531
        self.assertEquals(messages[1:], messages2)
1656
532
        filters = dict(marker=messages[1]['id'])
1657
533
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1658
534
        self.assertEquals(messages[2:], messages2)
1659
535
        filters = dict(marker=messages[2]['id'])
1660
536
        messages2 = self.backend.get_messages('a', 'q', filters)
1661
537
        self.assertRaises(burrow.backend.NotFound, list, messages2)
1662
538
        filters = dict(marker='unknown')
1663
539
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1664
540
        self.assertEquals(messages, messages2)
1665
541
        self.delete_messages()
1666
542
1667
543
    def test_messages_get_limit(self):
1668
544
        self.backend.create_message('a', 'q', 'm1', 'test')
1669
545
        self.backend.create_message('a', 'q', 'm2', 'test')
1670
546
        self.backend.create_message('a', 'q', 'm3', 'test')
1671
547
        messages = list(self.backend.get_messages('a', 'q'))
1672
548
        self.assertEquals(3, len(messages))
1673
549
        filters = dict(limit=1)
1674
550
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1675
551
        self.assertEquals(messages[:1], messages2)
1676
552
        filters = dict(limit=2)
1677
553
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1678
554
        self.assertEquals(messages[:2], messages2)
1679
555
        filters = dict(limit=3)
1680
556
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1681
557
        self.assertEquals(messages, messages2)
1682
558
        filters = dict(limit=100)
1683
559
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1684
560
        self.assertEquals(messages, messages2)
1685
561
        self.delete_messages()
1686
562
1687
563
    def test_messages_get_marker_limit(self):
1688
564
        self.backend.create_message('a', 'q', 'm1', 'test')
1689
565
        self.backend.create_message('a', 'q', 'm2', 'test')
1690
566
        self.backend.create_message('a', 'q', 'm3', 'test')
1691
567
        messages = list(self.backend.get_messages('a', 'q'))
1692
568
        self.assertEquals(3, len(messages))
1693
569
        filters = dict(marker=messages[1]['id'], limit=1)
1694
570
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1695
571
        self.assertEquals(messages[2:3], messages2)
1696
572
        filters = dict(marker=messages[0]['id'], limit=2)
1697
573
        messages2 = list(self.backend.get_messages('a', 'q', filters))
1698
574
        self.assertEquals(messages[1:3], messages2)
1699
575
        self.delete_messages()
1700
576
1701
577
    def test_messages_update_detail_all(self):
1702
578
        self.backend.create_message('a', 'q', 'm', 'test')
1703
579
        message = dict(id='m', ttl=100, hide=200, body='test')
1704
580
        attributes = dict(ttl=100, hide=200)
1705
581
        filters = dict(detail='all')
1706
582
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1707
583
        self.assertEquals([message], list(messages))
1708
584
        self.delete_messages()
1709
585
1710
586
    def test_messages_update_detail_attributes(self):
1711
587
        self.backend.create_message('a', 'q', 'm', 'test')
1712
588
        message = dict(id='m', ttl=100, hide=200)
1713
589
        attributes = dict(ttl=100, hide=200)
1714
590
        filters = dict(detail='attributes')
1715
591
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1716
592
        self.assertEquals([message], list(messages))
1717
593
        self.delete_messages()
1718
594
1719
595
    def test_messages_update_detail_body(self):
1720
596
        self.backend.create_message('a', 'q', 'm', 'test')
1721
597
        attributes = dict(ttl=100, hide=200)
1722
598
        filters = dict(detail='body')
1723
599
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1724
600
        self.assertEquals(['test'], list(messages))
1725
601
        self.delete_messages()
1726
602
1727
603
    def test_messages_update_detail_id(self):
1728
604
        self.backend.create_message('a', 'q', 'm', 'test')
1729
605
        attributes = dict(ttl=100, hide=200)
1730
606
        filters = dict(detail='id')
1731
607
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1732
608
        self.assertEquals(['m'], list(messages))
1733
609
        self.delete_messages()
1734
610
1735
611
    def test_messages_update_detail_none(self):
1736
612
        self.backend.create_message('a', 'q', 'm', 'test')
1737
613
        attributes = dict(ttl=100, hide=200)
1738
614
        filters = dict(detail='none')
1739
615
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1740
616
        self.assertEquals([], list(messages))
1741
617
        self.delete_messages()
1742
618
1743
619
    def test_messages_update_detail_bad(self):
1744
620
        self.backend.create_message('a', 'q', 'm', 'test')
1745
621
        attributes = dict(ttl=100, hide=200)
1746
622
        filters = dict(detail='bad')
1747
623
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1748
624
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
1749
625
        self.delete_messages()
1750
626
1751
627
    def test_messages_update_marker(self):
1752
628
        self.backend.create_message('a', 'q', 'm1', 'test')
1753
629
        self.backend.create_message('a', 'q', 'm2', 'test')
1754
630
        self.backend.create_message('a', 'q', 'm3', 'test')
1755
631
        attributes = dict(ttl=100, hide=200)
1756
632
        filters = dict(detail='all', match_hidden=True)
1757
633
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1758
634
        messages = list(messages)
1759
635
        self.assertEquals(3, len(messages))
1760
636
        filters.update(marker=messages[0]['id'])
1761
637
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1762
638
        self.assertEquals(messages[1:], list(messages2))
1763
639
        filters.update(marker=messages[1]['id'])
1764
640
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1765
641
        self.assertEquals(messages[2:], list(messages2))
1766
642
        filters.update(marker=messages[2]['id'])
1767
643
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1768
644
        self.assertRaises(burrow.backend.NotFound, list, messages2)
1769
645
        filters = dict(detail='all', marker='unknown', match_hidden=True)
1770
646
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1771
647
        self.assertEquals(messages, list(messages2))
1772
648
        self.delete_messages()
1773
649
1774
650
    def test_messages_update_limit(self):
1775
651
        self.backend.create_message('a', 'q', 'm1', 'test')
1776
652
        self.backend.create_message('a', 'q', 'm2', 'test')
1777
653
        self.backend.create_message('a', 'q', 'm3', 'test')
1778
654
        attributes = dict(ttl=100, hide=200)
1779
655
        filters = dict(detail='all', match_hidden=True)
1780
656
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1781
657
        messages = list(messages)
1782
658
        self.assertEquals(3, len(messages))
1783
659
        filters.update(limit=1)
1784
660
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1785
661
        self.assertEquals(messages[:1], list(messages2))
1786
662
        filters.update(limit=2)
1787
663
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1788
664
        self.assertEquals(messages[:2], list(messages2))
1789
665
        filters.update(limit=3)
1790
666
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1791
667
        self.assertEquals(messages, list(messages2))
1792
668
        filters.update(limit=100)
1793
669
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1794
670
        self.assertEquals(messages, list(messages2))
1795
671
        self.delete_messages()
1796
672
1797
673
    def test_messages_update_marker_limit(self):
1798
674
        self.backend.create_message('a', 'q', 'm1', 'test')
1799
675
        self.backend.create_message('a', 'q', 'm2', 'test')
1800
676
        self.backend.create_message('a', 'q', 'm3', 'test')
1801
677
        attributes = dict(ttl=100, hide=200)
1802
678
        filters = dict(detail='all', match_hidden=True)
1803
679
        messages = self.backend.update_messages('a', 'q', attributes, filters)
1804
680
        messages = list(messages)
1805
681
        self.assertEquals(3, len(messages))
1806
682
        filters.update(marker=messages[1]['id'], limit=1)
1807
683
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1808
684
        self.assertEquals(messages[2:3], list(messages2))
1809
685
        filters.update(marker=messages[0]['id'], limit=2)
1810
686
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
1811
687
        self.assertEquals(messages[1:3], list(messages2))
1812
688
        self.delete_messages()
1813
689
1814
690
    def test_message(self):
1815
691
        self.backend.create_message('a', 'q', 'm', 'test')
1816
692
        message = self.backend.get_message('a', 'q', 'm')
1817
693
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
1818
694
        attributes = dict(ttl=100, hide=200)
1819
695
        message = self.backend.update_message('a', 'q', 'm', attributes)
1820
696
        attributes = dict(ttl=0, hide=0)
1821
697
        message = self.backend.update_message('a', 'q', 'm', attributes)
1822
698
        self.assertEquals(None, message)
1823
699
        message = self.backend.update_message('a', 'q', 'm', dict())
1824
700
        self.assertEquals(None, message)
1825
701
        message = self.backend.delete_message('a', 'q', 'm')
1826
702
        self.assertEquals(None, message)
1827
703
1828
704
    def test_message_create(self):
1829
705
        created = self.backend.create_message('a', 'q', 'm', 'test1')
1830
706
        self.assertEquals(created, True)
1831
707
        message = self.backend.get_message('a', 'q', 'm')
1832
708
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test1'), message)
1833
709
        attributes = dict(ttl=100, hide=200)
1834
710
        created = self.backend.create_message('a', 'q', 'm', 'test2',
1835
711
            attributes)
1836
712
        self.assertEquals(created, False)
1837
713
        message = self.backend.get_message('a', 'q', 'm')
1838
714
        self.assertEquals(dict(id='m', ttl=100, hide=200, body='test2'),
1839
715
            message)
1840
716
        attributes = dict(ttl=0, hide=0)
1841
717
        created = self.backend.create_message('a', 'q', 'm', 'test3',
1842
718
            attributes)
1843
719
        self.assertEquals(created, False)
1844
720
        message = self.backend.get_message('a', 'q', 'm')
1845
721
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test3'), message)
1846
722
1847
723
        self.delete_messages()
1848
724
1849
725
    def test_message_delete_detail_all(self):
1850
726
        self.backend.create_message('a', 'q', 'm', 'test')
1851
727
        filters = dict(detail='all')
1852
728
        message = self.backend.delete_message('a', 'q', 'm', filters)
1853
729
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
1854
730
1855
731
    def test_message_delete_detail_attributes(self):
1856
732
        self.backend.create_message('a', 'q', 'm', 'test')
1857
733
        filters = dict(detail='attributes')
1858
734
        message = self.backend.delete_message('a', 'q', 'm', filters)
1859
735
        self.assertEquals(dict(id='m', ttl=0, hide=0), message)
1860
736
1861
737
    def test_message_delete_detail_body(self):
1862
738
        self.backend.create_message('a', 'q', 'm', 'test')
1863
739
        filters = dict(detail='body')
1864
740
        message = self.backend.delete_message('a', 'q', 'm', filters)
1865
741
        self.assertEquals('test', message)
1866
742
1867
743
    def test_message_delete_detail_id(self):
1868
744
        self.backend.create_message('a', 'q', 'm', 'test')
1869
745
        filters = dict(detail='id')
1870
746
        message = self.backend.delete_message('a', 'q', 'm', filters)
1871
747
        self.assertEquals('m', message)
1872
748
1873
749
    def test_message_delete_detail_none(self):
1874
750
        self.backend.create_message('a', 'q', 'm', 'test')
1875
751
        filters = dict(detail='none')
1876
752
        message = self.backend.delete_message('a', 'q', 'm', filters)
1877
753
        self.assertEquals(None, message)
1878
754
1879
755
    def test_message_delete_detail_bad(self):
1880
756
        self.backend.create_message('a', 'q', 'm', 'test')
1881
757
        filters = dict(detail='bad')
1882
758
        self.assertRaises(burrow.backend.InvalidArguments,
1883
759
            self.backend.delete_message, 'a', 'q', 'm', filters)
1884
760
        self.delete_messages()
1885
761
1886
762
    def test_message_get_detail_all(self):
1887
763
        self.backend.create_message('a', 'q', 'm', 'test')
1888
764
        filters = dict(detail='all')
1889
765
        message = self.backend.get_message('a', 'q', 'm', filters)
1890
766
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
1891
767
        self.delete_messages()
1892
768
1893
769
    def test_message_get_detail_attributes(self):
1894
770
        self.backend.create_message('a', 'q', 'm', 'test')
1895
771
        filters = dict(detail='attributes')
1896
772
        message = self.backend.get_message('a', 'q', 'm', filters)
1897
773
        self.assertEquals(dict(id='m', ttl=0, hide=0), message)
1898
774
        self.delete_messages()
1899
775
1900
776
    def test_message_get_detail_body(self):
1901
777
        self.backend.create_message('a', 'q', 'm', 'test')
1902
778
        filters = dict(detail='body')
1903
779
        message = self.backend.get_message('a', 'q', 'm', filters)
1904
780
        self.assertEquals('test', message)
1905
781
        self.delete_messages()
1906
782
1907
783
    def test_message_get_detail_id(self):
1908
784
        self.backend.create_message('a', 'q', 'm', 'test')
1909
785
        filters = dict(detail='id')
1910
786
        message = self.backend.get_message('a', 'q', 'm', filters)
1911
787
        self.assertEquals('m', message)
1912
788
        self.delete_messages()
1913
789
1914
790
    def test_message_get_detail_none(self):
1915
791
        self.backend.create_message('a', 'q', 'm', 'test')
1916
792
        filters = dict(detail='none')
1917
793
        message = self.backend.get_message('a', 'q', 'm', filters)
1918
794
        self.assertEquals(None, message)
1919
795
        self.delete_messages()
1920
796
1921
797
    def test_message_get_detail_bad(self):
1922
798
        self.backend.create_message('a', 'q', 'm', 'test')
1923
799
        filters = dict(detail='bad')
1924
800
        self.assertRaises(burrow.backend.InvalidArguments,
1925
801
            self.backend.get_message, 'a', 'q', 'm', filters)
1926
802
        self.delete_messages()
1927
803
1928
804
    def test_message_update_detail_all(self):
1929
805
        self.backend.create_message('a', 'q', 'm', 'test')
1930
806
        attributes = dict(ttl=100, hide=200)
1931
807
        filters = dict(detail='all')
1932
808
        message = self.backend.update_message('a', 'q', 'm', attributes,
1933
809
            filters)
1934
810
        self.assertEquals(dict(id='m', ttl=100, hide=200, body='test'),
1935
811
            message)
1936
812
        self.delete_messages()
1937
813
1938
814
    def test_message_update_detail_attributes(self):
1939
815
        self.backend.create_message('a', 'q', 'm', 'test')
1940
816
        attributes = dict(ttl=100, hide=200)
1941
817
        filters = dict(detail='attributes')
1942
818
        message = self.backend.update_message('a', 'q', 'm', attributes,
1943
819
            filters)
1944
820
        self.assertEquals(dict(id='m', ttl=100, hide=200), message)
1945
821
        self.delete_messages()
1946
822
1947
823
    def test_message_update_detail_body(self):
1948
824
        self.backend.create_message('a', 'q', 'm', 'test')
1949
825
        attributes = dict(ttl=100, hide=200)
1950
826
        filters = dict(detail='body')
1951
827
        message = self.backend.update_message('a', 'q', 'm', attributes,
1952
828
            filters)
1953
829
        self.assertEquals('test', message)
1954
830
        self.delete_messages()
1955
831
1956
832
    def test_message_update_detail_id(self):
1957
833
        self.backend.create_message('a', 'q', 'm', 'test')
1958
834
        attributes = dict(ttl=100, hide=200)
1959
835
        filters = dict(detail='id')
1960
836
        message = self.backend.update_message('a', 'q', 'm', attributes,
1961
837
            filters)
1962
838
        self.assertEquals('m', message)
1963
839
        self.delete_messages()
1964
840
1965
841
    def test_message_update_detail_none(self):
1966
842
        self.backend.create_message('a', 'q', 'm', 'test')
1967
843
        attributes = dict(ttl=100, hide=200)
1968
844
        filters = dict(detail='none')
1969
845
        message = self.backend.update_message('a', 'q', 'm', attributes,
1970
846
            filters)
1971
847
        self.assertEquals(None, message)
1972
848
        self.delete_messages()
1973
849
1974
850
    def test_message_update_detail_bad(self):
1975
851
        self.backend.create_message('a', 'q', 'm', 'test')
1976
852
        attributes = dict(ttl=100, hide=200)
1977
853
        filters = dict(detail='bad')
1978
854
        self.assertRaises(burrow.backend.InvalidArguments,
1979
855
            self.backend.update_message, 'a', 'q', 'm', attributes, filters)
1980
856
        self.delete_messages()
1981
857
1982
858
    def test_message_ttl(self):
1983
859
        attributes = dict(ttl=1)
1984
860
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
1985
861
        time.sleep(2)
1986
862
        self.backend.clean()
1987
863
1988
864
    def test_message_ttl_large(self):
1989
865
        attributes = dict(ttl=1)
1990
866
        for x in xrange(0, 1000):
1991
867
            self.backend.create_message('a', 'q', str(x), str(x), attributes)
1992
868
        time.sleep(2)
1993
869
        self.backend.clean()
1994
870
1995
871
    def test_message_hide(self):
1996
872
        attributes = dict(hide=1)
1997
873
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
1998
874
        time.sleep(2)
1999
875
        self.backend.clean()
2000
876
        message = self.backend.get_message('a', 'q', 'm')
2001
877
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
2002
878
        self.delete_messages()
2003
879
2004
880
    def test_message_hide_large(self):
2005
881
        attributes = dict(hide=1)
2006
882
        for x in xrange(0, 1000):
2007
883
            self.backend.create_message('a', 'q', str(x), str(x), attributes)
2008
884
        time.sleep(2)
2009
885
        self.backend.clean()
2010
886
        message = self.backend.get_message('a', 'q', '0')
2011
887
        self.assertEquals(dict(id='0', ttl=0, hide=0, body='0'), message)
2012
888
        self.delete_messages()
2013
889
2014
890
    def test_message_create_wait(self):
2015
891
        self.success = False
2016
892
        thread = eventlet.spawn(self.get_messages)
2017
893
        eventlet.spawn_after(0.2,
2018
894
            self.backend.create_message, 'a', 'q', 'm', 'test')
2019
895
        thread.wait()
2020
896
        self.assertTrue(self.success)
2021
897
        self.delete_messages()
2022
898
2023
899
    def test_message_update_wait(self):
2024
900
        attributes = dict(hide=100)
2025
901
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
2026
902
        self.success = False
2027
903
        thread = eventlet.spawn(self.get_messages)
2028
904
        attributes = dict(hide=0)
2029
905
        eventlet.spawn_after(0.2,
2030
906
            self.backend.update_message, 'a', 'q', 'm', attributes)
2031
907
        thread.wait()
2032
908
        self.assertTrue(self.success)
2033
909
        self.delete_messages()
2034
910
2035
911
    def test_messages_update_wait(self):
2036
912
        attributes = dict(hide=100)
2037
913
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
2038
914
        self.success = False
2039
915
        thread = eventlet.spawn(self.get_messages)
2040
916
        attributes = dict(hide=0)
2041
917
        filters = dict(match_hidden=True)
2042
918
        messages = self.backend.update_messages('a', 'q', attributes, filters)
2043
919
        eventlet.spawn_after(0.2, list, messages)
2044
920
        thread.wait()
2045
921
        self.assertTrue(self.success)
2046
922
        self.delete_messages()
2047
923
2048
924
    def delete_messages(self):
2049
925
        filters = dict(match_hidden=True)
2050
926
        messages = list(self.backend.delete_messages('a', 'q', filters))
2051
927
        self.assertEquals([], messages)
2052
928
2053
929
    def get_messages(self):
2054
930
        message = dict(id='m', ttl=0, hide=0, body='test')
2055
931
        filters = dict(wait=2)
2056
932
        messages = list(self.backend.get_messages('a', 'q', filters))
2057
933
        self.assertEquals([message], messages)
2058
934
        self.success = True
2078
935
50
2079
=== modified file 'test/backend/test_sqlite.py'
2080
--- test/backend/test_sqlite.py	2011-08-09 23:04:39 +0000
2081
+++ test/backend/test_sqlite.py	2011-08-16 21:02:23 +0000
2082
@@ -12,15 +12,17 @@
2083
12
# See the License for the specific language governing permissions and
12
# See the License for the specific language governing permissions and
2084
13
# limitations under the License.
13
# limitations under the License.
2085
14
14
2086
15
'''Unittests for the sqlite backend.'''
2087
16
2088
15
import ConfigParser
17
import ConfigParser
2089
16
import os
18
import os
2090
17
19
2091
18
import burrow.backend.sqlite
20
import burrow.backend.sqlite
2097
19
import test.backend.test_memory
21
import test.backend
2098
20
22
2099
21
23
2100
22
class TestSQLite(test.backend.test_memory.TestMemory):
24
class SQLiteBase(test.backend.Base):
2101
23
    '''Unittests for the memory-based SQLite backend.'''
25
    '''Base test case for sqlite backend.'''
2102
24
26
2103
25
    def setUp(self):
27
    def setUp(self):
2104
26
        config = (ConfigParser.ConfigParser(), 'test')
28
        config = (ConfigParser.ConfigParser(), 'test')
2105
@@ -28,8 +30,28 @@
2106
28
        self.check_empty()
30
        self.check_empty()
2107
29
31
2108
30
32
2111
31
class TestSQLiteFile(test.backend.test_memory.TestMemory):
33
class TestSQLiteAccounts(SQLiteBase, test.backend.TestAccounts):
2112
32
    '''Unittests for the file-based SQLite backend.'''
34
    '''Test case for accounts with sqlite backend.'''
2113
35
    pass
2114
36
2115
37
2116
38
class TestSQLiteQueues(SQLiteBase, test.backend.TestQueues):
2117
39
    '''Test case for queues with sqlite backend.'''
2118
40
    pass
2119
41
2120
42
2121
43
class TestSQLiteMessages(SQLiteBase, test.backend.TestMessages):
2122
44
    '''Test case for messages with sqlite backend.'''
2123
45
    pass
2124
46
2125
47
2126
48
class TestSQLiteMessage(SQLiteBase, test.backend.TestMessage):
2127
49
    '''Test case for message with sqlite backend.'''
2128
50
    pass
2129
51
2130
52
2131
53
class SQLiteFileBase(test.backend.Base):
2132
54
    '''Base test case for file-based sqlite backend.'''
2133
33
55
2134
34
    def setUp(self):
56
    def setUp(self):
2135
35
        try:
57
        try:
2136
@@ -47,3 +69,23 @@
2137
47
    def tearDown(self):
69
    def tearDown(self):
2138
48
        self.check_empty()
70
        self.check_empty()
2139
49
        os.unlink('TestSQLiteFile.db')
71
        os.unlink('TestSQLiteFile.db')
2140
72
2141
73
2142
74
class TestSQLiteFileAccounts(SQLiteFileBase, test.backend.TestAccounts):
2143
75
    '''Test case for accounts with file-based sqlite backend.'''
2144
76
    pass
2145
77
2146
78
2147
79
class TestSQLiteFileQueues(SQLiteFileBase, test.backend.TestQueues):
2148
80
    '''Test case for queues with file-based sqlite backend.'''
2149
81
    pass
2150
82
2151
83
2152
84
class TestSQLiteFileMessages(SQLiteFileBase, test.backend.TestMessages):
2153
85
    '''Test case for messages with file-based sqlite backend.'''
2154
86
    pass
2155
87
2156
88
2157
89
class TestSQLiteFileMessage(SQLiteFileBase, test.backend.TestMessage):
2158
90
    '''Test case for message with file-based sqlite backend.'''
2159
91
    pass
Status:	Merged
Approved by:	Eric Day on 2011-08-16
Approved revision:	34
Merged at revision:	34
Proposed branch:	lp:~eday/burrow/doc-updates
Merge into:	lp:burrow
Diff against target:	2159 lines (+1109/-943) 6 files modified .pylintrc (+5/-0) test/__init__.py (+15/-0) test/backend/__init__.py (+963/-0) test/backend/test_http.py (+50/-24) test/backend/test_memory.py (+27/-912) test/backend/test_sqlite.py (+49/-7)
To merge this branch:	bzr merge lp:~eday/burrow/doc-updates
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Burrow Core Team		2011-08-16	Pending
Review via email: mp+71777@code.launchpad.net