befly 3.10.1 → 3.10.2

package/tests/syncTable-db-integration.test.ts

@@ -1,237 +0,0 @@
-/**
- * syncTable 端到端行为测试（纯 mock，不连接真实数据库）
- */
-
-import type { FieldDefinition } from "../types/validate.js";
-import type { ScanFileResult } from "../utils/scanFiles.js";
-import type { MockSqliteState } from "./_mocks/mockSqliteDb.js";
-
-import { describe, expect, test } from "bun:test";
-
-import { CacheKeys } from "../lib/cacheKeys.js";
-import { syncTable } from "../sync/syncTable.js";
-import { createMockSqliteDb } from "./_mocks/mockSqliteDb.js";
-
-function buildTableItem(options: { tableFileName: string; content: any }): ScanFileResult {
-    return {
-        source: "app",
-        type: "table",
-        sourceName: "项目",
-        filePath: "",
-        relativePath: options.tableFileName,
-        fileName: options.tableFileName,
-        moduleName: `app_${options.tableFileName}`,
-        addonName: "",
-        fileBaseName: "",
-        fileDir: "",
-        content: options.content
-    } as any;
-}
-
-function fdString(options: { name: string; min: number; max: number; defaultValue: any; nullable: boolean }): FieldDefinition {
-    return {
-        name: options.name,
-        type: "string",
-        min: options.min,
-        max: options.max,
-        default: options.defaultValue,
-        nullable: options.nullable
-    } as any;
-}
-
-function fdNumber(options: { name: string; min: number; max: number; defaultValue: any; nullable: boolean }): FieldDefinition {
-    return {
-        name: options.name,
-        type: "number",
-        min: options.min,
-        max: options.max,
-        default: options.defaultValue,
-        nullable: options.nullable
-    } as any;
-}
-
-function fdText(options: { name: string; min: number; max: number; defaultValue: any; nullable: boolean }): FieldDefinition {
-    return {
-        name: options.name,
-        type: "text",
-        min: options.min,
-        max: options.max,
-        default: options.defaultValue,
-        nullable: options.nullable
-    } as any;
-}
-
-describe("syncTable(ctx, items) - mock sqlite", () => {
-    test("首次同步：应创建表并包含系统字段 + 业务字段，同时清理 columns 缓存", async () => {
-        const state: MockSqliteState = {
-            executedSql: [],
-            tables: {}
-        };
-
-        const db = createMockSqliteDb(state);
-
-        const redisCalls: Array<{ keys: string[] }> = [];
-        const ctx = {
-            db: db,
-            redis: {
-                delBatch: async (keys: string[]) => {
-                    redisCalls.push({ keys: keys });
-                    return keys.length;
-                }
-            },
-            config: {
-                db: { type: "sqlite", database: "" }
-            }
-        } as any;
-
-        const tableFileName = "test_sync_table_integration_user";
-        const item = buildTableItem({
-            tableFileName: tableFileName,
-            content: {
-                email: fdString({ name: "邮箱", min: 0, max: 100, defaultValue: null, nullable: false }),
-                nickname: fdString({ name: "昵称", min: 0, max: 50, defaultValue: "用户", nullable: true }),
-                age: fdNumber({ name: "年龄", min: 0, max: 999, defaultValue: 0, nullable: true })
-            }
-        });
-
-        await syncTable(ctx, [item]);
-
-        expect(state.executedSql.some((s) => s.includes("CREATE TABLE") && s.includes(tableFileName))).toBe(true);
-
-        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
-        const exists = await syncTable.TestKit.tableExistsRuntime(runtime, tableFileName);
-        expect(exists).toBe(true);
-
-        const columns = await syncTable.TestKit.getTableColumnsRuntime(runtime, tableFileName);
-
-        expect(columns.id).toBeDefined();
-        expect(columns.created_at).toBeDefined();
-        expect(columns.updated_at).toBeDefined();
-        expect(columns.state).toBeDefined();
-
-        expect(columns.email).toBeDefined();
-        expect(columns.nickname).toBeDefined();
-        expect(columns.age).toBeDefined();
-
-        expect(redisCalls.length).toBe(1);
-        expect(redisCalls[0].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
-    });
-
-    test("二次同步：新增字段应落库（ADD COLUMN），同时清理 columns 缓存", async () => {
-        const state: MockSqliteState = {
-            executedSql: [],
-            tables: {}
-        };
-
-        const db = createMockSqliteDb(state);
-
-        const redisCalls: Array<{ keys: string[] }> = [];
-        const ctx = {
-            db: db,
-            redis: {
-                delBatch: async (keys: string[]) => {
-                    redisCalls.push({ keys: keys });
-                    return keys.length;
-                }
-            },
-            config: {
-                db: { type: "sqlite", database: "" }
-            }
-        } as any;
-
-        const tableFileName = "test_sync_table_integration_profile";
-
-        const itemV1 = buildTableItem({
-            tableFileName: tableFileName,
-            content: {
-                nickname: fdString({ name: "昵称", min: 0, max: 50, defaultValue: "用户", nullable: true })
-            }
-        });
-
-        await syncTable(ctx, [itemV1]);
-
-        const itemV2 = buildTableItem({
-            tableFileName: tableFileName,
-            content: {
-                nickname: fdString({ name: "昵称", min: 0, max: 50, defaultValue: "用户", nullable: true }),
-                bio: fdText({ name: "简介", min: 0, max: 200, defaultValue: null, nullable: true })
-            }
-        });
-
-        await syncTable(ctx, [itemV2]);
-
-        expect(state.executedSql.some((s) => s.includes("ALTER TABLE") && s.includes(tableFileName) && s.includes("ADD COLUMN") && s.includes("bio"))).toBe(true);
-
-        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
-        const columns = await syncTable.TestKit.getTableColumnsRuntime(runtime, tableFileName);
-        expect(columns.nickname).toBeDefined();
-        expect(columns.bio).toBeDefined();
-
-        // 两次同步，每次都会清一次缓存
-        expect(redisCalls.length).toBe(2);
-        expect(redisCalls[0].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
-        expect(redisCalls[1].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
-    });
-
-    test("索引变更：仅删除单列索引；复合索引不会被误删", async () => {
-        const tableFileName = "test_sync_table_integration_indexes";
-
-        const state: MockSqliteState = {
-            executedSql: [],
-            tables: {
-                [tableFileName]: {
-                    columns: {
-                        id: { name: "id", type: "INTEGER", notnull: 1, dflt_value: null },
-                        created_at: { name: "created_at", type: "INTEGER", notnull: 1, dflt_value: "0" },
-                        updated_at: { name: "updated_at", type: "INTEGER", notnull: 1, dflt_value: "0" },
-                        deleted_at: { name: "deleted_at", type: "INTEGER", notnull: 1, dflt_value: "0" },
-                        state: { name: "state", type: "INTEGER", notnull: 1, dflt_value: "1" },
-                        user_id: { name: "user_id", type: "INTEGER", notnull: 1, dflt_value: "0" },
-                        user_name: { name: "user_name", type: "TEXT", notnull: 1, dflt_value: "''" }
-                    },
-                    indexes: {
-                        // 单列索引：应该能被识别并在 index=false 时被 drop
-                        idx_user_name: ["user_name"],
-                        // 复合索引：即使名字像单列索引，也因为多列而被 runtime 忽略，因此不会被 drop
-                        idx_user_id: ["user_id", "created_at"]
-                    }
-                }
-            }
-        };
-
-        const db = createMockSqliteDb(state);
-
-        const redisCalls: Array<{ keys: string[] }> = [];
-        const ctx = {
-            db: db,
-            redis: {
-                delBatch: async (keys: string[]) => {
-                    redisCalls.push({ keys: keys });
-                    return keys.length;
-                }
-            },
-            config: {
-                db: { type: "sqlite", database: "" }
-            }
-        } as any;
-
-        const item = buildTableItem({
-            tableFileName: tableFileName,
-            content: {
-                userId: fdNumber({ name: "用户ID", min: 0, max: 999999999, defaultValue: 0, nullable: false }),
-                userName: fdString({ name: "用户名", min: 0, max: 50, defaultValue: "", nullable: false })
-            }
-        });
-
-        await syncTable(ctx, [item]);
-
-        const dropUserName = state.executedSql.some((s) => s.includes("DROP INDEX") && s.includes("idx_user_name"));
-        expect(dropUserName).toBe(true);
-
-        const dropUserIdComposite = state.executedSql.some((s) => s.includes("DROP INDEX") && s.includes("idx_user_id"));
-        expect(dropUserIdComposite).toBe(false);
-
-        expect(redisCalls.length).toBe(1);
-        expect(redisCalls[0].keys).toEqual([CacheKeys.tableColumns(tableFileName)]);
-    });
-});

package/tests/syncTable-ddl.test.ts

@@ -1,245 +0,0 @@
-/**
- * syncTable DDL 构建模块测试
- *
- * 测试 ddl.ts 中的函数：
- * - buildIndexSQL
- * - buildSystemColumnDefs
- * - buildBusinessColumnDefs
- * - generateDDLClause
- * - isCompatibleTypeChange
- */
-
-import { describe, test, expect } from "bun:test";
-
-import { syncTable } from "../sync/syncTable.js";
-
-describe("buildIndexSQL (MySQL)", () => {
-    test("创建索引 SQL", () => {
-        const sql = syncTable.TestKit.buildIndexSQL("mysql", "user", "idx_created_at", "created_at", "create");
-        expect(sql).toContain("ALTER TABLE `user`");
-        expect(sql).toContain("ADD INDEX `idx_created_at`");
-        expect(sql).toContain("(`created_at`)");
-        expect(sql).toContain("ALGORITHM=INPLACE");
-        expect(sql).toContain("LOCK=NONE");
-    });
-
-    test("删除索引 SQL", () => {
-        const sql = syncTable.TestKit.buildIndexSQL("mysql", "user", "idx_created_at", "created_at", "drop");
-        expect(sql).toContain("ALTER TABLE `user`");
-        expect(sql).toContain("DROP INDEX `idx_created_at`");
-    });
-});
-
-describe("buildSystemColumnDefs (MySQL)", () => {
-    test("返回 5 个系统字段定义", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
-        expect(defs.length).toBe(5);
-    });
-
-    test("包含 id 主键", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
-        const idDef = defs.find((d: string) => d.includes("`id`"));
-        expect(idDef).toContain("PRIMARY KEY");
-        expect(idDef).toContain("AUTO_INCREMENT");
-        expect(idDef).toContain("BIGINT UNSIGNED");
-    });
-
-    test("包含 created_at 字段", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
-        const def = defs.find((d: string) => d.includes("`created_at`"));
-        expect(def).toContain("BIGINT UNSIGNED");
-        expect(def).toContain("NOT NULL");
-        expect(def).toContain("DEFAULT 0");
-    });
-
-    test("包含 state 字段", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("mysql");
-        const def = defs.find((d: string) => d.includes("`state`"));
-        expect(def).toContain("BIGINT UNSIGNED");
-        expect(def).toContain("NOT NULL");
-        expect(def).toContain("DEFAULT 1");
-    });
-});
-
-describe("buildSystemColumnDefs (PostgreSQL)", () => {
-    test("返回 5 个系统字段定义", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
-        expect(defs.length).toBe(5);
-    });
-
-    test("包含 id 主键 identity", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
-        const idDef = defs.find((d: string) => d.includes('"id"'));
-        expect(idDef).toContain("BIGINT");
-        expect(idDef).toContain("PRIMARY KEY");
-        expect(idDef).toContain("GENERATED");
-        expect(idDef).toContain("IDENTITY");
-    });
-
-    test("包含 created_at BIGINT 默认值", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
-        const def = defs.find((d: string) => d.includes('"created_at"'));
-        expect(def).toContain("BIGINT");
-        expect(def).toContain("NOT NULL");
-        expect(def).toContain("DEFAULT 0");
-    });
-
-    test("包含 state BIGINT 默认值", () => {
-        const defs = syncTable.TestKit.buildSystemColumnDefs("postgresql");
-        const def = defs.find((d: string) => d.includes('"state"'));
-        expect(def).toContain("BIGINT");
-        expect(def).toContain("NOT NULL");
-        expect(def).toContain("DEFAULT 1");
-    });
-});
-
-describe("buildBusinessColumnDefs (MySQL)", () => {
-    test("生成 string 类型字段", () => {
-        const fields = {
-            userName: {
-                name: "用户名",
-                type: "string",
-                max: 50,
-                default: null,
-                unique: false,
-                nullable: false,
-                unsigned: true
-            }
-        };
-        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
-        expect(defs.length).toBe(1);
-        expect(defs[0]).toContain("`user_name`");
-        expect(defs[0]).toContain("VARCHAR(50)");
-        expect(defs[0]).toContain("NOT NULL");
-        expect(defs[0]).toContain("DEFAULT ''");
-        expect(defs[0]).toContain('COMMENT "用户名"');
-    });
-
-    test("生成 number 类型字段", () => {
-        const fields = {
-            age: {
-                name: "年龄",
-                type: "number",
-                max: null,
-                default: 0,
-                unique: false,
-                nullable: false,
-                unsigned: true
-            }
-        };
-        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
-        expect(defs[0]).toContain("`age`");
-        expect(defs[0]).toContain("BIGINT UNSIGNED");
-        expect(defs[0]).toContain("DEFAULT 0");
-    });
-
-    test("生成 unique 字段", () => {
-        const fields = {
-            email: {
-                name: "邮箱",
-                type: "string",
-                max: 100,
-                default: null,
-                unique: true,
-                nullable: false,
-                unsigned: true
-            }
-        };
-        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
-        expect(defs[0]).toContain("UNIQUE");
-    });
-
-    test("生成 nullable 字段", () => {
-        const fields = {
-            remark: {
-                name: "备注",
-                type: "string",
-                max: 200,
-                default: null,
-                unique: false,
-                nullable: true,
-                unsigned: true
-            }
-        };
-        const defs = syncTable.TestKit.buildBusinessColumnDefs("mysql", fields as any);
-        expect(defs[0]).toContain("NULL");
-        expect(defs[0]).not.toContain("NOT NULL");
-    });
-});
-
-describe("generateDDLClause (MySQL)", () => {
-    test("生成 ADD COLUMN 子句", () => {
-        const fieldDef = {
-            name: "用户名",
-            type: "string",
-            max: 50,
-            default: null,
-            unique: false,
-            nullable: false,
-            unsigned: true
-        };
-        const clause = syncTable.TestKit.generateDDLClause("mysql", "userName", fieldDef as any, true);
-        expect(clause).toContain("ADD COLUMN");
-        expect(clause).toContain("`user_name`");
-        expect(clause).toContain("VARCHAR(50)");
-    });
-
-    test("生成 MODIFY COLUMN 子句", () => {
-        const fieldDef = {
-            name: "用户名",
-            type: "string",
-            max: 100,
-            default: null,
-            unique: false,
-            nullable: false,
-            unsigned: true
-        };
-        const clause = syncTable.TestKit.generateDDLClause("mysql", "userName", fieldDef as any, false);
-        expect(clause).toContain("MODIFY COLUMN");
-        expect(clause).toContain("`user_name`");
-        expect(clause).toContain("VARCHAR(100)");
-    });
-});
-
-describe("isCompatibleTypeChange", () => {
-    test("varchar -> text 是兼容变更", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange("character varying", "text")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("varchar(100)", "text")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("varchar(100)", "mediumtext")).toBe(true);
-    });
-
-    test("text -> varchar 不是兼容变更", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange("text", "character varying")).toBe(false);
-        expect(syncTable.TestKit.isCompatibleTypeChange("text", "varchar(100)")).toBe(false);
-    });
-
-    test("int -> bigint 是兼容变更", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange("int", "bigint")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("int unsigned", "bigint unsigned")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("tinyint", "int")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("tinyint", "bigint")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("smallint", "int")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("mediumint", "bigint")).toBe(true);
-    });
-
-    test("bigint -> int 不是兼容变更（收缩）", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange("bigint", "int")).toBe(false);
-        expect(syncTable.TestKit.isCompatibleTypeChange("int", "tinyint")).toBe(false);
-    });
-
-    test("PG integer -> bigint 是兼容变更", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange("integer", "bigint")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("smallint", "integer")).toBe(true);
-        expect(syncTable.TestKit.isCompatibleTypeChange("smallint", "bigint")).toBe(true);
-    });
-
-    test("相同类型不是变更", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange("text", "text")).toBe(false);
-        expect(syncTable.TestKit.isCompatibleTypeChange("bigint", "bigint")).toBe(false);
-    });
-
-    test("空值处理", () => {
-        expect(syncTable.TestKit.isCompatibleTypeChange(null as any, "text")).toBe(false);
-        expect(syncTable.TestKit.isCompatibleTypeChange("text", null as any)).toBe(false);
-    });
-});

