~hudson-openstack/burrow/trunk

« back to all changes in this revision

Viewing changes to test/backend/__init__.py

  • Committer: Eric Day
  • Date: 2011-08-16 20:59:06 UTC
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: eday@oddments.org-20110816205906-n0785h4cwj8zfz44
Test case cleanup, moved backend base test cases to test.backend (out of memory test).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2011 OpenStack LLC.
 
2
#
 
3
# Licensed under the Apache License, Version 2.0 (the "License");
 
4
# you may not use this file except in compliance with the License.
 
5
# You may obtain a copy of the License at
 
6
#
 
7
#     http://www.apache.org/licenses/LICENSE-2.0
 
8
#
 
9
# Unless required by applicable law or agreed to in writing, software
 
10
# distributed under the License is distributed on an "AS IS" BASIS,
 
11
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
12
# See the License for the specific language governing permissions and
 
13
# limitations under the License.
 
14
 
 
15
'''Unittests for burrow backends.'''
 
16
 
 
17
import time
 
18
import unittest
 
19
 
 
20
import eventlet
 
21
eventlet.monkey_patch(socket=True)
 
22
 
 
23
import burrow.backend
 
24
 
 
25
 
 
26
class Base(unittest.TestCase):
 
27
    '''Base test case.'''
 
28
 
 
29
    def __init__(self, *args, **kwargs):
 
30
        super(Base, self).__init__(*args, **kwargs)
 
31
        self.backend = None
 
32
        self.success = False
 
33
 
 
34
    def setUp(self):
 
35
        self.check_empty()
 
36
 
 
37
    def tearDown(self):
 
38
        self.check_empty()
 
39
 
 
40
    def check_empty(self):
 
41
        '''Ensure the backend is empty before, used before and after
 
42
        each test.'''
 
43
        accounts = self.backend.get_accounts()
 
44
        self.assertRaises(burrow.backend.NotFound, list, accounts)
 
45
        queues = self.backend.get_queues('a')
 
46
        self.assertRaises(burrow.backend.NotFound, list, queues)
 
47
        filters = dict(match_hidden=True)
 
48
        messages = self.backend.get_messages('a', 'q', filters)
 
49
        self.assertRaises(burrow.backend.NotFound, list, messages)
 
50
 
 
51
    def delete_messages(self):
 
52
        '''Delete messages, including those that are hidden. Use
 
53
        after tests that don't need to delete.'''
 
54
        filters = dict(match_hidden=True)
 
55
        messages = list(self.backend.delete_messages('a', 'q', filters))
 
56
        self.assertEquals([], messages)
 
57
 
 
58
    def get_messages(self):
 
59
        '''Get messages and ensure it is correct. Used for concurrent
 
60
        tests as an eventlet thread.'''
 
61
        message = dict(id='m', ttl=0, hide=0, body='test')
 
62
        filters = dict(wait=2)
 
63
        messages = list(self.backend.get_messages('a', 'q', filters))
 
64
        self.assertEquals([message], messages)
 
65
        self.success = True
 
66
 
 
67
 
 
68
class TestAccounts(Base):
 
69
    '''Test case for accounts.'''
 
70
 
 
71
    def test_basic(self):
 
72
        self.backend.create_message('a', 'q', 'm', 'test')
 
73
        self.assertEquals(['a'], list(self.backend.get_accounts()))
 
74
        self.assertEquals([], list(self.backend.delete_accounts()))
 
75
        accounts = self.backend.delete_accounts()
 
76
        self.assertRaises(burrow.backend.NotFound, list, accounts)
 
77
 
 
78
    def test_large(self):
 
79
        for name in xrange(0, 1000):
 
80
            name = str(name)
 
81
            self.backend.create_message(name, name, name, name)
 
82
        filters = dict(marker='unknown')
 
83
        self.assertEquals([], list(self.backend.delete_accounts(filters)))
 
84
 
 
85
    def test_delete_detail_all(self):
 
86
        self.backend.create_message('a', 'q', 'm', 'test')
 
87
        filters = dict(detail='all')
 
88
        accounts = list(self.backend.delete_accounts(filters))
 
89
        self.assertEquals([dict(id='a')], accounts)
 
90
 
 
91
    def test_delete_detail_id(self):
 
92
        self.backend.create_message('a', 'q', 'm', 'test')
 
93
        filters = dict(detail='id')
 
94
        accounts = list(self.backend.delete_accounts(filters))
 
95
        self.assertEquals(['a'], accounts)
 
96
 
 
97
    def test_delete_detail_none(self):
 
98
        self.backend.create_message('a', 'q', 'm', 'test')
 
99
        filters = dict(detail='none')
 
100
        accounts = list(self.backend.delete_accounts(filters))
 
101
        self.assertEquals([], accounts)
 
102
 
 
103
    def test_delete_detail_bad(self):
 
104
        self.backend.create_message('a', 'q', 'm', 'test')
 
105
        filters = dict(detail='bad')
 
106
        accounts = self.backend.delete_accounts(filters)
 
107
        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
 
108
        self.assertEquals([], list(self.backend.delete_accounts()))
 
109
 
 
110
    def test_delete_marker(self):
 
111
        self.backend.create_message('a1', 'q', 'm', 'test')
 
112
        self.backend.create_message('a2', 'q', 'm', 'test')
 
113
        self.backend.create_message('a3', 'q', 'm', 'test')
 
114
        accounts = list(self.backend.get_accounts())
 
115
        self.assertEquals(3, len(accounts))
 
116
        filters = dict(detail='id', marker=accounts[0])
 
117
        accounts2 = list(self.backend.delete_accounts(filters))
 
118
        self.assertEquals(accounts[1:], accounts2)
 
119
        accounts2 = list(self.backend.get_accounts())
 
120
        self.assertEquals(accounts[:1], accounts2)
 
121
        filters = dict(detail='id', marker='unknown')
 
122
        accounts2 = list(self.backend.delete_accounts(filters))
 
123
        self.assertEquals(accounts[:1], accounts2)
 
124
 
 
125
    def test_delete_limit(self):
 
