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

[Eric Day]

Added client API unit tests, moved exceptions to main burrow module, and added more WSGI frontend tests.

=== modified file 'burrow/__init__.py'
--- burrow/__init__.py	2011-04-20 18:21:51 +0000
+++ burrow/__init__.py	2011-08-24 20:17:24 +0000
@@ -25,3 +25,14 @@
 # This installs the _(...) function as a built-in so all other modules
 # don't need to.
 gettext.install('burrow')
+
+
+class NotFound(Exception):
+    '''Raised when an account, queue, or message can not be found.'''
+    pass
+
+
+class InvalidArguments(Exception):
+    '''Raised when the given arguments are invalid, usually from attributes
+    or filters.'''
+    pass

=== modified file 'burrow/backend/__init__.py'
--- burrow/backend/__init__.py	2011-08-24 16:54:43 +0000
+++ burrow/backend/__init__.py	2011-08-24 20:17:24 +0000
@@ -228,7 +228,7 @@
         if detail == 'none':
             detail = None
         elif detail is not None and detail not in ['id', 'all']:
-            raise burrow.backend.InvalidArguments(detail)
+            raise burrow.InvalidArguments(detail)
         return detail
 
     def _get_message_detail(self, filters, default=None):
@@ -239,7 +239,7 @@
         if detail == 'none':
             detail = None
         elif detail is not None and detail not in options:
-            raise burrow.backend.InvalidArguments(detail)
+            raise burrow.InvalidArguments(detail)
         return detail
 
     def notify(self, account, queue):
@@ -293,20 +293,9 @@
             for message in method():
                 yield message
             return
-        except burrow.backend.NotFound, exception:
+        except burrow.NotFound, exception:
             now = time.time()
             if seconds - now > 0:
                 self.wait(account, queue, seconds - now)
             if seconds < time.time():
                 raise exception
-
-
-class NotFound(Exception):
-    '''Raised when an account, queue, or message can not be found.'''
-    pass
-
-
-class InvalidArguments(Exception):
-    '''Raised when the given arguments are invalid, usually from attributes
-    or filters.'''
-    pass

=== modified file 'burrow/backend/http.py'
--- burrow/backend/http.py	2011-08-24 16:54:43 +0000
+++ burrow/backend/http.py	2011-08-24 20:17:24 +0000
@@ -145,8 +145,11 @@
                         yield item
                     return
             yield body
+        body = response.read()
+        if body == '':
+            body = response.reason
         if response.status == 400:
-            raise burrow.backend.InvalidArguments(response.reason)
+            raise burrow.InvalidArguments(body)
         if response.status == 404:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound(body)
         raise Exception(response.reason)

=== modified file 'burrow/backend/memory.py'
--- burrow/backend/memory.py	2011-08-24 16:54:43 +0000
+++ burrow/backend/memory.py	2011-08-24 20:17:24 +0000
@@ -110,7 +110,7 @@
         try:
             message = queue.messages.get(message)
             created = False
-        except burrow.backend.NotFound:
+        except burrow.NotFound:
             message = queue.messages.get(message, True)
             created = True
         message.ttl = ttl
@@ -226,7 +226,7 @@
             return self.index[id]
         elif create:
             return self.add(self.item_class(id))
-        raise burrow.backend.NotFound()
+        raise burrow.NotFound(self.item_class.__name__ + " not found")
 
     def iter(self, filters=None):
         '''Iterate through all items in the list, possibly filtered.'''
@@ -241,7 +241,7 @@
         else:
             item = self.first
         if item is None:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound(self.item_class.__name__ + " not found")
         while item is not None:
             yield item
             if limit:
@@ -253,7 +253,7 @@
     def reset(self):
         '''Remove all items in the list.'''
         if self.count() == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound(self.item_class.__name__ + " not found")
         self.first = None
         self.last = None
         self.index.clear()
@@ -287,7 +287,7 @@
         elif create:
             account = self.add(Account(account))
         else:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Account not found')
         return account, account.queues.get(queue, create)
 
 
@@ -361,4 +361,4 @@
                         break
             item = item.next
         if count == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Message not found')

