Merge lp:~pedronis/u1db/http-more-of-simple-ops into lp:u1db

[Samuele Pedroni]

support the various aspects of get_doc, put_doc, and delete_doc with HTTPDatabase passing the corresponding tests

introduce DocumentDoesNotExist and DocumentAlreadyDeleted to avoid overloading KeyError

improve the way we handle and transmit errors over HTTP; try to make sure all relevant wire descriptions off errors are listed in errors.py

[John A Meinel (jameinel)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On 11/28/2011 7:02 PM, Samuele Pedroni wrote:
> Samuele Pedroni has proposed merging
> lp:~pedronis/u1db/http-more-of-simple-ops into lp:u1db.
>
> Requested reviews: Ubuntu One hackers (ubuntuone-hackers)
>
> For more details, see:
> https://code.launchpad.net/~pedronis/u1db/http-more-of-simple-ops/+merge/83656
>
> support the various aspects of get_doc, put_doc, and delete_doc
> with HTTPDatabase passing the corresponding tests
>
> introduce DocumentDoesNotExist and DocumentAlreadyDeleted to avoid
> overloading KeyError
>
> improve the way we handle and transmit errors over HTTP; try to
> make sure all relevant wire descriptions off errors are listed in
> errors.py

If we are adding "wire_description = XXYY", should we be adding
"http_status = 404/409/etc"?

It seems better than hard-coding those values in the code itself.

+# wire error descriptions not corresponding to an exception
+DOCUMENT_DELETED = "document deleted"

It seems a bit odd to have DocumentAlreadyDeleted.wire_description as
one way to spell these things and DOCUMENT_DELETED as the other way.

The fact that we send the meta information for the document makes me
wonder if 404 is a good response.

...

> + except errors.HTTPError, e: + pass + +
> self.assertEqual(400, e.status)

^- I thought on some versions of python, e is only scoped inside the
except: clause. Maybe that is just python 3?

Anyway, just some thoughts:

 merge: approve

John
=:->
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iEYEARECAAYFAk7Uh60ACgkQJdeBCYSNAAOY9QCgn0x3zY9vu29NfMtie89dHIdI
q+UAnR6leTGtWV5WdP3UWqiDC33ol7Bw
=IilN
-----END PGP SIGNATURE-----

review: Approve

[lp:~pedronis/u1db/http-more-of-simple-ops]

142. By Samuele Pedroni on 2011-11-29

hardcode errors/statuses even less

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2011-11-28 14:58:52 +0000
+++ u1db/backends/inmemory.py	2011-11-29 10:29:24 +0000
@@ -134,9 +134,9 @@
 
     def delete_doc(self, doc):
         if doc.doc_id not in self._docs:
-            raise KeyError
+            raise errors.DocumentDoesNotExist
         if self._docs[doc.doc_id][1] in ('null', None):
-            raise KeyError
+            raise errors.DocumentAlreadyDeleted
         doc.content = None
         self.put_doc(doc)
 

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2011-11-28 14:58:52 +0000
+++ u1db/backends/sqlite_backend.py	2011-11-29 10:29:24 +0000
@@ -325,11 +325,11 @@
         with self._db_handle:
             old_doc = self._get_doc(doc.doc_id)
             if old_doc is None:
-                raise KeyError
+                raise errors.DocumentDoesNotExist
             if old_doc.rev != doc.rev:
                 raise errors.RevisionConflict()
             if old_doc.content is None:
-                raise KeyError
+                raise errors.DocumentAlreadyDeleted
             if self._has_conflicts(doc.doc_id):
                 raise errors.ConflictedDoc()
             new_rev = self._allocate_doc_rev(doc.rev)

=== modified file 'u1db/errors.py'
--- u1db/errors.py	2011-11-25 16:46:43 +0000
+++ u1db/errors.py	2011-11-29 10:29:24 +0000
@@ -46,6 +46,17 @@
     request.
     """
 
+class DocumentDoesNotExist(U1DBError):
+    """The document does not exist."""
+
+    wire_description="document does not exist"
+
+
+class DocumentAlreadyDeleted(U1DBError):
+    """The document was already deleted."""
+
+    wire_description="document already deleted"
+
 
 class DatabaseDoesNotExist(U1DBError):
     """The database does not exist."""
@@ -56,13 +67,20 @@
 
     wire_description = None
 
-    def __init__(self, status, message=None):
+    def __init__(self, status, message=None, headers={}):
         self.status = status
         self.message = message
+        self.headers = headers
 
 
 # mapping wire (transimission) descriptions/tags for errors to the exceptions
 wire_description_to_exc = dict(
     (x.wire_description, x) for x in globals().values()
-                            if getattr(x, 'wire_description', None) is not None
+            if getattr(x, 'wire_description', None) not in (None, "error")
 )
+wire_description_to_exc["error"] = U1DBError
+
+
+#
+# wire error descriptions not corresponding to an exception
+DOCUMENT_DELETED = "document deleted"

=== modified file 'u1db/remote/http_app.py'
--- u1db/remote/http_app.py	2011-11-25 16:52:40 +0000
+++ u1db/remote/http_app.py	2011-11-29 10:29:24 +0000
@@ -28,6 +28,9 @@
     Document,
     errors,
     )
+from u1db.remote import (
+    http_errors,
+    )
 
 
 class _FencedReader(object):
@@ -126,6 +129,8 @@
             if not (required_args <= set(args) <= all_args):
                 raise BadRequest()
             for name, conv in conversions:
+                if name not in args:
+                    continue
                 try:
                     args[name] = conv(args[name])
                 except ValueError:
@@ -183,7 +188,7 @@
         self.responder = responder
         self.db = state.open_database(dbname)
 
-    @http_method()
+    @http_method(old_rev=str)
     def put(self, content, old_rev=None):
         doc = Document(self.id, old_rev, content)
         doc_rev = self.db.put_doc(doc)
@@ -193,13 +198,37 @@
             status = 200
         self.responder.send_response(status, rev=doc_rev)
 
+    @http_method(old_rev=str)
+    def delete(self, old_rev=None):
+        doc = Document(self.id, old_rev, None)
+        self.db.delete_doc(doc)
+        self.responder.send_response(200, rev=doc.rev)
+
     @http_method()
     def get(self):
         doc = self.db.get_doc(self.id)
-        self.responder.send_response_content(doc.content, headers={
+        if doc is None:
+            wire_descr = errors.DocumentDoesNotExist.wire_description
+            self.responder.send_response(
+                http_errors.wire_description_to_status[wire_descr],
+                error=wire_descr,
+                headers={
+                    'x-u1db-rev': '',
+                    'x-u1db-has-conflicts': 'false'
+                    })
+            return
+        headers={
             'x-u1db-rev': doc.rev,
             'x-u1db-has-conflicts': simplejson.dumps(doc.has_conflicts)
-            })
+            }
+        if doc.content is None:
+            self.responder.send_response(
+               http_errors.wire_description_to_status[errors.DOCUMENT_DELETED],
+               error=errors.DOCUMENT_DELETED,
+               headers=headers)
+        else:
+            self.responder.send_response_content(doc.content, headers=headers)
+
 
 @url_to_resource.register
 class SyncResource(object):
@@ -254,8 +283,6 @@
         self.responder.finish_response()
 
 
-OK = 200
-
 class HTTPResponder(object):
     """Encode responses from the server back to the client."""
 
@@ -270,7 +297,7 @@
         self.content_type = 'application/json'
         self.content = []
 
-    def start_response(self, status=OK, headers={}, **kwargs):
+    def start_response(self, status=200, headers={}, **kwargs):
         """start sending response: header and args."""
         if self._started:
             return
@@ -288,7 +315,7 @@
         """finish sending response."""
         self.sent_response = True
 
-    def send_response(self, status=OK, headers={}, **kwargs):
+    def send_response(self, status=200, headers={}, **kwargs):
         """send and finish response in one go."""
         self.start_response(status, headers, **kwargs)
         self.finish_response()
@@ -296,7 +323,7 @@
     def send_response_content(self, content, headers={}):
         """send and finish response with content in one go."""
         headers['content-length'] = str(len(content))
-        self.start_response(OK, headers=headers)
+        self.start_response(200, headers=headers)
         self.content = [content]
         self.finish_response()
 
@@ -379,8 +406,11 @@
         try:
             resource = self._lookup_resource(environ, responder)
             HTTPInvocationByMethodWithBody(resource, environ)()
-        except (errors.RevisionConflict,), e:
-            responder.send_response(409, error=e.wire_description)
+        except errors.U1DBError, e:
+            status = http_errors.wire_description_to_status.get(
+                                                            e.wire_description,
+                                                            500)
+            responder.send_response(status, error=e.wire_description)
         except BadRequest:
             # xxx introduce logging
             #print environ['PATH_INFO']

=== modified file 'u1db/remote/http_client.py'
--- u1db/remote/http_client.py	2011-11-25 16:44:35 +0000
+++ u1db/remote/http_client.py	2011-11-29 10:29:24 +0000
@@ -22,6 +22,9 @@
 from u1db import (
     errors,
     )
+from u1db.remote import (
+    http_errors,
+    )
 
 
 class HTTPClientBase(object):
@@ -46,16 +49,22 @@
 
     def _response(self):
         resp = self._conn.getresponse()
+        body = resp.read()
+        headers = dict(resp.getheaders())
         if resp.status in (200, 201):
-            return resp.read(), dict(resp.getheaders())
-        elif resp.status in (409,):
-            # xxx be robust against non-json response bodies
-            respdic = simplejson.loads(resp.read())
-            exc_cls = errors.wire_description_to_exc.get(respdic.get("error"))
-            if exc_cls is not None:
-                message = respdic.get("message")
-                raise exc_cls(message)
-        raise errors.HTTPError(resp.status, resp.read())
+            return body, headers
+        elif resp.status in http_errors.ERROR_STATUSES:
+            try:
+                respdic = simplejson.loads(body)
+            except ValueError:
+                pass
+            else:
+                descr = respdic.get("error")
+                exc_cls = errors.wire_description_to_exc.get(descr)
+                if exc_cls is not None:
+                    message = respdic.get("message")
+                    raise exc_cls(message)
+        raise errors.HTTPError(resp.status, body, headers)
 
     def _request(self, method, url_parts, params=None, body=None,
                                                        content_type=None):

=== modified file 'u1db/remote/http_database.py'
--- u1db/remote/http_database.py	2011-11-25 15:01:59 +0000
+++ u1db/remote/http_database.py	2011-11-29 10:29:24 +0000
@@ -20,16 +20,24 @@
 from u1db import (
     Database,
     Document,
+    errors,
     )
 from u1db.remote import (
     http_client,
+    http_errors,
     )
 
 
+DOCUMENT_DELETED_STATUS = http_errors.wire_description_to_status[
+    errors.DOCUMENT_DELETED]
+
+
 class HTTPDatabase(http_client.HTTPClientBase, Database):
     """Implement the Database API to a remote HTTP server."""
 
     def put_doc(self, doc):
+        if doc.doc_id is None:
+            raise errors.InvalidDocId()
         params = {}
         if doc.rev is not None:
             params['old_rev'] = doc.rev
@@ -39,7 +47,17 @@
         return res['rev']
 
     def get_doc(self, doc_id):
-        res, headers = self._request('GET', ['doc', doc_id])
+        try:
+            res, headers = self._request('GET', ['doc', doc_id])
+        except errors.DocumentDoesNotExist:
+            return None
+        except errors.HTTPError, e:
+            if (e.status == DOCUMENT_DELETED_STATUS and
+                'x-u1db-rev' in e.headers):
+                res = None
+                headers = e.headers
+            else:
+                raise
         doc_rev = headers['x-u1db-rev']
         has_conflicts = simplejson.loads(headers['x-u1db-has-conflicts'])
         doc = Document(doc_id, doc_rev, res)
@@ -53,3 +71,11 @@
                                           content, 'application/json')
         new_doc = Document(doc_id, res['rev'], content)
         return new_doc
+
+    def delete_doc(self, doc):
+        if doc.doc_id is None:
+            raise errors.InvalidDocId()
+        params = {'old_rev': doc.rev}
+        res, headers = self._request_json('DELETE', ['doc', doc.doc_id], params)
+        doc.content = None
+        doc.rev = res['rev']

=== added file 'u1db/remote/http_errors.py'
--- u1db/remote/http_errors.py	1970-01-01 00:00:00 +0000
+++ u1db/remote/http_errors.py	2011-11-29 10:29:24 +0000
@@ -0,0 +1,34 @@
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Information about the encoding of errors over HTTP."""
+
+from u1db import (
+    errors,
+    )
+
+
+# error wire descriptions mapping to HTTP status codes
+wire_description_to_status = dict([
+    (errors.DocumentDoesNotExist.wire_description, 404),
+    (errors.DocumentAlreadyDeleted.wire_description, 404),
+    (errors.RevisionConflict.wire_description, 409),
+# without matching exception
+    (errors.DOCUMENT_DELETED, 404)
+])
+
+
+# 400 included for tests/anticipated usage
+ERROR_STATUSES = set(wire_description_to_status.values())|set([400])
+

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2011-11-28 14:58:52 +0000
+++ u1db/tests/test_backends.py	2011-11-29 10:29:24 +0000
@@ -48,6 +48,9 @@
                   'server_def': http_server_def}),
         ]
 