package/tests/syncTable-helpers.test.ts

@@ -1,99 +0,0 @@
-/**
- * syncTable 辅助工具模块测试
- *
- * 测试 helpers.ts 中的函数：
- * - quoteIdentifier
- * - escapeComment
- * - applyFieldDefaults
- */
-
-import { describe, test, expect } from "bun:test";
-
-import { syncTable } from "../sync/syncTable.js";
-
-describe("quoteIdentifier (MySQL)", () => {
-    test("使用反引号包裹标识符", () => {
-        expect(syncTable.TestKit.quoteIdentifier("mysql", "user_table")).toBe("`user_table`");
-    });
-
-    test("处理普通表名", () => {
-        expect(syncTable.TestKit.quoteIdentifier("mysql", "admin")).toBe("`admin`");
-    });
-
-    test("处理带下划线的表名", () => {
-        expect(syncTable.TestKit.quoteIdentifier("mysql", "addon_admin_menu")).toBe("`addon_admin_menu`");
-    });
-});
-
-describe("escapeComment", () => {
-    test("普通注释不变", () => {
-        expect(syncTable.TestKit.escapeComment("用户名称")).toBe("用户名称");
-    });
-
-    test("双引号被转义", () => {
-        expect(syncTable.TestKit.escapeComment('用户"昵称"')).toBe('用户\\"昵称\\"');
-    });
-
-    test("空字符串", () => {
-        expect(syncTable.TestKit.escapeComment("")).toBe("");
-    });
-});
-
-describe("applyFieldDefaults", () => {
-    test("为空字段定义应用默认值", () => {
-        const fieldDef: any = {
-            name: "用户名",
-            type: "string"
-        };
-
-        syncTable.TestKit.applyFieldDefaults(fieldDef);
-
-        expect(fieldDef.detail).toBe("");
-        expect(fieldDef.min).toBe(0);
-        expect(fieldDef.max).toBe(100);
-        expect(fieldDef.default).toBe(null);
-        expect(fieldDef.index).toBe(false);
-        expect(fieldDef.unique).toBe(false);
-        expect(fieldDef.nullable).toBe(false);
-        expect(fieldDef.unsigned).toBe(true);
-        expect(fieldDef.regexp).toBe(null);
-    });
-
-    test("保留已有值", () => {
-        const fieldDef: any = {
-            name: "用户名",
-            type: "string",
-            max: 200,
-            index: true,
-            unique: true,
-            nullable: true
-        };
-
-        syncTable.TestKit.applyFieldDefaults(fieldDef);
-
-        expect(fieldDef.max).toBe(200);
-        expect(fieldDef.index).toBe(true);
-        expect(fieldDef.unique).toBe(true);
-        expect(fieldDef.nullable).toBe(true);
-    });
-
-    test("处理 0 和 false 值", () => {
-        const fieldDef: any = {
-            name: "排序",
-            type: "number",
-            min: 0,
-            max: 0,
-            default: 0,
-            index: false,
-            unsigned: false
-        };
-
-        syncTable.TestKit.applyFieldDefaults(fieldDef);
-
-        expect(fieldDef.min).toBe(0);
-        expect(fieldDef.max).toBe(0);
-        expect(fieldDef.default).toBe(0);
-        expect(fieldDef.index).toBe(false);
-        expect(fieldDef.unsigned).toBe(false);
-    });
-});