=== modified file 'burrow/backend/sqlite.py'
--- burrow/backend/sqlite.py	2011-08-24 16:54:43 +0000
+++ burrow/backend/sqlite.py	2011-08-24 20:17:24 +0000
@@ -66,7 +66,7 @@
         if filters is None or len(filters) == 0:
             query = 'SELECT rowid FROM accounts LIMIT 1'
             if len(self.db.execute(query).fetchall()) == 0:
-                raise burrow.backend.NotFound()
+                raise burrow.NotFound('Account not found')
             self.db.execute('DELETE FROM accounts')
             self.db.execute('DELETE FROM queues')
             self.db.execute('DELETE FROM messages')
@@ -136,7 +136,7 @@
                 marker = self._get_account(marker)
                 query += ' WHERE rowid > ?'
                 values += (marker,)
-            except burrow.backend.NotFound:
+            except burrow.NotFound:
                 marker = None
         if limit is not None:
             query += ' LIMIT ?'
@@ -146,14 +146,14 @@
             count += 1
             yield row
         if count == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Account not found')
 
     def _get_account(self, account):
         '''Get the rowid for a given account ID.'''
         query = 'SELECT rowid FROM accounts WHERE account=?'
         rows = self.db.execute(query, (account,)).fetchall()
         if len(rows) == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Account not found')
         return rows[0][0]
 
     def delete_queues(self, account, filters=None):
@@ -213,7 +213,7 @@
                 marker = self._get_queue(account_rowid, marker)
                 query += ' AND rowid > ?'
                 values += (marker,)
-            except burrow.backend.NotFound:
+            except burrow.NotFound:
                 marker = None
         if limit is not None:
             query += ' LIMIT ?'
@@ -223,14 +223,14 @@
             count += 1
             yield row
         if count == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Queue not found')
 
     def _get_queue(self, account_rowid, queue):
         '''Get the rowid for a given queue ID.'''
         query = 'SELECT rowid FROM queues WHERE account=? AND queue=?'
         rows = self.db.execute(query, (account_rowid, queue)).fetchall()
         if len(rows) == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Queue not found')
         return rows[0][0]
 
     @burrow.backend.wait_without_attributes
@@ -311,7 +311,7 @@
                 marker = self._get_message(queue_rowid, marker)
                 query += ' AND rowid > ?'
                 values += (marker,)
-            except burrow.backend.NotFound:
+            except burrow.NotFound:
                 marker = None
         if match_hidden is False:
             query += ' AND hide=0'
@@ -323,7 +323,7 @@
             count += 1
             yield row
         if count == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Message not found')
 
     def _get_message(self, queue_rowid, message, full=False):
         '''Get the rowid for a given message ID.'''
@@ -334,7 +334,7 @@
         query += ' FROM messages WHERE queue=? AND message=?'
         rows = self.db.execute(query, (queue_rowid, message)).fetchall()
         if len(rows) == 0:
-            raise burrow.backend.NotFound()
+            raise burrow.NotFound('Message not found')
         if full:
             return rows[0]
         return rows[0][0]
@@ -390,12 +390,12 @@
         ttl, hide = self._get_attributes(attributes, ttl=0, hide=0)
         try:
             account_rowid = self._get_account(account)
-        except burrow.backend.NotFound:
+        except burrow.NotFound:
             query = 'INSERT INTO accounts VALUES (?)'
             account_rowid = self.db.execute(query, (account,)).lastrowid
         try:
             queue_rowid = self._get_queue(account_rowid, queue)
-        except burrow.backend.NotFound:
+        except burrow.NotFound:
             query = 'INSERT INTO queues VALUES (?,?)'
             values = (account_rowid, queue)
             queue_rowid = self.db.execute(query, values).lastrowid
@@ -404,7 +404,7 @@
             query = 'UPDATE messages SET ttl=?,hide=?,body=? WHERE rowid=?'
             self.db.execute(query, (ttl, hide, body, message_rowid))
             created = False
-        except burrow.backend.NotFound:
+        except burrow.NotFound:
             query = 'INSERT INTO messages VALUES (?,?,?,?,?)'
             self.db.execute(query, (queue_rowid, message, ttl, hide, body))
             created = True

=== modified file 'burrow/frontend/wsgi.py'
--- burrow/frontend/wsgi.py	2011-08-16 23:37:49 +0000
+++ burrow/frontend/wsgi.py	2011-08-24 20:17:24 +0000
@@ -21,7 +21,6 @@
 import routes.middleware
 import webob.dec
 