+    def test_close(self):
+        self.db.close()
+
     def test_create_doc_allocating_doc_id(self):
         doc = self.db.create_doc(simple_doc)
         self.assertNotEqual(None, doc.doc_id)
@@ -72,11 +75,15 @@
         new_rev = self.db.put_doc(doc)
         self.assertGetDoc(self.db, 'my_doc_id', new_rev, simple_doc, False)
 
-
-class LocalDatabaseTests(tests.DatabaseBaseTests):
-
-    def test_close(self):
-        self.db.close()
+    def test_put_doc_update(self):
+        doc = self.db.create_doc(simple_doc, doc_id='my_doc_id')
+        orig_rev = doc.rev
+        doc.content = '{"updated": "stuff"}'
+        new_rev = self.db.put_doc(doc)
+        self.assertNotEqual(new_rev, orig_rev)
+        self.assertGetDoc(self.db, 'my_doc_id', new_rev,
+                          '{"updated": "stuff"}', False)
+        self.assertEqual(doc.rev, new_rev)
 
     def test_put_doc_refuses_no_id(self):
         doc = Document(None, None, simple_doc)
@@ -86,6 +93,60 @@
         doc = Document('doc-id', 'test:4', simple_doc)
         self.assertRaises(errors.RevisionConflict, self.db.put_doc, doc)
 
