Add Android integration tests

Author: simolus3

core-tests-android/build.gradle.kts

@@ -8,6 +8,7 @@ plugins {
 
 dependencies {
     implementation(projects.core)
+    implementation(projects.sqlite3multipleciphers)
     implementation(libs.androidx.core)
     implementation(libs.androidx.appcompat)
     implementation(libs.androidx.material)

core-tests-android/src/androidTest/java/com/powersync/EncryptedDatabaseTest.kt

@@ -0,0 +1,57 @@
+package com.powersync
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.sqlite.SQLiteException
+import androidx.sqlite.execSQL
+import app.cash.turbine.turbineScope
+import com.powersync.db.schema.Schema
+import com.powersync.encryption.AndroidEncryptedDatabaseFactory
+import com.powersync.encryption.Key
+import com.powersync.testutils.UserRow
+import kotlinx.coroutines.*
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class EncryptedDatabaseTest {
+
+    @Test
+    fun testEncryptedDatabase()  =
+        runTest {
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+
+            val database = PowerSyncDatabase(
+                factory = AndroidEncryptedDatabaseFactory(
+                    context,
+                    Key.Passphrase("mykey")
+                ),
+                schema = Schema(UserRow.table),
+                dbFilename = "encrypted_test",
+            )
+
+            assertEquals("chacha20", database.get("PRAGMA cipher") { it.getString(0)!! })
+
+            database.execute(
+                "INSERT INTO users (id, name, email) VALUES (uuid(), ?, ?)",
+                listOf("Test", "[email protected]"),
+            )
+            database.close()
+
+            val unencryptedFactory = DatabaseDriverFactory(context)
+            val unencrypted = unencryptedFactory.openConnection("encrypted_test", null, false)
+
+            try {
+                unencrypted.execSQL("SELECT * FROM sqlite_schema")
+                throw IllegalStateException("Was able to read schema from encrypted database without supplying a key")
+            } catch (_: SQLiteException) {
+                // Expected
+            }
+            unencrypted.close()
+        }
+}

sqlite3multipleciphers/src/androidMain/kotlin/com/powersync/encryption/BundledSQLiteDriver.android.kt

@@ -1,4 +1,18 @@
 package com.powersync.encryption
 
+import android.content.Context
+
+public class AndroidEncryptedDatabaseFactory(
+    private val context: Context,
+    key: Key,
+) : BundledSQLiteDriver(key) {
+    override fun resolveDefaultDatabasePath(dbFilename: String): String = context.getDatabasePath(dbFilename).path
+}
+
+private val didLoadLibrary by lazy {
+    System.loadLibrary("sqlite3mc_bundled")
+}
+
 internal actual fun ensureJniLibraryLoaded() {
+    didLoadLibrary
 }

sqlite3multipleciphers/src/commonMain/kotlin/com/powersync/encryption/BaseEncryptedDatabaseFactory.kt

@@ -4,7 +4,9 @@ import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.execSQL
 
 public sealed interface Key {
-    public class Passphrase(public val passphrase: String) : Key
+    public class Passphrase(
+        public val passphrase: String,
+    ) : Key
     // TODO: Add raw key api
 }
 
@@ -20,4 +22,4 @@ internal fun SQLiteConnection.encryptOrClose(key: Key) {
         close()
         throw e
     }
-}
+}

sqlite3multipleciphers/src/jvmAndroidMain/kotlin/com/powersync/encryption/BundledSQLiteConnection.kt

@@ -14,13 +14,16 @@
  * limitations under the License.
  */
 @file:JvmName("BundledSQLiteConnectionKt")
+
 package com.powersync.encryption
 
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.SQLiteStatement
 import androidx.sqlite.throwSQLiteException
 
