befly 3.8.27 → 3.8.30

package/tests/cacheHelper.test.ts

@@ -0,0 +1,327 @@
+/**
+ * CacheHelper 单元测试
+ */
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { CacheHelper } from '../lib/cacheHelper.js';
+import { Logger, setMockLogger } from '../lib/logger.js';
+import { RedisKeys } from 'befly-shared/redisKeys';
+
+import type { BeflyContext } from '../types/befly.js';
+
+// Mock pino logger
+const mockPino = {
+    info: mock(() => {}),
+    warn: mock(() => {}),
+    error: mock(() => {}),
+    debug: mock(() => {}),
+    fatal: mock(() => {}),
+    trace: mock(() => {}),
+    silent: mock(() => {}),
+    child: mock(() => mockPino),
+    level: 'info'
+};
+
+describe('CacheHelper', () => {
+    let cacheHelper: CacheHelper;
+    let mockBefly: BeflyContext;
+    let mockDb: any;
+    let mockRedis: any;
+
+    beforeEach(() => {
+        // 设置 mock logger
+        setMockLogger(mockPino as any);
+
+        // Mock 数据库方法
+        mockDb = {
+            tableExists: mock(() => Promise.resolve(true)),
+            getAll: mock(() => Promise.resolve([]))
+        };
+
+        // Mock Redis 方法
+        mockRedis = {
+            setObject: mock(() => Promise.resolve('OK')),
+            getObject: mock(() => Promise.resolve(null)),
+            sadd: mock(() => Promise.resolve(1)),
+            smembers: mock(() => Promise.resolve([])),
+            sismember: mock(() => Promise.resolve(0)),
+            del: mock(() => Promise.resolve(1))
+        };
+
+        // 创建 mock befly context
+        mockBefly = {
+            db: mockDb,
+            redis: mockRedis
+        } as unknown as BeflyContext;
+
+        cacheHelper = new CacheHelper(mockBefly);
+    });
+
+    afterEach(() => {
+        // 重置 mock logger
+        setMockLogger(null);
+    });
+
+    describe('cacheApis', () => {
+        it('表不存在时跳过缓存', async () => {
+            mockDb.tableExists = mock(() => Promise.resolve(false));
+
+            await cacheHelper.cacheApis();
+
+            expect(mockDb.tableExists).toHaveBeenCalledWith('addon_admin_api');
+            expect(mockDb.getAll).not.toHaveBeenCalled();
+        });
+
+        it('正常缓存接口列表', async () => {
+            const apis = [
+                { id: 1, name: '登录', path: '/api/login', method: 'POST' },
+                { id: 2, name: '用户列表', path: '/api/user/list', method: 'GET' }
+            ];
+            mockDb.getAll = mock(() => Promise.resolve(apis));
+
+            await cacheHelper.cacheApis();
+
+            expect(mockRedis.setObject).toHaveBeenCalledWith(RedisKeys.apisAll(), apis);
+        });
+
+        it('缓存失败时记录警告', async () => {
+            mockRedis.setObject = mock(() => Promise.resolve(null));
+
+            await cacheHelper.cacheApis();
+
+            expect(mockPino.warn).toHaveBeenCalled();
+        });
+
+        it('异常时记录错误', async () => {
+            mockDb.getAll = mock(() => Promise.reject(new Error('DB Error')));
+
+            await cacheHelper.cacheApis();
+
+            expect(mockPino.error).toHaveBeenCalled();
+        });
+    });
+
+    describe('cacheMenus', () => {
+        it('表不存在时跳过缓存', async () => {
+            mockDb.tableExists = mock(() => Promise.resolve(false));
+
+            await cacheHelper.cacheMenus();
+
+            expect(mockDb.tableExists).toHaveBeenCalledWith('addon_admin_menu');
+            expect(mockDb.getAll).not.toHaveBeenCalled();
+        });
+
+        it('正常缓存菜单列表', async () => {
+            const menus = [
+                { id: 1, pid: 0, name: '首页', path: '/home', sort: 1 },
+                { id: 2, pid: 0, name: '用户管理', path: '/user', sort: 2 }
+            ];
+            mockDb.getAll = mock(() => Promise.resolve(menus));
+
+            await cacheHelper.cacheMenus();
+
+            expect(mockRedis.setObject).toHaveBeenCalledWith(RedisKeys.menusAll(), menus);
+        });
+    });
+
+    describe('cacheRolePermissions', () => {
+        it('表不存在时跳过缓存', async () => {
+            mockDb.tableExists = mock((table: string) => {
+                if (table === 'addon_admin_api') return Promise.resolve(true);
+                if (table === 'addon_admin_role') return Promise.resolve(false);
+                return Promise.resolve(false);
+            });
+
+            await cacheHelper.cacheRolePermissions();
+
+            expect(mockPino.warn).toHaveBeenCalled();
+        });
+
+        it('正常缓存角色权限', async () => {
+            const roles = [
+                { id: 1, code: 'admin', apis: '1,2,3' },
+                { id: 2, code: 'user', apis: '1' }
+            ];
+            const apis = [
+                { id: 1, path: '/api/login', method: 'POST' },
+                { id: 2, path: '/api/user/list', method: 'GET' },
+                { id: 3, path: '/api/user/del', method: 'POST' }
+            ];
+
+            mockDb.getAll = mock((opts: any) => {
+                if (opts.table === 'addon_admin_role') return Promise.resolve(roles);
+                if (opts.table === 'addon_admin_api') return Promise.resolve(apis);
+                return Promise.resolve([]);
+            });
+
+            await cacheHelper.cacheRolePermissions();
+
+            // 验证批量删除调用
+            expect(mockRedis.del).toHaveBeenCalledTimes(2);
+
+            // 验证批量添加调用
+            expect(mockRedis.sadd).toHaveBeenCalledTimes(2);
+            expect(mockRedis.sadd).toHaveBeenCalledWith(RedisKeys.roleApis('admin'), ['POST/api/login', 'GET/api/user/list', 'POST/api/user/del']);
+            expect(mockRedis.sadd).toHaveBeenCalledWith(RedisKeys.roleApis('user'), ['POST/api/login']);
+        });
+
+        it('无有效角色时不执行缓存', async () => {
+            const roles = [{ id: 1, code: 'empty', apis: null }];
+            const apis = [{ id: 1, path: '/api/login', method: 'POST' }];
+
+            mockDb.getAll = mock((opts: any) => {
+                if (opts.table === 'addon_admin_role') return Promise.resolve(roles);
+                if (opts.table === 'addon_admin_api') return Promise.resolve(apis);
+                return Promise.resolve([]);
+            });
+
+            await cacheHelper.cacheRolePermissions();
+
+            expect(mockRedis.sadd).not.toHaveBeenCalled();
+        });
+
+        it('使用 Promise.all 并行执行', async () => {
+            const roles = [
+                { id: 1, code: 'role1', apis: '1' },
+                { id: 2, code: 'role2', apis: '1' },
+                { id: 3, code: 'role3', apis: '1' }
+            ];
+            const apis = [{ id: 1, path: '/api/test', method: 'GET' }];
+
+            mockDb.getAll = mock((opts: any) => {
+                if (opts.table === 'addon_admin_role') return Promise.resolve(roles);
+                if (opts.table === 'addon_admin_api') return Promise.resolve(apis);
+                return Promise.resolve([]);
+            });
+
+            await cacheHelper.cacheRolePermissions();
+
+            // 3 个角色应该有 3 次删除和 3 次添加操作
+            expect(mockRedis.del).toHaveBeenCalledTimes(3);
+            expect(mockRedis.sadd).toHaveBeenCalledTimes(3);
+        });
+    });
+
+    describe('getApis', () => {
+        it('返回缓存的接口列表', async () => {
+            const apis = [{ id: 1, name: '登录' }];
+            mockRedis.getObject = mock(() => Promise.resolve(apis));
+
+            const result = await cacheHelper.getApis();
+
+            expect(result).toEqual(apis);
+        });
+
+        it('缓存不存在时返回空数组', async () => {
+            mockRedis.getObject = mock(() => Promise.resolve(null));
+
+            const result = await cacheHelper.getApis();
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('getMenus', () => {
+        it('返回缓存的菜单列表', async () => {
+            const menus = [{ id: 1, name: '首页' }];
+            mockRedis.getObject = mock(() => Promise.resolve(menus));
+
+            const result = await cacheHelper.getMenus();
+
+            expect(result).toEqual(menus);
+        });
+
+        it('缓存不存在时返回空数组', async () => {
+            mockRedis.getObject = mock(() => Promise.resolve(null));
+
+            const result = await cacheHelper.getMenus();
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('getRolePermissions', () => {
+        it('返回角色的权限列表', async () => {
+            const permissions = ['POST/api/login', 'GET/api/user/list'];
+            mockRedis.smembers = mock(() => Promise.resolve(permissions));
+
+            const result = await cacheHelper.getRolePermissions('admin');
+
+            expect(mockRedis.smembers).toHaveBeenCalledWith(RedisKeys.roleApis('admin'));
+            expect(result).toEqual(permissions);
+        });
+
+        it('权限不存在时返回空数组', async () => {
+            mockRedis.smembers = mock(() => Promise.resolve(null));
+
+            const result = await cacheHelper.getRolePermissions('unknown');
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('checkRolePermission', () => {
+        it('有权限时返回 true', async () => {
+            mockRedis.sismember = mock(() => Promise.resolve(1));
+
+            const result = await cacheHelper.checkRolePermission('admin', 'POST/api/login');
+
+            expect(mockRedis.sismember).toHaveBeenCalledWith(RedisKeys.roleApis('admin'), 'POST/api/login');
+            expect(result).toBe(true);
+        });
+
+        it('无权限时返回 false', async () => {
+            mockRedis.sismember = mock(() => Promise.resolve(0));
+
+            const result = await cacheHelper.checkRolePermission('user', 'POST/api/admin/del');
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('deleteRolePermissions', () => {
+        it('删除成功返回 true', async () => {
+            mockRedis.del = mock(() => Promise.resolve(1));
+
+            const result = await cacheHelper.deleteRolePermissions('admin');
+
+            expect(mockRedis.del).toHaveBeenCalledWith(RedisKeys.roleApis('admin'));
+            expect(result).toBe(true);
+        });
+
+        it('不存在时返回 false', async () => {
+            mockRedis.del = mock(() => Promise.resolve(0));
+
+            const result = await cacheHelper.deleteRolePermissions('unknown');
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('cacheAll', () => {
+        it('按顺序调用三个缓存方法', async () => {
+            const callOrder: string[] = [];
+
+            // 使用 spy 记录调用顺序
+            const originalCacheApis = cacheHelper.cacheApis.bind(cacheHelper);
+            const originalCacheMenus = cacheHelper.cacheMenus.bind(cacheHelper);
+            const originalCacheRolePermissions = cacheHelper.cacheRolePermissions.bind(cacheHelper);
+
+            cacheHelper.cacheApis = async () => {
+                callOrder.push('apis');
+                await originalCacheApis();
+            };
+            cacheHelper.cacheMenus = async () => {
+                callOrder.push('menus');
+                await originalCacheMenus();
+            };
+            cacheHelper.cacheRolePermissions = async () => {
+                callOrder.push('permissions');
+                await originalCacheRolePermissions();
+            };
+
+            await cacheHelper.cacheAll();
+
+            expect(callOrder).toEqual(['apis', 'menus', 'permissions']);
+        });
+    });
+});

package/tests/dbHelper-columns.test.ts

@@ -3,24 +3,9 @@
  * 测试表字段查询、Redis 缓存、SQL 语法修复等功能
  */
 
-import { test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { test, expect, mock } from 'bun:test';
 import { DbHelper } from '../lib/dbHelper.js';
-import { Logger } from '../lib/logger.js';
-
-// Mock Logger
-const originalLoggerError = Logger.error;
-let errorLogs: string[] = [];
-
-beforeEach(() => {
-    errorLogs = [];
-    Logger.error = mock((msg: string) => {
-        errorLogs.push(msg);
-    });
-});
-
-afterEach(() => {
-    Logger.error = originalLoggerError;
-});
+import { RedisKeys } from 'befly-shared/redisKeys';
 
 // 创建 Mock Befly 上下文
 function createMockBefly(sqlMock: any, redisMock?: any) {
@@ -58,7 +43,7 @@ test('getTableColumns - 正常查询表字段', async () => {
 
     expect(columns).toEqual(['id', 'username', 'email', 'created_at']);
     expect(sqlMock.unsafe).toHaveBeenCalledTimes(1);
-    expect(redisMock.getObject).toHaveBeenCalledWith('table:columns:users');
+    expect(redisMock.getObject).toHaveBeenCalledWith(RedisKeys.tableColumns('users'));
     expect(redisMock.setObject).toHaveBeenCalled();
 });
 
@@ -82,7 +67,7 @@ test('getTableColumns - Redis 缓存命中', async () => {
     const columns = await (dbHelper as any).getTableColumns('users');
 
     expect(columns).toEqual(cachedColumns);
-    expect(redisMock.getObject).toHaveBeenCalledWith('table:columns:users');
+    expect(redisMock.getObject).toHaveBeenCalledWith(RedisKeys.tableColumns('users'));
     expect(sqlMock.unsafe).not.toHaveBeenCalled(); // SQL 不应该被调用
     expect(redisMock.setObject).not.toHaveBeenCalled(); // 不需要写缓存
 });
@@ -159,7 +144,7 @@ test('getTableColumns - 缓存键格式正确', async () => {
         getObject: mock(async () => null),
         setObject: mock(async (key: string, value: any, seconds: number) => {
             // 验证缓存键格式
-            expect(key).toBe('table:columns:test_table');
+            expect(key).toBe(RedisKeys.tableColumns('test_table'));
             // 验证缓存值格式
             expect(Array.isArray(value)).toBe(true);
             // 验证过期时间

package/tests/dbHelper-execute.test.ts

@@ -1,33 +1,10 @@
 /**
  * DbHelper executeWithConn 方法单元测试
- * 测试 SQL 执行、错误处理、慢查询日志等功能
+ * 测试 SQL 执行、错误处理等功能
  */
 
-import { test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { test, expect, mock } from 'bun:test';
 import { DbHelper } from '../lib/dbHelper.js';
-import { Logger } from '../lib/logger.js';
-
-// Mock Logger
-const originalLoggerError = Logger.error;
-const originalLoggerWarn = Logger.warn;
-let errorLogs: string[] = [];
-let warnLogs: string[] = [];
-
-beforeEach(() => {
-    errorLogs = [];
-    warnLogs = [];
-    Logger.error = mock((msg: string) => {
-        errorLogs.push(msg);
-    });
-    Logger.warn = mock((msg: string) => {
-        warnLogs.push(msg);
-    });
-});
-
-afterEach(() => {
-    Logger.error = originalLoggerError;
-    Logger.warn = originalLoggerWarn;
-});
 
 // 创建 Mock Befly 上下文
 function createMockBefly(sqlMock: any) {
@@ -55,7 +32,6 @@ test('executeWithConn - 正常执行（无参数）', async () => {
 
     expect(result).toEqual(mockResult);
     expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT * FROM users');
-    expect(errorLogs.length).toBe(0);
 });
 
 test('executeWithConn - 正常执行（带参数）', async () => {
@@ -71,7 +47,6 @@ test('executeWithConn - 正常执行（带参数）', async () => {
 
     expect(result).toEqual(mockResult);
     expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT * FROM users WHERE id = ?', [1]);
-    expect(errorLogs.length).toBe(0);
 });
 
 test('executeWithConn - SQL 错误捕获', async () => {
@@ -95,16 +70,10 @@ test('executeWithConn - SQL 错误捕获', async () => {
         expect(error.sql).toBe('SELECT * FROM invalid_table');
         expect(error.params).toEqual([]);
         expect(error.duration).toBeGreaterThanOrEqual(0);
-
-        // 验证错误日志
-        expect(errorLogs.length).toBeGreaterThan(0);
-        expect(errorLogs.some((log) => log.includes('SQL 执行错误'))).toBe(true);
-        expect(errorLogs.some((log) => log.includes('SELECT * FROM invalid_table'))).toBe(true);
-        expect(errorLogs.some((log) => log.includes('You have an error in your SQL syntax'))).toBe(true);
     }
 });
 
-test('executeWithConn - 错误日志包含完整信息', async () => {
+test('executeWithConn - 错误信息包含完整信息', async () => {
     const sqlMock = {
         unsafe: mock(async () => {
             throw new Error('Syntax error near "??"');
@@ -124,20 +93,11 @@ test('executeWithConn - 错误日志包含完整信息', async () => {
         expect(error.sql).toBe(testSql);
         expect(error.params).toEqual(testParams);
         expect(typeof error.duration).toBe('number');
-
-        // 验证日志内容
-        const allLogs = errorLogs.join('\n');
-        expect(allLogs).toContain('SQL 语句:');
-        expect(allLogs).toContain('SHOW COLUMNS FROM ??');
-        expect(allLogs).toContain('参数列表:');
-        expect(allLogs).toContain('["users"]');
-        expect(allLogs).toContain('执行耗时:');
-        expect(allLogs).toContain('错误信息:');
-        expect(allLogs).toContain('Syntax error near "??"');
+        expect(error.originalError.message).toBe('Syntax error near "??"');
     }
 });
 
-test('executeWithConn - 超长 SQL 截断', async () => {
+test('executeWithConn - 超长 SQL 保留在错误对象中', async () => {
     const longSql = 'SELECT * FROM users WHERE ' + 'id = ? AND '.repeat(50) + 'name = ?';
     const sqlMock = {
         unsafe: mock(async () => {
@@ -151,20 +111,13 @@ test('executeWithConn - 超长 SQL 截断', async () => {
     try {
         await (dbHelper as any).executeWithConn(longSql);
     } catch (error: any) {
-        // SQL 应该被截断
-        expect(error.sql).toBe(longSql); // 完整保存在错误对象中
-
-        // 日志中应该截断并加 ...
-        const sqlLog = errorLogs.find((log) => log.includes('SQL 语句:'));
-        expect(sqlLog).toBeDefined();
-        if (sqlLog) {
-            expect(sqlLog.length).toBeLessThan(longSql.length + 50); // 截断后应该更短
-            expect(sqlLog).toContain('...');
-        }
+        // SQL 完整保存在错误对象中
+        expect(error.sql).toBe(longSql);
+        expect(error.params).toEqual([]);
     }
 });
 
-test('executeWithConn - 慢查询日志（>1000ms）', async () => {
+test('executeWithConn - 慢查询检测（>1000ms）', async () => {
     const mockResult = [{ id: 1 }];
     const sqlMock = {
         unsafe: mock(async () => {
@@ -179,10 +132,8 @@ test('executeWithConn - 慢查询日志（>1000ms）', async () => {
 
     const result = await (dbHelper as any).executeWithConn('SELECT SLEEP(1)');
 
+    // 功能仍正常返回结果
     expect(result).toEqual(mockResult);
-    expect(warnLogs.length).toBeGreaterThan(0);
-    expect(warnLogs.some((log) => log.includes('🐌 检测到慢查询'))).toBe(true);
-    expect(warnLogs.some((log) => log.includes('ms'))).toBe(true);
 });
 
 test('executeWithConn - 数据库未连接错误', async () => {
@@ -213,7 +164,7 @@ test('executeWithConn - 空参数数组', async () => {
     expect(sqlMock.unsafe).toHaveBeenCalledWith('SELECT COUNT(*) as count FROM users');
 });
 
-test('executeWithConn - 参数 JSON 序列化', async () => {
+test('executeWithConn - 复杂参数处理', async () => {
     const sqlMock = {
         unsafe: mock(async () => {
             throw new Error('Test error');
@@ -228,13 +179,8 @@ test('executeWithConn - 参数 JSON 序列化', async () => {
     try {
         await (dbHelper as any).executeWithConn('SELECT ?', complexParams);
     } catch (error: any) {
-        // 验证参数被正确序列化
-        const paramsLog = errorLogs.find((log) => log.includes('参数列表:'));
-        expect(paramsLog).toBeDefined();
-        if (paramsLog) {
-            // JSON.stringify 应该能处理复杂参数
-            expect(paramsLog).toContain('参数列表:');
-            expect(() => JSON.parse(paramsLog.split('参数列表:')[1].trim())).not.toThrow();
-        }
+        // 验证参数被正确保存
+        expect(error.params).toEqual(complexParams);
+        expect(error.sql).toBe('SELECT ?');
     }
 });

package/tests/fields-redis-cache.test.ts

@@ -2,6 +2,8 @@
  * 验证 Redis 缓存的字段查询功能
  */
 
+import { RedisKeys, RedisTTL } from 'befly-shared/redisKeys';
+
 console.log('\n========== Redis 缓存验证 ==========\n');
 
 // 模拟 Redis 缓存逻辑
@@ -38,7 +40,7 @@ async function queryDatabase(table: string): Promise<string[]> {
 // 模拟 getTableColumns 方法
 async function getTableColumns(redis: MockRedis, table: string): Promise<string[]> {
     // 1. 先查 Redis 缓存
-    const cacheKey = `table:columns:${table}`;
+    const cacheKey = RedisKeys.tableColumns(table);
     let columns = await redis.getObject<string[]>(cacheKey);
 
     if (columns && columns.length > 0) {
@@ -48,8 +50,8 @@ async function getTableColumns(redis: MockRedis, table: string): Promise<string[
     // 2. 缓存未命中，查询数据库
     columns = await queryDatabase(table);
 
-    // 3. 写入 Redis 缓存（1小时过期）
-    await redis.setObject(cacheKey, columns, 3600);
+    // 3. 写入 Redis 缓存
+    await redis.setObject(cacheKey, columns, RedisTTL.tableColumns);
 
     return columns;
 }

package/tests/integration.test.ts

@@ -1,10 +1,11 @@
-import { describe, test, expect, beforeAll } from 'bun:test';
+import { describe, test, expect } from 'bun:test';
+import { XMLParser } from 'fast-xml-parser';
 import { Cipher } from '../lib/cipher';
 import { Jwt } from '../lib/jwt';
 import { Validator } from '../lib/validator';
 import { SqlBuilder } from '../lib/sqlBuilder';
-import { Xml } from '../lib/xml';
-import { keysToCamel, keysToSnake } from 'befly-util';
+import { keysToCamel } from 'befly-shared/keysToCamel';
+import { keysToSnake } from 'befly-shared/keysToSnake';
 
 describe('Integration - 密码验证流程', () => {
     test('用户注册：密码加密 + 验证', async () => {
@@ -26,15 +27,13 @@ describe('Integration - 密码验证流程', () => {
 });
 
 describe('Integration - JWT + 权限验证', () => {
-    beforeAll(() => {
-        Jwt.configure({
-            secret: 'test-integration-secret',
-            algorithm: 'HS256',
-            expiresIn: '1h'
-        });
+    const jwt = new Jwt({
+        secret: 'test-integration-secret',
+        algorithm: 'HS256',
+        expiresIn: '1h'
     });
 
-    test('用户登录：JWT 签名 + 权限检查', async () => {
+    test('用户登录：JWT 签名 + 验证', () => {
         // 1. 用户登录生成 token
         const payload = {
             userId: 123,
@@ -43,26 +42,16 @@ describe('Integration - JWT + 权限验证', () => {
             permissions: ['read', 'write', 'delete']
         };
 
-        const token = await Jwt.sign(payload);
+        const token = jwt.sign(payload);
         expect(token).toBeDefined();
         expect(typeof token).toBe('string');
 
         // 2. 验证 token
-        const verified = await Jwt.verify(token);
+        const verified = jwt.verify(token);
         expect(verified.userId).toBe(123);
         expect(verified.username).toBe('john');
-
-        // 3. 检查角色
-        expect(Jwt.hasRole(verified, 'admin')).toBe(true);
-        expect(Jwt.hasRole(verified, 'guest')).toBe(false);
-
-        // 4. 检查权限
-        expect(Jwt.hasPermission(verified, 'write')).toBe(true);
-        expect(Jwt.hasPermission(verified, 'admin')).toBe(false);
-
-        // 5. 检查所有权限
-        expect(Jwt.hasAllPermissions(verified, ['read', 'write'])).toBe(true);
-        expect(Jwt.hasAllPermissions(verified, ['read', 'admin'])).toBe(false);
+        expect(verified.roles).toContain('admin');
+        expect(verified.permissions).toContain('write');
     });
 });
 
@@ -133,11 +122,11 @@ describe('Integration - 数据验证 + SQL 构建', () => {
 
 describe('Integration - XML 解析 + 数据转换', () => {
     test('XML API 响应：解析 + 字段转换', () => {
-        const xml = new Xml();
+        const xmlParser = new XMLParser();
 
         // 1. 解析 XML 响应
         const xmlData = '<response><user_id>123</user_id><user_name>John</user_name><is_active>true</is_active></response>';
-        const parsed = xml.parse(xmlData) as any;
+        const parsed = xmlParser.parse(xmlData).response as any;
 
         expect(parsed.user_id).toBe(123);
         expect(parsed.user_name).toBe('John');