+    def test_put_fails_with_bad_old_rev(self):
+        doc = self.db.create_doc(simple_doc, doc_id='my_doc_id')
+        old_rev = doc.rev
+        doc.rev = 'other:1'
+        doc.content = '{"something": "else"}'
+        self.assertRaises(errors.RevisionConflict, self.db.put_doc, doc)
+        self.assertGetDoc(self.db, 'my_doc_id', old_rev, simple_doc, False)
+
+    def test_get_doc_after_put(self):
+        doc = self.db.create_doc(simple_doc, doc_id='my_doc_id')
+        self.assertGetDoc(self.db, 'my_doc_id', doc.rev, simple_doc, False)
+
+    def test_get_doc_nonexisting(self):
+        self.assertIs(None, self.db.get_doc('non-existing'))
+
+    def test_handles_nested_content(self):
+        doc = self.db.create_doc(nested_doc)
+        self.assertGetDoc(self.db, doc.doc_id, doc.rev, nested_doc, False)
+
+    def test_handles_doc_with_null(self):
+        doc = self.db.create_doc('{"key": null}')
+        self.assertGetDoc(self.db, doc.doc_id, doc.rev, '{"key": null}', False)
+
+    def test_delete_doc(self):
+        doc = self.db.create_doc(simple_doc)
+        self.assertGetDoc(self.db, doc.doc_id, doc.rev, simple_doc, False)
+        orig_rev = doc.rev
+        self.db.delete_doc(doc)
+        self.assertNotEqual(orig_rev, doc.rev)
+        self.assertGetDoc(self.db, doc.doc_id, doc.rev, None, False)
+        self.assertIsNot(None, self.db.get_doc(doc.doc_id))
+
+    def test_delete_doc_non_existant(self):
+        doc = Document('non-existing', 'other:1', simple_doc)
+        self.assertRaises(errors.DocumentDoesNotExist,
+            self.db.delete_doc, doc)
+
+    def test_delete_doc_already_deleted(self):
+        doc = self.db.create_doc(simple_doc)
+        self.db.delete_doc(doc)
+        self.assertRaises(errors.DocumentAlreadyDeleted,
+                          self.db.delete_doc, doc)
+        self.assertGetDoc(self.db, doc.doc_id, doc.rev, None, False)
+
+    def test_delete_doc_bad_rev(self):
+        doc1 = self.db.create_doc(simple_doc)
+        self.assertGetDoc(self.db, doc1.doc_id, doc1.rev, simple_doc, False)
+        doc2 = Document(doc1.doc_id, 'other:1', simple_doc)
+        self.assertRaises(errors.RevisionConflict, self.db.delete_doc, doc2)
+        self.assertGetDoc(self.db, doc1.doc_id, doc1.rev, simple_doc, False)
+
+
+class LocalDatabaseTests(tests.DatabaseBaseTests):
+
     def test_get_docs(self):
         doc1 = self.db.create_doc(simple_doc)
         doc2 = self.db.create_doc(nested_doc)