126
        self.backend.create_message('a1', 'q', 'm', 'test')
 
127
        self.backend.create_message('a2', 'q', 'm', 'test')
 
128
        self.backend.create_message('a3', 'q', 'm', 'test')
 
129
        accounts = list(self.backend.get_accounts())
 
130
        self.assertEquals(3, len(accounts))
 
131
        filters = dict(detail='id', limit=1)
 
132
        accounts2 = list(self.backend.delete_accounts(filters))
 
133
        self.assertEquals(accounts[:1], accounts2)
 
134
        filters = dict(detail='id', limit=2)
 
135
        accounts2 = list(self.backend.delete_accounts(filters))
 
136
        self.assertEquals(accounts[1:3], accounts2)
 
137
 
 
138
    def test_delete_marker_limit(self):
 
139
        self.backend.create_message('a1', 'q', 'm', 'test')
 
140
        self.backend.create_message('a2', 'q', 'm', 'test')
 
141
        self.backend.create_message('a3', 'q', 'm', 'test')
 
142
        accounts = list(self.backend.get_accounts())
 
143
        self.assertEquals(3, len(accounts))
 
144
        filters = dict(detail='id', marker=accounts[1], limit=1)
 
145
        accounts2 = list(self.backend.delete_accounts(filters))
 
146
        self.assertEquals(accounts[2:3], accounts2)
 
147
        filters = dict(detail='id', marker=accounts[0], limit=2)
 
148
        accounts2 = list(self.backend.delete_accounts(filters))
 
149
        self.assertEquals(accounts[1:2], accounts2)
 
150
        self.assertEquals([], list(self.backend.delete_accounts()))
 
151
 
 
152
    def test_get_detail_all(self):
 
153
        self.backend.create_message('a', 'q', 'm', 'test')
 
154
        filters = dict(detail='all')
 
155
        accounts = list(self.backend.get_accounts(filters))
 
156
        self.assertEquals([dict(id='a')], accounts)
 
157
        self.assertEquals([], list(self.backend.delete_accounts()))
 
158
 
 
159
    def test_get_detail_id(self):
 
160
        self.backend.create_message('a', 'q', 'm', 'test')
 
161
        filters = dict(detail='id')
 
162
        accounts = list(self.backend.get_accounts(filters))
 
163
        self.assertEquals(['a'], accounts)
 
164
        self.assertEquals([], list(self.backend.delete_accounts()))
 
165
 
 
166
    def test_get_detail_none(self):
 
167
        self.backend.create_message('a', 'q', 'm', 'test')
 
168
        filters = dict(detail='none')
 
169
        accounts = list(self.backend.get_accounts(filters))
 
170
        self.assertEquals([], accounts)
 
171
        self.assertEquals([], list(self.backend.delete_accounts()))
 
172
 
 
173
    def test_get_detail_bad(self):
 
174
        self.backend.create_message('a', 'q', 'm', 'test')
 
175
        filters = dict(detail='bad')
 
176
        accounts = self.backend.get_accounts(filters)
 
177
        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
 
178
        self.assertEquals([], list(self.backend.delete_accounts()))
 
179
 
 
180
    def test_get_marker(self):
 
181
        self.backend.create_message('a1', 'q', 'm', 'test')
 
182
        self.backend.create_message('a2', 'q', 'm', 'test')
 
183
        self.backend.create_message('a3', 'q', 'm', 'test')
 
184
        accounts = list(self.backend.get_accounts())
 
185
        self.assertEquals(3, len(accounts))
 
186
        filters = dict(marker=accounts[0])
 
187
        accounts2 = list(self.backend.get_accounts(filters))
 
188
        self.assertEquals(accounts[1:], accounts2)
 
189
        filters = dict(marker=accounts[1])
 
190
        accounts2 = list(self.backend.get_accounts(filters))
 
191
        self.assertEquals(accounts[2:], accounts2)
 
192
        filters = dict(marker=accounts[2])
 
193
        accounts2 = self.backend.get_accounts(filters)
 
194
        self.assertRaises(burrow.backend.NotFound, list, accounts2)
 
195
        filters = dict(marker='unknown')
 
196
        accounts2 = list(self.backend.get_accounts(filters))
 
197
        self.assertEquals(accounts, accounts2)
 
198
        self.assertEquals([], list(self.backend.delete_accounts()))
 
199
 
 
200
    def test_get_limit(self):
 
201
        self.backend.create_message('a1', 'q', 'm', 'test')
 
202
        self.backend.create_message('a2', 'q', 'm', 'test')
 
203
        self.backend.create_message('a3', 'q', 'm', 'test')
 
204
        accounts = list(self.backend.get_accounts())
 
205
        self.assertEquals(3, len(accounts))
 
206
        filters = dict(limit=1)
 
207
        accounts2 = list(self.backend.get_accounts(filters))
 
208
        self.assertEquals(accounts[:1], accounts2)
 
209
        filters = dict(limit=2)
 
210
        accounts2 = list(self.backend.get_accounts(filters))
 
211
        self.assertEquals(accounts[:2], accounts2)
 
212
        filters = dict(limit=3)
 
213
        accounts2 = list(self.backend.get_accounts(filters))
 
214
        self.assertEquals(accounts, accounts2)
 
215
        filters = dict(limit=100)
 
216
        accounts2 = list(self.backend.get_accounts(filters))
 
217
        self.assertEquals(accounts, accounts2)
 
218
        self.assertEquals([], list(self.backend.delete_accounts()))
 
219
 
 
220
    def test_get_marker_limit(self):
 
221
        self.backend.create_message('a1', 'q', 'm', 'test')
 
222
        self.backend.create_message('a2', 'q', 'm', 'test')
 
223
        self.backend.create_message('a3', 'q', 'm', 'test')
 
224
        accounts = list(self.backend.get_accounts())
 
225
        self.assertEquals(3, len(accounts))
 
226
        filters = dict(marker=accounts[1], limit=1)
 
227
        accounts2 = list(self.backend.get_accounts(filters))
 
