[refactor] remove decpool

It's not being used

5 files changed, 15 insertions, 291 deletions

diff --git a/testing/tests/sync/test_encdecpool.py b/testing/tests/sync/test_encdecpool.py
index 4a32885e..7055a765 100644
--- a/testing/tests/sync/test_encdecpool.py
+++ b/testing/tests/sync/test_encdecpool.py
@@ -1,34 +1,11 @@
 # -*- coding: utf-8 -*-
-# test_encdecpool.py
-# Copyright (C) 2015 LEAP
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY 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/>.
-"""
-Tests for encryption and decryption pool.
-"""
 import json
-from random import shuffle
-
-from mock import MagicMock
 from twisted.internet.defer import inlineCallbacks
 
 from leap.soledad.client.encdecpool import SyncEncrypterPool
-from leap.soledad.client.encdecpool import SyncDecrypterPool
 
 from leap.soledad.common.document import SoledadDocument
 from test_soledad.util import BaseSoledadTest
-from twisted.internet import defer
 
 DOC_ID = "mydoc"
 DOC_REV = "rev"
@@ -69,238 +46,3 @@ class TestSyncEncrypterPool(BaseSoledadTest):
         encrypted = yield self._pool.get_encrypted_doc(DOC_ID, DOC_REV)
 
         self.assertIsNotNone(encrypted)
