befly 3.8.29 → 3.8.31

package/tests/jwt.test.ts

@@ -1,122 +1,64 @@
-import { describe, test, expect, beforeAll } from 'bun:test';
+import { describe, test, expect } from 'bun:test';
 import { Jwt } from '../lib/jwt';
 
-beforeAll(() => {
-    Jwt.configure({
-        secret: 'test-secret',
-        algorithm: 'HS256',
-        expiresIn: '7d'
-    });
+const jwt = new Jwt({
+    secret: 'test-secret',
+    algorithm: 'HS256',
+    expiresIn: '7d'
 });
 
-describe('JWT - 签名和验证', () => {
-    test('签名创建 token', async () => {
-        const token = await Jwt.sign({ userId: 1, name: 'test' });
+describe('JWT - sign', () => {
+    test('签名创建 token', () => {
+        const token = jwt.sign({ userId: 1, name: 'test' });
         expect(typeof token).toBe('string');
         expect(token.split('.').length).toBe(3);
     });
 
-    test('验证有效 token', async () => {
-        const token = await Jwt.sign({ userId: 123, email: 'test@test.com' });
-        const decoded = await Jwt.verify(token);
-        expect(decoded.userId).toBe(123);
-        expect(decoded.email).toBe('test@test.com');
+    test('自定义密钥', () => {
+        const secret = 'custom-secret';
+        const token = jwt.sign({ userId: 1 }, { secret: secret });
+        const decoded = jwt.verify(token, { secret: secret });
+        expect(decoded.userId).toBe(1);
     });
+});
 
-    test('验证过期 token 抛出错误', async () => {
-        const token = await Jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
-        expect(Jwt.verify(token)).rejects.toThrow('Token 已过期');
+describe('JWT - verify', () => {
+    test('验证有效 token', () => {
+        const token = jwt.sign({ userId: 123, email: 'test@test.com' });
+        const decoded = jwt.verify(token);
+        expect(decoded.userId).toBe(123);
+        expect(decoded.email).toBe('test@test.com');
     });
 
-    test('忽略过期验证', async () => {
-        const token = await Jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
-        const decoded = await Jwt.verify(token, { ignoreExpiration: true });
-        expect(decoded.userId).toBe(1);
+    test('验证过期 token 抛出错误', () => {
+        const token = jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+        expect(() => jwt.verify(token)).toThrow();
     });
 
-    test('自定义密钥', async () => {
-        const secret = 'custom-secret';
-        const token = await Jwt.sign({ userId: 1 }, { secret });
-        const decoded = await Jwt.verify(token, { secret });
+    test('忽略过期验证', () => {
+        const token = jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+        const decoded = jwt.verify(token, { ignoreExpiration: true });
         expect(decoded.userId).toBe(1);
     });
 
-    test('密钥不匹配验证失败', async () => {
-        const token = await Jwt.sign({ userId: 1 }, { secret: 'secret1' });
-        expect(Jwt.verify(token, { secret: 'secret2' })).rejects.toThrow('Token 签名无效');
+    test('密钥不匹配验证失败', () => {
+        const token = jwt.sign({ userId: 1 }, { secret: 'secret1' });
+        expect(() => jwt.verify(token, { secret: 'secret2' })).toThrow();
     });
 });
 
-describe('JWT - 解码', () => {
-    test('解码不验证签名', async () => {
-        const token = await Jwt.sign({ userId: 456 });
-        const decoded = Jwt.decode(token);
+describe('JWT - decode', () => {
+    test('解码不验证签名', () => {
+        const token = jwt.sign({ userId: 456 });
+        const decoded = jwt.decode(token);
         expect(decoded.userId).toBe(456);
     });
 
-    test('解码完整信息', async () => {
-        const token = await Jwt.sign({ userId: 1 });
-        const decoded = Jwt.decode(token, true);
+    test('解码完整信息', () => {
+        const token = jwt.sign({ userId: 1 });
+        const decoded = jwt.decode(token, true);
         expect(decoded.header).toBeDefined();
         expect(decoded.payload).toBeDefined();
         expect(decoded.signature).toBeDefined();
     });
 });
-
-describe('JWT - 时间相关', () => {
-    test('获取剩余时间', async () => {
-        const token = await Jwt.sign({ userId: 1 }, { expiresIn: '1h' });
-        const remaining = Jwt.getTimeToExpiry(token);
-        expect(remaining).toBeGreaterThan(3500);
-    });
-
-    test('检查是否过期', async () => {
-        const valid = await Jwt.sign({ userId: 1 }, { expiresIn: '1h' });
-        expect(Jwt.isExpired(valid)).toBe(false);
-
-        const expired = await Jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
-        expect(Jwt.isExpired(expired)).toBe(true);
-    });
-
-    test('检查即将过期', async () => {
-        const longToken = await Jwt.sign({ userId: 1 }, { expiresIn: '1h' });
-        expect(Jwt.isNearExpiry(longToken, 300)).toBe(false);
-
-        const shortToken = await Jwt.sign({ userId: 1 }, { expiresIn: '2m' });
-        expect(Jwt.isNearExpiry(shortToken, 300)).toBe(true);
-    });
-});
-
-describe('JWT - 权限检查', () => {
-    test('检查角色', () => {
-        const payload = { userId: 1, role: 'admin' };
-        expect(Jwt.hasRole(payload, 'admin')).toBe(true);
-        expect(Jwt.hasRole(payload, 'user')).toBe(false);
-    });
-
-    test('检查权限', () => {
-        const payload = { userId: 1, permissions: ['read', 'write'] };
-        expect(Jwt.hasPermission(payload, 'read')).toBe(true);
-        expect(Jwt.hasPermission(payload, 'delete')).toBe(false);
-    });
-
-    test('检查所有权限', () => {
-        const payload = { userId: 1, permissions: ['read', 'write', 'delete'] };
-        expect(Jwt.hasAllPermissions(payload, ['read', 'write'])).toBe(true);
-        expect(Jwt.hasAllPermissions(payload, ['read', 'admin'])).toBe(false);
-    });
-});
-
-describe('JWT - 快捷方法', () => {
-    test('create 和 check', async () => {
-        const token = await Jwt.create({ userId: 789 });
-        const decoded = await Jwt.check(token);
-        expect(decoded.userId).toBe(789);
-    });
-
-    test('parse 方法', async () => {
-        const token = await Jwt.create({ userId: 1 });
-        const decoded = Jwt.parse(token);
-        expect(decoded.userId).toBe(1);
-    });
-});

package/tests/logger.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { describe, test, expect, beforeAll, afterAll, afterEach } from 'bun:test';
 import { Logger } from '../lib/logger';
 import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
@@ -16,79 +16,77 @@ beforeAll(() => {
     });
 });
 
-afterAll(() => {
+afterAll(async () => {
+    // 延迟清理，等待 pino-roll 完成写入
+    await new Promise((resolve) => setTimeout(resolve, 500));
     if (existsSync(testLogDir)) {
         rmSync(testLogDir, { recursive: true, force: true });
     }
 });
 
-describe('Logger - 基本功能', () => {
-    test('记录 info 日志', async () => {
-        await Logger.log('info', 'Test info message');
+describe('Logger - 纯字符串消息', () => {
+    test('info(msg)', () => {
+        Logger.info('Test info message');
         expect(true).toBe(true);
     });
 
-    test('记录 warn 日志', async () => {
-        await Logger.log('warn', 'Test warning');
+    test('warn(msg)', () => {
+        Logger.warn('Test warning');
         expect(true).toBe(true);
     });
 
-    test('记录 error 日志', async () => {
-        await Logger.log('error', 'Test error');
+    test('error(msg)', () => {
+        Logger.error('Test error');
         expect(true).toBe(true);
     });
 
-    test('记录 debug 日志', async () => {
-        await Logger.log('debug', 'Test debug');
-        expect(true).toBe(true);
-    });
-
-    test('记录 success 日志', async () => {
-        await Logger.success('Test success');
+    test('debug(msg)', () => {
+        Logger.debug('Test debug');
         expect(true).toBe(true);
     });
 });
 
-describe('Logger - 不同类型消息', () => {
-    test('记录字符串', async () => {
-        await Logger.log('info', 'String message');
+describe('Logger - 对象 + 消息 (pino 原生格式)', () => {
+    test('info(obj, msg)', () => {
+        Logger.info({ userId: 1, action: 'login' }, 'User action');
         expect(true).toBe(true);
     });
 
-    test('记录数字', async () => {
-        await Logger.log('info', 12345);
+    test('warn(obj, msg)', () => {
+        Logger.warn({ ip: '127.0.0.1', count: 100 }, 'Rate limit warning');
         expect(true).toBe(true);
     });
 
-    test('记录对象', async () => {
-        await Logger.log('info', { userId: 1, action: 'test' });
+    test('error(obj, msg)', () => {
+        const err = new Error('Something went wrong');
+        Logger.error({ err: err }, 'Request failed');
         expect(true).toBe(true);
     });
 
-    test('记录数组', async () => {
-        await Logger.log('info', ['item1', 'item2']);
+    test('debug(obj, msg)', () => {
+        Logger.debug({ key: 'value', nested: { a: 1 } }, 'Debug data');
         expect(true).toBe(true);
     });
 });
 
-describe('Logger - 便捷方法', () => {
-    test('info 方法', () => {
-        Logger.info('Info test');
+describe('Logger - 仅对象', () => {
+    test('info(obj)', () => {
+        Logger.info({ event: 'startup', port: 3000 });
         expect(true).toBe(true);
     });
 
-    test('warn 方法', () => {
-        Logger.warn('Warn test');
+    test('warn(obj)', () => {
+        Logger.warn({ type: 'deprecation', feature: 'oldApi' });
         expect(true).toBe(true);
     });
 
-    test('error 方法', () => {
-        Logger.error('Error test');
+    test('error(obj)', () => {
+        Logger.error({ code: 500, message: 'Internal error' });
         expect(true).toBe(true);
     });
 
-    test('debug 方法', () => {
-        Logger.debug('Debug test');
+    test('debug(obj)', () => {
+        Logger.debug({ query: 'SELECT * FROM users', duration: 15 });
         expect(true).toBe(true);
     });
 });

package/tests/redisHelper.test.ts

@@ -6,7 +6,6 @@
 import { describe, expect, it, test, beforeAll, afterAll } from 'bun:test';
 import { RedisClient } from 'bun';
 
-import { defaultOptions } from '../config.js';
 import { Connect } from '../lib/connect.js';
 import { RedisHelper } from '../lib/redisHelper.js';
 
@@ -14,7 +13,7 @@ let redis: RedisHelper;
 
 beforeAll(async () => {
     // 连接 Redis
-    await Connect.connectRedis(defaultOptions.redis);
+    await Connect.connectRedis();
     redis = new RedisHelper();
 });
 
@@ -137,6 +136,47 @@ describe('RedisHelper - Set 操作', () => {
 
         await redis.del('test:set:members');
     });
+
+    test('saddBatch - 批量向多个 Set 添加成员', async () => {
+        const count = await redis.saddBatch([
+            { key: 'test:saddBatch:1', members: ['a', 'b'] },
+            { key: 'test:saddBatch:2', members: ['c', 'd', 'e'] }
+        ]);
+        expect(count).toBe(5);
+
+        // 验证
+        const members1 = await redis.smembers('test:saddBatch:1');
+        const members2 = await redis.smembers('test:saddBatch:2');
+        expect(members1.length).toBe(2);
+        expect(members2.length).toBe(3);
+
+        // 清理
+        await redis.delBatch(['test:saddBatch:1', 'test:saddBatch:2']);
+    });
+
+    test('saddBatch - 空数组返回 0', async () => {
+        const count = await redis.saddBatch([]);
+        expect(count).toBe(0);
+    });
+
+    test('sismemberBatch - 批量检查成员是否存在', async () => {
+        await redis.sadd('test:sismemberBatch', ['a', 'b', 'c']);
+
+        const results = await redis.sismemberBatch([
+            { key: 'test:sismemberBatch', member: 'a' },
+            { key: 'test:sismemberBatch', member: 'b' },
+            { key: 'test:sismemberBatch', member: 'x' }
+        ]);
+        expect(results).toEqual([true, true, false]);
+
+        // 清理
+        await redis.del('test:sismemberBatch');
+    });
+
+    test('sismemberBatch - 空数组返回空数组', async () => {
+        const results = await redis.sismemberBatch([]);
+        expect(results).toEqual([]);
+    });
 });
 
 describe('RedisHelper - 键操作', () => {
@@ -173,6 +213,38 @@ describe('RedisHelper - 键操作', () => {
         await redis.del('test:ttl:check');
     });
 
+    test('ttlBatch - 批量获取剩余过期时间', async () => {
+        await redis.setString('test:ttlBatch:1', 'value1', 60);
+        await redis.setString('test:ttlBatch:2', 'value2', 120);
+        // test:ttlBatch:3 不存在
+
+        const results = await redis.ttlBatch(['test:ttlBatch:1', 'test:ttlBatch:2', 'test:ttlBatch:3']);
+        expect(results.length).toBe(3);
+        expect(results[0]).toBeGreaterThan(0);
+        expect(results[0]).toBeLessThanOrEqual(60);
+        expect(results[1]).toBeGreaterThan(0);
+        expect(results[1]).toBeLessThanOrEqual(120);
+        expect(results[2]).toBe(-2); // 键不存在
+
+        // 清理
+        await redis.delBatch(['test:ttlBatch:1', 'test:ttlBatch:2']);
+    });
+
+    test('ttlBatch - 空数组返回空数组', async () => {
+        const results = await redis.ttlBatch([]);
+        expect(results).toEqual([]);
+    });
+
+    test('ttlBatch - 无过期时间返回 -1', async () => {
+        await redis.setString('test:ttlBatch:nox', 'value'); // 无 TTL
+
+        const results = await redis.ttlBatch(['test:ttlBatch:nox']);
+        expect(results[0]).toBe(-1);
+
+        // 清理
+        await redis.del('test:ttlBatch:nox');
+    });
+
     test('del - 删除键', async () => {
         await redis.setString('test:delete:key', 'value');
 
@@ -182,6 +254,203 @@ describe('RedisHelper - 键操作', () => {
         const value = await redis.getString('test:delete:key');
         expect(value).toBeNull();
     });
+
+    test('delBatch - 批量删除键', async () => {
+        // 创建多个键
+        await redis.setString('test:batch:1', 'value1');
+        await redis.setString('test:batch:2', 'value2');
+        await redis.setString('test:batch:3', 'value3');
+
+        // 批量删除
+        const count = await redis.delBatch(['test:batch:1', 'test:batch:2', 'test:batch:3']);
+        expect(count).toBe(3);
+
+        // 验证删除成功
+        const value1 = await redis.getString('test:batch:1');
+        const value2 = await redis.getString('test:batch:2');
+        const value3 = await redis.getString('test:batch:3');
+        expect(value1).toBeNull();
+        expect(value2).toBeNull();
+        expect(value3).toBeNull();
+    });
+
+    test('delBatch - 空数组返回 0', async () => {
+        const count = await redis.delBatch([]);
+        expect(count).toBe(0);
+    });
+
+    test('delBatch - 删除不存在的键返回 0', async () => {
+        const count = await redis.delBatch(['test:non:existent:1', 'test:non:existent:2']);
+        expect(count).toBe(0);
+    });
+
+    test('delBatch - 部分存在的键', async () => {
+        await redis.setString('test:partial:1', 'value1');
+        await redis.setString('test:partial:2', 'value2');
+        // test:partial:3 不存在
+
+        const count = await redis.delBatch(['test:partial:1', 'test:partial:2', 'test:partial:3']);
+        expect(count).toBe(2); // 只有 2 个键被删除
+    });
+
+    test('setBatch - 批量设置对象', async () => {
+        const items = [
+            { key: 'test:setBatch:1', value: { name: 'Alice' } },
+            { key: 'test:setBatch:2', value: { name: 'Bob' } },
+            { key: 'test:setBatch:3', value: { name: 'Charlie' } }
+        ];
+
+        const count = await redis.setBatch(items);
+        expect(count).toBe(3);
+
+        // 验证设置成功
+        const value1 = await redis.getObject('test:setBatch:1');
+        const value2 = await redis.getObject('test:setBatch:2');
+        const value3 = await redis.getObject('test:setBatch:3');
+        expect(value1).toEqual({ name: 'Alice' });
+        expect(value2).toEqual({ name: 'Bob' });
+        expect(value3).toEqual({ name: 'Charlie' });
+
+        // 清理
+        await redis.delBatch(['test:setBatch:1', 'test:setBatch:2', 'test:setBatch:3']);
+    });
+
+    test('setBatch - 空数组返回 0', async () => {
+        const count = await redis.setBatch([]);
+        expect(count).toBe(0);
+    });
+
+    test('setBatch - 带 TTL 的批量设置', async () => {
+        const items = [
+            { key: 'test:setBatch:ttl:1', value: { data: 1 }, ttl: 10 },
+            { key: 'test:setBatch:ttl:2', value: { data: 2 }, ttl: 10 }
+        ];
+
+        const count = await redis.setBatch(items);
+        expect(count).toBe(2);
+
+        // 验证 TTL 已设置
+        const ttl1 = await redis.ttl('test:setBatch:ttl:1');
+        const ttl2 = await redis.ttl('test:setBatch:ttl:2');
+        expect(ttl1).toBeGreaterThan(0);
+        expect(ttl1).toBeLessThanOrEqual(10);
+        expect(ttl2).toBeGreaterThan(0);
+        expect(ttl2).toBeLessThanOrEqual(10);
+
+        // 清理
+        await redis.delBatch(['test:setBatch:ttl:1', 'test:setBatch:ttl:2']);
+    });
+
+    test('getBatch - 批量获取对象', async () => {
+        // 设置测试数据
+        await redis.setObject('test:getBatch:1', { name: 'Alice' });
+        await redis.setObject('test:getBatch:2', { name: 'Bob' });
+        await redis.setObject('test:getBatch:3', { name: 'Charlie' });
+
+        // 批量获取
+        const results = await redis.getBatch(['test:getBatch:1', 'test:getBatch:2', 'test:getBatch:3']);
+        expect(results.length).toBe(3);
+        expect(results[0]).toEqual({ name: 'Alice' });
+        expect(results[1]).toEqual({ name: 'Bob' });
+        expect(results[2]).toEqual({ name: 'Charlie' });
+
+        // 清理
+        await redis.delBatch(['test:getBatch:1', 'test:getBatch:2', 'test:getBatch:3']);
+    });
+
+    test('getBatch - 空数组返回空数组', async () => {
+        const results = await redis.getBatch([]);
+        expect(results).toEqual([]);
+    });
+
+    test('getBatch - 不存在的键返回 null', async () => {
+        const results = await redis.getBatch(['test:non:existent:a', 'test:non:existent:b']);
+        expect(results).toEqual([null, null]);
+    });
+
+    test('getBatch - 部分存在的键', async () => {
+        await redis.setObject('test:partial:a', { data: 'a' });
+        // test:partial:b 不存在
+
+        const results = await redis.getBatch(['test:partial:a', 'test:partial:b']);
+        expect(results.length).toBe(2);
+        expect(results[0]).toEqual({ data: 'a' });
+        expect(results[1]).toBeNull();
+
+        // 清理
+        await redis.del('test:partial:a');
+    });
+
+    test('existsBatch - 批量检查键是否存在', async () => {
+        await redis.setString('test:existsBatch:1', 'value1');
+        await redis.setString('test:existsBatch:2', 'value2');
+        // test:existsBatch:3 不存在
+
+        const results = await redis.existsBatch(['test:existsBatch:1', 'test:existsBatch:2', 'test:existsBatch:3']);
+        expect(results).toEqual([true, true, false]);
+
+        // 清理
+        await redis.delBatch(['test:existsBatch:1', 'test:existsBatch:2']);
+    });
+
+    test('existsBatch - 空数组返回空数组', async () => {
+        const results = await redis.existsBatch([]);
+        expect(results).toEqual([]);
+    });
+
+    test('existsBatch - 全部不存在', async () => {
+        const results = await redis.existsBatch(['test:none:1', 'test:none:2']);
+        expect(results).toEqual([false, false]);
+    });
+
+    test('expireBatch - 批量设置过期时间', async () => {
+        await redis.setString('test:expireBatch:1', 'value1');
+        await redis.setString('test:expireBatch:2', 'value2');
+
+        const count = await redis.expireBatch([
+            { key: 'test:expireBatch:1', seconds: 60 },
+            { key: 'test:expireBatch:2', seconds: 120 }
+        ]);
+        expect(count).toBe(2);
+
+        // 验证 TTL 已设置
+        const ttl1 = await redis.ttl('test:expireBatch:1');
+        const ttl2 = await redis.ttl('test:expireBatch:2');
+        expect(ttl1).toBeGreaterThan(0);
+        expect(ttl1).toBeLessThanOrEqual(60);
+        expect(ttl2).toBeGreaterThan(0);
+        expect(ttl2).toBeLessThanOrEqual(120);
+
+        // 清理
+        await redis.delBatch(['test:expireBatch:1', 'test:expireBatch:2']);
+    });
+
+    test('expireBatch - 空数组返回 0', async () => {
+        const count = await redis.expireBatch([]);
+        expect(count).toBe(0);
+    });
+
+    test('expireBatch - 不存在的键返回 0', async () => {
+        const count = await redis.expireBatch([
+            { key: 'test:expire:none:1', seconds: 60 },
+            { key: 'test:expire:none:2', seconds: 60 }
+        ]);
+        expect(count).toBe(0);
+    });
+
+    test('expireBatch - 部分存在的键', async () => {
+        await redis.setString('test:expire:partial:1', 'value1');
+        // test:expire:partial:2 不存在
+
+        const count = await redis.expireBatch([
+            { key: 'test:expire:partial:1', seconds: 60 },
+            { key: 'test:expire:partial:2', seconds: 60 }
+        ]);
+        expect(count).toBe(1);
+
+        // 清理
+        await redis.del('test:expire:partial:1');
+    });
 });
 
 describe('RedisHelper - ID 生成', () => {

package/tests/redisKeys.test.ts

@@ -0,0 +1,76 @@
+/**
+ * RedisKeys 和 RedisTTL 测试
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { RedisKeys, RedisTTL } from 'befly-shared/redisKeys';
+
+describe('RedisKeys - Key 生成函数', () => {
+    test('apisAll - 返回固定的接口缓存键', () => {
+        expect(RedisKeys.apisAll()).toBe('befly:apis:all');
+    });
+
+    test('menusAll - 返回固定的菜单缓存键', () => {
+        expect(RedisKeys.menusAll()).toBe('befly:menus:all');
+    });
+
+    test('roleInfo - 返回带角色代码的缓存键', () => {
+        expect(RedisKeys.roleInfo('admin')).toBe('befly:role:info:admin');
+        expect(RedisKeys.roleInfo('user')).toBe('befly:role:info:user');
+    });
+
+    test('roleApis - 返回带角色代码的权限缓存键', () => {
+        expect(RedisKeys.roleApis('admin')).toBe('befly:role:apis:admin');
+        expect(RedisKeys.roleApis('guest')).toBe('befly:role:apis:guest');
+    });
+
+    test('tableColumns - 返回带表名的结构缓存键', () => {
+        expect(RedisKeys.tableColumns('user')).toBe('befly:table:columns:user');
+        expect(RedisKeys.tableColumns('addon_admin_role')).toBe('befly:table:columns:addon_admin_role');
+    });
+
+    test('roleInfo - 特殊字符处理', () => {
+        expect(RedisKeys.roleInfo('super-admin')).toBe('befly:role:info:super-admin');
+        expect(RedisKeys.roleInfo('role_1')).toBe('befly:role:info:role_1');
+    });
+
+    test('tableColumns - 空字符串', () => {
+        expect(RedisKeys.tableColumns('')).toBe('befly:table:columns:');
+    });
+});
+
+describe('RedisTTL - 过期时间常量', () => {
+    test('tableColumns - 1小时 (3600秒)', () => {
+        expect(RedisTTL.tableColumns).toBe(3600);
+    });
+
+    test('roleApis - 24小时 (86400秒)', () => {
+        expect(RedisTTL.roleApis).toBe(86400);
+    });
+
+    test('roleInfo - 24小时 (86400秒)', () => {
+        expect(RedisTTL.roleInfo).toBe(86400);
+    });
+
+    test('apisAll - 永久 (null)', () => {
+        expect(RedisTTL.apisAll).toBeNull();
+    });
+
+    test('menusAll - 永久 (null)', () => {
+        expect(RedisTTL.menusAll).toBeNull();
+    });
+
+    test('所有 TTL 值都是数字或 null', () => {
+        for (const [key, value] of Object.entries(RedisTTL)) {
+            expect(value === null || typeof value === 'number').toBe(true);
+        }
+    });
+
+    test('数字类型的 TTL 都是正数', () => {
+        for (const [key, value] of Object.entries(RedisTTL)) {
+            if (typeof value === 'number') {
+                expect(value).toBeGreaterThan(0);
+            }
+        }
+    });
+});

package/tests/sync-connection.test.ts

@@ -47,12 +47,6 @@ describe('sync 模块连接管理', () => {
         });
     });
 
-    describe('Connect.getDbHelper', () => {
-        test('未连接时应该抛出错误', () => {
-            expect(() => Connect.getDbHelper()).toThrow('SQL 客户端未连接');
-        });
-    });
-
     describe('Mock 连接测试', () => {
         test('__setMockSql 应该设置 mock SQL 客户端', () => {
             const mockSql = { close: async () => {} } as any;