228
        self.assertEquals(accounts[2:3], accounts2)
 
229
        filters = dict(marker=accounts[0], limit=2)
 
230
        accounts2 = list(self.backend.get_accounts(filters))
 
231
        self.assertEquals(accounts[1:3], accounts2)
 
232
        self.assertEquals([], list(self.backend.delete_accounts()))
 
233
 
 
234
 
 
235
class TestQueues(Base):
 
236
    '''Test case for queues.'''
 
237
 
 
238
    def test_basic(self):
 
239
        self.backend.create_message('a', 'q', 'm', 'test')
 
240
        self.assertEquals(['q'], list(self.backend.get_queues('a')))
 
241
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
242
        queues = self.backend.delete_queues('a')
 
243
        self.assertRaises(burrow.backend.NotFound, list, queues)
 
244
 
 
245
    def test_large(self):
 
246
        for name in xrange(0, 1000):
 
247
            name = str(name)
 
248
            self.backend.create_message('a', name, name, name)
 
249
        filters = dict(marker='unknown')
 
250
        self.assertEquals([], list(self.backend.delete_queues('a', filters)))
 
251
 
 
252
    def test_delete_detail_all(self):
 
253
        self.backend.create_message('a', 'q', 'm', 'test')
 
254
        filters = dict(detail='all')
 
255
        queues = list(self.backend.delete_queues('a', filters))
 
256
        self.assertEquals([dict(id='q')], queues)
 
257
 
 
258
    def test_delete_detail_id(self):
 
259
        self.backend.create_message('a', 'q', 'm', 'test')
 
260
        filters = dict(detail='id')
 
261
        queues = list(self.backend.delete_queues('a', filters))
 
262
        self.assertEquals(['q'], queues)
 
263
 
 
264
    def test_delete_detail_none(self):
 
265
        self.backend.create_message('a', 'q', 'm', 'test')
 
266
        filters = dict(detail='none')
 
267
        queues = list(self.backend.delete_queues('a', filters))
 
268
        self.assertEquals([], queues)
 
269
 
 
270
    def test_delete_detail_bad(self):
 
271
        self.backend.create_message('a', 'q', 'm', 'test')
 
272
        filters = dict(detail='bad')
 
273
        queues = self.backend.delete_queues('a', filters)
 
274
        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
 
275
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
276
 
 
277
    def test_delete_marker(self):
 
278
        self.backend.create_message('a', 'q1', 'm', 'test')
 
279
        self.backend.create_message('a', 'q2', 'm', 'test')
 
280
        self.backend.create_message('a', 'q3', 'm', 'test')
 
281
        queues = list(self.backend.get_queues('a'))
 
282
        self.assertEquals(3, len(queues))
 
283
        filters = dict(detail='id', marker=queues[0])
 
284
        queues2 = list(self.backend.delete_queues('a', filters))
 
285
        self.assertEquals(queues[1:], queues2)
 
286
        queues2 = list(self.backend.get_queues('a'))
 
287
        self.assertEquals(queues[:1], queues2)
 
288
        filters = dict(detail='id', marker='unknown')
 
289
        queues2 = list(self.backend.delete_queues('a', filters))
 
290
        self.assertEquals(queues[:1], queues2)
 
291
 
 
292
    def test_delete_limit(self):
 
293
        self.backend.create_message('a', 'q1', 'm', 'test')
 
294
        self.backend.create_message('a', 'q2', 'm', 'test')
 
295
        self.backend.create_message('a', 'q3', 'm', 'test')
 
296
        queues = list(self.backend.get_queues('a'))
 
297
        self.assertEquals(3, len(queues))
 
298
        filters = dict(detail='id', limit=1)
 
299
        queues2 = list(self.backend.delete_queues('a', filters))
 
300
        self.assertEquals(queues[:1], queues2)
 
301
        filters = dict(detail='id', limit=2)
 
302
        queues2 = list(self.backend.delete_queues('a', filters))
 
303
        self.assertEquals(queues[1:3], queues2)
 
304
 
 
305
    def test_delete_marker_limit(self):
 
306
        self.backend.create_message('a', 'q1', 'm', 'test')
 
307
        self.backend.create_message('a', 'q2', 'm', 'test')
 
308
        self.backend.create_message('a', 'q3', 'm', 'test')
 
309
        queues = list(self.backend.get_queues('a'))
 
310
        self.assertEquals(3, len(queues))
 
311
        filters = dict(detail='id', marker=queues[1], limit=1)
 
312
        queues2 = list(self.backend.delete_queues('a', filters))
 
313
        self.assertEquals(queues[2:3], queues2)
 
314
        filters = dict(detail='id', marker=queues[0], limit=2)
 
315
        queues2 = list(self.backend.delete_queues('a', filters))
 
316
        self.assertEquals(queues[1:2], queues2)
 
317
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
318
 
 
319
    def test_get_detail_all(self):
 
320
        self.backend.create_message('a', 'q', 'm', 'test')
 
321
        filters = dict(detail='all')
 
322
        queues = list(self.backend.get_queues('a', filters))
 
323
        self.assertEquals([dict(id='q')], queues)
 
324
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
325
 
 
326
    def test_get_detail_id(self):
 
327
        self.backend.create_message('a', 'q', 'm', 'test')
 
328
        filters = dict(detail='id')
 
329
        queues = list(self.backend.get_queues('a', filters))
 
330
        self.assertEquals(['q'], queues)
 
331
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
332
 
 
333
    def test_get_detail_none(self):
 
334
        self.backend.create_message('a', 'q', 'm', 'test')
 
335
        filters = dict(detail='none')
 
336
        queues = list(self.backend.get_queues('a', filters))
 
337
        self.assertEquals([], queues)
 
338
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
339
 
 
340
    def test_get_detail_bad(self):
 
341
        self.backend.create_message('a', 'q', 'm', 'test')
 
342
        filters = dict(detail='bad')
 
343
        queues = self.backend.get_queues('a', filters)
 
344
        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
 
345
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
346
 
 
347
    def test_get_marker(self):
 