-
-
-class TestSyncDecrypterPool(BaseSoledadTest):
-
-    def _insert_doc_cb(self, doc, gen, trans_id):
-        """
-        Method used to mock the sync's return_doc_cb callback.
-        """
-        self._inserted_docs.append((doc, gen, trans_id))
-
-    def _setup_pool(self, sync_db=None):
-        sync_db = sync_db or self._soledad._sync_db
-        return SyncDecrypterPool(
-            self._soledad._crypto,
-            sync_db,
-            source_replica_uid=self._soledad._dbpool.replica_uid,
-            insert_doc_cb=self._insert_doc_cb)
-
-    def setUp(self):
-        BaseSoledadTest.setUp(self)
-        # setup the pool
-        self._pool = self._setup_pool()
-        # reset the inserted docs mock
-        self._inserted_docs = []
-
-    def tearDown(self):
-        if self._pool.running:
-            self._pool.stop()
-        BaseSoledadTest.tearDown(self)
-
-    def test_insert_received_doc(self):
-        """
-        Test that one document added to the pool is inserted using the
-        callback.
-        """
-        self._pool.start(1)
-        self._pool.insert_received_doc(
-            DOC_ID, DOC_REV, "{}", 1, "trans_id", 1)
-
-        def _assert_doc_was_inserted(_):
-            self.assertEqual(
-                self._inserted_docs,
-                [(SoledadDocument(DOC_ID, DOC_REV, "{}"), 1, u"trans_id")])
-
-        self._pool.deferred.addCallback(_assert_doc_was_inserted)
-        return self._pool.deferred
-
-    def test_looping_control(self):
-        """
-        Start and stop cleanly.
-        """
-        self._pool.start(10)
-        self.assertTrue(self._pool.running)
-        self._pool.stop()
-        self.assertFalse(self._pool.running)
-        self.assertTrue(self._pool.deferred.called)
-
-    def test_sync_id_col_is_created_if_non_existing_in_docs_recvd_table(self):
-        """
-        Test that docs_received table is migrated, and has the sync_id column
-        """
-        mock_run_query = MagicMock(return_value=defer.succeed(None))
-        mock_sync_db = MagicMock()
-        mock_sync_db.runQuery = mock_run_query
-        pool = self._setup_pool(mock_sync_db)
-        d = pool.start(10)
-        pool.stop()
-
-        def assert_trial_to_create_sync_id_column(_):
-            mock_run_query.assert_called_once_with(
-                "ALTER TABLE docs_received ADD COLUMN sync_id")
-
-        d.addCallback(assert_trial_to_create_sync_id_column)
-        return d
-
-    def test_insert_received_doc_many(self):
-        """
-        Test that many documents added to the pool are inserted using the
-        callback.
-        """
-        many = 100
-        self._pool.start(many)
-
-        # insert many docs in the pool
-        for i in xrange(many):
-            gen = idx = i + 1
-            doc_id = "doc_id: %d" % idx
-            rev = "rev: %d" % idx
-            content = {'idx': idx}
-            trans_id = "trans_id: %d" % idx
-            self._pool.insert_received_doc(
-                doc_id, rev, content, gen, trans_id, idx)
-
-        def _assert_doc_was_inserted(_):
-            self.assertEqual(many, len(self._inserted_docs))
-            idx = 1
-            for doc, gen, trans_id in self._inserted_docs:
-                expected_gen = idx
-                expected_doc_id = "doc_id: %d" % idx
-                expected_rev = "rev: %d" % idx
-                expected_content = json.dumps({'idx': idx})
-                expected_trans_id = "trans_id: %d" % idx
-
-                self.assertEqual(expected_doc_id, doc.doc_id)
-                self.assertEqual(expected_rev, doc.rev)
-                self.assertEqual(expected_content, json.dumps(doc.content))
-                self.assertEqual(expected_gen, gen)
-                self.assertEqual(expected_trans_id, trans_id)
-
-                idx += 1
-
-        self._pool.deferred.addCallback(_assert_doc_was_inserted)
-        return self._pool.deferred
-
-    def test_insert_encrypted_received_doc(self):
-        """
-        Test that one encrypted document added to the pool is decrypted and
-        inserted using the callback.
-        """
-        crypto = self._soledad._crypto
-        doc = SoledadDocument(
-            doc_id=DOC_ID, rev=DOC_REV, json=json.dumps(DOC_CONTENT))
-        encrypted_content = json.loads(crypto.encrypt_doc(doc))
-
-        # insert the encrypted document in the pool
-        self._pool.start(1)
-        self._pool.insert_encrypted_received_doc(
-            DOC_ID, DOC_REV, encrypted_content, 1, "trans_id", 1)
-
-        def _assert_doc_was_decrypted_and_inserted(_):
-            self.assertEqual(1, len(self._inserted_docs))
-            self.assertEqual(self._inserted_docs, [(doc, 1, u"trans_id")])
-
-        self._pool.deferred.addCallback(
-            _assert_doc_was_decrypted_and_inserted)
-        return self._pool.deferred
-
-    @inlineCallbacks
-    def test_processing_order(self):
-        """
-        This test ensures that processing of documents only occur if there is
-        a sequence in place.
-        """
-        crypto = self._soledad._crypto
-
-        docs = []
-        for i in xrange(1, 10):
-            i = str(i)
-            doc = SoledadDocument(
-                doc_id=DOC_ID + i, rev=DOC_REV + i,
-                json=json.dumps(DOC_CONTENT))
-            encrypted_content = json.loads(crypto.encrypt_doc(doc))
-            docs.append((doc, encrypted_content))
-
-        # insert the encrypted document in the pool
-        yield self._pool.start(10)  # pool is expecting to process 10 docs
-        self._pool._loop.stop()  # we are processing manually
-        # first three arrives, forming a sequence
-        for i, (doc, encrypted_content) in enumerate(docs[:3]):
-            gen = idx = i + 1
-            yield self._pool.insert_encrypted_received_doc(
-                doc.doc_id, doc.rev, encrypted_content, gen, "trans_id", idx)
-
-        # last one arrives alone, so it can't be processed
-        doc, encrypted_content = docs[-1]
-        yield self._pool.insert_encrypted_received_doc(
-            doc.doc_id, doc.rev, encrypted_content, 10, "trans_id", 10)
-
-        yield self._pool._decrypt_and_recurse()
-
-        self.assertEqual(3, self._pool._processed_docs)
-
-    def test_insert_encrypted_received_doc_many(self, many=100):
-        """
-        Test that many encrypted documents added to the pool are decrypted and
-        inserted using the callback.
-        """
-        crypto = self._soledad._crypto
-        self._pool.start(many)
-        docs = []
-
-        # insert many encrypted docs in the pool
-        for i in xrange(many):
-            gen = idx = i + 1
-            doc_id = "doc_id: %d" % idx
-            rev = "rev: %d" % idx
-            content = {'idx': idx}
-            trans_id = "trans_id: %d" % idx
-
-            doc = SoledadDocument(
-                doc_id=doc_id, rev=rev, json=json.dumps(content))
-
-            encrypted_content = json.loads(crypto.encrypt_doc(doc))
-            docs.append((doc_id, rev, encrypted_content, gen,
-                         trans_id, idx))
-        shuffle(docs)
-
-        for doc in docs:
-            self._pool.insert_encrypted_received_doc(*doc)
-
-        def _assert_docs_were_decrypted_and_inserted(_):
-            self.assertEqual(many, len(self._inserted_docs))
-            idx = 1
-            for doc, gen, trans_id in self._inserted_docs:
-                expected_gen = idx
-                expected_doc_id = "doc_id: %d" % idx
-                expected_rev = "rev: %d" % idx
-                expected_content = json.dumps({'idx': idx})
-                expected_trans_id = "trans_id: %d" % idx
-
-                self.assertEqual(expected_doc_id, doc.doc_id)
-                self.assertEqual(expected_rev, doc.rev)
-                self.assertEqual(expected_content, json.dumps(doc.content))
-                self.assertEqual(expected_gen, gen)
-                self.assertEqual(expected_trans_id, trans_id)
-
-                idx += 1
-
-        self._pool.deferred.addCallback(
-            _assert_docs_were_decrypted_and_inserted)
-        return self._pool.deferred
-
-    @inlineCallbacks
-    def test_pool_reuse(self):
-        """
-        The pool is reused between syncs, this test verifies that
-        reusing is fine.
-        """
-        for i in xrange(3):
-            yield self.test_insert_encrypted_received_doc_many(5)
-            self._inserted_docs = []
-            decrypted_docs = yield self._pool._get_docs(encrypted=False)
-            # check that decrypted docs staging is clean
-            self.assertEquals([], decrypted_docs)
-            self._pool.stop()
diff --git a/testing/tests/sync/test_sync.py b/testing/tests/sync/test_sync.py
index 5290003e..a7d0a92b 100644
--- a/testing/tests/sync/test_sync.py
+++ b/testing/tests/sync/test_sync.py
@@ -187,7 +187,7 @@ class TestSoledadDbSync(
         self.addCleanup(target.close)
         return sync.SoledadSynchronizer(
             self.db,
-            target).sync(defer_decryption=False)
+            target).sync()
 
     @defer.inlineCallbacks
     def test_db_sync(self):
