Add test for storage migrations, set up CI for tests

Author: zsmb13

.github/workflows/build-all.yml

@@ -23,6 +23,8 @@ jobs:
           java-version: 21
       - name: Assemble desktop jar
         run: ./gradlew :shared:jvmJar
+      - name: Run JVM tests
+        run: ./gradlew jvmTest
 
   build-android:
     name: Build Android

gradle/libs.versions.toml

@@ -65,6 +65,7 @@ koin-ktor = { module = "io.insert-koin:koin-ktor", version.ref = "koin" }
 koin-slf4j = { module = "io.insert-koin:koin-logger-slf4j", version.ref = "koin" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
 kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
 kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinxSerializationCore" }
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerializationCore" }
@@ -99,6 +100,7 @@ settings = { module = "com.russhwolf:multiplatform-settings", version.ref = "mul
 settings-coroutines = { module = "com.russhwolf:multiplatform-settings-coroutines", version.ref = "multiplatform-settings" }
 settings-observable = { module = "com.russhwolf:multiplatform-settings-make-observable", version.ref = "multiplatform-settings" }
 settings-serialization = { module = "com.russhwolf:multiplatform-settings-serialization", version.ref = "multiplatform-settings" }
+settings-test = { module = "com.russhwolf:multiplatform-settings-test", version.ref = "multiplatform-settings" }
 slf4j-nop = { module = "org.slf4j:slf4j-nop", version.ref = "slf4jNop" }
 
 [plugins]

shared/build.gradle.kts

@@ -105,6 +105,8 @@ kotlin {
 
         commonTest.dependencies {
             implementation(kotlin("test"))
+            implementation(libs.settings.test)
+            implementation(libs.kotlinx.coroutines.test)
         }
 
         val nonAndroidMain by creating {

shared/src/commonMain/kotlin/org/jetbrains/kotlinconf/storage/MultiplatformSettingsStorage.kt

@@ -142,7 +142,7 @@ class MultiplatformSettingsStorage(
         },
     )
 
-    private companion object {
+    companion object {
         const val V2025 = 2025_000
         const val V2026 = 2026_000
         const val CURRENT_STORAGE_VERSION: Int = V2026

shared/src/commonTest/kotlin/org/jetbrains/kotlinconf/storage/MultiplatformSettingsStorageMigrationTest.kt

@@ -0,0 +1,105 @@
+package org.jetbrains.kotlinconf.storage
+
+import com.russhwolf.settings.ExperimentalSettingsApi
+import com.russhwolf.settings.MapSettings
+import com.russhwolf.settings.ObservableSettings
+import com.russhwolf.settings.observable.makeObservable
+import com.russhwolf.settings.set
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import org.jetbrains.kotlinconf.NotificationSettings
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class MultiplatformSettingsStorageMigrationTest {
+
+    @OptIn(ExperimentalSettingsApi::class)
+    private fun inMemorySettings(): ObservableSettings = MapSettings().makeObservable()
+
+    /**
+     * Creates a storage object with data matching the older, 2025 storage version.
+     */
+    private fun get2025Settings() = inMemorySettings().apply {
+        this["storageVersion"] = MultiplatformSettingsStorage.V2025
+        this["newsCache"] = "{\"dummy\":\"value\"}"
+        this["notificationSettings"] = """
+            {
+              "sessionReminders": true,
+              "scheduleUpdates": false,
+              "jetBrainsNews": true,
+              "kotlinConfNews": "true"
+            }
+        """.trimIndent()
+    }
+
+    @Test
+    fun migration_2025_to_2026_updates_version() {
+        val settings = get2025Settings()
+        val storage = MultiplatformSettingsStorage(settings)
+
+        // Run migrations
+        storage.ensureCurrentVersion()
+
+        // Storage version should be successfully updated to the current version
+        assertEquals(MultiplatformSettingsStorage.CURRENT_STORAGE_VERSION, settings.getInt("storageVersion", 0))
+    }
+
+    @Test
+    fun migration_2026_to_2026_removes_news_cache() {
+        val settings = get2025Settings()
+        val storage = MultiplatformSettingsStorage(settings)
+
+        // Run migrations
+        storage.ensureCurrentVersion()
+
+        // The newsCache key should be removed by the migration
+        assertNull(settings.getStringOrNull("newsCache"))
+    }
+
+    @Test
+    fun migration_2026_to_2026_migrates_notification_settings() = runTest {
+        val settings = get2025Settings()
+        val storage = MultiplatformSettingsStorage(settings)
+
+        // Run migrations
+        storage.ensureCurrentVersion()
+
+        // Notification settings should still be readable with the current version
+        val notiSettings = storage.getNotificationSettings().first()
+        assertTrue(notiSettings != null)
+    }
+
+    @Test
+    fun unknown_storage_version_triggers_destructive_upgrade_and_clears_all_keys() {
+        val settings = inMemorySettings()
+        settings["userId2025"] = "user-123"
+        settings["newsCache"] = "legacy-data"
+        settings["notificationSettings"] = "{\"sessionReminders\":false,\"scheduleUpdates\":true}"
+        val storage = MultiplatformSettingsStorage(settings)
+
+        // Run migrations
+        storage.ensureCurrentVersion()
+
+        // Only the storageVersion should remain and be set to the current version
+        assertEquals(setOf("storageVersion"), settings.keys)
+        assertEquals(MultiplatformSettingsStorage.CURRENT_STORAGE_VERSION, settings.getInt("storageVersion", 0))
+    }
+
+    @Test
+    fun unknown_migration_path_triggers_destructive_upgrade() {
+        val settings = inMemorySettings()
+        settings["storageVersion"] = 2024_000 // A version we don't have a migration for
+        settings["favorites"] = "[\"S1\",\"S2\"]"
+        val storage = MultiplatformSettingsStorage(settings)
+
+        // Run migrations
+        storage.ensureCurrentVersion()
+
+        // Only the storageVersion should remain and be set to the current version
+        assertEquals(setOf("storageVersion"), settings.keys)
+        assertEquals(MultiplatformSettingsStorage.CURRENT_STORAGE_VERSION, settings.getInt("storageVersion", 0))
+    }
+}