Reformat

Author: simolus3

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

@@ -120,62 +120,65 @@ class SyncIntegrationTest {
 
     @Test
     @OptIn(DelicateCoroutinesApi::class)
-    fun closesResponseStreamOnDatabaseClose() = runTest {
-        val syncStream = syncStream()
-        database.connectInternal(syncStream, 1000L)
+    fun closesResponseStreamOnDatabaseClose() =
+        runTest {
+            val syncStream = syncStream()
+            database.connectInternal(syncStream, 1000L)
 
-        turbineScope(timeout = 10.0.seconds) {
-            val turbine = database.currentStatus.asFlow().testIn(this)
-            turbine.waitFor { it.connected }
+            turbineScope(timeout = 10.0.seconds) {
+                val turbine = database.currentStatus.asFlow().testIn(this)
+                turbine.waitFor { it.connected }
 
-            database.close()
-            turbine.waitFor { !it.connected }
-            turbine.cancel()
-        }
+                database.close()
+                turbine.waitFor { !it.connected }
+                turbine.cancel()
+            }
 
-        // Closing the database should have closed the channel
-        assertTrue { syncLines.isClosedForSend }
-    }
+            // Closing the database should have closed the channel
+            assertTrue { syncLines.isClosedForSend }
+        }
 
     @Test
     @OptIn(DelicateCoroutinesApi::class)
-    fun cleansResourcesOnDisconnect() = runTest {
-        val syncStream = syncStream()
-        database.connectInternal(syncStream, 1000L)
+    fun cleansResourcesOnDisconnect() =
+        runTest {
+            val syncStream = syncStream()
+            database.connectInternal(syncStream, 1000L)
 
-        turbineScope(timeout = 10.0.seconds) {
-            val turbine = database.currentStatus.asFlow().testIn(this)
-            turbine.waitFor { it.connected }
+            turbineScope(timeout = 10.0.seconds) {
+                val turbine = database.currentStatus.asFlow().testIn(this)
+                turbine.waitFor { it.connected }
 
-            database.disconnect()
-            turbine.waitFor { !it.connected }
-            turbine.cancel()
-        }
+                database.disconnect()
+                turbine.waitFor { !it.connected }
+                turbine.cancel()
+            }
 
-        // Disconnecting should have closed the channel
-        assertTrue { syncLines.isClosedForSend }
+            // Disconnecting should have closed the channel
+            assertTrue { syncLines.isClosedForSend }
 
-        // And called invalidateCredentials on the connector
-        verify { connector.invalidateCredentials() }
-    }
+            // And called invalidateCredentials on the connector
+            verify { connector.invalidateCredentials() }
+        }
 
     @Test
-    fun cannotUpdateSchemaWhileConnected() = runTest {
-        val syncStream = syncStream()
-        database.connectInternal(syncStream, 1000L)
-
-        turbineScope(timeout = 10.0.seconds) {
-            val turbine = database.currentStatus.asFlow().testIn(this)
-            turbine.waitFor { it.connected }
-            turbine.cancel()
-        }
+    fun cannotUpdateSchemaWhileConnected() =
+        runTest {
+            val syncStream = syncStream()
+            database.connectInternal(syncStream, 1000L)
 
-        assertFailsWith<PowerSyncException>("Cannot update schema while connected") {
-            database.updateSchema(Schema())
-        }
+            turbineScope(timeout = 10.0.seconds) {
+                val turbine = database.currentStatus.asFlow().testIn(this)
+                turbine.waitFor { it.connected }
+                turbine.cancel()
+            }
 
-        database.close()
-    }
+            assertFailsWith<PowerSyncException>("Cannot update schema while connected") {
+                database.updateSchema(Schema())
+            }
+
+            database.close()
+        }
 
     @Test
     fun testPartialSync() =

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

@@ -488,4 +488,4 @@ internal class PowerSyncDatabaseImpl(
     }
 }
 
-internal object DisconnectRequestedException: CancellationException("disconnect() called")
+internal object DisconnectRequestedException : CancellationException("disconnect() called")

core/src/commonMain/kotlin/com/powersync/sync/SyncStatus.kt

@@ -5,7 +5,6 @@ import com.powersync.connectors.PowerSyncBackendConnector
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.cancel
 import kotlinx.datetime.Instant
 
 @ConsistentCopyVisibility

core/src/commonTest/kotlin/com/powersync/sync/SyncStreamTest.kt

@@ -30,7 +30,6 @@ import dev.mokkery.verifySuspend
 import io.ktor.client.engine.mock.MockEngine
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.withTimeout

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

@@ -33,27 +33,28 @@ import kotlinx.serialization.encodeToString
 internal class MockSyncService(
     private val lines: ReceiveChannel<SyncLine>,
 ) : HttpClientEngineBase("sync-service") {
-
     override val config: HttpClientEngineConfig
         get() = Config
 
-    override val supportedCapabilities: Set<HttpClientEngineCapability<out Any>> = setOf(
-        HttpTimeoutCapability,
-    )
+    override val supportedCapabilities: Set<HttpClientEngineCapability<out Any>> =
+        setOf(
+            HttpTimeoutCapability,
+        )
 
     @OptIn(InternalAPI::class)
     override suspend fun execute(data: HttpRequestData): HttpResponseData {
         val context = callContext()
         val scope = CoroutineScope(context)
 
         return if (data.url.encodedPath == "/sync/stream") {
-            val job = scope.writer {
-                lines.consumeEach {
-                    val serializedLine = JsonUtil.json.encodeToString(it)
-                    channel.writeStringUtf8("$serializedLine\n")
-                    channel.flush()
+            val job =
+                scope.writer {
+                    lines.consumeEach {
+                        val serializedLine = JsonUtil.json.encodeToString(it)
+                        channel.writeStringUtf8("$serializedLine\n")
+                        channel.flush()
+                    }
                 }
-            }
 
             HttpResponseData(
                 HttpStatusCode.OK,