-import burrow.backend
 import burrow.frontend
 
 # Default configuration values for this module.
@@ -101,7 +100,7 @@
             args['attributes'] = self._parse_attributes(req)
         method = getattr(self.backend, '%s_%s' % (method, action), None)
         if method is None:
-            return self._response(status=400)
+            return self._response(status=405)
         args['filters'] = self._parse_filters(req)
         return self._response(body=lambda: method(**args))
 
@@ -187,12 +186,12 @@
                 body = body()
             if isinstance(body, types.GeneratorType):
                 body = list(body)
-        except burrow.backend.InvalidArguments:
+        except burrow.InvalidArguments, exception:
             status = 400
-            body = None
-        except burrow.backend.NotFound:
+            body = exception.message
+        except burrow.NotFound, exception:
             status = 404
-            body = None
+            body = exception.message
         if body == []:
             body = None
         return status, body

=== modified file 'burrow/shell.py'
--- burrow/shell.py	2011-04-22 02:18:26 +0000
+++ burrow/shell.py	2011-08-24 20:17:24 +0000
@@ -112,7 +112,10 @@
         '''Run the command given in arguments or enter an interactive shell.'''
         if len(self.args) == 0:
             for command in self._get_command():
-                self.run_command(command[0], command[1:])
+                try:
+                    self.run_command(command[0], command[1:])
+                except burrow.NotFound, exception:
+                    print exception
         else:
             self.run_command(self.args[0], self.args[1:])
 
@@ -131,6 +134,8 @@
         while True:
             try:
                 command = raw_input(prompt)
+            except KeyboardInterrupt:
+                break
             except EOFError:
                 if os.isatty(sys.stdin.fileno()):
                     print
@@ -164,11 +169,7 @@
             args.append(self._pack_attributes())
         if section.get('filters', None):
             args.append(self._pack_filters())
-        try:
-            result = getattr(self.client, command)(*args)
-        except Exception, exception:
-            print exception
-            return
+        result = getattr(self.client, command)(*args)
         self._print_result(result)
 
     def _get_section(self, command):

=== modified file 'test/__init__.py'
--- test/__init__.py	2011-08-16 20:59:06 +0000
+++ test/__init__.py	2011-08-24 20:17:24 +0000
@@ -13,3 +13,58 @@
 # limitations under the License.
 
 '''Unittests for burrow.'''
+
+import atexit
+import os
+import signal
+import sys
+import time
+
+import burrow
+
+
+def start_server():
+    '''Fork and start the server, saving the pid in a file.'''
+    kill_server()
+    pid = os.fork()
+    if pid == 0:
+        try:
+            import coverage
+            cov = coverage.coverage(data_suffix=True)
+            cov.start()
+
+            def save_coverage(_signum, _frame):
+                '''Callback for signal to save coverage info to file.'''
+                cov.save()
+
+            signal.signal(signal.SIGUSR1, save_coverage)
+        except ImportError:
+            pass
+        server = burrow.Server(add_default_log_handler=False)
+        server.frontends[0].default_ttl = 0
+        server.run()
+        sys.exit(0)
+    pid_file = open('TestHTTP.pid', 'w')
+    pid_file.write(str(pid))
+    pid_file.close()
+    atexit.register(kill_server)
+    time.sleep(1)
+
+
+def kill_server():
+    '''Try killing the server if the pid file exists.'''
+    try:
+        pid_file = open('TestHTTP.pid', 'r')
+        pid = pid_file.read()
+        pid_file.close()
+        try:
+            os.kill(int(pid), signal.SIGUSR1)
+            time.sleep(1)
+            os.kill(int(pid), signal.SIGTERM)
+        except OSError:
+            pass
+        os.unlink('TestHTTP.pid')
+    except IOError:
+        pass
+
+start_server()

=== modified file 'test/backend/__init__.py'
--- test/backend/__init__.py	2011-08-16 20:59:06 +0000
+++ test/backend/__init__.py	2011-08-24 20:17:24 +0000
@@ -41,12 +41,12 @@
         '''Ensure the backend is empty before, used before and after
         each test.'''
         accounts = self.backend.get_accounts()