@@ -183,11 +244,6 @@
     def test_get_docs_empty_list(self):
         self.assertEqual([], self.db.get_docs([]))
 
-    def test_put_doc_creating_initial(self):
-        doc = Document('my_doc_id', None, simple_doc)
-        new_rev = self.db.put_doc(doc)
-        self.assertGetDoc(self.db, 'my_doc_id', new_rev, simple_doc, False)
-
     def test_simple_put_doc_if_newer(self):
         doc = Document('my-doc-id', 'test:1', simple_doc)
         state = self.db.put_doc_if_newer(doc)
@@ -231,53 +287,11 @@
                           (doc1.rev, simple_doc)],
                          self.db.get_doc_conflicts(doc1.doc_id))
 
-    def test_get_doc_after_put(self):
-        doc = self.db.create_doc(simple_doc, doc_id='my_doc_id')
-        self.assertGetDoc(self.db, 'my_doc_id', doc.rev, simple_doc, False)
-
-    def test_get_doc_nonexisting(self):
-        self.assertIs(None, self.db.get_doc('non-existing'))
-
     def test_get_sync_generation(self):
         self.assertEqual(0, self.db.get_sync_generation('other-db'))
         self.db.set_sync_generation('other-db', 2)
         self.assertEqual(2, self.db.get_sync_generation('other-db'))
 