348
        self.backend.create_message('a', 'q1', 'm', 'test')
 
349
        self.backend.create_message('a', 'q2', 'm', 'test')
 
350
        self.backend.create_message('a', 'q3', 'm', 'test')
 
351
        queues = list(self.backend.get_queues('a'))
 
352
        self.assertEquals(3, len(queues))
 
353
        filters = dict(marker=queues[0])
 
354
        queues2 = list(self.backend.get_queues('a', filters))
 
355
        self.assertEquals(queues[1:], queues2)
 
356
        filters = dict(marker=queues[1])
 
357
        queues2 = list(self.backend.get_queues('a', filters))
 
358
        self.assertEquals(queues[2:], queues2)
 
359
        filters = dict(marker=queues[2])
 
360
        queues2 = self.backend.get_queues('a', filters)
 
361
        self.assertRaises(burrow.backend.NotFound, list, queues2)
 
362
        filters = dict(marker='unknown')
 
363
        queues2 = list(self.backend.get_queues('a', filters))
 
364
        self.assertEquals(queues, queues2)
 
365
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
366
 
 
367
    def test_get_limit(self):
 
368
        self.backend.create_message('a', 'q1', 'm', 'test')
 
369
        self.backend.create_message('a', 'q2', 'm', 'test')
 
370
        self.backend.create_message('a', 'q3', 'm', 'test')
 
371
        queues = list(self.backend.get_queues('a'))
 
372
        self.assertEquals(3, len(queues))
 
373
        filters = dict(limit=1)
 
374
        queues2 = list(self.backend.get_queues('a', filters))
 
375
        self.assertEquals(queues[:1], queues2)
 
376
        filters = dict(limit=2)
 
377
        queues2 = list(self.backend.get_queues('a', filters))
 
378
        self.assertEquals(queues[:2], queues2)
 
379
        filters = dict(limit=3)
 
380
        queues2 = list(self.backend.get_queues('a', filters))
 
381
        self.assertEquals(queues, queues2)
 
382
        filters = dict(limit=100)
 
383
        queues2 = list(self.backend.get_queues('a', filters))
 
384
        self.assertEquals(queues, queues2)
 
385
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
386
 
 
387
    def test_get_marker_limit(self):
 
388
        self.backend.create_message('a', 'q1', 'm', 'test')
 
389
        self.backend.create_message('a', 'q2', 'm', 'test')
 
390
        self.backend.create_message('a', 'q3', 'm', 'test')
 
391
        queues = list(self.backend.get_queues('a'))
 
392
        self.assertEquals(3, len(queues))
 
393
        filters = dict(marker=queues[1], limit=1)
 
394
        queues2 = list(self.backend.get_queues('a', filters))
 
395
        self.assertEquals(queues[2:3], queues2)
 
396
        filters = dict(marker=queues[0], limit=2)
 
397
        queues2 = list(self.backend.get_queues('a', filters))
 
398
        self.assertEquals(queues[1:3], queues2)
 
399
        self.assertEquals([], list(self.backend.delete_queues('a')))
 
400
 
 
401
 
 
402
class TestMessages(Base):
 
403
    '''Test case for messages.'''
 
404
 
 
405
    def test_basic(self):
 
406
        self.backend.create_message('a', 'q', 'm', 'test')
 
407
        message = dict(id='m', ttl=0, hide=0, body='test')
 
408
        messages = list(self.backend.get_messages('a', 'q'))
 
409
        self.assertEquals([message], messages)
 
410
        attributes = dict(ttl=100, hide=200)
 
411
        messages = list(self.backend.update_messages('a', 'q', attributes))
 
412
        self.assertEquals([], messages)
 
413
        attributes = dict(ttl=0, hide=0)
 
414
        filters = dict(match_hidden=True)
 
415
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
416
        self.assertEquals([], list(messages))
 
417
        messages = self.backend.update_messages('a', 'q', dict(), filters)
 
418
        self.assertEquals([], list(messages))
 
419
        self.delete_messages()
 
420
        messages = self.backend.delete_messages('a', 'q')
 
421
        self.assertRaises(burrow.backend.NotFound, list, messages)
 
422
        messages = self.backend.update_messages('a', 'q', attributes)
 
423
        self.assertRaises(burrow.backend.NotFound, list, messages)
 
424
 
 
425
    def test_large(self):
 
426
        for name in xrange(0, 1000):
 
427
            name = str(name)
 
428
            self.backend.create_message('a', 'q', name, name)
 
429
        attributes = dict(ttl=100, hide=200)
 
430
        messages = self.backend.update_messages('a', 'q', attributes)
 
431
        self.assertEquals([], list(messages))
 
432
        self.delete_messages()
 
433
 
 
434
    def test_delete_detail_all(self):
 
435
        self.backend.create_message('a', 'q', 'm', 'test')
 
436
        message = dict(id='m', ttl=0, hide=0, body='test')
 
437
        filters = dict(detail='all')
 
438
        messages = list(self.backend.delete_messages('a', 'q', filters))
 
439
        self.assertEquals([message], messages)
 
440
 
 
441
    def test_delete_detail_attributes(self):
 
442
        self.backend.create_message('a', 'q', 'm', 'test')
 
443
        message = dict(id='m', ttl=0, hide=0)
 
444
        filters = dict(detail='attributes')
 
445
        messages = list(self.backend.delete_messages('a', 'q', filters))
 
446
        self.assertEquals([message], messages)
 
447
 
 
448
    def test_delete_detail_body(self):
 
449
        self.backend.create_message('a', 'q', 'm', 'test')
 
450
        filters = dict(detail='body')
 
451
        messages = list(self.backend.delete_messages('a', 'q', filters))
 
452
        self.assertEquals(['test'], messages)
 
453
 
 
454
    def test_delete_detail_id(self):
 
455
        self.backend.create_message('a', 'q', 'm', 'test')
 
456
        filters = dict(detail='id')
 
457
        messages = list(self.backend.delete_messages('a', 'q', filters))
 
458
        self.assertEquals(['m'], messages)
 