-        self.assertRaises(burrow.backend.NotFound, list, accounts)
+        self.assertRaises(burrow.NotFound, list, accounts)
         queues = self.backend.get_queues('a')
-        self.assertRaises(burrow.backend.NotFound, list, queues)
+        self.assertRaises(burrow.NotFound, list, queues)
         filters = dict(match_hidden=True)
         messages = self.backend.get_messages('a', 'q', filters)
-        self.assertRaises(burrow.backend.NotFound, list, messages)
+        self.assertRaises(burrow.NotFound, list, messages)
 
     def delete_messages(self):
         '''Delete messages, including those that are hidden. Use
@@ -73,7 +73,7 @@
         self.assertEquals(['a'], list(self.backend.get_accounts()))
         self.assertEquals([], list(self.backend.delete_accounts()))
         accounts = self.backend.delete_accounts()
-        self.assertRaises(burrow.backend.NotFound, list, accounts)
+        self.assertRaises(burrow.NotFound, list, accounts)
 
     def test_large(self):
         for name in xrange(0, 1000):
@@ -104,7 +104,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         accounts = self.backend.delete_accounts(filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
+        self.assertRaises(burrow.InvalidArguments, list, accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
     def test_delete_marker(self):
@@ -174,7 +174,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         accounts = self.backend.get_accounts(filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, accounts)
+        self.assertRaises(burrow.InvalidArguments, list, accounts)
         self.assertEquals([], list(self.backend.delete_accounts()))
 
     def test_get_marker(self):
@@ -191,7 +191,7 @@
         self.assertEquals(accounts[2:], accounts2)
         filters = dict(marker=accounts[2])
         accounts2 = self.backend.get_accounts(filters)
-        self.assertRaises(burrow.backend.NotFound, list, accounts2)
+        self.assertRaises(burrow.NotFound, list, accounts2)
         filters = dict(marker='unknown')
         accounts2 = list(self.backend.get_accounts(filters))
         self.assertEquals(accounts, accounts2)
@@ -240,7 +240,7 @@
         self.assertEquals(['q'], list(self.backend.get_queues('a')))
         self.assertEquals([], list(self.backend.delete_queues('a')))
         queues = self.backend.delete_queues('a')
-        self.assertRaises(burrow.backend.NotFound, list, queues)
+        self.assertRaises(burrow.NotFound, list, queues)
 
     def test_large(self):
         for name in xrange(0, 1000):
@@ -271,7 +271,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         queues = self.backend.delete_queues('a', filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
+        self.assertRaises(burrow.InvalidArguments, list, queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
     def test_delete_marker(self):
@@ -341,7 +341,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         queues = self.backend.get_queues('a', filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, queues)
+        self.assertRaises(burrow.InvalidArguments, list, queues)
         self.assertEquals([], list(self.backend.delete_queues('a')))
 
     def test_get_marker(self):
@@ -358,7 +358,7 @@
         self.assertEquals(queues[2:], queues2)
         filters = dict(marker=queues[2])
         queues2 = self.backend.get_queues('a', filters)
-        self.assertRaises(burrow.backend.NotFound, list, queues2)
+        self.assertRaises(burrow.NotFound, list, queues2)
         filters = dict(marker='unknown')
         queues2 = list(self.backend.get_queues('a', filters))
         self.assertEquals(queues, queues2)
@@ -418,9 +418,9 @@
         self.assertEquals([], list(messages))
         self.delete_messages()
         messages = self.backend.delete_messages('a', 'q')
-        self.assertRaises(burrow.backend.NotFound, list, messages)
+        self.assertRaises(burrow.NotFound, list, messages)
         messages = self.backend.update_messages('a', 'q', attributes)
-        self.assertRaises(burrow.backend.NotFound, list, messages)
+        self.assertRaises(burrow.NotFound, list, messages)
 
     def test_large(self):
         for name in xrange(0, 1000):
@@ -467,7 +467,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         messages = self.backend.delete_messages('a', 'q', filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
+        self.assertRaises(burrow.InvalidArguments, list, messages)
         self.assertEquals([], list(self.backend.delete_messages('a', 'q')))
 
     def test_delete_marker(self):
@@ -553,7 +553,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
         messages = self.backend.get_messages('a', 'q', filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
+        self.assertRaises(burrow.InvalidArguments, list, messages)
         self.delete_messages()
 
     def test_get_marker(self):
@@ -570,7 +570,7 @@
         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)
+        self.assertRaises(burrow.NotFound, list, messages2)
         filters = dict(marker='unknown')
         messages2 = list(self.backend.get_messages('a', 'q', filters))
         self.assertEquals(messages, messages2)
@@ -657,7 +657,7 @@
         attributes = dict(ttl=100, hide=200)
         filters = dict(detail='bad')
         messages = self.backend.update_messages('a', 'q', attributes, filters)
-        self.assertRaises(burrow.backend.InvalidArguments, list, messages)
+        self.assertRaises(burrow.InvalidArguments, list, messages)
         self.delete_messages()
 
     def test_update_marker(self):
@@ -677,7 +677,7 @@
         self.assertEquals(messages[2:], list(messages2))
         filters.update(marker=messages[2]['id'])
         messages2 = self.backend.update_messages('a', 'q', attributes, filters)
-        self.assertRaises(burrow.backend.NotFound, list, messages2)
+        self.assertRaises(burrow.NotFound, list, messages2)
         filters = dict(detail='all', marker='unknown', match_hidden=True)
         messages2 = self.backend.update_messages('a', 'q', attributes, filters)
         self.assertEquals(messages, list(messages2))
@@ -807,7 +807,7 @@
     def test_delete_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
-        self.assertRaises(burrow.backend.InvalidArguments,
+        self.assertRaises(burrow.InvalidArguments,
             self.backend.delete_message, 'a', 'q', 'm', filters)
         self.delete_messages()
 
@@ -849,7 +849,7 @@
     def test_get_detail_bad(self):
         self.backend.create_message('a', 'q', 'm', 'test')
         filters = dict(detail='bad')
-        self.assertRaises(burrow.backend.InvalidArguments,
+        self.assertRaises(burrow.InvalidArguments,
             self.backend.get_message, 'a', 'q', 'm', filters)
         self.delete_messages()
 
@@ -903,7 +903,7 @@
         self.backend.create_message('a', 'q', 'm', 'test')
         attributes = dict(ttl=100, hide=200)
         filters = dict(detail='bad')
-        self.assertRaises(burrow.backend.InvalidArguments,
+        self.assertRaises(burrow.InvalidArguments,
             self.backend.update_message, 'a', 'q', 'm', attributes, filters)
         self.delete_messages()
 

=== modified file 'test/backend/test_http.py'
--- test/backend/test_http.py	2011-08-16 20:59:06 +0000
+++ test/backend/test_http.py	2011-08-24 20:17:24 +0000
@@ -15,12 +15,7 @@
 '''Unittests for the HTTP backend. This starts the WSGI server so
 tests the WSGI frontend as well.'''
 
-import atexit
 import ConfigParser
-import os
-import signal
-import sys
-import time
 
 import burrow.backend.http
 import test.backend
@@ -53,51 +48,3 @@
 class TestHTTPMessage(HTTPBase, test.backend.TestMessage):
     '''Test case for message with http backend.'''
     pass
-
-
-def start_server():
-    '''Fork and start the server, saving the pid in a file.'''
-    kill_server()
-    pid = os.fork()
-    if pid == 0:
-        try:
-            import coverage
-            cov = coverage.coverage(data_suffix=True)
-            cov.start()
-
-            def save_coverage(_signum, _frame):
-                '''Callback for signal to save coverage info to file.'''
-                cov.save()
-
-            signal.signal(signal.SIGUSR1, save_coverage)
-        except ImportError:
-            pass
-        server = burrow.Server(add_default_log_handler=False)
-        server.frontends[0].default_ttl = 0
-        server.run()
-        sys.exit(0)
-    pid_file = open('TestHTTP.pid', 'w')
-    pid_file.write(str(pid))
-    pid_file.close()
-    atexit.register(kill_server)
-    time.sleep(1)
-
-
-def kill_server():
-    '''Try killing the server if the pid file exists.'''
-    try:
-        pid_file = open('TestHTTP.pid', 'r')
-        pid = pid_file.read()
-        pid_file.close()
-        try:
-            os.kill(int(pid), signal.SIGUSR1)
-            time.sleep(1)
-            os.kill(int(pid), signal.SIGTERM)
-        except OSError:
-            pass
-        os.unlink('TestHTTP.pid')
-    except IOError:
-        pass
-
-
-start_server()

=== added directory 'test/frontend'
=== added file 'test/frontend/__init__.py'
--- test/frontend/__init__.py	1970-01-01 00:00:00 +0000
+++ test/frontend/__init__.py	2011-08-24 20:17:24 +0000
@@ -0,0 +1,15 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''Unittests for burrow frontends.'''