-internal class BundledSQLiteConnection(private val connectionPointer: Long) : SQLiteConnection {
+internal class BundledSQLiteConnection(
+    private val connectionPointer: Long,
+) : SQLiteConnection {
     @Volatile private var isClosed = false
 
     override fun inTransaction(): Boolean {
@@ -38,7 +41,10 @@ internal class BundledSQLiteConnection(private val connectionPointer: Long) : SQ
         return BundledSQLiteStatement(connectionPointer, statementPointer)
     }
 
-    internal fun loadExtension(fileName: String, entryPoint: String?) {
+    internal fun loadExtension(
+        fileName: String,
+        entryPoint: String?,
+    ) {
         if (isClosed) {
             throwSQLiteException(SQLITE_MISUSE, "connection is closed")
         }
@@ -60,8 +66,15 @@ internal class BundledSQLiteConnection(private val connectionPointer: Long) : SQ
 
 private external fun nativeInTransaction(pointer: Long): Boolean
 
-private external fun nativePrepare(pointer: Long, sql: String): Long
+private external fun nativePrepare(
+    pointer: Long,
+    sql: String,
+): Long
 
-private external fun nativeLoadExtension(pointer: Long, fileName: String, entryPoint: String?)
+private external fun nativeLoadExtension(
+    pointer: Long,
+    fileName: String,
+    entryPoint: String?,
+)
 
 private external fun nativeClose(pointer: Long)

sqlite3multipleciphers/src/jvmAndroidMain/kotlin/com/powersync/encryption/BundledSQLiteDriver.kt

@@ -14,14 +14,20 @@
  * limitations under the License.
  */
 @file:JvmName("BundledSQLiteDriverKt")
+
 package com.powersync.encryption
 
 import androidx.sqlite.SQLiteConnection
 import com.powersync.PersistentConnectionFactory
 import com.powersync.resolvePowerSyncLoadableExtensionPath
 
-public abstract class BundledSQLiteDriver internal constructor(private val key: Key): PersistentConnectionFactory {
-    private fun open(fileName: String, flags: Int): SQLiteConnection {
+public abstract class BundledSQLiteDriver internal constructor(
+    private val key: Key,
+) : PersistentConnectionFactory {
+    private fun open(
+        fileName: String,
+        flags: Int,
+    ): SQLiteConnection {
         ensureJniLibraryLoaded()
 
         val address = nativeOpen(fileName, flags)
@@ -36,15 +42,17 @@ public abstract class BundledSQLiteDriver internal constructor(private val key:
         return connection
     }
 
-    override fun openConnection(path: String, openFlags: Int): SQLiteConnection {
-        return open(path, openFlags).also { it.encryptOrClose(key) }
-    }
+    override fun openConnection(
+        path: String,
+        openFlags: Int,
+    ): SQLiteConnection = open(path, openFlags).also { it.encryptOrClose(key) }
 
-    override fun openInMemoryConnection(): SQLiteConnection {
-        return open(":memory:", 2)
-    }
+    override fun openInMemoryConnection(): SQLiteConnection = open(":memory:", 2)
 }
 
 internal expect fun ensureJniLibraryLoaded()
 
-private external fun nativeOpen(name: String, openFlags: Int): Long
+private external fun nativeOpen(
+    name: String,
+    openFlags: Int,
+): Long

sqlite3multipleciphers/src/jvmAndroidMain/kotlin/com/powersync/encryption/BundledSQLiteStatement.kt

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 @file:JvmName("BundledSQLiteStatementKt")
+
 package com.powersync.encryption
 
 import androidx.sqlite.SQLiteStatement
@@ -23,25 +24,36 @@ internal class BundledSQLiteStatement(
     private val connectionPointer: Long,
     private val statementPointer: Long,
 ) : SQLiteStatement {
-
     @Volatile private var isClosed = false
 
-    override fun bindBlob(index: Int, value: ByteArray) {
+    override fun bindBlob(
+        index: Int,
+        value: ByteArray,
+    ) {
         throwIfClosed()
         nativeBindBlob(statementPointer, index, value)
     }
 
-    override fun bindDouble(index: Int, value: Double) {
+    override fun bindDouble(
+        index: Int,
+        value: Double,
+    ) {
         throwIfClosed()
         nativeBindDouble(statementPointer, index, value)
     }
 
-    override fun bindLong(index: Int, value: Long) {
+    override fun bindLong(
+        index: Int,
+        value: Long,
+    ) {
         throwIfClosed()
         nativeBindLong(statementPointer, index, value)
     }
 
-    override fun bindText(index: Int, value: String) {
+    override fun bindText(
+        index: Int,
+        value: String,
+    ) {
         throwIfClosed()
         nativeBindText(statementPointer, index, value)
     }
@@ -115,7 +127,7 @@ internal class BundledSQLiteStatement(
 
     private fun throwIfClosed() {
         if (isClosed) {
-            throwSQLiteException(21 /* SQLITE_MISUSE */, "statement is closed")
+            throwSQLiteException(21, "statement is closed")
         }
     }
 
@@ -124,24 +136,71 @@ internal class BundledSQLiteStatement(
     }
 }
 
-
-private external fun nativeBindBlob(pointer: Long, index: Int, value: ByteArray)
-private external fun nativeBindDouble(pointer: Long, index: Int, value: Double)
-private external fun nativeBindLong(pointer: Long, index: Int, value: Long)
-private external fun nativeBindText(pointer: Long, index: Int, value: String)
-private external fun nativeBindNull(pointer: Long, index: Int)
+private external fun nativeBindBlob(
+    pointer: Long,
+    index: Int,
+    value: ByteArray,
+)
+
+private external fun nativeBindDouble(
+    pointer: Long,
+    index: Int,
+    value: Double,
+)
+
+private external fun nativeBindLong(
+    pointer: Long,
+    index: Int,
+    value: Long,
+)
+
+private external fun nativeBindText(
+    pointer: Long,
+    index: Int,
+    value: String,
+)
+
+private external fun nativeBindNull(
+    pointer: Long,
+    index: Int,
+)
 
 private external fun nativeStep(pointer: Long): Boolean
 
-private external fun nativeGetBlob(pointer: Long, index: Int): ByteArray
-private external fun nativeGetDouble(pointer: Long, index: Int): Double
-private external fun nativeGetLong(pointer: Long, index: Int): Long
-private external fun nativeGetText(pointer: Long, index: Int): String
+private external fun nativeGetBlob(
+    pointer: Long,
+    index: Int,
+): ByteArray
+
+private external fun nativeGetDouble(
+    pointer: Long,
+    index: Int,
+): Double
+
+private external fun nativeGetLong(
+    pointer: Long,
+    index: Int,
+): Long
+
+private external fun nativeGetText(
+    pointer: Long,
+    index: Int,
+): String
+
 private external fun nativeGetColumnCount(pointer: Long): Int
-private external fun nativeGetColumnName(pointer: Long, index: Int): String
-private external fun nativeGetColumnType(pointer: Long, index: Int): Int
+
+private external fun nativeGetColumnName(
+    pointer: Long,
+    index: Int,
+): String
+
+private external fun nativeGetColumnType(
+    pointer: Long,
+    index: Int,
+): Int
 
 private external fun nativeReset(pointer: Long)
 
 private external fun nativeClearBindings(pointer: Long)
+
 private external fun nativeClose(pointer: Long)

sqlite3multipleciphers/src/jvmMain/kotlin/com/powersync/encryption/BundledSQLiteDriver.jvm.kt

@@ -2,10 +2,10 @@ package com.powersync.encryption
 
 import com.powersync.extractLib
 
-public class JavaEncryptedDatabaseFactory(key: Key): BundledSQLiteDriver(key) {
-    override fun resolveDefaultDatabasePath(dbFilename: String): String {
-        return dbFilename
-    }
+public class JavaEncryptedDatabaseFactory(
+    key: Key,
+) : BundledSQLiteDriver(key) {
+    override fun resolveDefaultDatabasePath(dbFilename: String): String = dbFilename
 }
 
 private val didLoadLibrary by lazy {

sqlite3multipleciphers/src/nativeMain/kotlin/com/powersync/encryption/EncryptedDatabaseFactory.kt renamed to sqlite3multipleciphers/src/nativeMain/kotlin/com/powersync/encryption/NativeEncryptedDatabaseFactory.kt

@@ -7,17 +7,19 @@ import com.powersync.db.NativeConnectionFactory
 /**
  * A [NativeConnectionFactory] that links sqlite3multipleciphers and opens database with a [Key].
  */
-public class NativeEncryptedDatabaseFactory(private val key: Key): NativeConnectionFactory() {
-    override fun resolveDefaultDatabasePath(dbFilename: String): String {
-        return appleDefaultDatabasePath(dbFilename)
-    }
+public class NativeEncryptedDatabaseFactory(
+    private val key: Key,
+) : NativeConnectionFactory() {
+    override fun resolveDefaultDatabasePath(dbFilename: String): String = appleDefaultDatabasePath(dbFilename)
 
-    override fun openConnection(path: String, openFlags: Int): SQLiteConnection {
-        return super.openConnection(path, openFlags).apply {
+    override fun openConnection(
+        path: String,
+        openFlags: Int,
+    ): SQLiteConnection =
+        super.openConnection(path, openFlags).apply {
             if (path != ":memory:") {
                 // Settings keys for in-memory or temporary databases is not supported.
                 encryptOrClose(key)
             }
         }
-    }
 }