Merge lp:~eday/burrow/backend-unittests into lp:burrow

[Eric Day]

Added backend message tests, pushed message detail processing down to backend, added NotFound exception to backend to differentiate from empty lists, and cleaned up message storage in memory backend.

=== modified file 'burrow/backend/__init__.py'
--- burrow/backend/__init__.py	2011-07-15 00:15:56 +0000
+++ burrow/backend/__init__.py	2011-08-04 23:47:24 +0000
@@ -98,5 +98,9 @@
             eventlet.sleep(1)
 
 
+class NotFound(Exception):
+    pass
+
+
 class BadDetail(Exception):
     pass

=== modified file 'burrow/backend/memory.py'
--- burrow/backend/memory.py	2011-07-22 19:05:31 +0000
+++ burrow/backend/memory.py	2011-08-04 23:47:24 +0000
@@ -24,7 +24,7 @@
     structures. It uses a linked list of objects to store data
     (accounts, queues, and messages) with a dict as a secondary index
     into this list. This is required so we can have O(1) appends,
-    deletes, and lookups by name, along with easy traversal starting
+    deletes, and lookups by id, along with easy traversal starting
     anywhere in the list.'''
 
     def __init__(self, config):
@@ -32,195 +32,198 @@
         self.accounts = Accounts()
 
     def delete_accounts(self, filters={}):
-        return self.accounts.delete(filters)
+        if len(filters) == 0:
+            self.accounts.reset()
+            return
+        detail = self._get_detail(filters)
+        for account in self.accounts.iter(filters):
+            self.accounts.delete(account.id)
+            if detail is not None:
+                yield account.detail(detail)
 
     def get_accounts(self, filters={}):
-        return self.accounts.iter_detail(filters)
+        detail = self._get_detail(filters, 'id')
+        for account in self.accounts.iter(filters):
+            if detail is not None:
+                yield account.detail(detail)
 
     def delete_queues(self, account, filters={}):
-        return self.accounts.delete_queues(account, filters)
+        account = self.accounts.get(account)
+        if account is None:
+            raise burrow.backend.NotFound()
+        if len(filters) == 0:
+            account.queues.reset()
+        else:
+            detail = self._get_detail(filters)
+            for queue in account.queues.iter(filters):
+                account.queues.delete(queue.id)
+                if detail is not None:
+                    yield queue.detail(detail)
+        if account.queues.count() == 0:
+            self.accounts.delete(account.id)
 
     def get_queues(self, account, filters={}):
-        return self.accounts.get_queues(account, filters)
+        account = self.accounts.get(account)
+        if account is None:
+            raise burrow.backend.NotFound()
+        detail = self._get_detail(filters, 'id')
+        for queue in account.queues.iter(filters):
+            if detail is not None:
+                yield queue.detail(detail)
 
     def delete_messages(self, account, queue, filters={}):
-        return self._scan_queue(account, queue, filters, delete=True)
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            raise burrow.backend.NotFound()
+        if len(filters) == 0:
+            queue.messages.reset()
+        else:
+            detail = self._get_message_detail(filters)
+            for message in queue.messages.iter(filters):
+                queue.messages.delete(message.id)
+                if detail is not None:
+                    yield message.detail(detail)
+        if queue.messages.count() == 0:
+            self.accounts.delete_queue(account.id, queue.id)
 
     def get_messages(self, account, queue, filters={}):
-        return self._scan_queue(account, queue, filters)
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            raise burrow.backend.NotFound()
+        detail = self._get_message_detail(filters, 'all')
+        for message in queue.messages.iter(filters):
+            if detail is not None:
+                yield message.detail(detail)
 
     def update_messages(self, account, queue, attributes={}, filters={}):
-        return self._scan_queue(account, queue, filters, attributes)
+        account, queue = self.accounts.get_queue(account, queue)
+        if queue is None:
+            raise burrow.backend.NotFound()
+        notify = False
+        ttl, hide = self._get_attributes(attributes)
+        detail = self._get_message_detail(filters)
+        for message in queue.messages.iter(filters):
+            if ttl is not None:
+                message.ttl = ttl
+            if hide is not None:
+                message.hide = hide
+                if hide == 0:
+                    notify = True
+            if detail is not None:
+                yield message.detail(detail)
+        if notify:
+            self.notify(account.id, queue.id)
 
     def create_message(self, account, queue, message, body, attributes={}):
         account, queue = self.accounts.get_queue(account, queue, True)
-        ttl = attributes.get('ttl', 0)
-        if ttl > 0:
-            ttl += int(time.time())
-        hide = attributes.get('hide', 0)
-        if hide > 0:
-            hide += int(time.time())
-        for index in xrange(0, len(queue.messages)):
-            if queue.messages[index]['id'] == message:
-                message = queue.messages[index]
-                message['ttl'] = ttl
-                message['hide'] = hide
-                message['body'] = body
-                if hide == 0:
-                    self.notify(account.name, queue.name)
-                return False
-        message = dict(id=message, ttl=ttl, hide=hide, body=body)
-        queue.messages.append(message)
-        self.notify(account.name, queue.name)
-        return True
+        ttl, hide = self._get_attributes(attributes, default_ttl=0,
+            default_hide=0)
+        if queue.messages.get(message) is None:
+            created = True
+        else:
+            created = False
+        message = queue.messages.get(message, True)
+        message.ttl = ttl
+        message.hide = hide
+        message.body = body
+        if created or hide == 0:
+            self.notify(account.id, queue.id)
+        return created
 
     def delete_message(self, account, queue, message, filters={}):
         account, queue = self.accounts.get_queue(account, queue)
         if queue is None:
             return None
-        for index in xrange(0, len(queue.messages)):
-            if queue.messages[index]['id'] == message:
-                message = queue.messages[index]
-                del queue.messages[index]
-                if len(queue.messages) == 0:
-                    self.accounts.delete_queue(account.name, queue.name)
-                if message['ttl'] > 0:
-                    message['ttl'] -= int(time.time())
-                if message['hide'] > 0:
-                    message['hide'] -= int(time.time())
-                return message
-        return None
+        message = queue.messages.get(message)
+        if message is None:
+            return None
+        queue.messages.delete(message.id)
+        if queue.messages.count() == 0:
+            self.accounts.delete_queue(account.id, queue.id)
+        return message.detail()
 
     def get_message(self, account, queue, message, filters={}):
         account, queue = self.accounts.get_queue(account, queue)
         if queue is None:
             return None
-        for index in xrange(0, len(queue.messages)):
-            if queue.messages[index]['id'] == message:
-                ttl = queue.messages[index]['ttl']
-                if ttl > 0:
-                    ttl -= int(time.time())
-                hide = queue.messages[index]['hide']
-                if hide > 0:
-                    hide -= int(time.time())
-                return dict(id=message, ttl=ttl, hide=hide,
-                    body=queue.messages[index]['body'])
-        return None
+        message = queue.messages.get(message)
+        if message is None:
+            return None
+        return message.detail()
 
     def update_message(self, account, queue, message, attributes={},
         filters={}):
         account, queue = self.accounts.get_queue(account, queue)
         if queue is None:
             return None
-        ttl = attributes.get('ttl', None)
-        if ttl is not None and ttl > 0:
-            ttl += int(time.time())
-        hide = attributes.get('hide', None)
-        if hide is not None and hide > 0:
-            hide += int(time.time())
-        for index in xrange(0, len(queue.messages)):
-            if queue.messages[index]['id'] == message:
-                message = queue.messages[index]
-                if ttl is not None:
-                    message['ttl'] = ttl
-                if hide is not None:
-                    message['hide'] = hide
-                    if hide == 0:
-                        self.notify(account.name, queue.name)
-                return message
-        return None
+        ttl, hide = self._get_attributes(attributes)
+        message = queue.messages.get(message)
+        if message is None:
+            return None
+        if ttl is not None:
+            message.ttl = ttl
+        if hide is not None:
+            message.hide = hide
+            if hide == 0:
+                self.notify(account.id, queue.id)
+        return message.detail()
 
     def clean(self):
         now = int(time.time())
         for account in self.accounts.iter():
             for queue in account.queues.iter():
-                index = 0
                 notify = False
-                total = len(queue.messages)
-                while index < total:
-                    message = queue.messages[index]
-                    if 0 < message['ttl'] <= now:
-                        del queue.messages[index]
-                        total -= 1
-                    else:
-                        if 0 < message['hide'] <= now:
-                            message['hide'] = 0
-                            notify = True
-                        index += 1
+                for message in queue.messages.iter(dict(match_hidden=True)):
+                    if 0 < message.ttl <= now:
+                        queue.messages.delete(message.id)
+                    elif 0 < message.hide <= now:
+                        message.hide = 0
+                        notify = True
                 if notify:
-                    self.notify(account.name, queue.name)
-                if len(queue.messages) == 0:
-                    self.accounts.delete_queue(account.name, queue.name)
+                    self.notify(account.id, queue.id)
+                if queue.messages.count() == 0:
+                    self.accounts.delete_queue(account.id, queue.id)
 
-    def _scan_queue(self, account, queue, filters, attributes={},
-        delete=False):
-        account, queue = self.accounts.get_queue(account, queue)
-        if queue is None:
-            return
-        index = 0
-        notify = False
-        if 'marker' in filters and filters['marker'] is not None:
-            found = False
-            for index in xrange(0, len(queue.messages)):
-                message = queue.messages[index]
-                if message['id'] == filters['marker']:
-                    index += 1
-                    found = True
-                    break
-            if not found:
-                index = 0
-        messages = []
-        total = len(queue.messages)
-        limit = filters.get('limit', None)
-        match_hidden = filters.get('match_hidden', False)
-        ttl = attributes.get('ttl', None)
+    def _get_attributes(self, attributes, default_ttl=None, default_hide=None):
+        ttl = attributes.get('ttl', default_ttl)
         if ttl is not None and ttl > 0:
             ttl += int(time.time())
-        hide = attributes.get('hide', None)
+        hide = attributes.get('hide', default_hide)
         if hide is not None and hide > 0:
             hide += int(time.time())
-        while index < total:
-            message = queue.messages[index]
-            if not match_hidden and message['hide'] != 0:
-                index += 1
-                continue
-            if ttl is not None:
-                message['ttl'] = ttl
-            if hide is not None:
-                message['hide'] = hide
-                if hide == 0:
-                    notify = True
-            if delete:
-                del queue.messages[index]
-                total -= 1
-            else:
-                index += 1
-            relative_ttl = message['ttl']
-            if relative_ttl > 0:
-                relative_ttl -= int(time.time())
-            relative_hide = message['hide']
-            if relative_hide > 0:
-                relative_hide -= int(time.time())
-            yield dict(id=message['id'], ttl=relative_ttl, hide=relative_hide,
-                    body=message['body'])
-            if limit:
-                limit -= 1
-                if limit == 0:
-                    break
-        if notify:
-            self.notify(account.name, queue.name)
-        if len(queue.messages) == 0:
-            self.accounts.delete_queue(account.name, queue.name)
+        return ttl, hide
+
+    def _get_detail(self, filters, default=None):
+        detail = filters.get('detail', default)
+        if detail == 'none':
+            detail = None
+        elif detail is not None and detail not in ['id', 'all']:
+            raise burrow.backend.BadDetail(detail)
+        return detail
+
+    def _get_message_detail(self, filters, default=None):
+        detail = filters.get('detail', default)
+        options = ['id', 'attributes', 'body', 'all']
+        if detail == 'none':
+            detail = None
+        elif detail is not None and detail not in options:
+            raise burrow.backend.BadDetail(detail)
+        return detail
 
 
 class Item(object):
     '''Object to represent elements in a indexed linked list.'''
 
-    def __init__(self, name=None):
-        self.name = name
+    def __init__(self, id=None):
+        self.id = id
         self.next = None
         self.prev = None
 
+    def detail(self, detail):
+        if detail == 'all':
+            return dict(id=self.id)
+        return self.id
+
 
 class IndexedList(object):
     '''Class for managing an indexed linked list.'''
@@ -237,30 +240,16 @@
             item.prev = self.last
             self.last.next = item
         self.last = item
-        self.index[item.name] = item
+        self.index[item.id] = item
         return item
 
     def count(self):
         return len(self.index)
 
-    def delete(self, filters):
-        if len(filters) == 0:
-            self.first = None
-            self.last = None
-            self.index.clear()
-            return
-        detail = self._get_detail(filters)
-        for item in self.iter(filters):
-            self.delete_item(item.name)
-            if detail == 'id':
-                yield item.name
-            elif detail == 'all':
-                yield dict(id=item.name)
-
-    def delete_item(self, name):
-        if name not in self.index:
-            return
-        item = self.index.pop(name)
+    def delete(self, id):
+        if id not in self.index:
+            return
+        item = self.index.pop(id)
         if item.next is not None:
             item.next.prev = item.prev
         if item.prev is not None:
@@ -270,9 +259,11 @@
         if self.last == item:
             self.last = item.prev
 
-    def get(self, name):
-        if name in self.index:
-            return self.index[name]
+    def get(self, id, create=False):
+        if id in self.index:
+            return self.index[id]
+        elif create:
+            return self.add(self.item_class(id))
         return None
 
     def iter(self, filters={}):
@@ -281,6 +272,8 @@
             item = self.index[marker].next
         else:
             item = self.first
+        if item is None:
+            raise burrow.backend.NotFound()
         limit = filters.get('limit', None)
         while item is not None:
             yield item
@@ -290,46 +283,31 @@
                     break
             item = item.next
 
-    def iter_detail(self, filters={}):
-        detail = self._get_detail(filters, 'id')
-        for item in self.iter(filters):
-            if detail == 'id':
-                yield item.name
-            elif detail == 'all':
-                yield dict(id=item.name)
-
-    def _get_detail(self, filters, default=None):
-        detail = filters.get('detail', default)
-        if detail == 'none':
-            detail = None
-        elif detail is not None and detail not in ['id', 'all']:
-            raise burrow.backend.BadDetail(detail)
-        return detail
+    def reset(self):
+        if self.count() == 0:
+            raise burrow.backend.NotFound()
+        self.first = None
+        self.last = None
+        self.index.clear()
 
 
 class Account(Item):
 
-    def __init__(self, name=None):
-        super(Account, self).__init__(name)
+    def __init__(self, id=None):
+        super(Account, self).__init__(id)
         self.queues = Queues()
 
 
 class Accounts(IndexedList):
 
+    item_class = Account
+
     def delete_queue(self, account, queue):
         account = self.get(account)
         if account is not None:
-            account.queues.delete_item(queue)
-            if account.queues.count() == 0:
-                self.delete_item(account.name)
-
-    def delete_queues(self, account, filters):
-        account = self.get(account)
-        if account is not None:
-            for queue in account.queues.delete(filters):
-                yield queue
-            if account.queues.count() == 0:
-                self.delete_item(account.name)
+            account.queues.delete(queue)
+            if account.queues.count() == 0:
+                self.delete(account.id)
 
     def get_queue(self, account, queue, create=False):
         if account in self.index:
@@ -340,26 +318,64 @@
             return None, None
         return account, account.queues.get(queue, create)
 
-    def get_queues(self, account, filters={}):
-        account = self.get(account)
-        if account is None:
-            return []
-        else:
-            return account.queues.iter_detail(filters)
-
 
 class Queue(Item):
 
-    def __init__(self, name=None):
-        super(Queue, self).__init__(name)
-        self.messages = []
+    def __init__(self, id=None):
+        super(Queue, self).__init__(id)
+        self.messages = Messages()
 
 
 class Queues(IndexedList):
 
-    def get(self, queue, create=False):
-        if queue in self.index:
-            return self.index[queue]
-        elif create:
-            return self.add(Queue(queue))
-        return None
+    item_class = Queue
+
+
+class Message(Item):
+
+    def __init__(self, id=None):
+        super(Message, self).__init__(id)
+        self.ttl = 0
+        self.hide = 0
+        self.body = None
+
+    def detail(self, detail=None):
+        if detail == 'id':
+            return self.id
+        elif detail == 'body':
+            return self.body
+        ttl = self.ttl
+        if ttl > 0:
+            ttl -= int(time.time())
+        hide = self.hide
+        if hide > 0:
+            hide -= int(time.time())
+        if detail == 'attributes':
+            return dict(id=self.id, ttl=ttl, hide=hide)
+        return dict(id=self.id, ttl=ttl, hide=hide, body=self.body)
+
+
+class Messages(IndexedList):
+
+    item_class = Message
+
+    def iter(self, filters={}):
+        marker = filters.get('marker', None)
+        if marker is not None and marker in self.index:
+            item = self.index[marker].next
+        else:
+            item = self.first
+        limit = filters.get('limit', None)
+        match_hidden = filters.get('match_hidden', False)
+        count = 0
+        while item is not None:
+            if match_hidden or item.hide == 0:
+                count += 1
+                yield item
+                if limit:
+                    limit -= 1
+                    if limit == 0:
+                        break
+            item = item.next
+        if count == 0:
+            raise burrow.backend.NotFound()

=== modified file 'burrow/backend/sqlite.py'
--- burrow/backend/sqlite.py	2011-07-22 19:40:38 +0000
+++ burrow/backend/sqlite.py	2011-08-04 23:47:24 +0000
@@ -66,6 +66,7 @@
         current_account = None
         ids = []
         marker_found = False
+        count = 0
         for row in self.db.execute(query, values):
             if marker == row[1]:
                 marker_found = True
@@ -78,6 +79,7 @@
                         break
                     limit -= 1
                 current_account = row[1]
+                count += 1
                 if detail == 'id':
                     yield row[1]
                 elif detail == 'all':
@@ -90,7 +92,10 @@
             filters = dict(filters)
             filters.pop('marker')
             for account in self.delete_accounts(filters):
+                count += 1
                 yield account
+        if count == 0:
+            raise burrow.backend.NotFound()
         if len(ids) > 0:
             self._delete_queues(ids)
 
@@ -109,12 +114,14 @@
             values += (limit,)
         detail = self._get_detail(filters, 'id')
         marker_found = False
+        count = 0
         for row in self.db.execute(query, values):
             if marker == row[0]:
                 marker_found = True
                 continue
             elif marker is not None and not marker_found:
                 break
+            count += 1
             if detail == 'id':
                 yield row[0]
             elif detail == 'all':
@@ -123,7 +130,10 @@
             filters = dict(filters)
             filters.pop('marker')
             for account in self.get_accounts(filters):
+                count += 1
                 yield account
+        if count == 0:
+            raise burrow.backend.NotFound()
 
     def delete_queues(self, account, filters={}):
         query = 'SELECT rowid,queue FROM queues WHERE account=?'
@@ -132,12 +142,14 @@
         detail = self._get_detail(filters, None)
         ids = []
         marker_found = False
+        count = 0
         for row in self.db.execute(query, values):
             if marker == row[1]:
                 marker_found = True
                 continue
             elif marker is not None and not marker_found:
                 break
+            count += 1
             if detail == 'id':
                 yield row[1]
             elif detail == 'all':
@@ -150,7 +162,10 @@
             filters = dict(filters)
             filters.pop('marker')
             for queue in self.delete_queues(account, filters):
+                count += 1
                 yield queue
+        if count == 0:
+            raise burrow.backend.NotFound()
         if len(ids) > 0:
             self._delete_queues(ids)
 
@@ -160,12 +175,14 @@
         query, values, marker = self._add_queue_filters(query, values, filters)
         detail = self._get_detail(filters, 'id')
         marker_found = False
+        count = 0
         for row in self.db.execute(query, values):
             if marker == row[0]:
                 marker_found = True
                 continue
             elif marker is not None and not marker_found:
                 break
+            count += 1
             if detail == 'id':
                 yield row[0]
             elif detail == 'all':
@@ -174,7 +191,10 @@
             filters = dict(filters)
             filters.pop('marker')
             for queue in self.get_queues(account, filters):
+                count += 1
                 yield queue
+        if count == 0:
+            raise burrow.backend.NotFound()
 
     def _add_queue_filters(self, query, values, filters):
         limit = filters.get('limit', None)
@@ -209,9 +229,11 @@
         result = self._get_messages(account, queue, filters)
         rowid = result.next()
         ids = []
+        detail = self._get_message_detail(filters)
         for message in result:
-            ids.append(message['id'])
-            yield message
+            ids.append(message[0])
+            if detail is not None:
+                yield self._message_detail(message, detail)
         if len(ids) == 0:
             return
         values = (rowid,) + tuple(ids)
@@ -224,36 +246,42 @@
 
     def get_messages(self, account, queue, filters={}):
         result = self._get_messages(account, queue, filters)
-        rowid = result.next()
-        return result
+        result.next()
+        detail = self._get_message_detail(filters, 'all')
+        for message in result:
+            if detail is not None:
+                yield self._message_detail(message, detail)
 
     def update_messages(self, account, queue, attributes={}, filters={}):
         result = self._get_messages(account, queue, filters)
         rowid = result.next()
         ids = []
         ttl = attributes.get('ttl', None)
+        if ttl is not None and ttl > 0:
+            ttl += int(time.time())
         hide = attributes.get('hide', None)
+        if hide is not None and hide > 0:
+            hide += int(time.time())
+        detail = self._get_message_detail(filters)
         for message in result:
-            ids.append(message['id'])
+            message = list(message)
+            ids.append(message[0])
             if ttl is not None:
-                message['ttl'] = ttl
+                message[1] = ttl
             if hide is not None:
-                message['hide'] = hide
-            yield message
+                message[2] = hide
+            if detail is not None:
+                yield self._message_detail(message, detail)
         if len(ids) == 0:
             return
         query = 'UPDATE messages SET'
         comma = ''
         values = tuple()
         if ttl is not None:
-            if ttl > 0:
-                ttl += int(time.time())
             query += '%s ttl=?' % comma
             values += (ttl,)
             comma = ','
         if hide is not None:
-            if hide > 0:
-                hide += int(time.time())
             query += '%s hide=?' % comma
             values += (hide,)
             comma = ','
@@ -410,7 +438,7 @@
         rowid = self._get_queue(account, queue)
         yield rowid
         if rowid is None:
-            return
+            raise burrow.backend.NotFound()
         marker = None
         if 'marker' in filters and filters['marker'] is not None:
             query = "SELECT rowid FROM messages " \
@@ -426,12 +454,33 @@
             query += " AND hide == 0"
         if 'limit' in filters and filters['limit'] is not None:
             query += " LIMIT %d" % filters['limit']
-        result = self.db.execute(query).fetchall()
-        for row in result:
-            ttl = row[1]
-            if ttl > 0:
-                ttl -= int(time.time())
-            hide = row[2]
-            if hide > 0:
-                hide -= int(time.time())
-            yield dict(id=row[0], ttl=ttl, hide=hide, body=str(row[3]))
+        count = 0
+        for row in self.db.execute(query):
+            yield row
+            count += 1
+        if count == 0:
+            raise burrow.backend.NotFound()
+
+    def _get_message_detail(self, filters, default=None):
+        detail = filters.get('detail', default)
+        options = ['id', 'attributes', 'body', 'all']
+        if detail == 'none':
+            detail = None
+        elif detail is not None and detail not in options:
+            raise burrow.backend.BadDetail(detail)
+        return detail
+
+    def _message_detail(self, row, detail):
+        if detail == 'id':
+            return row[0]
+        elif detail == 'body':
+            return str(row[3])
+        ttl = row[1]
+        if ttl > 0:
+            ttl -= int(time.time())
+        hide = row[2]
+        if hide > 0:
+            hide -= int(time.time())
+        if detail == 'attributes':
+            return dict(id=self.id, ttl=ttl, hide=hide)
+        return dict(id=row[0], ttl=ttl, hide=hide, body=str(row[3]))

=== modified file 'burrow/frontend/wsgi.py'
--- burrow/frontend/wsgi.py	2011-07-22 19:10:39 +0000
+++ burrow/frontend/wsgi.py	2011-08-04 23:47:24 +0000
@@ -16,6 +16,7 @@
 
 import json
 import time
+import types
 
 import eventlet
 import eventlet.wsgi
@@ -23,6 +24,7 @@
 import routes.middleware
 import webob.dec
 
+import burrow.backend
 import burrow.frontend
 
 # Default configuration values for this module.
@@ -127,61 +129,46 @@
     @webob.dec.wsgify
     def _delete_accounts(self, req):
         filters = self._parse_filters(req)
-        accounts = [account for account in
-            self.backend.delete_accounts(filters)]
-        if len(accounts) == 0:
-            return self._response()
-        return self._response(body=accounts)
+        return self._response(body=self.backend.delete_accounts(filters))
 
     @webob.dec.wsgify
     def _get_accounts(self, req):
         filters = self._parse_filters(req)
-        accounts = [account for account in self.backend.get_accounts(filters)]
-        if len(accounts) == 0:
-            return self._response(status=404)
-        return self._response(body=accounts)
+        return self._response(body=self.backend.get_accounts(filters))
 
     @webob.dec.wsgify
     def _delete_queues(self, req, account):
         filters = self._parse_filters(req)
-        queues = [queue for queue in
-            self.backend.delete_queues(account, filters)]
-        if len(queues) == 0:
-            return self._response()
+        queues = self.backend.delete_queues(account, filters)
         return self._response(body=queues)
 
     @webob.dec.wsgify
     def _get_queues(self, req, account):
         filters = self._parse_filters(req)
-        queues = [queue for queue in self.backend.get_queues(account, filters)]
-        if len(queues) == 0:
-            return self._response(status=404)
-        return self._response(body=queues)
+        return self._response(body=self.backend.get_queues(account, filters))
 
     @webob.dec.wsgify
     @wait_on_queue
     def _delete_messages(self, req, account, queue):
         filters = self._parse_filters(req)
-        messages = [message for message in
-            self.backend.delete_messages(account, queue, filters)]
-        return self._return_messages(req, account, queue, messages, 'none')
+        messages = self.backend.delete_messages(account, queue, filters)
+        return self._response(body=messages)
 
     @webob.dec.wsgify
     @wait_on_queue
     def _get_messages(self, req, account, queue):
         filters = self._parse_filters(req)
-        messages = [message for message in
-            self.backend.get_messages(account, queue, filters)]
-        return self._return_messages(req, account, queue, messages, 'all')
+        messages = self.backend.get_messages(account, queue, filters)
+        return self._response(body=messages)
 
     @webob.dec.wsgify
     @wait_on_queue
     def _post_messages(self, req, account, queue):
         attributes = self._parse_attributes(req)
         filters = self._parse_filters(req)
-        messages = [message for message in
-            self.backend.update_messages(account, queue, attributes, filters)]
-        return self._return_messages(req, account, queue, messages, 'all')
+        messages = self.backend.update_messages(account, queue, attributes,
+            filters)
+        return self._response(body=messages)
 
     @webob.dec.wsgify
     def _delete_message(self, req, account, queue, message):
@@ -240,20 +227,6 @@
             return self._response(body=message)
         return self._response()
 
-    def _return_messages(self, req, account, queue, messages, detail):
-        if len(messages) == 0:
-            return self._response(status=404)
-        if 'detail' in req.params:
-            detail = req.params['detail']
-        filtered_messages = []
-        for message in messages:
-            message = self._filter_message(detail, message)
-            if message is not None:
-                filtered_messages.append(message)
-        if len(filtered_messages) == 0:
-            return self._response()
-        return self._response(body=filtered_messages)
-
     def _parse_filters(self, req):
         filters = {}
         if 'limit' in req.params:
@@ -282,15 +255,23 @@
         return attributes
 
     def _response(self, status=200, body=None, content_type=None):
-        if content_type is None:
-            if body is None:
-                content_type = ''
-            else:
+        if isinstance(body, types.GeneratorType):
+            try:
+                body = list(body)
+            except burrow.backend.NotFound:
+                body = None
+                status = 404
+        if body == []:
+            body = None
+        if body is None:
+            content_type = ''
+            if status == 200:
+                status = 204
+        else:
+            if content_type is None:
                 content_type = 'application/json'
-        if content_type == 'application/json':
-            body = json.dumps(body, indent=2)
-        if body is None and status == 200:
-            status = 204
+            if content_type == 'application/json':
+                body = json.dumps(body, indent=2)
         return webob.Response(status=status, body=body,
             content_type=content_type)
 

=== modified file 'test/backend/test_memory.py'
--- test/backend/test_memory.py	2011-07-22 18:24:23 +0000
+++ test/backend/test_memory.py	2011-08-04 23:47:24 +0000
@@ -15,6 +15,7 @@
 import ConfigParser
 import unittest
 
+import burrow.backend
 import burrow.backend.memory
 
 
@@ -25,50 +26,52 @@
     def setUp(self):
         config = (ConfigParser.ConfigParser(), 'test')
         self.backend = self.backend_class(config)
-        self.assertEquals([], list(self.backend.get_accounts()))
-        self.assertEquals([], list(self.backend.get_queues('a')))
-        self.assertEquals([], list(self.backend.get_messages('a', 'q')))
+        accounts = self.backend.get_accounts()
+        self.assertRaises(burrow.backend.NotFound, list, accounts)
+        queues = self.backend.get_queues('a')
+        self.assertRaises(burrow.backend.NotFound, list, queues)
+        messages = self.backend.get_messages('a', 'q')
+        self.assertRaises(burrow.backend.NotFound, list, messages)
 
     def tearDown(self):
-        self.assertEquals([], list(self.backend.get_messages('a', 'q')))
-        self.assertEquals([], list(self.backend.get_queues('a')))
-        self.assertEquals([], list(self.backend.get_accounts()))
+        messages = self.backend.get_messages('a', 'q')
+        self.assertRaises(burrow.backend.NotFound, list, messages)
+        queues = self.backend.get_queues('a')
+        self.assertRaises(burrow.backend.NotFound, list, queues)
+        accounts = self.backend.get_accounts()
+        self.assertRaises(burrow.backend.NotFound, list, accounts)
 
-    def test_account(self):
+    def test_accounts(self):
         self.backend.create_message('a', 'q', 'm', 'test')
         self.assertEquals(['a'], list(self.backend.get_accounts()))
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_delete_detail_all(self):
+    def test_accounts_delete_detail_all(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='all')
         accounts = list(self.backend.delete_accounts(filters))
         self.assertEquals([dict(id='a')], accounts)
 
-    def test_account_delete_detail_id(self):
+    def test_accounts_delete_detail_id(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='id')
         accounts = list(self.backend.delete_accounts(filters))
         self.assertEquals(['a'], accounts)
 
-    def test_account_delete_detail_none(self):
+    def test_accounts_delete_detail_none(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='none')
         accounts = list(self.backend.delete_accounts(filters))
         self.assertEquals([], accounts)
 
-    def test_account_delete_detail_bad(self):
+    def test_accounts_delete_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='bad')
         accounts = self.backend.delete_accounts(filters)
         self.assertRaises(burrow.backend.BadDetail, list, accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_delete_marker(self):
+    def test_accounts_delete_marker(self):
         self.backend.create_message('a1', 'q', 'm', 'test')
         self.backend.create_message('a2', 'q', 'm', 'test')
         self.backend.create_message('a3', 'q', 'm', 'test')
@@ -77,13 +80,13 @@
         filters = dict(detail='id', marker=accounts[0])
         accounts2 = list(self.backend.delete_accounts(filters))
         self.assertEquals(accounts[1:], accounts2)
-        accounts3 = list(self.backend.get_accounts())
-        self.assertEquals(accounts[:1], accounts3)
+        accounts2 = list(self.backend.get_accounts())
+        self.assertEquals(accounts[:1], accounts2)
         filters = dict(detail='id', marker='unknown')
-        accounts4 = list(self.backend.delete_accounts(filters))
-        self.assertEquals(accounts[:1], accounts4)
+        accounts2 = list(self.backend.delete_accounts(filters))
+        self.assertEquals(accounts[:1], accounts2)
 
-    def test_account_delete_limit(self):
+    def test_accounts_delete_limit(self):
         self.backend.create_message('a1', 'q', 'm', 'test')
         self.backend.create_message('a2', 'q', 'm', 'test')
         self.backend.create_message('a3', 'q', 'm', 'test')
@@ -93,10 +96,10 @@
         accounts2 = list(self.backend.delete_accounts(filters))
         self.assertEquals(accounts[:1], accounts2)
         filters = dict(detail='id', limit=2)
-        accounts3 = list(self.backend.delete_accounts(filters))
-        self.assertEquals(accounts[1:3], accounts3)
+        accounts2 = list(self.backend.delete_accounts(filters))
+        self.assertEquals(accounts[1:3], accounts2)
 
-    def test_account_delete_marker_limit(self):
+    def test_accounts_delete_marker_limit(self):
         self.backend.create_message('a1', 'q', 'm', 'test')
         self.backend.create_message('a2', 'q', 'm', 'test')
         self.backend.create_message('a3', 'q', 'm', 'test')
@@ -106,43 +109,39 @@
         accounts2 = list(self.backend.delete_accounts(filters))
         self.assertEquals(accounts[2:3], accounts2)
         filters = dict(detail='id', marker=accounts[0], limit=2)
-        accounts3 = list(self.backend.delete_accounts(filters))
-        self.assertEquals(accounts[1:2], accounts3)
+        accounts2 = list(self.backend.delete_accounts(filters))
+        self.assertEquals(accounts[1:2], accounts2)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_detail_all(self):
+    def test_accounts_get_detail_all(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='all')
         accounts = list(self.backend.get_accounts(filters))
         self.assertEquals([dict(id='a')], accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_detail_id(self):
+    def test_accounts_get_detail_id(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='id')
         accounts = list(self.backend.get_accounts(filters))
         self.assertEquals(['a'], accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_detail_none(self):
+    def test_accounts_get_detail_none(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='none')
         accounts = list(self.backend.get_accounts(filters))
         self.assertEquals([], accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_detail_bad(self):
+    def test_accounts_get_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['a'], list(self.backend.get_accounts()))
         filters = dict(detail='bad')
         accounts = self.backend.get_accounts(filters)
         self.assertRaises(burrow.backend.BadDetail, list, accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_marker(self):
+    def test_accounts_get_marker(self):
         self.backend.create_message('a1', 'q', 'm', 'test')
         self.backend.create_message('a2', 'q', 'm', 'test')
         self.backend.create_message('a3', 'q', 'm', 'test')
@@ -152,17 +151,17 @@
         accounts2 = list(self.backend.get_accounts(filters))
         self.assertEquals(accounts[1:], accounts2)
         filters = dict(marker=accounts[1])
-        accounts3 = list(self.backend.get_accounts(filters))
-        self.assertEquals(accounts[2:], accounts3)
+        accounts2 = list(self.backend.get_accounts(filters))
+        self.assertEquals(accounts[2:], accounts2)
         filters = dict(marker=accounts[2])
-        accounts4 = list(self.backend.get_accounts(filters))
-        self.assertEquals([], accounts4)
+        accounts2 = self.backend.get_accounts(filters)
+        self.assertRaises(burrow.backend.NotFound, list, accounts2)
         filters = dict(marker='unknown')
-        accounts5 = list(self.backend.get_accounts(filters))
-        self.assertEquals(accounts, accounts5)
+        accounts2 = list(self.backend.get_accounts(filters))
+        self.assertEquals(accounts, accounts2)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_limit(self):
+    def test_accounts_get_limit(self):
         self.backend.create_message('a1', 'q', 'm', 'test')
         self.backend.create_message('a2', 'q', 'm', 'test')
         self.backend.create_message('a3', 'q', 'm', 'test')
@@ -172,17 +171,17 @@
         accounts2 = list(self.backend.get_accounts(filters))
         self.assertEquals(accounts[:1], accounts2)
         filters = dict(limit=2)
-        accounts3 = list(self.backend.get_accounts(filters))
-        self.assertEquals(accounts[:2], accounts3)
+        accounts2 = list(self.backend.get_accounts(filters))
+        self.assertEquals(accounts[:2], accounts2)
         filters = dict(limit=3)
-        accounts4 = list(self.backend.get_accounts(filters))
-        self.assertEquals(accounts, accounts4)
+        accounts2 = list(self.backend.get_accounts(filters))
+        self.assertEquals(accounts, accounts2)
         filters = dict(limit=100)
-        accounts5 = list(self.backend.get_accounts(filters))
-        self.assertEquals(accounts, accounts5)
+        accounts2 = list(self.backend.get_accounts(filters))
+        self.assertEquals(accounts, accounts2)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_account_get_marker_limit(self):
+    def test_accounts_get_marker_limit(self):
         self.backend.create_message('a1', 'q', 'm', 'test')
         self.backend.create_message('a2', 'q', 'm', 'test')
         self.backend.create_message('a3', 'q', 'm', 'test')
@@ -192,45 +191,41 @@
         accounts2 = list(self.backend.get_accounts(filters))
         self.assertEquals(accounts[2:3], accounts2)
         filters = dict(marker=accounts[0], limit=2)
-        accounts3 = list(self.backend.get_accounts(filters))
-        self.assertEquals(accounts[1:3], accounts3)
+        accounts2 = list(self.backend.get_accounts(filters))
+        self.assertEquals(accounts[1:3], accounts2)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
-    def test_queue(self):
+    def test_queues(self):
         self.backend.create_message('a', 'q', 'm', 'test')
         self.assertEquals(['q'], list(self.backend.get_queues('a')))
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_delete_detail_all(self):
+    def test_queues_delete_detail_all(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='all')
         queues = list(self.backend.delete_queues('a', filters))
         self.assertEquals([dict(id='q')], queues)
 
-    def test_queue_delete_detail_id(self):
+    def test_queues_delete_detail_id(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='id')
         queues = list(self.backend.delete_queues('a', filters))
         self.assertEquals(['q'], queues)
 
-    def test_queue_delete_detail_none(self):
+    def test_queues_delete_detail_none(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='none')
         queues = list(self.backend.delete_queues('a', filters))
         self.assertEquals([], queues)
 
-    def test_queue_delete_detail_bad(self):
+    def test_queues_delete_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='bad')
         queues = self.backend.delete_queues('a', filters)
         self.assertRaises(burrow.backend.BadDetail, list, queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_delete_marker(self):
+    def test_queues_delete_marker(self):
         self.backend.create_message('a', 'q1', 'm', 'test')
         self.backend.create_message('a', 'q2', 'm', 'test')
         self.backend.create_message('a', 'q3', 'm', 'test')
@@ -239,13 +234,13 @@
         filters = dict(detail='id', marker=queues[0])
         queues2 = list(self.backend.delete_queues('a', filters))
         self.assertEquals(queues[1:], queues2)
-        queues3 = list(self.backend.get_queues('a'))
-        self.assertEquals(queues[:1], queues3)
+        queues2 = list(self.backend.get_queues('a'))
+        self.assertEquals(queues[:1], queues2)
         filters = dict(detail='id', marker='unknown')
-        queues4 = list(self.backend.delete_queues('a', filters))
-        self.assertEquals(queues[:1], queues4)
+        queues2 = list(self.backend.delete_queues('a', filters))
+        self.assertEquals(queues[:1], queues2)
 
-    def test_queue_delete_limit(self):
+    def test_queues_delete_limit(self):
         self.backend.create_message('a', 'q1', 'm', 'test')
         self.backend.create_message('a', 'q2', 'm', 'test')
         self.backend.create_message('a', 'q3', 'm', 'test')
@@ -255,10 +250,10 @@
         queues2 = list(self.backend.delete_queues('a', filters))
         self.assertEquals(queues[:1], queues2)
         filters = dict(detail='id', limit=2)
-        queues3 = list(self.backend.delete_queues('a', filters))
-        self.assertEquals(queues[1:3], queues3)
+        queues2 = list(self.backend.delete_queues('a', filters))
+        self.assertEquals(queues[1:3], queues2)
 
-    def test_queue_delete_marker_limit(self):
+    def test_queues_delete_marker_limit(self):
         self.backend.create_message('a', 'q1', 'm', 'test')
         self.backend.create_message('a', 'q2', 'm', 'test')
         self.backend.create_message('a', 'q3', 'm', 'test')
@@ -268,43 +263,39 @@
         queues2 = list(self.backend.delete_queues('a', filters))
         self.assertEquals(queues[2:3], queues2)
         filters = dict(detail='id', marker=queues[0], limit=2)
-        queues3 = list(self.backend.delete_queues('a', filters))
-        self.assertEquals(queues[1:2], queues3)
+        queues2 = list(self.backend.delete_queues('a', filters))
+        self.assertEquals(queues[1:2], queues2)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_detail_all(self):
+    def test_queues_get_detail_all(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='all')
         queues = list(self.backend.get_queues('a', filters))
         self.assertEquals([dict(id='q')], queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_detail_id(self):
+    def test_queues_get_detail_id(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='id')
         queues = list(self.backend.get_queues('a', filters))
         self.assertEquals(['q'], queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_detail_none(self):
+    def test_queues_get_detail_none(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='none')
         queues = list(self.backend.get_queues('a', filters))
         self.assertEquals([], queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_detail_bad(self):
+    def test_queues_get_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
-        self.assertEquals(['q'], list(self.backend.get_queues('a')))
         filters = dict(detail='bad')
         queues = self.backend.get_queues('a', filters)
         self.assertRaises(burrow.backend.BadDetail, list, queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_marker(self):
+    def test_queues_get_marker(self):
         self.backend.create_message('a', 'q1', 'm', 'test')
         self.backend.create_message('a', 'q2', 'm', 'test')
         self.backend.create_message('a', 'q3', 'm', 'test')
@@ -314,17 +305,17 @@
         queues2 = list(self.backend.get_queues('a', filters))
         self.assertEquals(queues[1:], queues2)
         filters = dict(marker=queues[1])
-        queues3 = list(self.backend.get_queues('a', filters))
-        self.assertEquals(queues[2:], queues3)
+        queues2 = list(self.backend.get_queues('a', filters))
+        self.assertEquals(queues[2:], queues2)
         filters = dict(marker=queues[2])
-        queues4 = list(self.backend.get_queues('a', filters))
-        self.assertEquals([], queues4)
+        queues2 = self.backend.get_queues('a', filters)
+        self.assertRaises(burrow.backend.NotFound, list, queues2)
         filters = dict(marker='unknown')
-        queues5 = list(self.backend.get_queues('a', filters))
-        self.assertEquals(queues, queues5)
+        queues2 = list(self.backend.get_queues('a', filters))
+        self.assertEquals(queues, queues2)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_limit(self):
+    def test_queues_get_limit(self):
         self.backend.create_message('a', 'q1', 'm', 'test')
         self.backend.create_message('a', 'q2', 'm', 'test')
         self.backend.create_message('a', 'q3', 'm', 'test')
@@ -334,17 +325,17 @@
         queues2 = list(self.backend.get_queues('a', filters))
         self.assertEquals(queues[:1], queues2)
         filters = dict(limit=2)
-        queues3 = list(self.backend.get_queues('a', filters))
-        self.assertEquals(queues[:2], queues3)
+        queues2 = list(self.backend.get_queues('a', filters))
+        self.assertEquals(queues[:2], queues2)
         filters = dict(limit=3)
-        queues4 = list(self.backend.get_queues('a', filters))
-        self.assertEquals(queues, queues4)
+        queues2 = list(self.backend.get_queues('a', filters))
+        self.assertEquals(queues, queues2)
         filters = dict(limit=100)
-        queues5 = list(self.backend.get_queues('a', filters))
-        self.assertEquals(queues, queues5)
+        queues2 = list(self.backend.get_queues('a', filters))
+        self.assertEquals(queues, queues2)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
-    def test_queue_get_marker_limit(self):
+    def test_queues_get_marker_limit(self):
         self.backend.create_message('a', 'q1', 'm', 'test')
         self.backend.create_message('a', 'q2', 'm', 'test')
         self.backend.create_message('a', 'q3', 'm', 'test')
@@ -354,6 +345,164 @@
         queues2 = list(self.backend.get_queues('a', filters))
         self.assertEquals(queues[2:3], queues2)
         filters = dict(marker=queues[0], limit=2)
-        queues3 = list(self.backend.get_queues('a', filters))
-        self.assertEquals(queues[1:3], queues3)
+        queues2 = list(self.backend.get_queues('a', filters))
+        self.assertEquals(queues[1:3], queues2)
         self.assertEquals([], list(self.backend.delete_queues('a')))
+
+    def test_messages(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        message = dict(id='m', ttl=0, hide=0, body='test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals([message], messages)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_delete_detail_all(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        message = dict(id='m', ttl=0, hide=0, body='test')
+        filters = dict(detail='all')
+        messages = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals([message], messages)
+
+    def test_messages_delete_detail_id(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        filters = dict(detail='id')
+        queues = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(['m'], queues)
+
+    def test_messages_delete_detail_none(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        filters = dict(detail='none')
+        messages = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals([], messages)
+
+    def test_messages_delete_detail_bad(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        filters = dict(detail='bad')
+        messages = self.backend.delete_messages('a', 'q', filters)
+        self.assertRaises(burrow.backend.BadDetail, list, messages)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_delete_marker(self):
+        self.backend.create_message('a', 'q', 'm1', 'test')
+        self.backend.create_message('a', 'q', 'm2', 'test')
+        self.backend.create_message('a', 'q', 'm3', 'test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(3, len(messages))
+        filters = dict(detail='all', marker=messages[0]['id'])
+        messages2 = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(messages[1:], messages2)
+        messages2 = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(messages[:1], messages2)
+        filters = dict(detail='all', marker='unknown')
+        messages2 = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(messages[:1], messages2)
+
+    def test_messages_delete_limit(self):
+        self.backend.create_message('a', 'q', 'm1', 'test')
+        self.backend.create_message('a', 'q', 'm2', 'test')
+        self.backend.create_message('a', 'q', 'm3', 'test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(3, len(messages))
+        filters = dict(detail='all', limit=1)
+        messages2 = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(messages[:1], messages2)
+        filters = dict(detail='all', limit=2)
+        messages2 = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(messages[1:3], messages2)
+
+    def test_messages_delete_marker_limit(self):
+        self.backend.create_message('a', 'q', 'm1', 'test')
+        self.backend.create_message('a', 'q', 'm2', 'test')
+        self.backend.create_message('a', 'q', 'm3', 'test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(3, len(messages))
+        filters = dict(detail='all', marker=messages[1]['id'], limit=1)
+        messages2 = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(messages[2:3], messages2)
+        filters = dict(detail='all', marker=messages[0]['id'], limit=2)
+        messages2 = list(self.backend.delete_messages('a', 'q', filters))
+        self.assertEquals(messages[1:2], messages2)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_detail_all(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        message = dict(id='m', ttl=0, hide=0, body='test')
+        filters = dict(detail='all')
+        messages = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals([message], messages)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_detail_id(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        filters = dict(detail='id')
+        messages = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(['m'], messages)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_detail_none(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        filters = dict(detail='none')
+        messages = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals([], messages)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_detail_bad(self):
+        self.backend.create_message('a', 'q', 'm', 'test')
+        filters = dict(detail='bad')
+        messages = self.backend.get_messages('a', 'q', filters)
+        self.assertRaises(burrow.backend.BadDetail, list, messages)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_marker(self):
+        self.backend.create_message('a', 'q', 'm1', 'test')
+        self.backend.create_message('a', 'q', 'm2', 'test')
+        self.backend.create_message('a', 'q', 'm3', 'test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(3, len(messages))
+        filters = dict(marker=messages[0]['id'])
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages[1:], messages2)
+        filters = dict(marker=messages[1]['id'])
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages[2:], messages2)
+        filters = dict(marker=messages[2]['id'])
+        messages2 = self.backend.get_messages('a', 'q', filters)
+        self.assertRaises(burrow.backend.NotFound, list, messages2)
+        filters = dict(marker='unknown')
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages, messages2)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_limit(self):
+        self.backend.create_message('a', 'q', 'm1', 'test')
+        self.backend.create_message('a', 'q', 'm2', 'test')
+        self.backend.create_message('a', 'q', 'm3', 'test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(3, len(messages))
+        filters = dict(limit=1)
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages[:1], messages2)
+        filters = dict(limit=2)
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages[:2], messages2)
+        filters = dict(limit=3)
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages, messages2)
+        filters = dict(limit=100)
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages, messages2)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
+
+    def test_messages_get_marker_limit(self):
+        self.backend.create_message('a', 'q', 'm1', 'test')
+        self.backend.create_message('a', 'q', 'm2', 'test')
+        self.backend.create_message('a', 'q', 'm3', 'test')
+        messages = list(self.backend.get_messages('a', 'q'))
+        self.assertEquals(3, len(messages))
+        filters = dict(marker=messages[1]['id'], limit=1)
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages[2:3], messages2)
+        filters = dict(marker=messages[0]['id'], limit=2)
+        messages2 = list(self.backend.get_messages('a', 'q', filters))
+        self.assertEquals(messages[1:3], messages2)
+        self.assertEquals([], list(self.backend.delete_messages('a', 'q')))

=== modified file 'test/frontend/test_wsgi.py'
--- test/frontend/test_wsgi.py	2011-06-15 18:27:24 +0000
+++ test/frontend/test_wsgi.py	2011-08-04 23:47:24 +0000
@@ -263,7 +263,7 @@
         self._put_url('/a/q/1?hide=10')
         thread = eventlet.spawn(self._message_wait)
         url = '/a/q?hide=0&match_hidden=true'
-        eventlet.spawn_after(0.2, self._post_url, url)
+        eventlet.spawn_after(0.2, self._post_url, url, status=204)
         thread.wait()
         self.assertTrue(self.success)
         self._delete_url('/a/q/1')