=== added file 'test/frontend/test_wsgi.py'
--- test/frontend/test_wsgi.py	1970-01-01 00:00:00 +0000
+++ test/frontend/test_wsgi.py	2011-08-24 20:17:24 +0000
@@ -0,0 +1,45 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''Unittests for the WSGI frontend. Most of the WSGI server is tested by
+the HTTP backend, so this covers things that don't translate directly to
+the Python API.'''
+
+import httplib
+import json
+import unittest
+
+
+class TestWSGI(unittest.TestCase):
+    '''Test case for WSGI frontend.'''
+
+    def test_versions(self):
+        connection = httplib.HTTPConnection('localhost', 8080)
+        connection.request('GET', '/')
+        response = connection.getresponse()
+        self.assertEquals(response.status, 200)
+        body = json.loads(response.read())
+        self.assertEquals(body, ['v1.0'])
+
+    def test_unknown_method(self):
+        connection = httplib.HTTPConnection('localhost', 8080)
+        connection.request('OPTIONS', '/v1.0')
+        response = connection.getresponse()
+        self.assertEquals(response.status, 405)
+
+    def test_unknown_url(self):
+        connection = httplib.HTTPConnection('localhost', 8080)
+        connection.request('GET', '/unknown')
+        response = connection.getresponse()
+        self.assertEquals(response.status, 404)

=== added file 'test/test_client.py'
--- test/test_client.py	1970-01-01 00:00:00 +0000
+++ test/test_client.py	2011-08-24 20:17:24 +0000
@@ -0,0 +1,60 @@
+# Copyright (C) 2011 OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''Unittests for the Client API.'''
+
+import unittest
+
+import burrow
+
+
+class TestClient(unittest.TestCase):
+    '''Test case for Client API.'''
+
+    def test_client(self):
+        client = burrow.Client()
+        self.assertRaises(burrow.NotFound, list, client.get_accounts())
+        self.assertEquals(True, client.create_message('a', 'q', 'm', 'body'))
+        self.assertEquals(['a'], list(client.get_accounts()))
+        self.assertEquals([], list(client.delete_accounts()))
+
+    def test_account(self):
+        account = burrow.Account('a')
+        self.assertRaises(burrow.NotFound, list, account.get_queues())
+        self.assertEquals(True, account.create_message('q', 'm', 'body'))
+        self.assertEquals(['q'], list(account.get_queues()))
+        self.assertEquals([], list(account.delete_accounts()))
+
+    def test_queue(self):
+        queue = burrow.Queue('a', 'q')
+        self.assertRaises(burrow.NotFound, list, queue.get_messages())
+        self.assertEquals(True, queue.create_message('m', 'body'))
+        messages = queue.get_messages(filters=dict(detail='id'))
+        self.assertEquals(['m'], list(messages))
+        self.assertEquals([], list(queue.delete_accounts()))
+
+    def test_url(self):
+        client = burrow.Client(url='http://localhost:8080')
+        self.assertRaises(burrow.NotFound, list, client.get_accounts())
+        self.assertEquals(True, client.create_message('a', 'q', 'm', 'body'))
+        self.assertEquals(['a'], list(client.get_accounts()))
+        self.assertEquals([], list(client.delete_accounts()))
+
+    def test_shared_client(self):
+        client = burrow.Client(url='http://localhost:8080')
+        self.assertRaises(burrow.NotFound, list, client.get_accounts())
+        self.assertEquals(True, client.create_message('a', 'q', 'm', 'body'))
+        account = burrow.Account('a', client=client)
+        self.assertEquals(['q'], list(account.get_queues()))
+        self.assertEquals([], list(account.delete_accounts()))