-    def test_put_fails_with_bad_old_rev(self):
-        doc = self.db.create_doc(simple_doc, doc_id='my_doc_id')
-        old_rev = doc.rev
-        doc.rev = 'other:1'
-        doc.content = '{"something": "else"}'
-        self.assertRaises(errors.RevisionConflict, self.db.put_doc, doc)
-        self.assertGetDoc(self.db, 'my_doc_id', old_rev, simple_doc, False)
-
-    def test_delete_doc(self):
-        doc = self.db.create_doc(simple_doc)
-        self.assertGetDoc(self.db, doc.doc_id, doc.rev, simple_doc, False)
-        orig_rev = doc.rev
-        self.db.delete_doc(doc)
-        self.assertNotEqual(orig_rev, doc.rev)
-        self.assertGetDoc(self.db, doc.doc_id, doc.rev, None, False)
-        self.assertIsNot(None, self.db.get_doc(doc.doc_id))
-
-    def test_delete_doc_non_existant(self):
-        doc = Document('non-existing', 'other:1', simple_doc)
-        self.assertRaises(KeyError,
-            self.db.delete_doc, doc)
-
-    def test_delete_doc_already_deleted(self):
-        doc = self.db.create_doc(simple_doc)
-        self.db.delete_doc(doc)
-        self.assertRaises(KeyError, self.db.delete_doc, doc)
-        self.assertGetDoc(self.db, doc.doc_id, doc.rev, None, False)
-
-    def test_delete_doc_bad_rev(self):
-        doc1 = self.db.create_doc(simple_doc)
-        self.assertGetDoc(self.db, doc1.doc_id, doc1.rev, simple_doc, False)
-        doc2 = Document(doc1.doc_id, 'other:1', simple_doc)
-        self.assertRaises(errors.RevisionConflict, self.db.delete_doc, doc2)
-        self.assertGetDoc(self.db, doc1.doc_id, doc1.rev, simple_doc, False)
-
     def test_put_updates_transaction_log(self):
         doc = self.db.create_doc(simple_doc)
         self.assertEqual([doc.doc_id], self.db._get_transaction_log())
