Remove LeapDatabase because we don't need it (LeapSyncTarget does the job).

2 files changed, 5 insertions, 179 deletions

diff --git a/backends/leap_backend.py b/backends/leap_backend.py
index a2208404..c0a22feb 100644
--- a/backends/leap_backend.py
+++ b/backends/leap_backend.py
@@ -86,44 +86,6 @@ class LeapDocument(Document):
         doc="Wrapper to ensure `doc.rev` is always returned as bytes.")
 
 
-class LeapDatabase(HTTPDatabase):
-    """Implement the HTTP remote database API to a Leap server."""
-
-    def __init__(self, url, document_factory=None, creds=None, soledad=None):
-        super(LeapDatabase, self).__init__(url, creds=creds)
-        self._soledad = soledad
-
-        # wrap soledad in factory
-        def factory(doc_id=None, rev=None, json='{}', has_conflicts=False,
-                    encrypted_json=None, syncable=True):
-            return LeapDocument(doc_id=doc_id, rev=rev, json=json,
-                                has_conflicts=has_conflicts,
-                                encrypted_json=encrypted_json,
-                                syncable=syncable, soledad=self._soledad)
-        self.set_document_factory(factory)
-
-    @staticmethod
-    def open_database(url, create):
-        db = LeapDatabase(url)
-        db.open(create)
-        return db
-
-    @staticmethod
-    def delete_database(url):
-        db = LeapDatabase(url)
-        db._delete()
-        db.close()
-
-    def _allocate_doc_id(self):
-        """Generate a unique identifier for this document."""
-        return 'D-' + uuid.uuid4().hex  # 'D-' stands for document
-
-    def get_sync_target(self):
-        st = LeapSyncTarget(self._url.geturl())
-        st._creds = self._creds
-        return st
-
-
 class LeapSyncTarget(HTTPSyncTarget):
     """
     A SyncTarget that encrypts data before sending and decrypts data after
diff --git a/tests/test_leap_backend.py b/tests/test_leap_backend.py
index cdd60b10..a061533c 100644
--- a/tests/test_leap_backend.py
+++ b/tests/test_leap_backend.py
@@ -21,51 +21,9 @@ from leap.soledad.tests.u1db_tests import test_https
 
 
 #-----------------------------------------------------------------------------
-# The following tests come from `u1db.tests.test_common_backend`.
-#-----------------------------------------------------------------------------
-
-class TestLeapBackendImpl(tests.TestCase):
-
-    def test__allocate_doc_id(self):
-        db = leap_backend.LeapDatabase('test')
-        doc_id1 = db._allocate_doc_id()
-        self.assertTrue(doc_id1.startswith('D-'))
-        self.assertEqual(34, len(doc_id1))
-        int(doc_id1[len('D-'):], 16)
-        self.assertNotEqual(doc_id1, db._allocate_doc_id())
-
-
-#-----------------------------------------------------------------------------
 # The following tests come from `u1db.tests.test_backends`.
 #-----------------------------------------------------------------------------
 
-def make_leap_database_for_test(test, replica_uid, path='test'):
-    test.startServer()
-    test.request_state._create_database(replica_uid)
-    return leap_backend.LeapDatabase(test.getURL(path))
-
-
-def copy_leap_database_for_test(test, db):
-    # DO NOT COPY OR REUSE THIS CODE OUTSIDE TESTS: COPYING U1DB DATABASES IS
-    # THE WRONG THING TO DO, THE ONLY REASON WE DO SO HERE IS TO TEST THAT WE
-    # CORRECTLY DETECT IT HAPPENING SO THAT WE CAN RAISE ERRORS RATHER THAN
-    # CORRUPT USER DATA. USE SYNC INSTEAD, OR WE WILL SEND NINJA TO YOUR
-    # HOUSE.
-    return test.request_state._copy_database(db)
-
-
-def make_oauth_leap_database_for_test(test, replica_uid):
-    http_db = make_leap_database_for_test(test, replica_uid, '~/test')
-    http_db.set_oauth_credentials(tests.consumer1.key, tests.consumer1.secret,
-                                  tests.token1.key, tests.token1.secret)
-    return http_db
-
-
-def make_document_for_test(test, doc_id, rev, content, has_conflicts=False):
-    return leap_backend.LeapDocument(
-        doc_id, rev, content, has_conflicts=has_conflicts)
-
-
 def make_leap_document_for_test(test, doc_id, rev, content,
                                 has_conflicts=False):
     return leap_backend.LeapDocument(
@@ -82,10 +40,11 @@ def make_leap_encrypted_document_for_test(test, doc_id, rev, encrypted_content,
 
 
 LEAP_SCENARIOS = [
-    ('http', {'make_database_for_test': make_leap_database_for_test,
-              'copy_database_for_test': copy_leap_database_for_test,
-              'make_document_for_test': make_leap_document_for_test,
-              'make_app_with_state': make_http_app}),
+    ('http', {
+        'make_database_for_test': test_backends.make_http_database_for_test,
+        'copy_database_for_test': test_backends.copy_http_database_for_test,
+        'make_document_for_test': make_leap_document_for_test,
+        'make_app_with_state': make_http_app}),
 ]
 
 
@@ -95,101 +54,6 @@ class LeapTests(test_backends.AllDatabaseTests, BaseSoledadTest):
 
 
 #-----------------------------------------------------------------------------
-# The following tests come from `u1db.tests.test_http_database`.
-#-----------------------------------------------------------------------------
-
-class TestLeapDatabaseSimpleOperations(
-        test_http_database.TestHTTPDatabaseSimpleOperations):
-
-    def setUp(self):
-        super(test_http_database.TestHTTPDatabaseSimpleOperations,
-              self).setUp()
-        self.db = leap_backend.LeapDatabase('dbase')
-        self.db._conn = object()  # crash if used
-        self.got = None
-        self.response_val = None
-
-        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
-
-    def test_get_sync_target(self):
-        st = self.db.get_sync_target()
-        self.assertIsInstance(st, leap_backend.LeapSyncTarget)
-        self.assertEqual(st._url, self.db._url)
-
-
-class TestLeapDatabaseCtrWithCreds(
-        test_http_database.TestHTTPDatabaseCtrWithCreds):
-    pass
-
-
-class TestLeapDatabaseIntegration(
-        test_http_database.TestHTTPDatabaseIntegration):
-
-    def test_non_existing_db(self):
-        db = leap_backend.LeapDatabase(self.getURL('not-there'))
-        self.assertRaises(u1db.errors.DatabaseDoesNotExist, db.get_doc, 'doc1')
-
-    def test__ensure(self):
-        db = leap_backend.LeapDatabase(self.getURL('new'))
-        db._ensure()
-        self.assertIs(None, db.get_doc('doc1'))
-
-    def test__delete(self):
-        self.request_state._create_database('db0')
-        db = leap_backend.LeapDatabase(self.getURL('db0'))
-        db._delete()
-        self.assertRaises(u1db.errors.DatabaseDoesNotExist,
-                          self.request_state.check_database, 'db0')
-
-    def test_open_database_existing(self):
-        self.request_state._create_database('db0')
-        db = leap_backend.LeapDatabase.open_database(self.getURL('db0'),
-                                                     create=False)
-        self.assertIs(None, db.get_doc('doc1'))
-
-    def test_open_database_non_existing(self):
-        self.assertRaises(u1db.errors.DatabaseDoesNotExist,
-                          leap_backend.LeapDatabase.open_database,
-                          self.getURL('not-there'),
-                          create=False)
-
-    def test_open_database_create(self):
-        db = leap_backend.LeapDatabase.open_database(self.getURL('new'),
-                                                     create=True)
-        self.assertIs(None, db.get_doc('doc1'))
-
-    def test_delete_database_existing(self):
-        self.request_state._create_database('db0')
-        leap_backend.LeapDatabase.delete_database(self.getURL('db0'))
-        self.assertRaises(u1db.errors.DatabaseDoesNotExist,
-                          self.request_state.check_database, 'db0')
-
-    def test_doc_ids_needing_quoting(self):
-        db0 = self.request_state._create_database('db0')
-        db = leap_backend.LeapDatabase.open_database(self.getURL('db0'),
-                                                     create=False)
-        doc = leap_backend.LeapDocument('%fff', None, '{}')
-        db.put_doc(doc)
-        self.assertGetDoc(db0, '%fff', doc.rev, '{}', False)
-        self.assertGetDoc(db, '%fff', doc.rev, '{}', False)
-
-
-#-----------------------------------------------------------------------------
 # The following tests come from `u1db.tests.test_http_client`.
 #-----------------------------------------------------------------------------