Burrow

Merge lp:~eday/burrow/doc-updates into lp:burrow

  1. doc-updates
  2. Merge into trunk
Proposed by Eric Day
Status: Merged
Approved by: Eric Day
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
Reviewer Review Type Date Requested Status
Burrow Core Team Pending
Review via email: mp+71777@code.launchpad.net

Description of the change

Test case cleanup, moved backend base test cases to test.backend (out of memory test).

To post a comment you must log in.

Preview Diff

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

Subscribers

People subscribed via source and target branches