@@ -303,14 +317,6 @@
         self.assertEqual((2, set([doc.doc_id])), self.db.whats_changed())
         self.assertEqual((2, set()), self.db.whats_changed(2))
 
-    def test_handles_nested_content(self):
-        doc = self.db.create_doc(nested_doc)
-        self.assertGetDoc(self.db, doc.doc_id, doc.rev, nested_doc, False)
-
-    def test_handles_doc_with_null(self):
-        doc = self.db.create_doc('{"key": null}')
-        self.assertGetDoc(self.db, doc.doc_id, doc.rev, '{"key": null}', False)
-
 
 class DatabaseIndexTests(tests.DatabaseBaseTests):
 

=== modified file 'u1db/tests/test_http_app.py'
--- u1db/tests/test_http_app.py	2011-11-25 15:01:59 +0000
+++ u1db/tests/test_http_app.py	2011-11-29 10:29:24 +0000
@@ -26,6 +26,7 @@
 
 from u1db.remote import (
     http_app,
+    http_errors,
     )
 
 
@@ -160,6 +161,13 @@
         self.assertRaises(http_app.BadRequest, f, "self",
                                                   {"a": "x", "b": "foo"}, None)
 
+    def test_args_conversion_with_default(self):
+        @http_app.http_method(b=str)
+        def f(self, a, b=None):
+            return self, a, b
+        res = f("self", {"a": "x"}, None)
+        self.assertEqual(("self", "x", None), res)
+
     def test_args_content(self):
         @http_app.http_method()
         def f(self, a, content):
@@ -432,6 +440,15 @@
         self.assertEqual('application/json', resp.header('content-type'))
         self.assertEqual({'rev': doc.rev}, simplejson.loads(resp.body))
 
+    def test_delete_doc(self):
+        doc = self.db0.create_doc('{"x": 1}', doc_id='doc1')
+        resp = self.app.delete('/db0/doc/doc1?old_rev=%s' % doc.rev)
+        doc = self.db0.get_doc('doc1')
+        self.assertEqual(None, doc.content)
+        self.assertEqual(200, resp.status)
+        self.assertEqual('application/json', resp.header('content-type'))
+        self.assertEqual({'rev': doc.rev}, simplejson.loads(resp.body))
+
     def test_get_doc(self):
         doc = self.db0.create_doc('{"x": 1}', doc_id='doc1')
         resp = self.app.get('/db0/doc/%s' % doc.doc_id)
@@ -441,6 +458,26 @@
         self.assertEqual(doc.rev, resp.header('x-u1db-rev'))
         self.assertEqual('false', resp.header('x-u1db-has-conflicts'))
 
