Prevent file descriptor leaks on tests.

10 files changed, 106 insertions, 60 deletions

diff --git a/common/src/leap/soledad/common/tests/test_couch.py b/common/src/leap/soledad/common/tests/test_couch.py
index 77c46e61..17d4a519 100644
--- a/common/src/leap/soledad/common/tests/test_couch.py
+++ b/common/src/leap/soledad/common/tests/test_couch.py
@@ -27,8 +27,8 @@ from base64 import b64decode
 from mock import Mock
 from urlparse import urljoin
 
-from couchdb.client import Server
 from u1db import errors as u1db_errors
+from couchdb.client import Server
 
 from leap.common.files import mkdir_p
 
@@ -186,8 +186,9 @@ def copy_couch_database_for_test(test, db):
         create=True,
         replica_uid=db._replica_uid or 'test')
     # copy all docs
-    old_couch_db = Server(couch_url)[db._replica_uid]
-    new_couch_db = Server(couch_url)[new_dbname]
+    session = couch.Session()
+    old_couch_db = Server(couch_url, session=session)[db._replica_uid]
+    new_couch_db = Server(couch_url, session=session)[new_dbname]
     for doc_id in old_couch_db:
         doc = old_couch_db.get(doc_id)
         # bypass u1db_config document
@@ -217,6 +218,8 @@ def copy_couch_database_for_test(test, db):
                 if (att is not None):
                     new_couch_db.put_attachment(new_doc, att,
                                                 filename=att_name)
+    # cleanup connections to prevent file descriptor leaking
+    session.close_connections()
     return new_db
 
 
@@ -249,8 +252,10 @@ class CouchTests(test_backends.AllDatabaseTests, CouchDBTestCase):
         if self.id() == \
                 'leap.soledad.common.tests.test_couch.CouchTests.' \
                 'test_close(couch)':
-            server = Server(url=self._url)
+            session = couch.Session()
+            server = Server(url=self._url, session=session)
             del(server[self._dbname])
+            session.close_connections()
         else:
             self.db.delete_database()
         test_backends.AllDatabaseTests.tearDown(self)
@@ -367,10 +372,9 @@ from u1db.backends.inmemory import InMemoryIndex
 
 class IndexedCouchDatabase(couch.CouchDatabase):
 
-    def __init__(self, url, dbname, replica_uid=None, ensure_ddocs=True,
-            session=None):
+    def __init__(self, url, dbname, replica_uid=None, ensure_ddocs=True):
         old_class.__init__(self, url, dbname, replica_uid=replica_uid, 
-                           ensure_ddocs=ensure_ddocs, session=session)
+                           ensure_ddocs=ensure_ddocs)
         self._indexes = {}
 
     def _put_doc(self, old_doc, doc):
@@ -459,19 +463,22 @@ class CouchDatabaseSyncTests(test_sync.DatabaseSyncTests, CouchDBTestCase):
         self.db1 = None
         self.db2 = None
         self.db3 = None
+        self.db1_copy = None
+        self.db2_copy = None
         test_sync.DatabaseSyncTests.setUp(self)
 
     def tearDown(self):
-        self.db and self.db.delete_database()
-        self.db1 and self.db1.delete_database()
-        self.db2 and self.db2.delete_database()
-        self.db3 and self.db3.delete_database()
-        db = self.create_database('test1_copy', 'source')
-        db.delete_database()
-        db = self.create_database('test2_copy', 'target')
-        db.delete_database()
-        db = self.create_database('test3', 'target')
-        db.delete_database()
+        for db in [self.db, self.db1, self.db2, self.db3, self.db1_copy,
+                self.db2_copy]:
+            if db is not None:
+                db.delete_database()
+                db.close()
+        for replica_uid, dbname in [('test1_copy', 'source'),
+                ('test2_copy', 'target'), ('test3', 'target')]:
+            db = self.create_database(replica_uid, dbname)
+            db.delete_database()
+            # cleanup connections to avoid leaking of file descriptors
+            db.close()
         test_sync.DatabaseSyncTests.tearDown(self)
 
 