package/tests/syncTable-schema.test.ts

@@ -1,99 +0,0 @@
-/**
- * syncTable 表结构查询模块测试（纯 mock，不连接真实数据库）
- */
-
-import { describe, expect, test } from "bun:test";
-
-import { syncTable } from "../sync/syncTable.js";
-import { createMockSqliteDb } from "./_mocks/mockSqliteDb.js";
-
-describe("tableExistsRuntime", () => {
-    test("sql 执行器未初始化时抛出错误", async () => {
-        try {
-            await syncTable.TestKit.tableExistsRuntime(syncTable.TestKit.createRuntime("sqlite", null as any, ""), "user");
-            expect(true).toBe(false);
-        } catch (error: any) {
-            expect(error.message).toBe("SQL 执行器未初始化");
-        }
-    });
-
-    test("mock sqlite：表存在返回 true；表不存在返回 false", async () => {
-        const db = createMockSqliteDb({
-            executedSql: [],
-            tables: {
-                test_sync_table_exists: {
-                    columns: {},
-                    indexes: {}
-                }
-            }
-        });
-
-        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
-        const exist = await syncTable.TestKit.tableExistsRuntime(runtime, "test_sync_table_exists");
-        expect(exist).toBe(true);
-
-        const notExist = await syncTable.TestKit.tableExistsRuntime(runtime, "test_sync_table_not_exist_12345");
-        expect(notExist).toBe(false);
-    });
-});
-
-describe("getTableColumnsRuntime", () => {
-    test("mock sqlite：返回列信息结构（至少包含我们定义的列）", async () => {
-        const db = createMockSqliteDb({
-            executedSql: [],
-            tables: {
-                test_sync_table_columns: {
-                    columns: {
-                        id: { name: "id", type: "INTEGER", notnull: 1, dflt_value: null },
-                        user_name: { name: "user_name", type: "TEXT", notnull: 1, dflt_value: "''" },
-                        user_id: { name: "user_id", type: "INTEGER", notnull: 1, dflt_value: "0" },
-                        age: { name: "age", type: "INTEGER", notnull: 0, dflt_value: "0" },
-                        created_at: { name: "created_at", type: "INTEGER", notnull: 1, dflt_value: "0" }
-                    },
-                    indexes: {}
-                }
-            }
-        });
-
-        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
-        const columns = await syncTable.TestKit.getTableColumnsRuntime(runtime, "test_sync_table_columns");
-
-        expect(columns.id).toBeDefined();
-        expect(columns.user_name).toBeDefined();
-        expect(columns.user_id).toBeDefined();
-        expect(columns.age).toBeDefined();
-        expect(columns.created_at).toBeDefined();
-
-        expect(columns.user_name.nullable).toBe(false);
-    });
-});
-
-describe("getTableIndexesRuntime", () => {
-    test("mock sqlite：返回索引信息结构（仅单列索引；复合索引会被忽略）", async () => {
-        const db = createMockSqliteDb({
-            executedSql: [],
-            tables: {
-                test_sync_table_indexes: {
-                    columns: {},
-                    indexes: {
-                        idx_created_at: ["created_at"],
-                        idx_user_name: ["user_name"],
-                        idx_composite: ["user_id", "created_at"]
-                    }
-                }
-            }
-        });
-
-        const runtime = syncTable.TestKit.createRuntime("sqlite", db as any, "");
-        const indexes = await syncTable.TestKit.getTableIndexesRuntime(runtime, "test_sync_table_indexes");
-
-        expect(indexes.idx_created_at).toBeDefined();
-        expect(indexes.idx_created_at).toContain("created_at");
-
-        expect(indexes.idx_user_name).toBeDefined();
-        expect(indexes.idx_user_name).toContain("user_name");
-
-        // sqlite 路径下为了避免多列索引误判，仅收集单列索引
-        expect(indexes.idx_composite).toBeUndefined();
-    });
-});