+    def test_get_doc_non_existing(self):
+        resp = self.app.get('/db0/doc/not-there', expect_errors=True)
+        self.assertEqual(404, resp.status)
+        self.assertEqual('application/json', resp.header('content-type'))
+        self.assertEqual({"error": "document does not exist"},
+                         simplejson.loads(resp.body))
+        self.assertEqual('', resp.header('x-u1db-rev'))
+        self.assertEqual('false', resp.header('x-u1db-has-conflicts'))
+
+    def test_get_doc_deleted(self):
+        doc = self.db0.create_doc('{"x": 1}', doc_id='doc1')
+        self.db0.delete_doc(doc)
+        resp = self.app.get('/db0/doc/doc1', expect_errors=True)
+        self.assertEqual(404, resp.status)
+        self.assertEqual('application/json', resp.header('content-type'))
+        self.assertEqual({"error": errors.DOCUMENT_DELETED},
+                         simplejson.loads(resp.body))
+        self.assertEqual(doc.rev, resp.header('x-u1db-rev'))
+        self.assertEqual('false', resp.header('x-u1db-has-conflicts'))
+
     def test_get_sync_info(self):
         self.db0.set_sync_generation('other-id', 1)
         resp = self.app.get('/db0/sync-from/other-id')
@@ -497,6 +534,12 @@
                          simplejson.loads(parts[1]))
 
 
+class TestHTTPErrors(tests.TestCase):
+
+    def test_wire_description_to_status(self):
+        self.assertNotIn("error", http_errors.wire_description_to_status)
+
+
 class TestHTTPAppErrorHandling(tests.TestCase):
 
     def setUp(self):
@@ -515,7 +558,7 @@
         application._lookup_resource = lookup_resource
         self.app = paste.fixture.TestApp(application)
 
-    def test_RevisionConflict(self):
+    def test_RevisionConflict_etc(self):
         self.exc = errors.RevisionConflict()
         resp = self.app.post('/req', params='{}',
                              headers={'content-type': 'application/json'},
@@ -524,3 +567,13 @@
         self.assertEqual('application/json', resp.header('content-type'))
         self.assertEqual({"error": "revision conflict"},
                          simplejson.loads(resp.body))
+
+    def test_generic_u1db_errors(self):
+        self.exc = errors.U1DBError()
+        resp = self.app.post('/req', params='{}',
+                             headers={'content-type': 'application/json'},
+                             expect_errors=True)
+        self.assertEqual(500, resp.status)
+        self.assertEqual('application/json', resp.header('content-type'))
+        self.assertEqual({"error": "error"},
+                         simplejson.loads(resp.body))

=== modified file 'u1db/tests/test_http_client.py'
--- u1db/tests/test_http_client.py	2011-11-25 14:48:06 +0000
+++ u1db/tests/test_http_client.py	2011-11-29 10:29:24 +0000
@@ -42,12 +42,14 @@
         elif environ['PATH_INFO'].endswith('error'):
             content_length = int(environ['CONTENT_LENGTH'])
             error = simplejson.loads(environ['wsgi.input'].read(content_length))
-            start_response(error['status'],
-                           [('Content-Type', 'application/json')])
             response = error['response']
             if isinstance(response, basestring):
+                start_response(error['status'],
+                               [('Content-Type', 'text/plain')])
                 return [response]
             else:
+                start_response(error['status'],
+                               [('Content-Type', 'application/json')])
                 return [simplejson.dumps(error['response'])]
 
     def server_def(self):
@@ -142,6 +144,7 @@
 
         self.assertEqual(500, e.status)
         self.assertEqual("Fail.", e.message)
+        self.assertTrue("content-type" in e.headers)
 
     def test_revision_conflict(self):
         cli = self.getClient()
@@ -149,3 +152,34 @@
                           cli._request_json, 'POST', ['error'], {},
                           {'status': "409 Conflict",
                            'response': {"error": "revision conflict"}})
