Python sqlcipher.SQLCipherDatabase类代码示例

 def test__allocate_doc_id(self):
     db = SQLCipherDatabase(':memory:', PASSWORD)
     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())

 def test_open_existing(self):
     db = SQLCipherDatabase(self.db_path, PASSWORD)
     self.addCleanup(db.close)
     doc = db.create_doc_from_json(tests.simple_doc)
     # Even though create=True, we shouldn't wipe the db
     db2 = u1db_open(self.db_path, password=PASSWORD, create=True)
     self.addCleanup(db2.close)
     doc2 = db2.get_doc(doc.doc_id)
     self.assertEqual(doc, doc2)

 def test_delete_database_existent(self):
     temp_dir = self.createTempDir(prefix='u1db-test-')
     path = temp_dir + '/new.sqlite'
     db = sqlcipher_open(path, "123", create=True)
     db.close()
     SQLCipherDatabase.delete_database(path)
     self.assertRaises(errors.DatabaseDoesNotExist,
                       sqlcipher_open, path, "123",
                       create=False)

class BaseSoledadDeferredEncTest(SoledadWithCouchServerMixin):
    """
    Another base class for testing the deferred encryption/decryption during
    the syncs, using the intermediate database.
    """
    defer_sync_encryption = True

    def setUp(self):
        SoledadWithCouchServerMixin.setUp(self)
        # config info
        self.db1_file = os.path.join(self.tempdir, "db1.u1db")
        os.unlink(self.db1_file)
        self.db_pass = DBPASS
        self.email = ADDRESS

        # get a random prefix for each test, so we do not mess with
        # concurrency during initialization and shutting down of
        # each local db.
        self.rand_prefix = ''.join(
            map(lambda x: random.choice(string.ascii_letters), range(6)))

        # open test dbs: db1 will be the local sqlcipher db (which
        # instantiates a syncdb). We use the self._soledad instance that was
        # already created on some setUp method.
        import binascii
        tohex = binascii.b2a_hex
        key = tohex(self._soledad.secrets.get_local_storage_key())
        sync_db_key = tohex(self._soledad.secrets.get_sync_db_key())
        dbpath = self._soledad._local_db_path

        self.opts = SQLCipherOptions(
            dbpath, key, is_raw_key=True, create=False,
            defer_encryption=True, sync_db_key=sync_db_key)
        self.db1 = SQLCipherDatabase(self.opts)

        self.db2 = couch.CouchDatabase.open_database(
            urljoin(
                'http://localhost:' + str(self.wrapper.port), 'test'),
                create=True,
                ensure_ddocs=True)

    def tearDown(self):
        self.db1.close()
        self.db2.close()
        self._soledad.close()

        # XXX should not access "private" attrs
        shutil.rmtree(os.path.dirname(self._soledad._local_db_path))
        SoledadWithCouchServerMixin.tearDown(self)

    def test__open_database_during_init(self):
        temp_dir = self.createTempDir(prefix='u1db-test-')
        path = temp_dir + '/initialised.db'
        db = SQLCipherDatabase.__new__(
            SQLCipherDatabase)
        db._db_handle = dbapi2.connect(path)  # db is there but not yet init-ed
        db._syncers = {}
        c = db._db_handle.cursor()
        c.execute('PRAGMA key="%s"' % PASSWORD)
        self.addCleanup(db.close)
        observed = []

        class SQLiteDatabaseTesting(SQLCipherDatabase):
            WAIT_FOR_PARALLEL_INIT_HALF_INTERVAL = 0.1

            @classmethod
            def _which_index_storage(cls, c):
                res = SQLCipherDatabase._which_index_storage(c)
                db._ensure_schema()  # init db
                observed.append(res[0])
                return res

        db2 = SQLiteDatabaseTesting._open_database(path, PASSWORD)
        self.addCleanup(db2.close)
        self.assertIsInstance(db2, SQLCipherDatabase)
        self.assertEqual(
            [None,
             SQLCipherDatabase._index_storage_value],
            observed)

 def test_open_database_with_factory(self):
     temp_dir = self.createTempDir(prefix='u1db-test-')
     path = temp_dir + '/existing.sqlite'
     SQLCipherDatabase(path, PASSWORD)
     db2 = SQLCipherDatabase.open_database(
         path, PASSWORD, create=False,
         document_factory=TestAlternativeDocument)
     doc = db2.create_doc({})
     self.assertTrue(isinstance(doc, SoledadDocument))

