befly 3.8.25 → 3.8.27

package/tests/sync-connection.test.ts

@@ -0,0 +1,189 @@
+/**
+ * sync 模块连接管理集成测试
+ * 验证数据库连接的正确关闭
+ */
+import { describe, test, expect, afterEach } from 'bun:test';
+
+import { Connect } from '../lib/connect.js';
+
+describe('sync 模块连接管理', () => {
+    afterEach(() => {
+        // 每个测试后重置连接状态
+        Connect.__reset();
+    });
+
+    describe('Connect.isConnected', () => {
+        test('初始状态应该都是未连接', () => {
+            const status = Connect.isConnected();
+            expect(status.sql).toBe(false);
+            expect(status.redis).toBe(false);
+        });
+    });
+
+    describe('Connect.disconnect', () => {
+        test('disconnect 应该能安全地关闭未连接的状态', async () => {
+            // 即使没有连接，disconnect 也不应该抛出错误
+            await expect(Connect.disconnect()).resolves.toBeUndefined();
+        });
+
+        test('disconnectSql 应该能安全地关闭未连接的状态', async () => {
+            await expect(Connect.disconnectSql()).resolves.toBeUndefined();
+        });
+
+        test('disconnectRedis 应该能安全地关闭未连接的状态', async () => {
+            await expect(Connect.disconnectRedis()).resolves.toBeUndefined();
+        });
+    });
+
+    describe('Connect.getSql', () => {
+        test('未连接时应该抛出错误', () => {
+            expect(() => Connect.getSql()).toThrow('SQL 客户端未连接');
+        });
+    });
+
+    describe('Connect.getRedis', () => {
+        test('未连接时应该抛出错误', () => {
+            expect(() => Connect.getRedis()).toThrow('Redis 客户端未连接');
+        });
+    });
+
+    describe('Connect.getDbHelper', () => {
+        test('未连接时应该抛出错误', () => {
+            expect(() => Connect.getDbHelper()).toThrow('SQL 客户端未连接');
+        });
+    });
+
+    describe('Mock 连接测试', () => {
+        test('__setMockSql 应该设置 mock SQL 客户端', () => {
+            const mockSql = { close: async () => {} } as any;
+            Connect.__setMockSql(mockSql);
+
+            const status = Connect.isConnected();
+            expect(status.sql).toBe(true);
+            expect(status.redis).toBe(false);
+        });
+
+        test('__setMockRedis 应该设置 mock Redis 客户端', () => {
+            const mockRedis = { close: () => {} } as any;
+            Connect.__setMockRedis(mockRedis);
+
+            const status = Connect.isConnected();
+            expect(status.sql).toBe(false);
+            expect(status.redis).toBe(true);
+        });
+
+        test('__reset 应该重置所有连接', () => {
+            const mockSql = { close: async () => {} } as any;
+            const mockRedis = { close: () => {} } as any;
+            Connect.__setMockSql(mockSql);
+            Connect.__setMockRedis(mockRedis);
+
+            expect(Connect.isConnected().sql).toBe(true);
+            expect(Connect.isConnected().redis).toBe(true);
+
+            Connect.__reset();
+
+            expect(Connect.isConnected().sql).toBe(false);
+            expect(Connect.isConnected().redis).toBe(false);
+        });
+
+        test('disconnect 应该正确关闭 mock 连接', async () => {
+            let sqlClosed = false;
+            let redisClosed = false;
+
+            const mockSql = {
+                close: async () => {
+                    sqlClosed = true;
+                }
+            } as any;
+            const mockRedis = {
+                close: () => {
+                    redisClosed = true;
+                }
+            } as any;
+
+            Connect.__setMockSql(mockSql);
+            Connect.__setMockRedis(mockRedis);
+
+            await Connect.disconnect();
+
+            expect(sqlClosed).toBe(true);
+            expect(redisClosed).toBe(true);
+            expect(Connect.isConnected().sql).toBe(false);
+            expect(Connect.isConnected().redis).toBe(false);
+        });
+    });
+
+    describe('连接异常处理', () => {
+        test('disconnectSql 应该处理关闭时的错误', async () => {
+            const mockSql = {
+                close: async () => {
+                    throw new Error('Close error');
+                }
+            } as any;
+
+            Connect.__setMockSql(mockSql);
+
+            // 不应该抛出错误，只是记录日志
+            await expect(Connect.disconnectSql()).resolves.toBeUndefined();
+            expect(Connect.isConnected().sql).toBe(false);
+        });
+
+        test('disconnectRedis 应该处理关闭时的错误', async () => {
+            const mockRedis = {
+                close: () => {
+                    throw new Error('Close error');
+                }
+            } as any;
+
+            Connect.__setMockRedis(mockRedis);
+
+            // 不应该抛出错误，只是记录日志
+            await expect(Connect.disconnectRedis()).resolves.toBeUndefined();
+            expect(Connect.isConnected().redis).toBe(false);
+        });
+    });
+
+    describe('Connect.getStatus', () => {
+        test('未连接时返回正确的状态', () => {
+            const status = Connect.getStatus();
+
+            expect(status.sql.connected).toBe(false);
+            expect(status.sql.connectedAt).toBeNull();
+            expect(status.sql.uptime).toBeNull();
+            expect(status.sql.poolMax).toBe(1);
+
+            expect(status.redis.connected).toBe(false);
+            expect(status.redis.connectedAt).toBeNull();
+            expect(status.redis.uptime).toBeNull();
+        });
+
+        test('Mock 连接后返回正确的状态', () => {
+            const mockSql = { close: async () => {} } as any;
+            const mockRedis = { close: () => {} } as any;
+
+            Connect.__setMockSql(mockSql);
+            Connect.__setMockRedis(mockRedis);
+
+            const status = Connect.getStatus();
+
+            // Mock 不会设置连接时间，但连接状态应该为 true
+            expect(status.sql.connected).toBe(true);
+            expect(status.redis.connected).toBe(true);
+        });
+
+        test('__reset 应该重置所有状态包括连接时间', () => {
+            const mockSql = { close: async () => {} } as any;
+            Connect.__setMockSql(mockSql);
+
+            expect(Connect.getStatus().sql.connected).toBe(true);
+
+            Connect.__reset();
+
+            const status = Connect.getStatus();
+            expect(status.sql.connected).toBe(false);
+            expect(status.sql.connectedAt).toBeNull();
+            expect(status.sql.poolMax).toBe(1);
+        });
+    });
+});

