Fix interference from other tests

Author: simolus3

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

@@ -22,49 +22,43 @@ internal expect fun disposeWhenDeallocated(resource: ActiveDatabaseResource): An
  */
 internal class ActiveDatabaseGroup(
     val identifier: String,
+    private val collection: GroupsCollection,
 ) {
     internal var refCount = 0 // Guarded by companion object
     internal val syncMutex = Mutex()
 
     fun removeUsage() {
-        ActiveDatabaseGroup.synchronize {
+        collection.synchronize {
             if (--refCount == 0) {
-                allGroups.remove(this)
+                collection.allGroups.remove(this)
             }
         }
     }
 
-    companion object : Synchronizable() {
-        internal val multipleInstancesMessage =
-            """
-            Multiple PowerSync instances for the same database have been detected.
-            This can cause unexpected results.
-            Please check your PowerSync client instantiation logic if this is not intentional.
-            """.trimIndent()
-
+    internal open class GroupsCollection: Synchronizable() {
         internal val allGroups = mutableListOf<ActiveDatabaseGroup>()
 
         private fun findGroup(
             warnOnDuplicate: Logger,
             identifier: String,
         ): ActiveDatabaseGroup = synchronize {
-                val existing = allGroups.asSequence().firstOrNull { it.identifier == identifier }
-                val resolvedGroup =
-                    if (existing == null) {
-                        val added = ActiveDatabaseGroup(identifier)
-                        allGroups.add(added)
-                        added
-                    } else {
-                        existing
-                    }
-
-                if (resolvedGroup.refCount++ != 0) {
-                    warnOnDuplicate.w { multipleInstancesMessage }
+            val existing = allGroups.asSequence().firstOrNull { it.identifier == identifier }
+            val resolvedGroup =
+                if (existing == null) {
+                    val added = ActiveDatabaseGroup(identifier, this)
+                    allGroups.add(added)
+                    added
+                } else {
+                    existing
                 }
 
-                resolvedGroup
+            if (resolvedGroup.refCount++ != 0) {
+                warnOnDuplicate.w { multipleInstancesMessage }
             }
 
+            resolvedGroup
+        }
+
         internal fun referenceDatabase(
             warnOnDuplicate: Logger,
             identifier: String,
@@ -75,6 +69,15 @@ internal class ActiveDatabaseGroup(
             return resource to disposeWhenDeallocated(resource)
         }
     }
+
+    companion object : GroupsCollection() {
+        internal val multipleInstancesMessage =
+            """
+            Multiple PowerSync instances for the same database have been detected.
+            This can cause unexpected results.
+            Please check your PowerSync client instantiation logic if this is not intentional.
+            """.trimIndent()
+    }
 }
 
 internal class ActiveDatabaseResource(

core/src/commonTest/kotlin/com/powersync/db/ActiveDatabaseGroupTest.kt

@@ -26,28 +26,31 @@ class ActiveDatabaseGroupTest {
             ),
         )
 
+    private lateinit var collection: ActiveDatabaseGroup.GroupsCollection
+
     @BeforeTest
-    fun setupDatabase() {
+    fun setup() {
+        collection = ActiveDatabaseGroup.GroupsCollection()
         logWriter.reset()
     }
 
     @Test
     fun testTrackDatabase() {
-        val usage = ActiveDatabaseGroup.referenceDatabase(logger, "test")
-        assertEquals(1, ActiveDatabaseGroup.allGroups.size)
+        val usage = collection.referenceDatabase(logger, "test")
+        assertEquals(1, collection.allGroups.size)
 
         usage.first.dispose()
-        assertEquals(0, ActiveDatabaseGroup.allGroups.size)
+        assertEquals(0, collection.allGroups.size)
     }
 
     @Test
     fun testWarnsOnDuplicate() {
-        val usage = ActiveDatabaseGroup.referenceDatabase(logger, "test")
-        assertEquals(1, ActiveDatabaseGroup.allGroups.size)
+        val usage = collection.referenceDatabase(logger, "test")
+        assertEquals(1, collection.allGroups.size)
 
         assertEquals(0, logWriter.logs.size)
 
-        val another = ActiveDatabaseGroup.referenceDatabase(logger, "test")
+        val another = collection.referenceDatabase(logger, "test")
         assertNotNull(
             logWriter.logs.find {
                 it.message == ActiveDatabaseGroup.multipleInstancesMessage
@@ -57,23 +60,23 @@ class ActiveDatabaseGroupTest {
         assertEquals(usage.first.group, another.first.group)
 
         usage.first.dispose()
-        assertEquals(1, ActiveDatabaseGroup.allGroups.size)
+        assertEquals(1, collection.allGroups.size)
         another.first.dispose()
-        assertEquals(0, ActiveDatabaseGroup.allGroups.size)
+        assertEquals(0, collection.allGroups.size)
     }
 
     @Test
     fun testDoesNotWarnForDifferentIdentifiers() {
-        val usage = ActiveDatabaseGroup.referenceDatabase(logger, "test")
-        assertEquals(1, ActiveDatabaseGroup.allGroups.size)
-        val another = ActiveDatabaseGroup.referenceDatabase(logger, "test2")
-        assertEquals(2, ActiveDatabaseGroup.allGroups.size)
+        val usage = collection.referenceDatabase(logger, "test")
+        assertEquals(1, collection.allGroups.size)
+        val another = collection.referenceDatabase(logger, "test2")
+        assertEquals(2, collection.allGroups.size)
 
         assertEquals(0, logWriter.logs.size)
 
         usage.first.dispose()
-        assertEquals(1, ActiveDatabaseGroup.allGroups.size)
+        assertEquals(1, collection.allGroups.size)
         another.first.dispose()
-        assertEquals(0, ActiveDatabaseGroup.allGroups.size)
+        assertEquals(0, collection.allGroups.size)
     }
 }