为Room迁移测试类选择约束方法执行顺序的合适设计模式

针对Room迁移测试中Builder模式无法约束方法调用顺序的问题，推荐以下几种简洁有效的解决方案：

方案1：分步构建器（Stage Builder） #

将测试流程拆分为多个阶段，每个阶段仅暴露当前允许调用的方法，从编译层面强制顺序。核心思路是每个方法调用后返回对应阶段的构建器，引导开发者按固定步骤操作。

示例代码（Kotlin）：

// 初始化阶段：仅允许添加迁移规则
class MigrationTestInitializer {
    fun addMigrations(vararg migrations: Migration): MigrationTestPreparer {
        return MigrationTestPreparer(migrations)
    }
}

// 准备阶段：允许创建旧库、插入测试数据
class MigrationTestPreparer(private val migrations: Array<out Migration>) {
    fun createOldDatabase(dbName: String): MigrationTestPreparer {
        // 执行旧版本数据库创建逻辑
        return this
    }

    fun insertTestData(data: TestData): MigrationTestExecutor {
        // 执行测试数据插入逻辑
        return MigrationTestExecutor(migrations, data)
    }
}

// 执行阶段：仅允许执行迁移
class MigrationTestExecutor(private val migrations: Array<out Migration>, private val testData: TestData) {
    fun runMigration(): MigrationTestVerifier {
        // 执行迁移逻辑
        return MigrationTestVerifier(testData)
    }
}

// 验证阶段：仅允许验证数据完整性
class MigrationTestVerifier(private val testData: TestData) {
    fun verifyDataIntegrity() {
        // 执行数据完整性验证逻辑
    }
}

// 使用方式（顺序被强制，无法跳过或乱序）
MigrationTestInitializer()
    .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
    .createOldDatabase("test_db")
    .insertTestData(TestData())
    .runMigration()
    .verifyDataIntegrity()

优点：编译期强制顺序，无运行时错误风险；代码职责清晰，可读性强。
缺点：需要创建多个阶段类，结构稍复杂。

方案2：Kotlin DSL 约束流程 #

利用Kotlin的DSL特性，将测试步骤封装为固定顺序的代码块，开发者只能按预设流程编写逻辑，也可通过嵌套lambda进一步强化顺序约束。

示例代码：

class MigrationTestContext {
    private lateinit var migrations: Array<out Migration>
    private var oldDbName: String? = null
    private var testData: TestData? = null

    fun addMigrations(vararg migrations: Migration) {
        this.migrations = migrations
    }

    fun createOldDatabase(dbName: String) {
        oldDbName = dbName
        // 执行旧库创建逻辑
    }

    fun insertTestData(data: TestData) {
        testData = data
        // 执行数据插入逻辑
    }

    private fun runMigrationInternal() {
        check(::migrations.isInitialized) { "未添加迁移规则" }
        // 执行迁移逻辑
    }

    private fun verifyInternal() {
        check(testData != null) { "未插入测试数据" }
        // 执行数据验证逻辑
    }
}

// 定义DSL函数，内部按固定顺序执行步骤
fun testRoomMigration(block: MigrationTestContext.() -> Unit) {
    val context = MigrationTestContext()
    context.block()
    // 强制按顺序执行核心逻辑
    context.runMigrationInternal()
    context.verifyInternal()
}

// 使用方式
testRoomMigration {
    addMigrations(MIGRATION_1_2, MIGRATION_2_3)
    createOldDatabase("test_db")
    insertTestData(TestData())
}

优点：语法简洁，贴近自然测试流程；可通过内部逻辑强制执行顺序，开发者只需按步骤填写内容。
缺点：依赖Kotlin语言特性，Java项目无法直接使用。

方案3：现有Builder加前置检查（最小改动） #

如果不想重构现有Builder，可在关键方法中添加前置条件检查，运行时拦截非法调用顺序。

示例代码：

class MigrationHelperBuilder {
    private var hasAddedMigrations = false
    private var migrations: List<Migration>? = null

    fun addMigrations(vararg migrations: Migration): MigrationHelperBuilder {
        this.migrations = migrations.toList()
        hasAddedMigrations = true
        return this
    }

    fun createOldDatabase(dbName: String): MigrationHelperBuilder {
        // 执行旧库创建逻辑
        return this
    }

    fun insertTestData(data: TestData): MigrationHelperBuilder {
        // 执行数据插入逻辑
        return this
    }

    fun runMigration(): MigrationHelperBuilder {
        check(hasAddedMigrations) { "必须先调用addMigrations()才能执行迁移" }
        // 执行迁移逻辑
        return this
    }

    fun verifyDataIntegrity() {
        // 执行数据验证逻辑
    }
}

优点：改动极小，兼容现有代码；快速生效。
缺点：仅能在运行时发现顺序错误，无法提前在编译期拦截。

内容的提问来源于stack exchange，提问作者Saneen K P