459
 
 
460
    def test_delete_detail_none(self):
 
461
        self.backend.create_message('a', 'q', 'm', 'test')
 
462
        filters = dict(detail='none')
 
463
        messages = list(self.backend.delete_messages('a', 'q', filters))
 
464
        self.assertEquals([], messages)
 
465
 
 
466
    def test_delete_detail_bad(self):
 
467
        self.backend.create_message('a', 'q', 'm', 'test')
 
468
        filters = dict(detail='bad')
 
469
        messages = self.backend.delete_messages('a', 'q', filters)
 
470
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
 
471
        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
 
472
 
 
473
    def test_delete_marker(self):
 
474
        self.backend.create_message('a', 'q', 'm1', 'test')
 
475
        self.backend.create_message('a', 'q', 'm2', 'test')
 
476
        self.backend.create_message('a', 'q', 'm3', 'test')
 
477
        messages = list(self.backend.get_messages('a', 'q'))
 
478
        self.assertEquals(3, len(messages))
 
479
        filters = dict(detail='all', marker=messages[0]['id'])
 
480
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
 
481
        self.assertEquals(messages[1:], messages2)
 
482
        messages2 = list(self.backend.get_messages('a', 'q'))
 
483
        self.assertEquals(messages[:1], messages2)
 
484
        filters = dict(detail='all', marker='unknown')
 
485
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
 
486
        self.assertEquals(messages[:1], messages2)
 
487
 
 
488
    def test_delete_limit(self):
 
489
        self.backend.create_message('a', 'q', 'm1', 'test')
 
490
        self.backend.create_message('a', 'q', 'm2', 'test')
 
491
        self.backend.create_message('a', 'q', 'm3', 'test')
 
492
        messages = list(self.backend.get_messages('a', 'q'))
 
493
        self.assertEquals(3, len(messages))
 
494
        filters = dict(detail='all', limit=1)
 
495
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
 
496
        self.assertEquals(messages[:1], messages2)
 
497
        filters = dict(detail='all', limit=2)
 
498
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
 
499
        self.assertEquals(messages[1:3], messages2)
 
500
 
 
501
    def test_delete_marker_limit(self):
 
502
        self.backend.create_message('a', 'q', 'm1', 'test')
 
503
        self.backend.create_message('a', 'q', 'm2', 'test')
 
504
        self.backend.create_message('a', 'q', 'm3', 'test')
 
505
        messages = list(self.backend.get_messages('a', 'q'))
 
506
        self.assertEquals(3, len(messages))
 
507
        filters = dict(detail='all', marker=messages[1]['id'], limit=1)
 
508
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
 
509
        self.assertEquals(messages[2:3], messages2)
 
510
        filters = dict(detail='all', marker=messages[0]['id'], limit=2)
 
511
        messages2 = list(self.backend.delete_messages('a', 'q', filters))
 
512
        self.assertEquals(messages[1:2], messages2)
 
513
        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
 
514
 
 
515
    def test_get_detail_all(self):
 
516
        self.backend.create_message('a', 'q', 'm', 'test')
 
517
        message = dict(id='m', ttl=0, hide=0, body='test')
 
518
        filters = dict(detail='all')
 
519
        messages = list(self.backend.get_messages('a', 'q', filters))
 
520
        self.assertEquals([message], messages)
 
521
        self.delete_messages()
 
522
 
 
523
    def test_get_detail_attributes(self):
 
524
        self.backend.create_message('a', 'q', 'm', 'test')
 
525
        message = dict(id='m', ttl=0, hide=0)
 
526
        filters = dict(detail='attributes')
 
527
        messages = list(self.backend.get_messages('a', 'q', filters))
 
528
        self.assertEquals([message], messages)
 
529
        self.delete_messages()
 
530
 
 
531
    def test_get_detail_body(self):
 
532
        self.backend.create_message('a', 'q', 'm', 'test')
 
533
        filters = dict(detail='body')
 
534
        messages = list(self.backend.get_messages('a', 'q', filters))
 
535
        self.assertEquals(['test'], messages)
 
536
        self.delete_messages()
 
537
 
 
538
    def test_get_detail_id(self):
 
539
        self.backend.create_message('a', 'q', 'm', 'test')
 
540
        filters = dict(detail='id')
 
541
        messages = list(self.backend.get_messages('a', 'q', filters))
 
542
        self.assertEquals(['m'], messages)
 
543
        self.delete_messages()
 
544
 
 
545
    def test_get_detail_none(self):
 
546
        self.backend.create_message('a', 'q', 'm', 'test')
 
547
        filters = dict(detail='none')
 
548
        messages = list(self.backend.get_messages('a', 'q', filters))
 
549
        self.assertEquals([], messages)
 
550
        self.delete_messages()
 
551
 
 
552
    def test_get_detail_bad(self):
 
553
        self.backend.create_message('a', 'q', 'm', 'test')
 
554
        filters = dict(detail='bad')
 
555
        messages = self.backend.get_messages('a', 'q', filters)
 
556
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
 
557
        self.delete_messages()
 
558
 
 
559
    def test_get_marker(self):
 
560
        self.backend.create_message('a', 'q', 'm1', 'test')
 
561
        self.backend.create_message('a', 'q', 'm2', 'test')
 
562
        self.backend.create_message('a', 'q', 'm3', 'test')
 
563
        messages = list(self.backend.get_messages('a', 'q'))
 
564
        self.assertEquals(3, len(messages))
 
565
        filters = dict(marker=messages[0]['id'])
 
566
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
567
        self.assertEquals(messages[1:], messages2)
 
568
        filters = dict(marker=messages[1]['id'])
 
569
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
570
        self.assertEquals(messages[2:], messages2)
 
571
        filters = dict(marker=messages[2]['id'])
 
572
        messages2 = self.backend.get_messages('a', 'q', filters)
 
573
        self.assertRaises(burrow.backend.NotFound, list, messages2)
 
574
        filters = dict(marker='unknown')
 
575
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
576
        self.assertEquals(messages, messages2)
 
577
        self.delete_messages()
 
