Remove unused wrapper

Author: simolus3

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

@@ -4,8 +4,8 @@ import app.cash.turbine.turbineScope
 import co.touchlab.kermit.ExperimentalKermitApi
 import com.powersync.db.ActiveDatabaseGroup
 import com.powersync.db.schema.Schema
-import com.powersync.testutils.PowerSyncTestFixtures
 import com.powersync.testutils.UserRow
+import com.powersync.testutils.databaseTest
 import com.powersync.testutils.getTempDir
 import com.powersync.testutils.waitFor
 import io.kotest.assertions.throwables.shouldThrow
@@ -23,7 +23,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 
 @OptIn(ExperimentalKermitApi::class)
-class DatabaseTest: PowerSyncTestFixtures() {
+class DatabaseTest {
     @Test
     fun testLinksPowerSync() =
         databaseTest {
@@ -247,7 +247,7 @@ class DatabaseTest: PowerSyncTestFixtures() {
             val db2 = openDatabase()
             waitFor {
                 assertNotNull(
-                    logWriter().logs.find {
+                    logWriter.logs.find {
                         it.message == ActiveDatabaseGroup.multipleInstancesMessage
                     },
                 )

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

@@ -10,8 +10,8 @@ import com.powersync.bucket.OplogEntry
 import com.powersync.db.PowerSyncDatabaseImpl
 import com.powersync.db.schema.Schema
 import com.powersync.sync.SyncLine
-import com.powersync.testutils.PowerSyncTestFixtures
 import com.powersync.testutils.UserRow
+import com.powersync.testutils.databaseTest
 import com.powersync.testutils.waitFor
 import com.powersync.utils.JsonUtil
 import dev.mokkery.verify
@@ -26,7 +26,7 @@ import kotlin.test.assertFailsWith
 import kotlin.test.assertNotNull
 import kotlin.time.Duration.Companion.seconds
 
-class SyncIntegrationTest: PowerSyncTestFixtures() {
+class SyncIntegrationTest {
     private suspend fun PowerSyncDatabase.expectUserCount(amount: Int) {
         val users = getAll("SELECT * FROM users;") { UserRow.from(it) }
         users shouldHaveSize amount

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

@@ -7,17 +7,21 @@ import co.touchlab.kermit.Severity
 import co.touchlab.kermit.TestConfig
 import co.touchlab.kermit.TestLogWriter
 import com.powersync.DatabaseDriverFactory
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.job
-import kotlinx.coroutines.launch
+import com.powersync.PowerSyncDatabase
+import com.powersync.connectors.PowerSyncBackendConnector
+import com.powersync.connectors.PowerSyncCredentials
+import com.powersync.db.PowerSyncDatabaseImpl
+import com.powersync.db.schema.Schema
+import com.powersync.sync.SyncLine
+import com.powersync.sync.SyncStream
+import dev.mokkery.answering.returns
+import dev.mokkery.everySuspend
+import dev.mokkery.mock
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runTest
-import kotlinx.coroutines.withContext
 import kotlinx.io.files.Path
-import kotlinx.io.files.SystemFileSystem
-import kotlin.coroutines.CoroutineContext
+import kotlinx.serialization.json.JsonObject
 
 expect val factory: DatabaseDriverFactory
 
@@ -37,8 +41,26 @@ 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()
+    }
+}
+
 @OptIn(ExperimentalKermitApi::class)
-class DatabaseTestScope : CoroutineContext.Element {
+internal class ActiveDatabaseTest(val scope: TestScope) {
+    private val cleanupItems: MutableList<suspend () -> Unit> = mutableListOf()
+
+    lateinit var database: PowerSyncDatabaseImpl
+
     val logWriter =
         TestLogWriter(
             loggable = Severity.Debug,
@@ -51,31 +73,71 @@ class DatabaseTestScope : CoroutineContext.Element {
             ),
         )
 
-    val testDirectory by lazy {
-        getTempDir() ?: SystemFileSystem.resolve(Path(".")).name
-    }
+    val syncLines = Channel<SyncLine>()
 
+    val testDirectory by lazy { getTempDir() }
     val databaseName by lazy {
         val allowedChars = ('A'..'Z') + ('a'..'z') + ('0'..'9')
-        CharArray(8) { allowedChars.random() }.concatToString()
+        val suffix = CharArray(8) { allowedChars.random() }.concatToString()
+
+        "db-$suffix"
     }
 
-    private val cleanupItems: MutableList<suspend () -> Unit> = mutableListOf()
+    val connector = mock<PowerSyncBackendConnector> {
+        everySuspend { getCredentialsCached() } returns
+                PowerSyncCredentials(
+                    token = "test-token",
+                    userId = "test-user",
+                    endpoint = "https://test.com",
+                )
+
+        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,
+        )
+        doOnCleanup { db.close() }
+        return db as PowerSyncDatabaseImpl
+    }
 
-    override val key: CoroutineContext.Key<*>
-        get() = Companion
+    suspend fun openDatabaseAndInitialize(): PowerSyncDatabaseImpl {
+        return openDatabase().also { it.readLock {  } }
+    }
 
-    companion object : CoroutineContext.Key<DatabaseTestScope>
-}
+    fun syncStream(): SyncStream {
+        val client = MockSyncService(syncLines)
+        return SyncStream(
+            bucketStorage = database.bucketStorage,
+            connector = connector,
+            httpEngine = client,
+            uploadCrud = { },
+            retryDelayMs = 10,
+            logger = logger,
+            params = JsonObject(emptyMap()),
+        )
+    }
 
-val CoroutineContext.database: DatabaseTestScope get() = get(DatabaseTestScope) ?: error("Not in PowerSync test: $this")
+    fun doOnCleanup(action: suspend () -> Unit) {
+        cleanupItems += action
+    }
 
-fun databaseTest(
-    testBody: suspend TestScope.() -> Unit
-) = runTest {
-    val test = DatabaseTestScope()
+    suspend fun cleanup() {
+        for (item in cleanupItems) {
+            item()
+        }
 
-    withContext(test) {
-        testBody()
+        var path = databaseName
+        testDirectory?.let {
+            path = Path(it, path).name
+        }
+        cleanup(path)
     }
 }