diff --git a/testing/tests/sync/test_sync_deferred.py b/testing/tests/sync/test_sync_deferred.py
index 4948aaf8..482b150c 100644
--- a/testing/tests/sync/test_sync_deferred.py
+++ b/testing/tests/sync/test_sync_deferred.py
@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 """
-Test Leap backend bits: sync with deferred encryption/decryption.
+Test Leap backend bits: sync with deferred encryption.
 """
 import time
 import os
@@ -22,12 +22,8 @@ import random
 import string
 import shutil
 
-from urlparse import urljoin
-
 from twisted.internet import defer
 
-from leap.soledad.common import couch
-
 from leap.soledad.client import sync
 from leap.soledad.client.sqlcipher import SQLCipherOptions
 from leap.soledad.client.sqlcipher import SQLCipherDatabase
@@ -41,9 +37,6 @@ from test_soledad.util import make_soledad_app
 from test_soledad.util import soledad_sync_target
 
 
-# Just to make clear how this test is different... :)
-DEFER_DECRYPTION = True
-
 WAIT_STEP = 1
 MAX_WAIT = 10
 DBPASS = "pass"
@@ -52,7 +45,7 @@ DBPASS = "pass"
 class BaseSoledadDeferredEncTest(SoledadWithCouchServerMixin):
 
     """
-    Another base class for testing the deferred encryption/decryption during
+    Another base class for testing the deferred encryption during
     the syncs, using the intermediate database.
     """
     defer_sync_encryption = True