package/tests/syncDb-apply.test.ts

@@ -0,0 +1,287 @@
+/**
+ * syncDb 变更应用模块测试
+ *
+ * 测试 apply.ts 中的函数：
+ * - compareFieldDefinition
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+
+// 设置环境变量模拟 MySQL 环境
+process.env.DB_TYPE = 'mysql';
+
+let compareFieldDefinition: any;
+
+beforeAll(async () => {
+    const apply = await import('../sync/syncDb/apply.js');
+    compareFieldDefinition = apply.compareFieldDefinition;
+});
+
+describe('compareFieldDefinition', () => {
+    describe('长度变化检测', () => {
+        test('string 类型长度变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 50,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const lengthChange = changes.find((c: any) => c.type === 'length');
+
+            expect(lengthChange).toBeDefined();
+            expect(lengthChange.current).toBe(50);
+            expect(lengthChange.expected).toBe(100);
+        });
+
+        test('长度相同无变化', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const lengthChange = changes.find((c: any) => c.type === 'length');
+
+            expect(lengthChange).toBeUndefined();
+        });
+    });
+
+    describe('注释变化检测', () => {
+        test('注释变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '旧注释'
+            };
+            const fieldDef = {
+                name: '新注释',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const commentChange = changes.find((c: any) => c.type === 'comment');
+
+            expect(commentChange).toBeDefined();
+            expect(commentChange.current).toBe('旧注释');
+            expect(commentChange.expected).toBe('新注释');
+        });
+
+        test('注释相同无变化', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const commentChange = changes.find((c: any) => c.type === 'comment');
+
+            expect(commentChange).toBeUndefined();
+        });
+    });
+
+    describe('数据类型变化检测', () => {
+        test('类型变化被检测到', () => {
+            const existingColumn = {
+                type: 'bigint',
+                max: null,
+                nullable: false,
+                defaultValue: 0,
+                comment: '数量'
+            };
+            const fieldDef = {
+                name: '数量',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const typeChange = changes.find((c: any) => c.type === 'datatype');
+
+            expect(typeChange).toBeDefined();
+            expect(typeChange.current).toBe('bigint');
+            expect(typeChange.expected).toBe('varchar');
+        });
+
+        test('类型相同无变化', () => {
+            const existingColumn = {
+                type: 'bigint',
+                max: null,
+                nullable: false,
+                defaultValue: 0,
+                comment: '数量'
+            };
+            const fieldDef = {
+                name: '数量',
+                type: 'number',
+                max: null,
+                nullable: false,
+                default: 0
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const typeChange = changes.find((c: any) => c.type === 'datatype');
+
+            expect(typeChange).toBeUndefined();
+        });
+    });
+
+    describe('可空性变化检测', () => {
+        test('nullable 变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: true,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const nullableChange = changes.find((c: any) => c.type === 'nullable');
+
+            expect(nullableChange).toBeDefined();
+            expect(nullableChange.current).toBe(false);
+            expect(nullableChange.expected).toBe(true);
+        });
+    });
+
+    describe('默认值变化检测', () => {
+        test('默认值变化被检测到', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: 'old',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: 'new'
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const defaultChange = changes.find((c: any) => c.type === 'default');
+
+            expect(defaultChange).toBeDefined();
+            expect(defaultChange.current).toBe('old');
+            expect(defaultChange.expected).toBe('new');
+        });
+
+        test('null 默认值被正确处理', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null // null 会被解析为空字符串
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+            const defaultChange = changes.find((c: any) => c.type === 'default');
+
+            // null -> '' (空字符串)，与现有值相同，无变化
+            expect(defaultChange).toBeUndefined();
+        });
+    });
+
+    describe('多变化组合', () => {
+        test('多个变化同时被检测', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 50,
+                nullable: false,
+                defaultValue: 'old',
+                comment: '旧注释'
+            };
+            const fieldDef = {
+                name: '新注释',
+                type: 'string',
+                max: 100,
+                nullable: true,
+                default: 'new'
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+
+            expect(changes.length).toBe(4); // length, comment, nullable, default
+            expect(changes.some((c: any) => c.type === 'length')).toBe(true);
+            expect(changes.some((c: any) => c.type === 'comment')).toBe(true);
+            expect(changes.some((c: any) => c.type === 'nullable')).toBe(true);
+            expect(changes.some((c: any) => c.type === 'default')).toBe(true);
+        });
+
+        test('无变化返回空数组', () => {
+            const existingColumn = {
+                type: 'varchar',
+                max: 100,
+                nullable: false,
+                defaultValue: '',
+                comment: '用户名'
+            };
+            const fieldDef = {
+                name: '用户名',
+                type: 'string',
+                max: 100,
+                nullable: false,
+                default: null
+            };
+
+            const changes = compareFieldDefinition(existingColumn, fieldDef);
+
+            expect(changes.length).toBe(0);
+        });
+    });
+});

package/tests/syncDb-constants.test.ts

@@ -0,0 +1,150 @@
+/**
+ * syncDb 常量模块测试
+ *
+ * 测试 constants.ts 中的常量：
+ * - DB_VERSION_REQUIREMENTS
+ * - SYSTEM_FIELDS
+ * - SYSTEM_INDEX_FIELDS
+ * - CHANGE_TYPE_LABELS
+ * - MYSQL_TABLE_CONFIG
+ * - typeMapping
+ */
+
+import { describe, test, expect, beforeAll } from 'bun:test';
+
+// 设置环境变量模拟 MySQL 环境
+process.env.DB_TYPE = 'mysql';
+
+let constants: any;
+
+beforeAll(async () => {
+    constants = await import('../sync/syncDb/constants.js');
+});
+
+describe('DB_VERSION_REQUIREMENTS', () => {
+    test('MySQL 最低版本为 8', () => {
+        expect(constants.DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR).toBe(8);
+    });
+
+    test('PostgreSQL 最低版本为 17', () => {
+        expect(constants.DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR).toBe(17);
+    });
+
+    test('SQLite 最低版本为 3.50.0', () => {
+        expect(constants.DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION).toBe('3.50.0');
+    });
+});
+
+describe('SYSTEM_FIELDS', () => {
+    test('包含 id 字段', () => {
+        expect(constants.SYSTEM_FIELDS.ID.name).toBe('id');
+    });
+
+    test('包含 created_at 字段', () => {
+        expect(constants.SYSTEM_FIELDS.CREATED_AT.name).toBe('created_at');
+    });
+
+    test('包含 updated_at 字段', () => {
+        expect(constants.SYSTEM_FIELDS.UPDATED_AT.name).toBe('updated_at');
+    });
+
+    test('包含 deleted_at 字段', () => {
+        expect(constants.SYSTEM_FIELDS.DELETED_AT.name).toBe('deleted_at');
+    });
+
+    test('包含 state 字段', () => {
+        expect(constants.SYSTEM_FIELDS.STATE.name).toBe('state');
+    });
+});
+
+describe('SYSTEM_INDEX_FIELDS', () => {
+    test('包含 created_at', () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain('created_at');
+    });
+
+    test('包含 updated_at', () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain('updated_at');
+    });
+
+    test('包含 state', () => {
+        expect(constants.SYSTEM_INDEX_FIELDS).toContain('state');
+    });
+
+    test('共 3 个系统索引字段', () => {
+        expect(constants.SYSTEM_INDEX_FIELDS.length).toBe(3);
+    });
+});
+
+describe('CHANGE_TYPE_LABELS', () => {
+    test('length 对应 "长度"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.length).toBe('长度');
+    });
+
+    test('datatype 对应 "类型"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.datatype).toBe('类型');
+    });
+
+    test('comment 对应 "注释"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.comment).toBe('注释');
+    });
+
+    test('default 对应 "默认值"', () => {
+        expect(constants.CHANGE_TYPE_LABELS.default).toBe('默认值');
+    });
+});
+
+describe('MYSQL_TABLE_CONFIG', () => {
+    test('ENGINE 为 InnoDB', () => {
+        expect(constants.MYSQL_TABLE_CONFIG.ENGINE).toBe('InnoDB');
+    });
+
+    test('CHARSET 为 utf8mb4', () => {
+        expect(constants.MYSQL_TABLE_CONFIG.CHARSET).toBe('utf8mb4');
+    });
+
+    test('COLLATE 为 utf8mb4_0900_ai_ci', () => {
+        expect(constants.MYSQL_TABLE_CONFIG.COLLATE).toBe('utf8mb4_0900_ai_ci');
+    });
+});
+
+describe('typeMapping (MySQL)', () => {
+    test('number 映射为 BIGINT', () => {
+        expect(constants.typeMapping.number).toBe('BIGINT');
+    });
+
+    test('string 映射为 VARCHAR', () => {
+        expect(constants.typeMapping.string).toBe('VARCHAR');
+    });
+
+    test('text 映射为 MEDIUMTEXT', () => {
+        expect(constants.typeMapping.text).toBe('MEDIUMTEXT');
+    });
+
+    test('array_string 映射为 VARCHAR', () => {
+        expect(constants.typeMapping.array_string).toBe('VARCHAR');
+    });
+
+    test('array_text 映射为 MEDIUMTEXT', () => {
+        expect(constants.typeMapping.array_text).toBe('MEDIUMTEXT');
+    });
+});
+
+describe('IS_PLAN', () => {
+    test('IS_PLAN 为 boolean 类型', () => {
+        expect(typeof constants.IS_PLAN).toBe('boolean');
+    });
+});
+
+describe('数据库类型判断 (MySQL)', () => {
+    test('IS_MYSQL 为 true', () => {
+        expect(constants.IS_MYSQL).toBe(true);
+    });
+
+    test('IS_PG 为 false', () => {
+        expect(constants.IS_PG).toBe(false);
+    });
+
+    test('IS_SQLITE 为 false', () => {
+        expect(constants.IS_SQLITE).toBe(false);
+    });
+});