test(model-server): RepositoryMigrationTest is tested for simultaneously changing type and storage

Author: abstraktor

model-server/src/test/kotlin/org/modelix/model/server/RepositoryMigrationTest.kt

@@ -12,6 +12,8 @@ import org.modelix.model.client2.runWriteOnBranch
 import org.modelix.model.data.ModelData
 import org.modelix.model.data.NodeData
 import org.modelix.model.data.asData
+import org.modelix.model.lazy.BranchReference
+import org.modelix.model.lazy.CLVersion
 import org.modelix.model.lazy.RepositoryId
 import org.modelix.model.mutable.asModelSingleThreaded
 import org.modelix.model.server.api.RepositoryConfig
@@ -25,14 +27,14 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class RepositoryMigrationTest {
-    val config = RepositoryConfig(
+    private val config = RepositoryConfig(
         nodeIdType = NodeIdType.INT64,
         modelId = "d9330ca8-2145-4d1f-9b50-8f5aed1804cf",
         repositoryId = "d9330ca8-2145-4d1f-9b50-8f5aed1804cf",
         repositoryName = "my-repo",
     )
 
-    val modelData = ModelData(
+    private val modelData = ModelData(
         root = NodeData(
             id = PNodeReference(config.modelId, ITree.ROOT_ID).serialize(),
             children = listOf(
@@ -55,7 +57,7 @@ class RepositoryMigrationTest {
     // A repository configured with int64 IDs is expected to generate new IDs and store the provided ID in the
     // #originalRef# property.
     // language=json
-    val expectedImportData = NodeData.fromJson(
+    private val expectedImportData = NodeData.fromJson(
         """
         {
             "id": "modelix:d9330ca8-2145-4d1f-9b50-8f5aed1804cf/1",
@@ -90,37 +92,58 @@ class RepositoryMigrationTest {
         """,
     ).toJson()
 
-    @Test
-    fun `migrate int64 to string IDs`() = runTest {
-        val repositoryManager = RepositoriesManager(InMemoryStoreClient())
-
-        @OptIn(RequiresTransaction::class)
-        val version1 = repositoryManager.getTransactionManager().runWrite {
-            val emptyVersion = repositoryManager.createRepository(
-                config,
-                null,
-            )
-            emptyVersion.runWrite(IdGenerator.newInstance(456), author = null) {
+    // Helper functions to reduce duplication
+    @OptIn(RequiresTransaction::class)
+    private fun createRepositoryWithData(
+        repositoryManager: RepositoriesManager,
+        config: RepositoryConfig,
+    ): CLVersion {
+        return repositoryManager.getTransactionManager().runWrite {
+            val emptyVersion = repositoryManager.createRepository(config, null)
+            val versionWithData = emptyVersion.runWrite(IdGenerator.newInstance(456), author = null) {
                 modelData.load(it)
-            }!!.also { repositoryManager.mergeChanges(RepositoryId(config.repositoryId).getBranchReference(), it.getContentHash()) }
+            }!! as CLVersion
+            repositoryManager.mergeChanges(RepositoryId(config.repositoryId).getBranchReference(), versionWithData.getContentHash())
+            versionWithData
         }
+    }
 
-        assertEquals(
-            expectedImportData,
-            version1.getModelTree().asModelSingleThreaded().getRootNode().asData().toJson(),
-        )
+    @OptIn(RequiresTransaction::class)
+    private fun migrateRepository(
+        repositoryManager: RepositoriesManager,
+        newConfig: RepositoryConfig,
+    ): CLVersion {
+        return repositoryManager.getTransactionManager().runWrite {
+            repositoryManager.migrateRepository(newConfig, null)
+            repositoryManager.getVersion(RepositoryId(newConfig.repositoryId).getBranchReference())!!
+        }
+    }
 
-        @OptIn(RequiresTransaction::class)
-        val version2 = repositoryManager.getTransactionManager().runWrite {
-            repositoryManager.migrateRepository(
-                config.copy(nodeIdType = NodeIdType.STRING),
-                null,
-            )
-            repositoryManager.getVersion(RepositoryId(config.repositoryId).getBranchReference())!!
+    @OptIn(RequiresTransaction::class)
+    private fun getRepositoryConfig(
+        repositoryManager: RepositoriesManager,
+        repositoryId: RepositoryId,
+        branchRef: BranchReference,
+    ): RepositoryConfig {
+        return repositoryManager.getTransactionManager().runRead {
+            repositoryManager.getConfig(repositoryId, branchRef)
         }
+    }
+
+    private fun extractNodeData(version: CLVersion): String {
+        return version.getModelTree().asModelSingleThreaded().getRootNode().asData().toJson()
+    }
+
+    @Test
+    fun `migrate int64 to string IDs`() = runTest {
+        val repositoryManager = RepositoriesManager(InMemoryStoreClient())
+
+        val version1 = createRepositoryWithData(repositoryManager, config)
+        assertEquals(expectedImportData, extractNodeData(version1))
 
+        val version2 = migrateRepository(repositoryManager, config.copy(nodeIdType = NodeIdType.STRING))
         // After migration the repository should use the IDs that were provided in the import data.
-        assertEquals(modelData.root.toJson(), version2.getModelTree().asModelSingleThreaded().getRootNode().asData().toJson())
+        assertEquals(modelData.root.toJson(), extractNodeData(version2))
     }
 
     @Test
@@ -138,7 +161,7 @@ class RepositoryMigrationTest {
 
         val repositoryId = RepositoryId(config.repositoryId)
         val modelClient = ModelClientV2.builder().url("http://localhost/v2").client(client).build().also { it.init() }
-        val version0 = modelClient.initRepository(config)
+        modelClient.initRepository(config)
         modelClient.runWriteOnBranch(repositoryId.getBranchReference()) {
             modelData.load(it)
         }
@@ -167,49 +190,51 @@ class RepositoryMigrationTest {
 
         // Create repository with global storage (legacyGlobalStorage = true)
         val globalConfig = config.copy(legacyGlobalStorage = true)
-
-        @OptIn(RequiresTransaction::class)
-        val version1 = repositoryManager.getTransactionManager().runWrite {
-            val emptyVersion = repositoryManager.createRepository(globalConfig, null)
-            emptyVersion.runWrite(IdGenerator.newInstance(456), author = null) {
-                modelData.load(it)
-            }!!.also {
-                repositoryManager.mergeChanges(branchRef, it.getContentHash())
-            }
-        }
+        createRepositoryWithData(repositoryManager, globalConfig)
 
         // Verify initial config has global storage
-        @OptIn(RequiresTransaction::class)
-        val configBeforeMigration = repositoryManager.getTransactionManager().runRead {
-            repositoryManager.getConfig(repositoryId, branchRef)
-        }
+        val configBeforeMigration = getRepositoryConfig(repositoryManager, repositoryId, branchRef)
         assertEquals(true, configBeforeMigration.legacyGlobalStorage, "Repository should start with global storage")
 
         // Migrate to isolated storage
-        @OptIn(RequiresTransaction::class)
-        repositoryManager.getTransactionManager().runWrite {
-            repositoryManager.migrateRepository(
-                globalConfig.copy(legacyGlobalStorage = false),
-                null,
-            )
-        }
+        val version2 = migrateRepository(repositoryManager, globalConfig.copy(legacyGlobalStorage = false))
 
         // Verify config after migration has isolated storage
-        @OptIn(RequiresTransaction::class)
-        val configAfterMigration = repositoryManager.getTransactionManager().runRead {
-            repositoryManager.getConfig(repositoryId, branchRef)
-        }
+        val configAfterMigration = getRepositoryConfig(repositoryManager, repositoryId, branchRef)
         assertEquals(false, configAfterMigration.legacyGlobalStorage, "Repository should have isolated storage after migration")
 
         // Verify data is preserved after migration
-        @OptIn(RequiresTransaction::class)
-        val version2 = repositoryManager.getTransactionManager().runRead {
-            repositoryManager.getVersion(branchRef)!!
-        }
-        assertEquals(
-            expectedImportData,
-            version2.getModelTree().asModelSingleThreaded().getRootNode().asData().toJson(),
-            "Data should be preserved after migration",
-        )
+        assertEquals(expectedImportData, extractNodeData(version2), "Data should be preserved after migration")
+    }
+
+    @Test
+    fun `migrate int64 to string IDs and global to isolated storage simultaneously`() = runTest {
+        val repositoryManager = RepositoriesManager(InMemoryStoreClient())
+        val repositoryId = RepositoryId(config.repositoryId)
+        val branchRef = repositoryId.getBranchReference()
+
+        // Create repository with int64 IDs and global storage
+        val initialConfig = config.copy(nodeIdType = NodeIdType.INT64, legacyGlobalStorage = true)
+        val version1 = createRepositoryWithData(repositoryManager, initialConfig)
+
+        // Verify initial configuration
+        val configBeforeMigration = getRepositoryConfig(repositoryManager, repositoryId, branchRef)
+        assertEquals(NodeIdType.INT64, configBeforeMigration.nodeIdType, "Repository should start with INT64 IDs")
+        assertEquals(true, configBeforeMigration.legacyGlobalStorage, "Repository should start with global storage")
+
+        // Verify initial data has generated IDs
+        assertEquals(expectedImportData, extractNodeData(version1))
+
+        // Migrate both: int64 -> string IDs AND global -> isolated storage
+        val targetConfig = config.copy(nodeIdType = NodeIdType.STRING, legacyGlobalStorage = false)
+        val version2 = migrateRepository(repositoryManager, targetConfig)
+
+        // Verify config after migration
+        val configAfterMigration = getRepositoryConfig(repositoryManager, repositoryId, branchRef)
+        assertEquals(NodeIdType.STRING, configAfterMigration.nodeIdType, "Repository should have STRING IDs after migration")
+        assertEquals(false, configAfterMigration.legacyGlobalStorage, "Repository should have isolated storage after migration")
+
+        // After migration the repository should use the original IDs from import data
+        assertEquals(modelData.root.toJson(), extractNodeData(version2), "Data should use original IDs after migration")
     }
 }