@@ -486,6 +493,7 @@ class CouchDatabaseExceptionsTests(CouchDBTestCase):
 
     def tearDown(self):
         self.db.delete_database()
+        self.db.close()
 
     def test_missing_design_doc_raises(self):
         """
diff --git a/common/src/leap/soledad/common/tests/test_couch_operations_atomicity.py b/common/src/leap/soledad/common/tests/test_couch_operations_atomicity.py
index 3c219b91..b03f79e7 100644
--- a/common/src/leap/soledad/common/tests/test_couch_operations_atomicity.py
+++ b/common/src/leap/soledad/common/tests/test_couch_operations_atomicity.py
@@ -114,6 +114,7 @@ class CouchAtomicityTestCase(CouchDBTestCase, TestCaseWithServer):
 
     def tearDown(self):
         self.db.delete_database()
+        self.db.close()
         CouchDBTestCase.tearDown(self)
         TestCaseWithServer.tearDown(self)
 
@@ -218,6 +219,7 @@ class CouchAtomicityTestCase(CouchDBTestCase, TestCaseWithServer):
 
         _create_docs_and_sync(sol, 0)
         _create_docs_and_sync(sol, 1)
+        sol.close()
 
     #
     # Concurrency tests
@@ -351,6 +353,7 @@ class CouchAtomicityTestCase(CouchDBTestCase, TestCaseWithServer):
             self.assertEqual(
                 1,
                 len(filter(lambda t: t[0] == doc_id, transaction_log)))
+        sol.close()
 
     def test_concurrent_syncs_do_not_fail(self):
         """
@@ -394,3 +397,4 @@ class CouchAtomicityTestCase(CouchDBTestCase, TestCaseWithServer):
             self.assertEqual(
                 1,
                 len(filter(lambda t: t[0] == doc_id, transaction_log)))
+        sol.close()
diff --git a/common/src/leap/soledad/common/tests/test_crypto.py b/common/src/leap/soledad/common/tests/test_crypto.py
index af11bc76..4b2470ba 100644
--- a/common/src/leap/soledad/common/tests/test_crypto.py
+++ b/common/src/leap/soledad/common/tests/test_crypto.py
@@ -44,7 +44,6 @@ from leap.soledad.common.crypto import WrongMac, UnknownMacMethod
 from leap.soledad.common.tests.u1db_tests import (
     simple_doc,
     nested_doc,
-    TestCaseWithServer,
 )
 
 
@@ -95,6 +94,7 @@ class RecoveryDocumentTestCase(BaseSoledadTest):
         self.assertEqual(self._soledad._get_storage_secret(),
                          s._get_storage_secret(),
                          'Failed settinng secret for symmetric encryption.')
+        s.close()
 
 
 class SoledadSecretsTestCase(BaseSoledadTest):
@@ -110,6 +110,7 @@ class SoledadSecretsTestCase(BaseSoledadTest):
         # generate new secret
         secret_id_2 = sol._gen_secret()
         self.assertTrue(secret_id_1 != secret_id_2)