578
 
 
579
    def test_get_limit(self):
 
580
        self.backend.create_message('a', 'q', 'm1', 'test')
 
581
        self.backend.create_message('a', 'q', 'm2', 'test')
 
582
        self.backend.create_message('a', 'q', 'm3', 'test')
 
583
        messages = list(self.backend.get_messages('a', 'q'))
 
584
        self.assertEquals(3, len(messages))
 
585
        filters = dict(limit=1)
 
586
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
587
        self.assertEquals(messages[:1], messages2)
 
588
        filters = dict(limit=2)
 
589
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
590
        self.assertEquals(messages[:2], messages2)
 
591
        filters = dict(limit=3)
 
592
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
593
        self.assertEquals(messages, messages2)
 
594
        filters = dict(limit=100)
 
595
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
596
        self.assertEquals(messages, messages2)
 
597
        self.delete_messages()
 
598
 
 
599
    def test_get_marker_limit(self):
 
600
        self.backend.create_message('a', 'q', 'm1', 'test')
 
601
        self.backend.create_message('a', 'q', 'm2', 'test')
 
602
        self.backend.create_message('a', 'q', 'm3', 'test')
 
603
        messages = list(self.backend.get_messages('a', 'q'))
 
604
        self.assertEquals(3, len(messages))
 
605
        filters = dict(marker=messages[1]['id'], limit=1)
 
606
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
607
        self.assertEquals(messages[2:3], messages2)
 
608
        filters = dict(marker=messages[0]['id'], limit=2)
 
609
        messages2 = list(self.backend.get_messages('a', 'q', filters))
 
610
        self.assertEquals(messages[1:3], messages2)
 
611
        self.delete_messages()
 
612
 
 
613
    def test_update_detail_all(self):
 
614
        self.backend.create_message('a', 'q', 'm', 'test')
 
615
        message = dict(id='m', ttl=100, hide=200, body='test')
 
616
        attributes = dict(ttl=100, hide=200)
 
617
        filters = dict(detail='all')
 
618
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
619
        self.assertEquals([message], list(messages))
 
620
        self.delete_messages()
 
621
 
 
622
    def test_update_detail_attributes(self):
 
623
        self.backend.create_message('a', 'q', 'm', 'test')
 
624
        message = dict(id='m', ttl=100, hide=200)
 
625
        attributes = dict(ttl=100, hide=200)
 
626
        filters = dict(detail='attributes')
 
627
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
628
        self.assertEquals([message], list(messages))
 
629
        self.delete_messages()
 
630
 
 
631
    def test_update_detail_body(self):
 
632
        self.backend.create_message('a', 'q', 'm', 'test')
 
633
        attributes = dict(ttl=100, hide=200)
 
634
        filters = dict(detail='body')
 
635
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
636
        self.assertEquals(['test'], list(messages))
 
637
        self.delete_messages()
 
638
 
 
639
    def test_update_detail_id(self):
 
640
        self.backend.create_message('a', 'q', 'm', 'test')
 
641
        attributes = dict(ttl=100, hide=200)
 
642
        filters = dict(detail='id')
 
643
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
644
        self.assertEquals(['m'], list(messages))
 
645
        self.delete_messages()
 
646
 
 
647
    def test_update_detail_none(self):
 
648
        self.backend.create_message('a', 'q', 'm', 'test')
 
649
        attributes = dict(ttl=100, hide=200)
 
650
        filters = dict(detail='none')
 
651
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
652
        self.assertEquals([], list(messages))
 
653
        self.delete_messages()
 
654
 
 
655
    def test_update_detail_bad(self):
 
656
        self.backend.create_message('a', 'q', 'm', 'test')
 
657
        attributes = dict(ttl=100, hide=200)
 
658
        filters = dict(detail='bad')
 
659
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
660
        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
 
661
        self.delete_messages()
 
662
 
 
663
    def test_update_marker(self):
 
664
        self.backend.create_message('a', 'q', 'm1', 'test')
 
665
        self.backend.create_message('a', 'q', 'm2', 'test')
 
666
        self.backend.create_message('a', 'q', 'm3', 'test')
 
667
        attributes = dict(ttl=100, hide=200)
 
668
        filters = dict(detail='all', match_hidden=True)
 
669
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
670
        messages = list(messages)
 
671
        self.assertEquals(3, len(messages))
 
672
        filters.update(marker=messages[0]['id'])
 
673
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
674
        self.assertEquals(messages[1:], list(messages2))
 
675
        filters.update(marker=messages[1]['id'])
 
676
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
677
        self.assertEquals(messages[2:], list(messages2))
 
678
        filters.update(marker=messages[2]['id'])
 
679
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
680
        self.assertRaises(burrow.backend.NotFound, list, messages2)
 
681
        filters = dict(detail='all', marker='unknown', match_hidden=True)
 
682
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
683
        self.assertEquals(messages, list(messages2))
 
684
        self.delete_messages()
 
685
 
 
686
    def test_update_limit(self):
 
687
        self.backend.create_message('a', 'q', 'm1', 'test')
 
688
        self.backend.create_message('a', 'q', 'm2', 'test')
 
689
        self.backend.create_message('a', 'q', 'm3', 'test')
 
690
        attributes = dict(ttl=100, hide=200)
 
691
        filters = dict(detail='all', match_hidden=True)
 
692
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
693
        messages = list(messages)
 
694
        self.assertEquals(3, len(messages))
 
695
        filters.update(limit=1)
 
696
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
697
        self.assertEquals(messages[:1], list(messages2))
 
698
        filters.update(limit=2)
 
699
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
700
        self.assertEquals(messages[:2], list(messages2))
 
701
        filters.update(limit=3)
 
702
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
703
        self.assertEquals(messages, list(messages2))
 
704
        filters.update(limit=100)
 
705
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
706
        self.assertEquals(messages, list(messages2))
 
707
        self.delete_messages()
 
708
 
 
709
    def test_update_marker_limit(self):
 
710
        self.backend.create_message('a', 'q', 'm1', 'test')
 