def copy_sqlcipher_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.
    new_db = SQLCipherDatabase(':memory:', PASSWORD)
    tmpfile = StringIO()
    for line in db._db_handle.iterdump():
        if not 'sqlite_sequence' in line:  # work around bug in iterdump
            tmpfile.write('%s\n' % line)
    tmpfile.seek(0)
    new_db._db_handle = dbapi2.connect(':memory:')
    new_db._db_handle.cursor().executescript(tmpfile.read())
    new_db._db_handle.commit()
    new_db._set_replica_uid(db._replica_uid)
    new_db._factory = db._factory
    return new_db

 def _is_initialized(self, c):
     res = SQLCipherDatabase._is_initialized(self, c)
     if self._try == 1:
         self._is_initialized_invocations += 1
         if self._is_initialized_invocations == 2:
             t2.start()
             # hard to do better and have a generic test
             time.sleep(0.05)
     return res

 def test__update_indexes(self):
     self.db = SQLCipherDatabase(':memory:', PASSWORD)
     g = self.db._parse_index_definition('fieldname')
     c = self.db._get_sqlite_handle().cursor()
     self.db._update_indexes('doc-id', {'fieldname': 'val'},
                             [('fieldname', g)], c)
     c.execute('SELECT doc_id, field_name, value FROM document_fields')
     self.assertEqual([('doc-id', 'fieldname', 'val')],
                      c.fetchall())

 def test__set_replica_uid(self):
     # Start from scratch, so that replica_uid isn't set.
     self.db = SQLCipherDatabase(':memory:', PASSWORD)
     self.assertIsNot(None, self.db._real_replica_uid)
     self.assertIsNot(None, self.db._replica_uid)
     self.db._set_replica_uid('foo')
     c = self.db._get_sqlite_handle().cursor()
     c.execute("SELECT value FROM u1db_config WHERE name='replica_uid'")
     self.assertEqual(('foo',), c.fetchone())
     self.assertEqual('foo', self.db._real_replica_uid)
     self.assertEqual('foo', self.db._replica_uid)
     self.db._close_sqlite_handle()
     self.assertEqual('foo', self.db._replica_uid)

    def setUp(self):
        """
        Need to explicitely invoke inicialization on all bases.
        """
        SoledadWithCouchServerMixin.setUp(self)
        self.server = self.server_thread = None
        self.startServer()
        self.syncer = None

        # config info
        self.db1_file = os.path.join(self.tempdir, "db1.u1db")
        os.unlink(self.db1_file)
        self.db_pass = DBPASS
        self.email = ADDRESS

        # get a random prefix for each test, so we do not mess with
        # concurrency during initialization and shutting down of
        # each local db.
        self.rand_prefix = ''.join(
            map(lambda x: random.choice(string.ascii_letters), range(6)))

        # open test dbs: db1 will be the local sqlcipher db (which
        # instantiates a syncdb). We use the self._soledad instance that was
        # already created on some setUp method.
        import binascii
        tohex = binascii.b2a_hex
        key = tohex(self._soledad.secrets.get_local_storage_key())
        sync_db_key = tohex(self._soledad.secrets.get_sync_db_key())
        dbpath = self._soledad._local_db_path

        self.opts = SQLCipherOptions(
            dbpath, key, is_raw_key=True, create=False,
            defer_encryption=True, sync_db_key=sync_db_key)
        self.db1 = SQLCipherDatabase(self.opts)

        self.db2 = couch.CouchDatabase.open_database(
            urljoin(
                'http://localhost:' + str(self.wrapper.port), 'test'),
                create=True,
                ensure_ddocs=True)

 def test_try_to_open_encrypted_db_with_sqlite_backend(self):
     """
     SQLite backend should not succeed to open SQLCipher databases.
     """
     db = SQLCipherDatabase(self.DB_FILE, PASSWORD)
     doc = db.create_doc_from_json(tests.simple_doc)
     db.close()
     try:
         # trying to open an encrypted database with the regular u1db
         # backend should raise a DatabaseError exception.
         SQLitePartialExpandDatabase(self.DB_FILE,
                                     document_factory=SoledadDocument)
         raise DatabaseIsNotEncrypted()
     except dbapi2.DatabaseError:
         # at this point we know that the regular U1DB sqlcipher backend
         # did not succeed on opening the database, so it was indeed
         # encrypted.
         db = SQLCipherDatabase(self.DB_FILE, PASSWORD)
         doc = db.get_doc(doc.doc_id)
         self.assertEqual(tests.simple_doc, doc.get_json(),
                          'decrypted content mismatch')

def make_sqlcipher_database_for_test(test, replica_uid):
    db = SQLCipherDatabase(
        SQLCipherOptions(':memory:', PASSWORD))
    db._set_replica_uid(replica_uid)
    return db

 def open_database(self, path):
     """Open a database at the given location."""
     from leap.soledad.client.sqlcipher import SQLCipherDatabase
     return SQLCipherDatabase.open_database(path, '123', False)

 def __init__(self, dbname, ntry):
     self._try = ntry
     self._is_initialized_invocations = 0
     SQLCipherDatabase.__init__(self, SQLCipherOptions(dbname, PASSWORD))