@@ -109,7 +102,7 @@ class TestSoledadDbSyncDeferredEncDecr(
 
     """
     Test db.sync remote sync shortcut.
-    Case with deferred encryption and decryption: using the intermediate
+    Case with deferred encryption: using the intermediate
     syncdb.
     """
 
@@ -158,7 +151,7 @@ class TestSoledadDbSyncDeferredEncDecr(
         self.addCleanup(target.close)
         return sync.SoledadSynchronizer(
             dbsyncer,
-            target).sync(defer_decryption=True)
+            target).sync()
 
     def wait_for_sync(self):
         """
diff --git a/testing/tests/sync/test_sync_mutex.py b/testing/tests/sync/test_sync_mutex.py
index 2626ab2a..2bcb3aec 100644
--- a/testing/tests/sync/test_sync_mutex.py
+++ b/testing/tests/sync/test_sync_mutex.py
@@ -47,7 +47,7 @@ from test_soledad.util import soledad_sync_target
 _old_sync = SoledadSynchronizer.sync
 
 
-def _timed_sync(self, defer_decryption=True):
+def _timed_sync(self):
     t = time.time()
 
     sync_id = uuid.uuid4()
@@ -62,7 +62,7 @@ def _timed_sync(self, defer_decryption=True):
         self.source.sync_times[sync_id]['end'] = t
         return passthrough
 
-    d = _old_sync(self, defer_decryption=defer_decryption)
+    d = _old_sync(self)
     d.addBoth(_store_finish_time)
     return d
 
diff --git a/testing/tests/sync/test_sync_target.py b/testing/tests/sync/test_sync_target.py
index 964468ce..a2935539 100644
--- a/testing/tests/sync/test_sync_target.py
+++ b/testing/tests/sync/test_sync_target.py
@@ -231,8 +231,7 @@ class TestSoledadSyncTarget(
         doc = self.make_document('doc-here', 'replica:1', '{"value": "here"}')
         new_gen, trans_id = yield remote_target.sync_exchange(
             [(doc, 10, 'T-sid')], 'replica', last_known_generation=0,
-            last_known_trans_id=None, insert_doc_cb=receive_doc,
-            defer_decryption=False)
+            last_known_trans_id=None, insert_doc_cb=receive_doc)
         self.assertEqual(1, new_gen)
         self.assertGetEncryptedDoc(
             db, 'doc-here', 'replica:1', '{"value": "here"}', False)
@@ -285,8 +284,7 @@ class TestSoledadSyncTarget(
                 'replica',
                 last_known_generation=0,
                 last_known_trans_id=None,
-                insert_doc_cb=receive_doc,
-                defer_decryption=False)
+                insert_doc_cb=receive_doc)
 
         self.assertGetEncryptedDoc(
             db, 'doc-here', 'replica:1', '{"value": "here"}',
@@ -298,8 +296,7 @@ class TestSoledadSyncTarget(
         trigger_ids = []
         new_gen, trans_id = yield remote_target.sync_exchange(
             [(doc2, 11, 'T-sud')], 'replica', last_known_generation=0,
-            last_known_trans_id=None, insert_doc_cb=receive_doc,
-            defer_decryption=False)
+            last_known_trans_id=None, insert_doc_cb=receive_doc)
         self.assertGetEncryptedDoc(
             db, 'doc-here2', 'replica:1', '{"value": "here2"}',
             False)
@@ -331,7 +328,7 @@ class TestSoledadSyncTarget(
         new_gen, trans_id = yield remote_target.sync_exchange(
             [(doc, 10, 'T-sid')], 'replica', last_known_generation=0,
             last_known_trans_id=None, insert_doc_cb=receive_doc,
-            ensure_callback=ensure_cb, defer_decryption=False)
+            ensure_callback=ensure_cb)
         self.assertEqual(1, new_gen)
         db = self.db2
         self.assertEqual(1, len(replica_uid_box))
@@ -446,8 +443,7 @@ class SoledadDatabaseSyncTargetTests(
              'T-sid')]
         new_gen, trans_id = yield self.st.sync_exchange(
             docs_by_gen, 'replica', last_known_generation=0,
-            last_known_trans_id=None, insert_doc_cb=self.receive_doc,
-            defer_decryption=False)
+            last_known_trans_id=None, insert_doc_cb=self.receive_doc)
         self.assertGetEncryptedDoc(
             self.db, 'doc-id', 'replica:1', tests.simple_doc, False)
         self.assertTransactionLog(['doc-id'], self.db)
@@ -471,8 +467,7 @@ class SoledadDatabaseSyncTargetTests(
                 'doc-id2', 'replica:1', tests.nested_doc), 11, 'T-2')]
         new_gen, trans_id = yield self.st.sync_exchange(
             docs_by_gen, 'replica', last_known_generation=0,
-            last_known_trans_id=None, insert_doc_cb=self.receive_doc,
-            defer_decryption=False)
+            last_known_trans_id=None, insert_doc_cb=self.receive_doc)
         self.assertGetEncryptedDoc(
             self.db, 'doc-id', 'replica:1', tests.simple_doc, False)
         self.assertGetEncryptedDoc(
@@ -498,8 +493,7 @@ class SoledadDatabaseSyncTargetTests(
         self.assertTransactionLog([doc.doc_id, doc2.doc_id], self.db)
         new_gen, _ = yield self.st.sync_exchange(
             [], 'other-replica', last_known_generation=0,
-            last_known_trans_id=None, insert_doc_cb=self.receive_doc,
-            defer_decryption=False)
+            last_known_trans_id=None, insert_doc_cb=self.receive_doc)
         self.assertTransactionLog([doc.doc_id, doc2.doc_id], self.db)
         self.assertEqual(2, new_gen)
         self.assertEqual(
@@ -779,10 +773,6 @@ class SoledadDatabaseSyncTargetTests(
         yield self.st.record_sync_info('replica', 0, 'T-sid')
         self.assertEqual(expected, called)
 
-
-# Just to make clear how this test is different... :)
-DEFER_DECRYPTION = False
-
 WAIT_STEP = 1
 MAX_WAIT = 10
 DBPASS = "pass"
@@ -890,8 +880,7 @@ class TestSoledadDbSync(
                 defer_encryption=True)
             self.dbsyncer = dbsyncer
             return dbsyncer.sync(target_url,
-                                 creds=creds,
-                                 defer_decryption=DEFER_DECRYPTION)
+                                 creds=creds)
         else:
             return self._do_sync(self, target_name)