711
        self.backend.create_message('a', 'q', 'm2', 'test')
 
712
        self.backend.create_message('a', 'q', 'm3', 'test')
 
713
        attributes = dict(ttl=100, hide=200)
 
714
        filters = dict(detail='all', match_hidden=True)
 
715
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
716
        messages = list(messages)
 
717
        self.assertEquals(3, len(messages))
 
718
        filters.update(marker=messages[1]['id'], limit=1)
 
719
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
720
        self.assertEquals(messages[2:3], list(messages2))
 
721
        filters.update(marker=messages[0]['id'], limit=2)
 
722
        messages2 = self.backend.update_messages('a', 'q', attributes, filters)
 
723
        self.assertEquals(messages[1:3], list(messages2))
 
724
        self.delete_messages()
 
725
 
 
726
    def test_update_wait(self):
 
727
        attributes = dict(hide=100)
 
728
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
 
729
        self.success = False
 
730
        thread = eventlet.spawn(self.get_messages)
 
731
        attributes = dict(hide=0)
 
732
        filters = dict(match_hidden=True)
 
733
        messages = self.backend.update_messages('a', 'q', attributes, filters)
 
734
        eventlet.spawn_after(0.2, list, messages)
 
735
        thread.wait()
 
736
        self.assertTrue(self.success)
 
737
        self.delete_messages()
 
738
 
 
739
 
 
740
class TestMessage(Base):
 
741
    '''Test case for message.'''
 
742
 
 
743
    def test_basic(self):
 
744
        self.backend.create_message('a', 'q', 'm', 'test')
 
745
        message = self.backend.get_message('a', 'q', 'm')
 
746
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
 
747
        attributes = dict(ttl=100, hide=200)
 
748
        message = self.backend.update_message('a', 'q', 'm', attributes)
 
749
        attributes = dict(ttl=0, hide=0)
 
750
        message = self.backend.update_message('a', 'q', 'm', attributes)
 
751
        self.assertEquals(None, message)
 
752
        message = self.backend.update_message('a', 'q', 'm', dict())
 
753
        self.assertEquals(None, message)
 
754
        message = self.backend.delete_message('a', 'q', 'm')
 
755
        self.assertEquals(None, message)
 
756
 
 
757
    def test_create(self):
 
758
        created = self.backend.create_message('a', 'q', 'm', 'test1')
 
759
        self.assertEquals(created, True)
 
760
        message = self.backend.get_message('a', 'q', 'm')
 
761
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test1'), message)
 
762
        attributes = dict(ttl=100, hide=200)
 
763
        created = self.backend.create_message('a', 'q', 'm', 'test2',
 
764
            attributes)
 
765
        self.assertEquals(created, False)
 
766
        message = self.backend.get_message('a', 'q', 'm')
 
767
        self.assertEquals(dict(id='m', ttl=100, hide=200, body='test2'),
 
768
            message)
 
769
        attributes = dict(ttl=0, hide=0)
 
770
        created = self.backend.create_message('a', 'q', 'm', 'test3',
 
771
            attributes)
 
772
        self.assertEquals(created, False)
 
773
        message = self.backend.get_message('a', 'q', 'm')
 
774
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test3'), message)
 
775
        self.delete_messages()
 
776
 
 
777
    def test_delete_detail_all(self):
 
778
        self.backend.create_message('a', 'q', 'm', 'test')
 
779
        filters = dict(detail='all')
 
780
        message = self.backend.delete_message('a', 'q', 'm', filters)
 
781
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
 
782
 
 
783
    def test_delete_detail_attributes(self):
 
784
        self.backend.create_message('a', 'q', 'm', 'test')
 
785
        filters = dict(detail='attributes')
 
786
        message = self.backend.delete_message('a', 'q', 'm', filters)
 
787
        self.assertEquals(dict(id='m', ttl=0, hide=0), message)
 
788
 
 
789
    def test_delete_detail_body(self):
 
790
        self.backend.create_message('a', 'q', 'm', 'test')
 
791
        filters = dict(detail='body')
 
792
        message = self.backend.delete_message('a', 'q', 'm', filters)
 
793
        self.assertEquals('test', message)
 
794
 
 
795
    def test_delete_detail_id(self):
 
796
        self.backend.create_message('a', 'q', 'm', 'test')
 
797
        filters = dict(detail='id')
 
798
        message = self.backend.delete_message('a', 'q', 'm', filters)
 
799
        self.assertEquals('m', message)
 
800
 
 
801
    def test_delete_detail_none(self):
 
802
        self.backend.create_message('a', 'q', 'm', 'test')
 
803
        filters = dict(detail='none')
 
804
        message = self.backend.delete_message('a', 'q', 'm', filters)
 
805
        self.assertEquals(None, message)
 
806
 
 
807
    def test_delete_detail_bad(self):
 
808
        self.backend.create_message('a', 'q', 'm', 'test')
 
809
        filters = dict(detail='bad')
 
810
        self.assertRaises(burrow.backend.InvalidArguments,
 
811
            self.backend.delete_message, 'a', 'q', 'm', filters)
 
812
        self.delete_messages()
 
813
 
 
814
    def test_get_detail_all(self):
 
815
        self.backend.create_message('a', 'q', 'm', 'test')
 
816
        filters = dict(detail='all')
 
817
        message = self.backend.get_message('a', 'q', 'm', filters)
 
818
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
 
819
        self.delete_messages()
 
820
 
 
821
    def test_get_detail_attributes(self):
 
822
        self.backend.create_message('a', 'q', 'm', 'test')
 
823
        filters = dict(detail='attributes')
 
824
        message = self.backend.get_message('a', 'q', 'm', filters)
 
825
        self.assertEquals(dict(id='m', ttl=0, hide=0), message)
 
826
        self.delete_messages()
 
827
 
 
828
    def test_get_detail_body(self):
 
829
        self.backend.create_message('a', 'q', 'm', 'test')
 
830
        filters = dict(detail='body')
 
831
        message = self.backend.get_message('a', 'q', 'm', filters)
 
832
        self.assertEquals('test', message)
 