+
+    def test_generic_u1db_error(self):
+        cli = self.getClient()
+        self.assertRaises(errors.U1DBError,
+                          cli._request_json, 'POST', ['error'], {},
+                          {'status': "400 Bad Request",
+                           'response': {"error": "error"}})
+        try:
+            cli._request_json('POST', ['error'], {},
+                              {'status': "400 Bad Request",
+                               'response': {"error": "error"}})
+        except errors.U1DBError, e:
+            pass
+        self.assertIs(e.__class__, errors.U1DBError)
+
+    def test_unspecified_bad_request(self):
+        cli = self.getClient()
+        self.assertRaises(errors.HTTPError,
+                          cli._request_json, 'POST', ['error'], {},
+                          {'status': "400 Bad Request",
+                           'response': "<Bad Request>"})
+        try:
+            cli._request_json('POST', ['error'], {},
+                              {'status': "400 Bad Request",
+                               'response': "<Bad Request>"})
+        except errors.HTTPError, e:
+            pass
+
+        self.assertEqual(400, e.status)
+        self.assertEqual("<Bad Request>", e.message)
+        self.assertTrue("content-type" in e.headers)

=== modified file 'u1db/tests/test_http_database.py'
--- u1db/tests/test_http_database.py	2011-11-25 15:01:59 +0000
+++ u1db/tests/test_http_database.py	2011-11-29 10:29:24 +0000
@@ -15,8 +15,10 @@
 """Tests for HTTPDatabase"""
 
 import inspect
+import simplejson
 
 from u1db import (
+    errors,
     Document,
     tests,
     )
@@ -36,10 +38,14 @@
         def _request(method, url_parts, params=None, body=None,
                                                      content_type=None):
             self.got = method, url_parts, params, body, content_type
+            if isinstance(self.response_val, Exception):
+                raise self.response_val
             return self.response_val
         def _request_json(method, url_parts, params=None, body=None,
                                                           content_type=None):
             self.got = method, url_parts, params, body, content_type
+            if isinstance(self.response_val, Exception):
+                raise self.response_val
             return self.response_val
         self.db._request = _request
         self.db._request_json = _request_json
@@ -79,6 +85,29 @@
         self.assertEqual(('GET', ['doc', 'doc-id'], None, None, None),
                          self.got)
 
+    def test_get_doc_non_existing(self):
+        self.response_val = errors.DocumentDoesNotExist()
+        self.assertIs(None, self.db.get_doc('not-there'))
+        self.assertEqual(('GET', ['doc', 'not-there'], None, None, None),
+                         self.got)
+
+    def test_get_doc_deleted(self):
+        self.response_val = errors.HTTPError(404,
+                                             simplejson.dumps(
+                                             {"error": errors.DOCUMENT_DELETED}
+                                             ),
+                                             {'x-u1db-rev': 'doc-rev-gone',
+                                              'x-u1db-has-conflicts': 'false'})
+        doc = self.db.get_doc('deleted')
+        self.assertEqual('deleted', doc.doc_id)
+        self.assertEqual('doc-rev-gone', doc.rev)
+        self.assertIs(None, doc.content)
+
+    def test_get_doc_pass_through_errors(self):
+        self.response_val = errors.HTTPError(500, 'Crash.')
+        self.assertRaises(errors.HTTPError,
+                          self.db.get_doc, 'something-something')
+
     def test_create_doc_with_id(self):
         self.response_val = {'rev': 'doc-rev'}, {}
         new_doc = self.db.create_doc('{"v": 1}', doc_id='doc-id')
@@ -95,3 +124,11 @@
         self.assertEqual('{"v": 3}', new_doc.content)
         self.assertEqual(('PUT', ['doc', new_doc.doc_id], {},
                           '{"v": 3}', 'application/json'), self.got)
+
+    def test_delete_doc(self):
+        self.response_val = {'rev': 'doc-rev-gone'}, {}
+        doc = Document('doc-id', 'doc-rev', None)
+        self.db.delete_doc(doc)
+        self.assertEqual('doc-rev-gone', doc.rev)
+        self.assertEqual(('DELETE', ['doc', 'doc-id'], {'old_rev': 'doc-rev'},
+                          None, None), self.got)