Reformat

Author: simolus3

core/src/commonIntegrationTest/kotlin/com/powersync/DatabaseTest.kt

@@ -33,7 +33,8 @@ class DatabaseTest {
     @Test
     fun testWAL() =
         databaseTest {
-            val mode = database.get(
+            val mode =
+                database.get(
                     "PRAGMA journal_mode",
                     mapper = { it.getString(0)!! },
                 )
@@ -258,18 +259,19 @@ class DatabaseTest {
     @Test
     fun readConnectionsReadOnly() =
         databaseTest {
-            val exception = shouldThrow<PowerSyncException> {
-                database.getOptional(
-                    """
+            val exception =
+                shouldThrow<PowerSyncException> {
+                    database.getOptional(
+                        """
                         INSERT INTO 
                              users (id, name, email)
                          VALUES
                              (uuid(), ?, ?) 
                          RETURNING *
                         """.trimIndent(),
-                    parameters = listOf("steven", "[email protected]"),
-                ) {}
-            }
+                        parameters = listOf("steven", "[email protected]"),
+                    ) {}
+                }
 
             // The exception messages differ slightly between drivers
             exception.message shouldContain "write a readonly database"

core/src/commonIntegrationTest/kotlin/com/powersync/testutils/TestUtils.kt

@@ -41,22 +41,23 @@ fun generatePrintLogWriter() =
         }
     }
 
-internal fun databaseTest(
-    testBody: suspend ActiveDatabaseTest.() -> Unit
-) = runTest {
-    val running = ActiveDatabaseTest(this)
-    // Make sure the database is initialized, we're using internal APIs that expect initialization.
-    running.database = running.openDatabaseAndInitialize()
-
-    try {
-        running.testBody()
-    } finally {
-        running.cleanup()
+internal fun databaseTest(testBody: suspend ActiveDatabaseTest.() -> Unit) =
+    runTest {
+        val running = ActiveDatabaseTest(this)
+        // Make sure the database is initialized, we're using internal APIs that expect initialization.
+        running.database = running.openDatabaseAndInitialize()
+
+        try {
+            running.testBody()
+        } finally {
+            running.cleanup()
+        }
     }
-}
 
 @OptIn(ExperimentalKermitApi::class)
-internal class ActiveDatabaseTest(val scope: TestScope) {
+internal class ActiveDatabaseTest(
+    val scope: TestScope,
+) {
     private val cleanupItems: MutableList<suspend () -> Unit> = mutableListOf()
 
     lateinit var database: PowerSyncDatabaseImpl
@@ -83,34 +84,34 @@ internal class ActiveDatabaseTest(val scope: TestScope) {
         "db-$suffix"
     }
 
-    val connector = mock<PowerSyncBackendConnector> {
-        everySuspend { getCredentialsCached() } returns
+    val connector =
+        mock<PowerSyncBackendConnector> {
+            everySuspend { getCredentialsCached() } returns
                 PowerSyncCredentials(
                     token = "test-token",
                     userId = "test-user",
                     endpoint = "https://test.com",
                 )
 
-        everySuspend { invalidateCredentials() } returns Unit
-    }
+            everySuspend { invalidateCredentials() } returns Unit
+        }
 
     fun openDatabase(): PowerSyncDatabaseImpl {
         logger.d { "Opening database $databaseName in directory $testDirectory" }
-        val db = PowerSyncDatabase(
-            factory = factory,
-            schema = Schema(UserRow.table),
-            dbFilename = databaseName,
-            dbDirectory = testDirectory,
-            logger = logger,
-            scope = scope,
-        )
+        val db =
+            PowerSyncDatabase(
+                factory = factory,
+                schema = Schema(UserRow.table),
+                dbFilename = databaseName,
+                dbDirectory = testDirectory,
+                logger = logger,
+                scope = scope,
+            )
         doOnCleanup { db.close() }
         return db as PowerSyncDatabaseImpl
     }
 
-    suspend fun openDatabaseAndInitialize(): PowerSyncDatabaseImpl {
-        return openDatabase().also { it.readLock {  } }
-    }
+    suspend fun openDatabaseAndInitialize(): PowerSyncDatabaseImpl = openDatabase().also { it.readLock { } }
 
     fun syncStream(): SyncStream {
         val client = MockSyncService(syncLines)

core/src/commonMain/kotlin/com/powersync/db/PowerSyncDatabaseImpl.kt

@@ -350,10 +350,11 @@ internal class PowerSyncDatabaseImpl(
         parameters: List<Any?>?,
         throttleMs: Long?,
         mapper: (SqlCursor) -> RowType,
-    ): Flow<List<RowType>> = flow {
-        waitReady()
-        emitAll(internalDb.watch(sql, parameters, throttleMs, mapper))
-    }
+    ): Flow<List<RowType>> =
+        flow {
+            waitReady()
+            emitAll(internalDb.watch(sql, parameters, throttleMs, mapper))
+        }
 
     override suspend fun <R> readLock(callback: ThrowableLockCallback<R>): R {
         waitReady()

core/src/commonTest/kotlin/com/powersync/testutils/WaitFor.kt

@@ -1,7 +1,6 @@
 package com.powersync.testutils
 
 import kotlinx.coroutines.delay
-import kotlinx.datetime.Clock
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.TimeSource