833
        self.delete_messages()
 
834
 
 
835
    def test_get_detail_id(self):
 
836
        self.backend.create_message('a', 'q', 'm', 'test')
 
837
        filters = dict(detail='id')
 
838
        message = self.backend.get_message('a', 'q', 'm', filters)
 
839
        self.assertEquals('m', message)
 
840
        self.delete_messages()
 
841
 
 
842
    def test_get_detail_none(self):
 
843
        self.backend.create_message('a', 'q', 'm', 'test')
 
844
        filters = dict(detail='none')
 
845
        message = self.backend.get_message('a', 'q', 'm', filters)
 
846
        self.assertEquals(None, message)
 
847
        self.delete_messages()
 
848
 
 
849
    def test_get_detail_bad(self):
 
850
        self.backend.create_message('a', 'q', 'm', 'test')
 
851
        filters = dict(detail='bad')
 
852
        self.assertRaises(burrow.backend.InvalidArguments,
 
853
            self.backend.get_message, 'a', 'q', 'm', filters)
 
854
        self.delete_messages()
 
855
 
 
856
    def test_update_detail_all(self):
 
857
        self.backend.create_message('a', 'q', 'm', 'test')
 
858
        attributes = dict(ttl=100, hide=200)
 
859
        filters = dict(detail='all')
 
860
        message = self.backend.update_message('a', 'q', 'm', attributes,
 
861
            filters)
 
862
        self.assertEquals(dict(id='m', ttl=100, hide=200, body='test'),
 
863
            message)
 
864
        self.delete_messages()
 
865
 
 
866
    def test_update_detail_attributes(self):
 
867
        self.backend.create_message('a', 'q', 'm', 'test')
 
868
        attributes = dict(ttl=100, hide=200)
 
869
        filters = dict(detail='attributes')
 
870
        message = self.backend.update_message('a', 'q', 'm', attributes,
 
871
            filters)
 
872
        self.assertEquals(dict(id='m', ttl=100, hide=200), message)
 
873
        self.delete_messages()
 
874
 
 
875
    def test_update_detail_body(self):
 
876
        self.backend.create_message('a', 'q', 'm', 'test')
 
877
        attributes = dict(ttl=100, hide=200)
 
878
        filters = dict(detail='body')
 
879
        message = self.backend.update_message('a', 'q', 'm', attributes,
 
880
            filters)
 
881
        self.assertEquals('test', message)
 
882
        self.delete_messages()
 
883
 
 
884
    def test_update_detail_id(self):
 
885
        self.backend.create_message('a', 'q', 'm', 'test')
 
886
        attributes = dict(ttl=100, hide=200)
 
887
        filters = dict(detail='id')
 
888
        message = self.backend.update_message('a', 'q', 'm', attributes,
 
889
            filters)
 
890
        self.assertEquals('m', message)
 
891
        self.delete_messages()
 
892
 
 
893
    def test_update_detail_none(self):
 
894
        self.backend.create_message('a', 'q', 'm', 'test')
 
895
        attributes = dict(ttl=100, hide=200)
 
896
        filters = dict(detail='none')
 
897
        message = self.backend.update_message('a', 'q', 'm', attributes,
 
898
            filters)
 
899
        self.assertEquals(None, message)
 
900
        self.delete_messages()
 
901
 
 
902
    def test_update_detail_bad(self):
 
903
        self.backend.create_message('a', 'q', 'm', 'test')
 
904
        attributes = dict(ttl=100, hide=200)
 
905
        filters = dict(detail='bad')
 
906
        self.assertRaises(burrow.backend.InvalidArguments,
 
907
            self.backend.update_message, 'a', 'q', 'm', attributes, filters)
 
908
        self.delete_messages()
 
909
 
 
910
    def test_ttl(self):
 
911
        attributes = dict(ttl=1)
 
912
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
 
913
        time.sleep(2)
 
914
        self.backend.clean()
 
915
 
 
916
    def test_ttl_large(self):
 
917
        attributes = dict(ttl=1)
 
918
        for name in xrange(0, 1000):
 
919
            name = str(name)
 
920
            self.backend.create_message('a', 'q', name, name, attributes)
 
921
        time.sleep(2)
 
922
        self.backend.clean()
 
923
 
 
924
    def test_hide(self):
 
925
        attributes = dict(hide=1)
 
926
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
 
927
        time.sleep(2)
 
928
        self.backend.clean()
 
929
        message = self.backend.get_message('a', 'q', 'm')
 
930
        self.assertEquals(dict(id='m', ttl=0, hide=0, body='test'), message)
 
931
        self.delete_messages()
 
932
 
 
933
    def test_hide_large(self):
 
934
        attributes = dict(hide=1)
 
935
        for name in xrange(0, 1000):
 
936
            name = str(name)
 
937
            self.backend.create_message('a', 'q', name, name, attributes)
 
938
        time.sleep(2)
 
939
        self.backend.clean()
 
940
        message = self.backend.get_message('a', 'q', '0')
 
941
        self.assertEquals(dict(id='0', ttl=0, hide=0, body='0'), message)
 
942
        self.delete_messages()
 
943
 
 
944
    def test_create_wait(self):
 
945
        self.success = False
 
946
        thread = eventlet.spawn(self.get_messages)
 
947
        eventlet.spawn_after(0.2,
 
948
            self.backend.create_message, 'a', 'q', 'm', 'test')
 
949
        thread.wait()
 
950
        self.assertTrue(self.success)
 
951
        self.delete_messages()
 
952
 
 
953
    def test_update_wait(self):
 
954
        attributes = dict(hide=100)
 
955
        self.backend.create_message('a', 'q', 'm', 'test', attributes)
 
956
        self.success = False
 
957
        thread = eventlet.spawn(self.get_messages)
 
958
        attributes = dict(hide=0)
 
959
        eventlet.spawn_after(0.2,
 
960
            self.backend.update_message, 'a', 'q', 'm', attributes)
 
961
        thread.wait()
 
962
        self.assertTrue(self.success)
 
963
        self.delete_messages()