+        sol.close()
         # re-instantiate
         sol = self._soledad_instance(
             user='user@leap.se',
@@ -130,6 +131,7 @@ class SoledadSecretsTestCase(BaseSoledadTest):
         # assert id is hash of new secret
         self.assertTrue(
             secret_id_2 == hashlib.sha256(sol.storage_secret).hexdigest())
+        sol.close()
 
     def test__has_secret(self):
         sol = self._soledad_instance(
@@ -144,6 +146,7 @@ class SoledadSecretsTestCase(BaseSoledadTest):
         # but not being able to decrypt correctly should
         sol._secrets[sol.secret_id][sol.SECRET_KEY] = None
         self.assertFalse(sol._has_secret())
+        sol.close()
 
 
 class MacAuthTestCase(BaseSoledadTest):
diff --git a/common/src/leap/soledad/common/tests/test_server.py b/common/src/leap/soledad/common/tests/test_server.py
index 6fe9211c..1c5a7407 100644
--- a/common/src/leap/soledad/common/tests/test_server.py
+++ b/common/src/leap/soledad/common/tests/test_server.py
@@ -391,6 +391,9 @@ class EncryptedSyncTestCase(
         # assert incoming doc is equal to the first sent doc
         self.assertEqual(doc1, doc2)
         db.delete_database()
+        db.close()
+        sol1.close()
+        sol2.close()
 
     def test_encrypted_sym_sync_with_unicode_passphrase(self):
         """
@@ -450,6 +453,9 @@ class EncryptedSyncTestCase(
         # assert incoming doc is equal to the first sent doc
         self.assertEqual(doc1, doc2)
         db.delete_database()
+        db.close()
+        sol1.close()
+        sol2.close()
 
     def test_sync_very_large_files(self):
         """
@@ -492,6 +498,9 @@ class EncryptedSyncTestCase(
         self.assertEqual(doc1, doc2)
         # delete remote database
         db.delete_database()
+        db.close()
+        sol1.close()
+        sol2.close()
 
 
     def test_sync_many_small_files(self):
@@ -535,6 +544,9 @@ class EncryptedSyncTestCase(
             self.assertEqual(sol1.get_doc(doc.doc_id), doc)
         # delete remote database
         db.delete_database()
+        db.close()
+        sol1.close()
+        sol2.close()
 
 class LockResourceTestCase(
         CouchDBTestCase, TestCaseWithServer):
diff --git a/common/src/leap/soledad/common/tests/test_soledad.py b/common/src/leap/soledad/common/tests/test_soledad.py
index 035c5ac5..5a3bf2b0 100644
--- a/common/src/leap/soledad/common/tests/test_soledad.py
+++ b/common/src/leap/soledad/common/tests/test_soledad.py
@@ -49,6 +49,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
         secrets_path = os.path.dirname(sol.secrets_path)
         self.assertTrue(os.path.isdir(local_db_dir))
         self.assertTrue(os.path.isdir(secrets_path))
+        sol.close()
 
     def test__init_db(self):
         sol = self._soledad_instance()
@@ -61,6 +62,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
         sol._init_db()
         from leap.soledad.client.sqlcipher import SQLCipherDatabase
         self.assertIsInstance(sol._db, SQLCipherDatabase)
+        sol.close()
 
     def test__init_config_defaults(self):
         """
@@ -103,6 +105,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
             os.path.join(self.tempdir, 'value_2'),
             sol.local_db_path)
         self.assertEqual('value_1', sol.server_url)
+        sol.close()
 
     def test_change_passphrase(self):
         """
@@ -118,6 +121,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
 
         # change the passphrase
         sol.change_passphrase(u'654321')
+        sol.close()
 
         self.assertRaises(
             WrongMac,
@@ -132,6 +136,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
             prefix=self.rand_prefix)
         doc2 = sol2.get_doc(doc_id)
         self.assertEqual(doc, doc2)
+        sol2.close()
 
     def test_change_passphrase_with_short_passphrase_raises(self):
         """
@@ -145,6 +150,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
         self.assertRaises(
             PassphraseTooShort,
             sol.change_passphrase, u'54321')
+        sol.close()
 
     def test_get_passphrase(self):
         """
@@ -152,6 +158,7 @@ class AuxMethodsTestCase(BaseSoledadTest):
         """
         sol = self._soledad_instance()
         self.assertEqual('123', sol.passphrase)
+        sol.close()
 
 
 class SoledadSharedDBTestCase(BaseSoledadTest):
@@ -165,6 +172,9 @@ class SoledadSharedDBTestCase(BaseSoledadTest):
             'https://provider/', ADDRESS, document_factory=SoledadDocument,
             creds=None)
 
+    def tearDown(self):
+        BaseSoledadTest.tearDown(self)
+
     def test__get_secrets_from_shared_db(self):
         """
         Ensure the shared db is queried with the correct doc_id.
@@ -209,7 +219,7 @@ class SoledadSignalingTestCase(BaseSoledadTest):
         BaseSoledadTest.setUp(self)
 
     def tearDown(self):
-        pass
+        BaseSoledadTest.tearDown(self)
 
     def _pop_mock_call(self, mocked):
         mocked.call_args_list.pop()
@@ -283,6 +293,7 @@ class SoledadSignalingTestCase(BaseSoledadTest):
         # assert db was locked and unlocked
         sol._shared_db.lock.assert_called_with()
         sol._shared_db.unlock.assert_called_with('atoken')
+        sol.close()
 
     def test_stage2_bootstrap_signals(self):
         """
@@ -305,6 +316,7 @@ class SoledadSignalingTestCase(BaseSoledadTest):
             def __call__(self):
                 return self
 
+        sol.close()
         # reset mock
         soledad.client.signal.reset_mock()
         # get a fresh instance so it emits all bootstrap signals
@@ -328,6 +340,7 @@ class SoledadSignalingTestCase(BaseSoledadTest):
             proto.SOLEDAD_DONE_DOWNLOADING_KEYS,
             ADDRESS,
         )
+        sol.close()
 
     def test_stage1_bootstrap_signals(self):
         """
@@ -337,6 +350,7 @@ class SoledadSignalingTestCase(BaseSoledadTest):
         # get an existent instance so it emits only some of bootstrap signals
         sol = self._soledad_instance()
         self.assertEqual([], soledad.client.signal.mock_calls)
+        sol.close()
 
     def test_sync_signals(self):
         """
@@ -355,6 +369,7 @@ class SoledadSignalingTestCase(BaseSoledadTest):
             proto.SOLEDAD_DONE_DATA_SYNC,
             ADDRESS,
         )
+        sol.close()
 
     def test_need_sync_signals(self):
         """
@@ -375,3 +390,4 @@ class SoledadSignalingTestCase(BaseSoledadTest):
             ADDRESS,
         )
         SoledadSyncTarget.get_sync_info = old_get_sync_info
+        sol.close()
diff --git a/common/src/leap/soledad/common/tests/test_sqlcipher.py b/common/src/leap/soledad/common/tests/test_sqlcipher.py
index 66a673b6..c79a6045 100644
--- a/common/src/leap/soledad/common/tests/test_sqlcipher.py
+++ b/common/src/leap/soledad/common/tests/test_sqlcipher.py
@@ -469,11 +469,9 @@ class SQLCipherDatabaseSyncTests(
 
     def setUp(self):
         test_sync.DatabaseSyncTests.setUp(self)
-        BaseSoledadTest.setUp(self)
 
     def tearDown(self):
         test_sync.DatabaseSyncTests.tearDown(self)
-        BaseSoledadTest.tearDown(self)
 
     def test_sync_autoresolves(self):
         """
@@ -683,11 +681,9 @@ class SQLCipherSyncTargetTests(
 
     def setUp(self):
         test_sync.DatabaseSyncTargetTests.setUp(self)
-        #BaseSoledadTest.setUp(self)
 
     def tearDown(self):
         test_sync.DatabaseSyncTargetTests.tearDown(self)
-        BaseSoledadTest.tearDown(self)
 
     def test_sync_exchange(self):
         """
diff --git a/common/src/leap/soledad/common/tests/test_target.py b/common/src/leap/soledad/common/tests/test_target.py
index 5a541745..c1e00d52 100644
--- a/common/src/leap/soledad/common/tests/test_target.py
+++ b/common/src/leap/soledad/common/tests/test_target.py
@@ -272,11 +272,9 @@ class TestSoledadParsingSyncStream(
 
     def setUp(self):
         test_remote_sync_target.TestParsingSyncStream.setUp(self)
-        BaseSoledadTest.setUp(self)
 
     def tearDown(self):
         test_remote_sync_target.TestParsingSyncStream.tearDown(self)
-        BaseSoledadTest.tearDown(self)
 
     def test_extra_comma(self):
         """
@@ -646,6 +644,7 @@ class SoledadDatabaseSyncTargetTests(
         self.assertEqual(([], 1, last_trans_id),
                          (self.other_changes, new_gen, last_trans_id))
         self.assertEqual(10, self.st.get_sync_info('replica')[3])
+        sol.close()
 
     def test_sync_exchange_push_many(self):
         """
diff --git a/common/src/leap/soledad/common/tests/u1db_tests/__init__.py b/common/src/leap/soledad/common/tests/u1db_tests/__init__.py
index 3bc12487..99ff77b4 100644
--- a/common/src/leap/soledad/common/tests/u1db_tests/__init__.py
+++ b/common/src/leap/soledad/common/tests/u1db_tests/__init__.py
@@ -208,8 +208,8 @@ class DatabaseBaseTests(TestCase):
         self.db = self.create_database('test')
 
     def tearDown(self):
-        # TODO: Add close_database parameterization
-        # self.close_database(self.db)
+        if hasattr(self, 'db') and self.db is not None:
+            self.db.close()
         super(DatabaseBaseTests, self).tearDown()
 
     def assertTransactionLog(self, doc_ids, db):
@@ -335,6 +335,13 @@ class TestCaseWithServer(TestCase):
         super(TestCaseWithServer, self).setUp()
         self.server = self.server_thread = None
 
+    def tearDown(self):
+        if self.server is not None:
+            self.server.shutdown()
+            self.server_thread.join()
+            self.server.server_close()
+        super(TestCaseWithServer, self).tearDown()
+
     @property
     def url_scheme(self):
         return self.server_def()[-1]
diff --git a/common/src/leap/soledad/common/tests/u1db_tests/test_backends.py b/common/src/leap/soledad/common/tests/u1db_tests/test_backends.py
index d2a91d11..c0a7e1f7 100644
--- a/common/src/leap/soledad/common/tests/u1db_tests/test_backends.py
+++ b/common/src/leap/soledad/common/tests/u1db_tests/test_backends.py
@@ -355,6 +355,9 @@ class LocalDatabaseTests(tests.DatabaseBaseTests):
 
     scenarios = tests.LOCAL_DATABASES_SCENARIOS
 
+    def setUp(self):
+        tests.DatabaseBaseTests.setUp(self)
+
     def test_create_doc_different_ids_diff_db(self):
         doc1 = self.db.create_doc_from_json(simple_doc)
         db2 = self.create_database('other-uid')
diff --git a/common/src/leap/soledad/common/tests/u1db_tests/test_sync.py b/common/src/leap/soledad/common/tests/u1db_tests/test_sync.py
index 1f78f912..a37c36db 100644
--- a/common/src/leap/soledad/common/tests/u1db_tests/test_sync.py
+++ b/common/src/leap/soledad/common/tests/u1db_tests/test_sync.py
@@ -85,7 +85,6 @@ class DatabaseSyncTargetTests(tests.DatabaseBaseTests,
     whitebox = True
 
     def setUp(self):
-        tests.DatabaseBaseTests.setUp(self)
         tests.TestCaseWithServer.setUp(self)
         self.db, self.st = self.create_db_and_target(self)
         self.other_changes = []
@@ -94,7 +93,6 @@ class DatabaseSyncTargetTests(tests.DatabaseBaseTests,
         # We delete them explicitly, so that connections are cleanly closed
         del self.st
         self.db.close()
-        del self.db
         super(DatabaseSyncTargetTests, self).tearDown()
 
     def create_db_and_target(self, *args):
@@ -1013,30 +1011,30 @@ class DatabaseSyncTests(tests.DatabaseBaseTests,
     def test_sync_supersedes_conflicts(self):
         self.db1 = self.create_database('test1', 'both')
         self.db2 = self.create_database('test2', 'target')
-        db3 = self.create_database('test3', 'both')
+        self.db3 = self.create_database('test3', 'both')
         doc1 = self.db1.create_doc_from_json('{"a": 1}', doc_id='the-doc')
         self.db2.create_doc_from_json('{"b": 1}', doc_id='the-doc')
-        db3.create_doc_from_json('{"c": 1}', doc_id='the-doc')
-        self.sync(db3, self.db1)
+        self.db3.create_doc_from_json('{"c": 1}', doc_id='the-doc')
+        self.sync(self.db3, self.db1)
         self.assertEqual(
             self.db1._get_generation_info(),
-            db3._get_replica_gen_and_trans_id(self.db1._replica_uid))
+            self.db3._get_replica_gen_and_trans_id(self.db1._replica_uid))
         self.assertEqual(
-            db3._get_generation_info(),
-            self.db1._get_replica_gen_and_trans_id(db3._replica_uid))
-        self.sync(db3, self.db2)
+            self.db3._get_generation_info(),
+            self.db1._get_replica_gen_and_trans_id(self.db3._replica_uid))
+        self.sync(self.db3, self.db2)
         self.assertEqual(
             self.db2._get_generation_info(),
-            db3._get_replica_gen_and_trans_id(self.db2._replica_uid))
+            self.db3._get_replica_gen_and_trans_id(self.db2._replica_uid))
         self.assertEqual(
-            db3._get_generation_info(),
-            self.db2._get_replica_gen_and_trans_id(db3._replica_uid))
-        self.assertEqual(3, len(db3.get_doc_conflicts('the-doc')))
+            self.db3._get_generation_info(),
+            self.db2._get_replica_gen_and_trans_id(self.db3._replica_uid))
+        self.assertEqual(3, len(self.db3.get_doc_conflicts('the-doc')))
         doc1.set_json('{"a": 2}')
         self.db1.put_doc(doc1)
-        self.sync(db3, self.db1)
+        self.sync(self.db3, self.db1)
         # original doc1 should have been removed from conflicts
-        self.assertEqual(3, len(db3.get_doc_conflicts('the-doc')))
+        self.assertEqual(3, len(self.db3.get_doc_conflicts('the-doc')))
 
     def test_sync_stops_after_get_sync_info(self):
         self.db1 = self.create_database('test1', 'source')
@@ -1054,70 +1052,70 @@ class DatabaseSyncTests(tests.DatabaseBaseTests,
         self.db2 = self.create_database('test2', 'target')
         self.db1.create_doc_from_json(tests.simple_doc, doc_id='doc1')
         self.sync(self.db1, self.db2)
-        db1_copy = self.copy_database(self.db1)
+        self.db1_copy = self.copy_database(self.db1)
         self.db1.create_doc_from_json(tests.simple_doc, doc_id='doc2')
         self.sync(self.db1, self.db2)
         self.assertRaises(
-            errors.InvalidGeneration, self.sync, db1_copy, self.db2)
+            errors.InvalidGeneration, self.sync, self.db1_copy, self.db2)
 
     def test_sync_detects_rollback_in_target(self):
         self.db1 = self.create_database('test1', 'source')
         self.db2 = self.create_database('test2', 'target')
         self.db1.create_doc_from_json(tests.simple_doc, doc_id="divergent")
         self.sync(self.db1, self.db2)
-        db2_copy = self.copy_database(self.db2)
+        self.db2_copy = self.copy_database(self.db2)
         self.db2.create_doc_from_json(tests.simple_doc, doc_id='doc2')
         self.sync(self.db1, self.db2)
         self.assertRaises(
-            errors.InvalidGeneration, self.sync, self.db1, db2_copy)
+            errors.InvalidGeneration, self.sync, self.db1, self.db2_copy)
 
     def test_sync_detects_diverged_source(self):
         self.db1 = self.create_database('test1', 'source')
         self.db2 = self.create_database('test2', 'target')
-        db3 = self.copy_database(self.db1)
+        self.db3 = self.copy_database(self.db1)
         self.db1.create_doc_from_json(tests.simple_doc, doc_id="divergent")
-        db3.create_doc_from_json(tests.simple_doc, doc_id="divergent")
+        self.db3.create_doc_from_json(tests.simple_doc, doc_id="divergent")
         self.sync(self.db1, self.db2)
         self.assertRaises(
-            errors.InvalidTransactionId, self.sync, db3, self.db2)
+            errors.InvalidTransactionId, self.sync, self.db3, self.db2)
 
     def test_sync_detects_diverged_target(self):
         self.db1 = self.create_database('test1', 'source')
         self.db2 = self.create_database('test2', 'target')
-        db3 = self.copy_database(self.db2)
-        db3.create_doc_from_json(tests.nested_doc, doc_id="divergent")
+        self.db3 = self.copy_database(self.db2)
+        self.db3.create_doc_from_json(tests.nested_doc, doc_id="divergent")
         self.db1.create_doc_from_json(tests.simple_doc, doc_id="divergent")
         self.sync(self.db1, self.db2)
         self.assertRaises(
-            errors.InvalidTransactionId, self.sync, self.db1, db3)
+            errors.InvalidTransactionId, self.sync, self.db1, self.db3)
 
     def test_sync_detects_rollback_and_divergence_in_source(self):
         self.db1 = self.create_database('test1', 'source')
         self.db2 = self.create_database('test2', 'target')
         self.db1.create_doc_from_json(tests.simple_doc, doc_id='doc1')
         self.sync(self.db1, self.db2)
-        db1_copy = self.copy_database(self.db1)
+        self.db1_copy = self.copy_database(self.db1)
         self.db1.create_doc_from_json(tests.simple_doc, doc_id='doc2')
         self.db1.create_doc_from_json(tests.simple_doc, doc_id='doc3')
         self.sync(self.db1, self.db2)
-        db1_copy.create_doc_from_json(tests.simple_doc, doc_id='doc2')
-        db1_copy.create_doc_from_json(tests.simple_doc, doc_id='doc3')
+        self.db1_copy.create_doc_from_json(tests.simple_doc, doc_id='doc2')
+        self.db1_copy.create_doc_from_json(tests.simple_doc, doc_id='doc3')
         self.assertRaises(
-            errors.InvalidTransactionId, self.sync, db1_copy, self.db2)
+            errors.InvalidTransactionId, self.sync, self.db1_copy, self.db2)
 
     def test_sync_detects_rollback_and_divergence_in_target(self):
         self.db1 = self.create_database('test1', 'source')
         self.db2 = self.create_database('test2', 'target')
         self.db1.create_doc_from_json(tests.simple_doc, doc_id="divergent")
         self.sync(self.db1, self.db2)
-        db2_copy = self.copy_database(self.db2)
+        self.db2_copy = self.copy_database(self.db2)
         self.db2.create_doc_from_json(tests.simple_doc, doc_id='doc2')
         self.db2.create_doc_from_json(tests.simple_doc, doc_id='doc3')
         self.sync(self.db1, self.db2)
-        db2_copy.create_doc_from_json(tests.simple_doc, doc_id='doc2')
-        db2_copy.create_doc_from_json(tests.simple_doc, doc_id='doc3')
+        self.db2_copy.create_doc_from_json(tests.simple_doc, doc_id='doc2')
+        self.db2_copy.create_doc_from_json(tests.simple_doc, doc_id='doc3')
         self.assertRaises(
-            errors.InvalidTransactionId, self.sync, self.db1, db2_copy)
+            errors.InvalidTransactionId, self.sync, self.db1, self.db2_copy)
 
 
 class TestDbSync(tests.TestCaseWithServer):