✅ test(integration): 新增集成测试用例覆盖更多场景

- 新增打印机管理API测试【状态查询、更新、删除、不存在的打印机处理】
- 新增打印任务管理API测试【详情查询、取消、重试、状态查询】
- 新增调度器管理API测试【状态查询、启动停止、健康检查、手动触发】
- 新增配置管理API测试【获取配置、更新配置、配置验证】
- 新增创建打印机API测试【正常流程、必填字段验证、默认打印机】
- 新增打印任务状态查询API测试【状态查询、不存在的任务、不同状态的任务】
- 新增分页和排序功能测试【打印机列表分页、打印任务列表分页、创建时间倒序排序、打印机类型筛选】
- 新增更多错误场景测试【无效打印机类型、无效打印类型、负数延迟时间、重试次数超限、不存在的配置键】
- 新增边界条件测试【打印机序列号重复、打印内容过长、延迟时间边界、状态转换边界】
- 修复取消打印任务路由的错误处理逻辑，根据错误类型返回不同的HTTP状态码
- 删除旧的集成测试备份文件，更新故事文档记录新增的测试任务

docs/stories/005.001.story.md

@@ -62,6 +62,20 @@ Ready for Review
   - [x] 为API客户端编写集成测试
   - [x] 为调度器编写测试
   - [x] 确保测试覆盖率 > 80%
+- [x] 任务9：补齐集成测试用例 (AC: 8)
+  - [x] 实现配置管理API测试（获取配置、更新配置、配置验证）
+  - [x] 实现调度器管理API测试（状态查询、启动停止、健康检查）
+  - [x] 实现打印任务详情API测试
+  - [x] 实现打印机状态和更新API测试
+  - [x] 实现打印机删除API测试
+  - [x] 实现打印任务重试和取消API测试
+  - [x] 实现调度器触发API测试
+  - [x] 实现更多边界条件测试
+- [x] 任务10：新增集成测试用例覆盖更多场景 (AC: 8)
+  - [x] 实现创建打印机API测试（正常流程、必填字段验证、默认打印机）
+  - [x] 实现打印任务状态查询API测试（状态查询、不存在的任务、不同状态的任务）
+  - [x] 实现分页和排序功能测试（打印机列表分页、打印任务列表分页、创建时间倒序排序、打印机类型筛选）
+  - [x] 实现更多错误场景测试（无效打印机类型、无效打印类型、负数延迟时间、重试次数超限、不存在的配置键）
 
 ## Dev Notes
 
@@ -269,6 +283,8 @@ CREATE TABLE feie_config_mt (
 |------|---------|-------------|--------|
 | 2025-12-06 | 1.0 | 初始创建故事文档 | Bob (Scrum Master) |
 | 2025-12-11 | 1.1 | 修复TypeScript类型错误：路由返回类型、枚举类型、参数转换等问题 | James (Developer Agent) |
+| 2025-12-11 | 1.2 | 补齐集成测试用例：新增28个测试用例，覆盖配置管理、调度器管理、打印任务详情、打印机状态更新、边界条件等 | James (Developer Agent) |
+| 2025-12-11 | 1.3 | 新增集成测试用例：补充15个测试用例，覆盖创建打印机API、打印任务状态查询、分页排序功能、更多错误场景等 | James (Developer Agent) |
 
 ## Dev Agent Record
 *此部分由开发代理在实现过程中填写*
@@ -312,6 +328,23 @@ CREATE TABLE feie_config_mt (
     - 修复服务方法参数类型转换问题
     - 修复Schema转换逻辑问题
     - 修复调度器响应类型不匹配问题
+11. ✅ 任务10：补齐集成测试用例（已完成）
+    - 分析现有集成测试覆盖度，识别缺失的测试用例
+    - 为故事添加新任务：补齐缺失的集成测试用例
+    - 实现配置管理API测试（获取配置、更新配置、配置验证）
+    - 实现调度器管理API测试（状态查询、启动停止、健康检查、手动触发）
+    - 实现打印任务详情API测试（查询详情、不存在的任务）
+    - 实现打印机状态和更新API测试（状态查询、更新、删除）
+    - 实现打印任务重试和取消API测试
+    - 实现更多边界条件测试（序列号重复、内容过长、延迟时间边界、状态转换）
+    - 修复测试中的配置清理问题，确保测试独立性
+12. ✅ 任务11：新增集成测试用例覆盖更多场景（已完成）
+    - 分析测试覆盖度，识别需要补充的测试场景
+    - 实现创建打印机API测试（正常流程、必填字段验证、默认打印机）
+    - 实现打印任务状态查询API测试（状态查询、不存在的任务、不同状态的任务）
+    - 实现分页和排序功能测试（打印机列表分页、打印任务列表分页、创建时间倒序排序、打印机类型筛选）
+    - 实现更多错误场景测试（无效打印机类型、无效打印类型、负数延迟时间、重试次数超限、不存在的配置键）
+    - 修复TypeScript类型错误（PrintType枚举使用、打印机类型、响应格式匹配）
 
 ### File List
 **包结构文件**:
@@ -359,7 +392,24 @@ CREATE TABLE feie_config_mt (
 - `packages/feie-printer-module-mt/tests/unit/printer.service.test.ts`
 - `packages/feie-printer-module-mt/tests/unit/print-task.service.test.ts`
 - `packages/feie-printer-module-mt/tests/unit/delay-scheduler.service.test.ts`
-- `packages/feie-printer-module-mt/tests/integration/feie-api.integration.test.ts`
+- `packages/feie-printer-module-mt/tests/integration/feie-api.integration.test.ts` - 新增完整的集成测试用例
+
+**新增的集成测试用例文件**:
+- `packages/feie-printer-module-mt/tests/integration/feie-api.integration.test.ts` - 已更新，包含：
+  - 配置管理API测试（3个测试用例）
+  - 调度器管理API测试（4个测试用例）
+  - 打印任务详情API测试（2个测试用例）
+  - 打印机状态和更新API测试（6个测试用例）
+  - 打印机删除API测试（2个测试用例）
+  - 打印任务重试和取消API测试（4个测试用例）
+  - 调度器触发API测试（1个测试用例）
+  - 更多边界条件测试（6个测试用例）
+  - 修复了测试配置清理问题
+  - **新增测试场景**：
+    - 创建打印机API测试（3个测试用例）
+    - 打印任务状态查询API测试（3个测试用例）
+    - 分页和排序功能测试（4个测试用例）
+    - 更多错误场景测试（5个测试用例）
 
 ## QA Results
 *此部分由QA代理在审查完成后填写*

packages/feie-printer-module-mt/src/routes/tasks/cancel.mt.ts

@@ -48,6 +48,10 @@ const cancelPrintTaskRoute = createRoute({
       description: '打印任务取消成功',
       content: { 'application/json': { schema: CancelPrintTaskResponseSchema } }
     },
+    400: {
+      description: '请求参数错误或业务逻辑错误',
+      content: { 'application/json': { schema: z.object({ success: z.boolean(), message: z.string() }) } }
+    },
     404: {
       description: '打印任务不存在',
       content: { 'application/json': { schema: z.object({ success: z.boolean(), message: z.string() }) } }
@@ -103,7 +107,15 @@ const app = new OpenAPIHono<AuthContext>()
     } catch (error) {
       console.error(`[租户${tenantId}] 取消打印任务失败，任务ID: ${taskId}:`, error);
       const errorMessage = error instanceof Error ? error.message : '取消打印任务失败';
-      return c.json({ success: false, message: errorMessage }, 500);
+
+      // 根据错误类型返回不同的状态码
+      if (errorMessage.includes('打印任务不存在')) {
+        return c.json({ success: false, message: errorMessage }, 404);
+      } else if (errorMessage.includes('无法取消')) {
+        return c.json({ success: false, message: errorMessage }, 400);
+      } else {
+        return c.json({ success: false, message: errorMessage }, 500);
+      }
     }
   });
 

packages/feie-printer-module-mt/tests/integration/feie-api.integration.test.ts

@@ -7,6 +7,7 @@ import { SystemConfigMt } from '@d8d/core-module-mt/system-config-module-mt/enti
 import { FeieMtRoutes } from '../../src/routes';
 import { FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt } from '../../src/entities';
 import { FeieTestDataFactory } from '../utils/test-data-factory';
+import { PrintType } from '../../src/types/feie.types';
 
 // 设置集成测试钩子
 setupIntegrationDatabaseHooksWithEntities([
@@ -117,11 +118,18 @@ describe('飞鹅打印多租户API集成测试', () => {
   });
 
   describe('打印机管理功能验证', () => {
+    let testPrinter: FeiePrinterMt;
+
+    beforeEach(async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      // 创建测试打印机
+      testPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '测试打印机' });
+    });
+
     it('应该能够查询打印机列表', async () => {
       const dataSource = await IntegrationTestDatabase.getDataSource();
 
-      // 创建测试打印机
-      const printer1 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '打印机1' });
+      // 创建另一个测试打印机
       const printer2 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '打印机2' });
 
       // 查询打印机列表
@@ -146,8 +154,7 @@ describe('飞鹅打印多租户API集成测试', () => {
     it('应该能够根据名称搜索打印机', async () => {
       const dataSource = await IntegrationTestDatabase.getDataSource();
 
-      // 创建测试打印机
-      const printer1 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '测试打印机A' });
+      // 创建另一个测试打印机
       const printer2 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '其他打印机' });
 
       // 搜索打印机
@@ -165,15 +172,14 @@ describe('飞鹅打印多租户API集成测试', () => {
 
         expect(data.success).toBe(true);
         expect(data.data.data).toHaveLength(1);
-        expect(data.data.data[0].printerName).toBe('测试打印机A');
+        expect(data.data.data[0].printerName).toBe('测试打印机');
       }
     });
 
     it('应该能够设置默认打印机', async () => {
       const dataSource = await IntegrationTestDatabase.getDataSource();
 
-      // 创建两个打印机
-      const printer1 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '打印机1', isDefault: 1 });
+      // 创建另一个打印机
       const printer2 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '打印机2', isDefault: 0 });
 
       // 设置打印机2为默认
@@ -193,28 +199,163 @@ describe('飞鹅打印多租户API集成测试', () => {
         expect(data.data.isDefault).toBe(1);
       }
 
-      // 验证打印机1不再是默认
-      const updatedPrinter1 = await dataSource.getRepository(FeiePrinterMt).findOne({
-        where: { tenantId: 1, printerSn: printer1.printerSn }
+      // 验证测试打印机不再是默认
+      const updatedTestPrinter = await dataSource.getRepository(FeiePrinterMt).findOne({
+        where: { tenantId: 1, printerSn: testPrinter.printerSn }
+      });
+      expect(updatedTestPrinter?.isDefault).toBe(0);
+    });
+
+    it('应该能够查询打印机状态', async () => {
+      const response = await client.printers[':printerSn'].status.$get({
+        param: { printerSn: testPrinter.printerSn }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+
+        expect(data.success).toBe(true);
+        expect(data.data.printerSn).toBe(testPrinter.printerSn);
+        expect(data.data.printerStatus).toBe('ACTIVE');
+      }
+    });
+
+    it('应该在查询不存在的打印机状态时返回404', async () => {
+      const response = await client.printers[':printerSn'].status.$get({
+        param: { printerSn: 'NONEXISTENT_PRINTER' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印机不存在');
+      }
+    });
+
+    it('应该能够更新打印机信息', async () => {
+      const updateData = {
+        printerName: '更新后的打印机名称',
+        printerType: '80mm' as const
+      };
+
+      const response = await client.printers[':printerSn'].$put({
+        param: { printerSn: testPrinter.printerSn },
+        json: updateData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+
+        expect(data.success).toBe(true);
+        expect(data.data.printerName).toBe('更新后的打印机名称');
+        expect(data.data.printerType).toBe('80mm');
+      }
+
+      // 验证打印机已更新
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const updatedPrinter = await dataSource.getRepository(FeiePrinterMt).findOne({
+        where: { tenantId: 1, printerSn: testPrinter.printerSn }
+      });
+      expect(updatedPrinter?.printerName).toBe('更新后的打印机名称');
+      expect(updatedPrinter?.printerType).toBe('80mm');
+    });
+
+    it('应该在更新不存在的打印机时返回404', async () => {
+      const updateData = {
+        printerName: '更新后的名称'
+      };
+
+      const response = await client.printers[':printerSn'].$put({
+        param: { printerSn: 'NONEXISTENT_PRINTER' },
+        json: updateData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印机不存在');
+      }
+    });
+
+    it('应该能够删除打印机', async () => {
+      const response = await client.printers[':printerSn'].$delete({
+        param: { printerSn: testPrinter.printerSn }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.message).toBe('打印机删除成功');
+      }
+
+      // 验证打印机已删除
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const deletedPrinter = await dataSource.getRepository(FeiePrinterMt).findOne({
+        where: { tenantId: 1, printerSn: testPrinter.printerSn }
+      });
+      expect(deletedPrinter).toBeNull();
+    });
+
+    it('应该在删除不存在的打印机时返回404', async () => {
+      const response = await client.printers[':printerSn'].$delete({
+        param: { printerSn: 'NONEXISTENT_PRINTER' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
       });
-      expect(updatedPrinter1?.isDefault).toBe(0);
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印机不存在');
+      }
     });
   });
 
   describe('打印任务管理功能验证', () => {
     let testPrinter: FeiePrinterMt;
+    let testTask: FeiePrintTaskMt;
 
     beforeEach(async () => {
       const dataSource = await IntegrationTestDatabase.getDataSource();
       // 创建测试打印机
       testPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+      // 创建测试打印任务
+      testTask = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
     });
 
     it.skip('应该能够创建打印任务 - 需要实际飞鹅API连接', async () => {
       const taskData = {
         printerSn: testPrinter.printerSn,
         content: '<CB>测试打印内容</CB><BR>',
-        printType: 'RECEIPT' as const,
+        printType: PrintType.RECEIPT,
         delaySeconds: 0
       };
 
@@ -245,8 +386,7 @@ describe('飞鹅打印多租户API集成测试', () => {
     it('应该能够查询打印任务列表', async () => {
       const dataSource = await IntegrationTestDatabase.getDataSource();
 
-      // 创建测试打印任务
-      const task1 = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
+      // 创建另一个测试打印任务
       const task2 = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
 
       // 查询打印任务列表
@@ -274,8 +414,7 @@ describe('飞鹅打印多租户API集成测试', () => {
       // 创建另一个打印机
       const otherPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
 
-      // 创建测试打印任务
-      const task1 = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
+      // 创建另一个测试打印任务
       const task2 = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, otherPrinter.printerSn);
 
       // 根据打印机筛选
@@ -296,6 +435,135 @@ describe('飞鹅打印多租户API集成测试', () => {
         expect(data.data.data[0].printerSn).toBe(testPrinter.printerSn);
       }
     });
+
+    it('应该能够查询单个打印任务详情', async () => {
+      const response = await client.tasks[':taskId'].$get({
+        param: { taskId: testTask.taskId }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+
+        expect(data.success).toBe(true);
+        expect(data.data.taskId).toBe(testTask.taskId);
+        expect(data.data.printerSn).toBe(testPrinter.printerSn);
+        expect(data.data.printType).toBe('RECEIPT');
+      }
+    });
+
+    it('应该在查询不存在的打印任务详情时返回404', async () => {
+      const response = await client.tasks[':taskId'].$get({
+        param: { taskId: 'NONEXISTENT_TASK_ID' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印任务不存在');
+      }
+    });
+
+    it('应该能够取消打印任务', async () => {
+      const response = await client.tasks[':taskId'].cancel.$post({
+        param: { taskId: testTask.taskId },
+        json: { reason: 'MANUAL' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.data.printStatus).toBe('CANCELLED');
+      }
+
+      // 验证任务状态已更新
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const updatedTask = await dataSource.getRepository(FeiePrintTaskMt).findOne({
+        where: { tenantId: 1, taskId: testTask.taskId }
+      });
+      expect(updatedTask?.printStatus).toBe('CANCELLED');
+    });
+
+    it('应该在取消不存在的打印任务时返回404', async () => {
+      const response = await client.tasks[':taskId'].cancel.$post({
+        param: { taskId: 'NONEXISTENT_TASK_ID' },
+        json: { reason: 'MANUAL' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印任务不存在');
+      }
+    });
+
+    it('应该能够重试失败的打印任务', async () => {
+      // 首先将任务状态设置为FAILED
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      await dataSource.getRepository(FeiePrintTaskMt).update(
+        { tenantId: 1, taskId: testTask.taskId },
+        { printStatus: 'FAILED', errorMessage: '测试失败' }
+      );
+
+      const response = await client.tasks[':taskId'].retry.$post({
+        param: { taskId: testTask.taskId }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.data.printStatus).toBe('PENDING');
+        expect(data.data.errorMessage).toBeNull();
+      }
+
+      // 验证任务状态已更新
+      const updatedTask = await dataSource.getRepository(FeiePrintTaskMt).findOne({
+        where: { tenantId: 1, taskId: testTask.taskId }
+      });
+      expect(updatedTask?.printStatus).toBe('PENDING');
+      expect(updatedTask?.errorMessage).toBeNull();
+    });
+
+    it('应该在重试不存在的打印任务时返回404', async () => {
+      const response = await client.tasks[':taskId'].retry.$post({
+        param: { taskId: 'NONEXISTENT_TASK_ID' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印任务不存在');
+      }
+    });
   });
 
   describe('错误处理验证', () => {
@@ -303,7 +571,7 @@ describe('飞鹅打印多租户API集成测试', () => {
       const taskData = {
         printerSn: 'NONEXISTENT_PRINTER',
         content: '测试内容',
-        printType: 'RECEIPT' as const
+        printType: PrintType.RECEIPT
       };
 
       const response = await client.tasks.$post({
@@ -362,212 +630,64 @@ describe('飞鹅打印多租户API集成测试', () => {
         expect(data.success).toBe(false);
         expect(data.message).toBe('飞鹅API配置未找到或配置不完整');
       }
+
+      // 重新创建配置，避免影响后续测试
+      await FeieTestDataFactory.createFullFeieConfig(dataSource, 1);
     });
   });
 
-  // 调度器管理功能验证 - 当前路由定义中不存在这些路由
-  // describe('调度器管理功能验证', () => {
-  //   it.skip('应该能够获取调度器状态 - 需要实际飞鹅API连接', async () => {
-  //     const response = await client['scheduler/status'].$get({}, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     expect(response.status).toBe(200);
-  //     if (response.status === 200) {
-  //       const data = await response.json();
-  //
-  //       expect(data.success).toBe(true);
-  //       expect(data.data).toBeDefined();
-  //       expect(data.data.isRunning).toBeDefined();
-  //       expect(data.data.lastRunTime).toBeDefined();
-  //     }
-  //   });
-  //
-  //   it.skip('应该能够启动和停止调度器 - 需要实际飞鹅API连接', async () => {
-  //     // 启动调度器
-  //     const startResponse = await client['scheduler/start'].$post({}, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     expect(startResponse.status).toBe(200);
-  //     if (startResponse.status === 200) {
-  //       const data = await startResponse.json();
-  //       expect(data.success).toBe(true);
-  //       expect(data.message).toBe('调度器已启动');
-  //     }
-  //
-  //     // 停止调度器
-  //     const stopResponse = await client['scheduler/stop'].$post({}, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     expect(stopResponse.status).toBe(200);
-  //     if (stopResponse.status === 200) {
-  //       const data = await stopResponse.json();
-  //       expect(data.success).toBe(true);
-  //       expect(data.message).toBe('调度器已停止');
-  //     }
-  //   });
-  //
-  //   it.skip('应该能够进行调度器健康检查 - 需要实际飞鹅API连接', async () => {
-  //     const response = await client['scheduler/health'].$get({}, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     expect(response.status).toBe(200);
-  //     if (response.status === 200) {
-  //       const data = await response.json();
-  //
-  //       expect(data.success).toBe(true);
-  //       expect(data.data).toBeDefined();
-  //       expect(data.data.healthy).toBeDefined();
-  //       expect(data.data.message).toBeDefined();
-  //     }
-  //   });
-  // });
-
-  // 配置管理功能验证 - 当前路由定义中不存在这些路由
-  // describe('配置管理功能验证', () => {
-  //   it('应该能够获取打印配置', async () => {
-  //     const response = await client.config.$get({}, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     expect(response.status).toBe(200);
-  //     if (response.status === 200) {
-  //       const data = await response.json();
-  //
-  //       expect(data.success).toBe(true);
-  //       expect(data.data.data).toBeDefined();
-  //       expect(Array.isArray(data.data.data)).toBe(true);
-  //
-  //       // 应该包含飞鹅API配置
-  //       const feieConfigs = data.data.data.filter((config: any) =>
-  //         config.configKey.startsWith('feie.api.')
-  //       );
-  //       expect(feieConfigs.length).toBeGreaterThan(0);
-  //     }
-  //   });
-  //
-  //   it('应该能够更新打印配置', async () => {
-  //     const updateData = {
-  //       configValue: 'new_test_user'
-  //     };
-  //
-  //     const response = await client['config/:configKey'].$put({
-  //       param: { configKey: 'feie.api.user' },
-  //       json: updateData
-  //     }, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     expect(response.status).toBe(200);
-  //     if (response.status === 200) {
-  //       const data = await response.json();
-  //
-  //       expect(data.success).toBe(true);
-  //       expect(data.data.configKey).toBe('feie.api.user');
-  //       expect(data.data.configValue).toBe('new_test_user');
-  //     }
-  //
-  //     // 验证配置已更新
-  //     const dataSource = await IntegrationTestDatabase.getDataSource();
-  //     const updatedConfig = await dataSource.getRepository(FeieConfigMt).findOne({
-  //       where: { tenantId: 1, configKey: 'feie.api.user' }
-  //     });
-  //     expect(updatedConfig?.configValue).toBe('new_test_user');
-  //     });
-  //   });
-  //
-  //   it('应该在配置值为空时返回错误', async () => {
-  //     const updateData = {
-  //       configValue: ''
-  //     };
-  //
-  //     const response = await client['config/:configKey'].$put({
-  //       param: { configKey: 'feie.api.user' },
-  //       json: updateData
-  //     }, {
-  //       headers: {
-  //         'Authorization': `Bearer ${userToken}`
-  //       }
-  //     });
-  //
-  //     // 应该返回400
-  //     expect(response.status).toBe(400);
-  //     if (response.status === 400) {
-  //       const data = await response.json();
-  //       expect(data.success).toBe(false);
-  //       expect(data.message).toBe('配置值不能为空');
-  //     }
-  //   });
-  // });
-
-  // 新增：越权访问防护测试
-  describe('越权访问防护验证', () => {
-    it('应该拒绝访问其他用户的打印机详情', async () => {
-      const dataSource = await IntegrationTestDatabase.getDataSource();
-
-      // 为otherUser创建打印机
-      const otherUserPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
-
-      // testUser尝试访问otherUser的打印机
-      const response = await client.printers[':printerSn'].$get({
-        param: { printerSn: otherUserPrinter.printerSn }
-      }, {
+  // 调度器管理功能验证
+  describe('调度器管理功能验证', () => {
+    it('应该能够获取调度器状态', async () => {
+      const response = await client.scheduler.status.$get({}, {
         headers: {
-          'Authorization': `Bearer ${userToken}` // testUser的token
+          'Authorization': `Bearer ${userToken}`
         }
       });
 
-      // 应该返回404，因为打印机查询包含租户ID过滤
-      expect(response.status).toBe(404);
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+
+        expect(data.success).toBe(true);
+        expect(data.data).toBeDefined();
+        expect(data.data.isRunning).toBeDefined();
+        expect(data.data.lastRunTime).toBeDefined();
+      }
     });
 
-    it('应该拒绝跨租户访问打印机详情', async () => {
-      const dataSource = await IntegrationTestDatabase.getDataSource();
+    it('应该能够启动和停止调度器', async () => {
+      // 启动调度器
+      const startResponse = await client.scheduler.start.$post({}, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
 
-      // 为otherTenantUser创建打印机（租户2）
-      const otherTenantPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 2);
+      expect(startResponse.status).toBe(200);
+      if (startResponse.status === 200) {
+        const data = await startResponse.json();
+        expect(data.success).toBe(true);
+        expect(data.message).toBe('调度器已启动');
+      }
 
-      // testUser（租户1）尝试访问otherTenantUser（租户2）的打印机
-      const response = await client.printers[':printerSn'].$get({
-        param: { printerSn: otherTenantPrinter.printerSn }
-      }, {
+      // 停止调度器
+      const stopResponse = await client.scheduler.stop.$post({}, {
         headers: {
-          'Authorization': `Bearer ${userToken}` // 租户1的用户
+          'Authorization': `Bearer ${userToken}`
         }
       });
 
-      // 应该返回404，因为租户ID不匹配
-      expect(response.status).toBe(404);
+      expect(stopResponse.status).toBe(200);
+      if (stopResponse.status === 200) {
+        const data = await stopResponse.json();
+        expect(data.success).toBe(true);
+        expect(data.message).toBe('调度器已停止');
+      }
     });
-  });
-
-  // 新增：边界条件测试
-  describe('边界条件测试', () => {
-    it('应该处理打印机名称为空的情况', async () => {
-      const dataSource = await IntegrationTestDatabase.getDataSource();
-
-      // 创建打印机名称为空的打印机
-      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '' });
 
-      // 查询打印机列表
-      const response = await client.printers.$get({
-        query: {}
-      }, {
+    it('应该能够进行调度器健康检查', async () => {
+      const response = await client.scheduler.health.$get({}, {
         headers: {
           'Authorization': `Bearer ${userToken}`
         }
@@ -576,9 +696,176 @@ describe('飞鹅打印多租户API集成测试', () => {
       expect(response.status).toBe(200);
       if (response.status === 200) {
         const data = await response.json();
+
         expect(data.success).toBe(true);
-        // 应该能正常返回，即使打印机名称为空
-        expect(data.data.data).toHaveLength(1);
+        expect(data.data).toBeDefined();
+        expect(data.data.isHealthy).toBeDefined();
+        expect(data.data.status).toBeDefined();
+      }
+    });
+
+    it('应该能够手动触发调度器执行', async () => {
+      const response = await client.scheduler.trigger.$post({}, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.data.processedTasks).toBeDefined();
+        expect(data.data.successfulTasks).toBeDefined();
+        expect(data.data.failedTasks).toBeDefined();
+      }
+    });
+  });
+
+  // 配置管理功能验证
+  describe('配置管理功能验证', () => {
+    it('应该能够获取打印配置', async () => {
+      const response = await client.config.$get({}, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+
+        expect(data.success).toBe(true);
+        expect(data.data.data).toBeDefined();
+        expect(Array.isArray(data.data.data)).toBe(true);
+
+        // 应该包含飞鹅API配置
+        const feieConfigs = data.data.data.filter((config: any) =>
+          config.configKey.startsWith('feie.api.')
+        );
+        expect(feieConfigs.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('应该能够更新打印配置', async () => {
+      const updateData = {
+        configValue: 'new_test_user'
+      };
+
+      const response = await client.config[':configKey'].$put({
+        param: { configKey: 'feie.api.user' },
+        json: updateData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+
+        expect(data.success).toBe(true);
+        expect(data.data.configKey).toBe('feie.api.user');
+        expect(data.data.configValue).toBe('new_test_user');
+      }
+
+      // 验证配置已更新
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const updatedConfig = await dataSource.getRepository(FeieConfigMt).findOne({
+        where: { tenantId: 1, configKey: 'feie.api.user' }
+      });
+      expect(updatedConfig?.configValue).toBe('new_test_user');
+    });
+
+    it('应该在配置值为空时返回错误', async () => {
+      const updateData = {
+        configValue: ''
+      };
+
+      const response = await client.config[':configKey'].$put({
+        param: { configKey: 'feie.api.user' },
+        json: updateData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回400
+      expect(response.status).toBe(400);
+      if (response.status === 400) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toBe('配置值不能为空');
+      }
+    });
+  });
+
+  // 新增：越权访问防护测试
+  describe('越权访问防护验证', () => {
+    it('应该拒绝访问其他用户的打印机详情', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+
+      // 为otherUser创建打印机
+      const otherUserPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+
+      // testUser尝试访问otherUser的打印机
+      const response = await client.printers[':printerSn'].$get({
+        param: { printerSn: otherUserPrinter.printerSn }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}` // testUser的token
+        }
+      });
+
+      // 应该返回404，因为打印机查询包含租户ID过滤
+      expect(response.status).toBe(404);
+    });
+
+    it('应该拒绝跨租户访问打印机详情', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+
+      // 为otherTenantUser创建打印机（租户2）
+      const otherTenantPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 2);
+
+      // testUser（租户1）尝试访问otherTenantUser（租户2）的打印机
+      const response = await client.printers[':printerSn'].$get({
+        param: { printerSn: otherTenantPrinter.printerSn }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}` // 租户1的用户
+        }
+      });
+
+      // 应该返回404，因为租户ID不匹配
+      expect(response.status).toBe(404);
+    });
+  });
+
+  // 新增：边界条件测试
+  describe('边界条件测试', () => {
+    it('应该处理打印机名称为空的情况', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+
+      // 创建打印机名称为空的打印机
+      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '' });
+
+      // 查询打印机列表
+      const response = await client.printers.$get({
+        query: {}
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        // 应该能正常返回，即使打印机名称为空
+        expect(data.data.data).toHaveLength(1);
       }
     });
 
@@ -606,6 +893,134 @@ describe('飞鹅打印多租户API集成测试', () => {
         expect(data.data.data[0].printerStatus).toBe('INVALID_STATUS');
       }
     });
+
+    it('应该处理打印机序列号重复的情况', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+
+      // 创建第一个打印机
+      const printer1 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerSn: 'DUPLICATE_SN' });
+
+      // 尝试创建相同序列号的打印机
+      const createData = {
+        printerSn: 'DUPLICATE_SN',
+        printerKey: 'TEST_KEY_2',
+        printerName: '重复打印机',
+        printerType: '58mm' as const
+      };
+
+      const response = await client.printers.$post({
+        json: createData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回错误，因为序列号重复
+      expect(response.status).toBe(400);
+      if (response.status === 400) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印机序列号已存在');
+      }
+    });
+
+    it('应该处理打印内容过长的情况', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+
+      // 创建超长打印内容
+      const longContent = 'A'.repeat(10000); // 10KB内容
+
+      const taskData = {
+        printerSn: printer.printerSn,
+        content: longContent,
+        printType: PrintType.RECEIPT,
+        delaySeconds: 0
+      };
+
+      const response = await client.tasks.$post({
+        json: taskData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该能正常处理，或者返回适当错误
+      // 这里假设系统能处理10KB内容
+      expect(response.status).toBe(200);
+    });
+
+    it('应该处理延迟时间边界值', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+
+      // 测试最小延迟时间（0秒）
+      const taskData1 = {
+        printerSn: printer.printerSn,
+        content: '测试内容',
+        printType: PrintType.RECEIPT,
+        delaySeconds: 0
+      };
+
+      const response1 = await client.tasks.$post({
+        json: taskData1
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 测试较大延迟时间（3600秒 = 1小时）
+      const taskData2 = {
+        printerSn: printer.printerSn,
+        content: '测试内容',
+        printType: PrintType.RECEIPT,
+        delaySeconds: 3600
+      };
+
+      const response2 = await client.tasks.$post({
+        json: taskData2
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 两个请求都应该能正常处理
+      expect(response1.status).toBe(200);
+      expect(response2.status).toBe(200);
+    });
+
+    it('应该处理打印任务状态转换边界情况', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+      const task = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, printer.printerSn);
+
+      // 测试从SUCCESS状态取消（应该失败）
+      await dataSource.getRepository(FeiePrintTaskMt).update(
+        { tenantId: 1, taskId: task.taskId },
+        { printStatus: 'SUCCESS' }
+      );
+
+      const response = await client.tasks[':taskId'].cancel.$post({
+        param: { taskId: task.taskId },
+        json: { reason: 'MANUAL' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回错误，因为已完成的任务不能取消
+      expect(response.status).toBe(400);
+      if (response.status === 400) {
+        const data = await response.json() as { success: boolean; message: string };
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('无法取消');
+      }
+    });
   });
 
   // 新增：管理员权限测试
@@ -644,7 +1059,7 @@ describe('飞鹅打印多租户API集成测试', () => {
       // 管理员更新打印机
       const updateData = {
         printerName: '管理员更新后的打印机',
-        printerType: 'RECEIPT' as const
+        printerType: '80mm' as const
       };
 
       const response = await client.printers[':printerSn'].$put({
@@ -665,4 +1080,461 @@ describe('飞鹅打印多租户API集成测试', () => {
       }
     });
   });
+
+  // 新增：创建打印机API测试
+  describe('创建打印机API测试', () => {
+    it('应该能够成功创建打印机', async () => {
+      const createData = {
+        printerSn: 'TEST_PRINTER_CREATE',
+        printerKey: 'TEST_KEY_CREATE',
+        printerName: '新创建的打印机',
+        printerType: '80mm' as const,
+        isDefault: false
+      };
+
+      const response = await client.printers.$post({
+        json: createData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.data.printerSn).toBe('TEST_PRINTER_CREATE');
+        expect(data.data.printerName).toBe('新创建的打印机');
+        expect(data.data.printerType).toBe('80mm');
+        expect(data.data.printerStatus).toBe('ONLINE');
+      }
+    });
+
+    it('应该在缺少必填字段时返回错误', async () => {
+      const createData = {
+        printerName: '缺少必填字段的打印机'
+        // 缺少printerSn和printerKey
+      } as any; // 使用类型断言绕过TypeScript检查，因为我们要测试验证逻辑
+
+      const response = await client.printers.$post({
+        json: createData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回400错误
+      expect(response.status).toBe(400);
+    });
+
+    it('应该能够创建默认打印机', async () => {
+      const createData = {
+        printerSn: 'TEST_DEFAULT_PRINTER',
+        printerKey: 'TEST_KEY_DEFAULT',
+        printerName: '默认打印机',
+        printerType: '58mm' as const,
+        isDefault: true
+      };
+
+      const response = await client.printers.$post({
+        json: createData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.data.isDefault).toBe(1);
+      }
+    });
+  });
+
+  // 新增：打印任务状态查询API测试
+  describe('打印任务状态查询API测试', () => {
+    let testPrinter: FeiePrinterMt;
+    let testTask: FeiePrintTaskMt;
+
+    beforeEach(async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      // 创建测试打印机
+      testPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+      // 创建测试打印任务
+      testTask = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
+    });
+
+    it('应该能够查询打印任务状态', async () => {
+      const response = await client.tasks[':taskId'].status.$get({
+        param: { taskId: testTask.taskId }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.data.taskId).toBe(testTask.taskId);
+        expect(data.data.printStatus).toBe('PENDING');
+        expect(data.data.retryCount).toBe(0);
+      }
+    });
+
+    it('应该在查询不存在的打印任务状态时返回404', async () => {
+      const response = await client.tasks[':taskId'].status.$get({
+        param: { taskId: 'NONEXISTENT_TASK_STATUS' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(404);
+      if (response.status === 404) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('打印任务不存在');
+      }
+    });
+
+    it('应该能够查询不同状态的打印任务', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+
+      // 创建不同状态的打印任务
+      const successTask = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
+      await dataSource.getRepository(FeiePrintTaskMt).update(
+        { tenantId: 1, taskId: successTask.taskId },
+        { printStatus: 'SUCCESS', printedAt: new Date() }
+      );
+
+      const failedTask = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
+      await dataSource.getRepository(FeiePrintTaskMt).update(
+        { tenantId: 1, taskId: failedTask.taskId },
+        { printStatus: 'FAILED', errorMessage: '打印失败' }
+      );
+
+      // 查询成功任务状态
+      const successResponse = await client.tasks[':taskId'].status.$get({
+        param: { taskId: successTask.taskId }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(successResponse.status).toBe(200);
+      if (successResponse.status === 200) {
+        const data = await successResponse.json();
+        expect(data.data.printStatus).toBe('SUCCESS');
+        expect(data.data.printedAt).not.toBeNull();
+      }
+
+      // 查询失败任务状态
+      const failedResponse = await client.tasks[':taskId'].status.$get({
+        param: { taskId: failedTask.taskId }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(failedResponse.status).toBe(200);
+      if (failedResponse.status === 200) {
+        const data = await failedResponse.json();
+        expect(data.data.printStatus).toBe('FAILED');
+        expect(data.data.errorMessage).toBe('打印失败');
+      }
+    });
+  });
+
+  // 新增：分页和排序功能测试
+  describe('分页和排序功能测试', () => {
+    beforeEach(async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+
+      // 创建多个打印机用于分页测试
+      for (let i = 1; i <= 15; i++) {
+        await FeieTestDataFactory.createTestPrinter(dataSource, 1, {
+          printerSn: `PAGINATION_PRINTER_${i}`,
+          printerName: `分页打印机 ${i}`,
+          printerType: i % 2 === 0 ? '58mm' : '80mm',
+          createdAt: new Date(Date.now() - i * 1000) // 创建时间递减
+        });
+      }
+
+      // 创建多个打印任务用于分页测试
+      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerSn: 'PAGINATION_TASK_PRINTER' });
+      for (let i = 1; i <= 15; i++) {
+        await FeieTestDataFactory.createTestPrintTask(dataSource, 1, printer.printerSn, {
+          taskId: `PAGINATION_TASK_${i}`,
+          content: `分页任务内容 ${i}`,
+          createdAt: new Date(Date.now() - i * 1000) // 创建时间递减
+        });
+      }
+    });
+
+    it('应该支持打印机列表分页', async () => {
+      // 第一页，每页5条
+      const response1 = await client.printers.$get({
+        query: { page: '1', pageSize: '5' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response1.status).toBe(200);
+      if (response1.status === 200) {
+        const data = await response1.json();
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(5);
+        expect(data.data.page).toBe(1);
+        expect(data.data.pageSize).toBe(5);
+        expect(data.data.total).toBeGreaterThanOrEqual(15);
+      }
+
+      // 第二页，每页5条
+      const response2 = await client.printers.$get({
+        query: { page: '2', pageSize: '5' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response2.status).toBe(200);
+      if (response2.status === 200) {
+        const data = await response2.json();
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(5);
+        expect(data.data.page).toBe(2);
+      }
+    });
+
+    it('应该支持打印任务列表分页', async () => {
+      // 第一页，每页5条
+      const response1 = await client.tasks.$get({
+        query: { page: '1', pageSize: '5' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response1.status).toBe(200);
+      if (response1.status === 200) {
+        const data = await response1.json();
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(5);
+        expect(data.data.page).toBe(1);
+        expect(data.data.pageSize).toBe(5);
+        expect(data.data.total).toBeGreaterThanOrEqual(15);
+      }
+
+      // 第三页，每页3条
+      const response2 = await client.tasks.$get({
+        query: { page: '3', pageSize: '3' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response2.status).toBe(200);
+      if (response2.status === 200) {
+        const data = await response2.json();
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(3);
+        expect(data.data.page).toBe(3);
+      }
+    });
+
+    it('应该支持按创建时间倒序排序', async () => {
+      // 查询打印机列表，应该按创建时间倒序排列
+      const response = await client.printers.$get({
+        query: { page: '1', pageSize: '10' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
+        expect(data.success).toBe(true);
+
+        // 验证数据按创建时间倒序排列（最新的在前面）
+        const printers = data.data.data;
+        for (let i = 0; i < printers.length - 1; i++) {
+          const currentDate = new Date(printers[i].createdAt);
+          const nextDate = new Date(printers[i + 1].createdAt);
+          expect(currentDate.getTime()).toBeGreaterThanOrEqual(nextDate.getTime());
+        }
+      }
+    });
+
+    it('应该支持按打印机类型筛选', async () => {
+      // 筛选58mm打印机
+      const response58mm = await client.printers.$get({
+        query: { printerType: 'RECEIPT', pageSize: '20' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response58mm.status).toBe(200);
+      if (response58mm.status === 200) {
+        const data = await response58mm.json();
+        expect(data.success).toBe(true);
+
+        // 验证所有返回的打印机都是58mm类型
+        const printers = data.data.data;
+        printers.forEach((printer: any) => {
+          expect(printer.printerType).toBe('RECEIPT');
+        });
+      }
+
+      // 筛选80mm打印机
+      const response80mm = await client.printers.$get({
+        query: { printerType: 'LABEL', pageSize: '20' }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      expect(response80mm.status).toBe(200);
+      if (response80mm.status === 200) {
+        const data = await response80mm.json();
+        expect(data.success).toBe(true);
+
+        // 验证所有返回的打印机都是80mm类型
+        const printers = data.data.data;
+        printers.forEach((printer: any) => {
+          expect(printer.printerType).toBe('LABEL');
+        });
+      }
+    });
+  });
+
+  // 新增：更多错误场景测试
+  describe('更多错误场景测试', () => {
+    it('应该在打印机类型无效时返回错误', async () => {
+      const updateData = {
+        printerType: 'INVALID_TYPE' as any // 无效的打印机类型
+      };
+
+      const response = await client.printers[':printerSn'].$put({
+        param: { printerSn: 'TEST_PRINTER' },
+        json: updateData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回400错误
+      expect(response.status).toBe(400);
+    });
+
+    it('应该在打印类型无效时返回错误', async () => {
+      const taskData = {
+        printerSn: 'TEST_PRINTER',
+        content: '测试内容',
+        printType: 'INVALID_TYPE' as any // 无效的打印类型
+      };
+
+      const response = await client.tasks.$post({
+        json: taskData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回400错误
+      expect(response.status).toBe(400);
+    });
+
+    it('应该在延迟时间为负数时返回错误', async () => {
+      const taskData = {
+        printerSn: 'TEST_PRINTER',
+        content: '测试内容',
+        printType: PrintType.RECEIPT,
+        delaySeconds: -1 // 负数的延迟时间
+      };
+
+      const response = await client.tasks.$post({
+        json: taskData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回400错误
+      expect(response.status).toBe(400);
+    });
+
+    it('应该在重试次数超过最大值时返回错误', async () => {
+      const dataSource = await IntegrationTestDatabase.getDataSource();
+      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1);
+      const task = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, printer.printerSn);
+
+      // 设置重试次数超过最大值
+      await dataSource.getRepository(FeiePrintTaskMt).update(
+        { tenantId: 1, taskId: task.taskId },
+        { printStatus: 'FAILED', retryCount: 10, maxRetries: 3 }
+      );
+
+      const response = await client.tasks[':taskId'].retry.$post({
+        param: { taskId: task.taskId }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 应该返回400错误，因为重试次数已超过最大值
+      expect(response.status).toBe(400);
+      if (response.status === 400) {
+        const data = await response.json();
+        expect(data.success).toBe(false);
+        expect(data.message).toContain('重试次数');
+      }
+    });
+
+    it('应该在配置键不存在时返回错误', async () => {
+      const updateData = {
+        configValue: '新配置值'
+      };
+
+      const response = await client.config[':configKey'].$put({
+        param: { configKey: 'NONEXISTENT_CONFIG_KEY' },
+        json: updateData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
+
+      // 根据实现，updatePrintConfig会创建新配置，所以应该返回200
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json() as { success: boolean; data: any };
+        expect(data.success).toBe(true);
+        expect(data.data.configKey).toBe('NONEXISTENT_CONFIG_KEY');
+        expect(data.data.configValue).toBe('新配置值');
+      }
+    });
+  });
 });

packages/feie-printer-module-mt/tests/integration/feie-api.integration.test.ts.backup

@@ -1,500 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { testClient } from 'hono/testing';
-import { IntegrationTestDatabase, setupIntegrationDatabaseHooksWithEntities } from '@d8d/shared-test-util';
-import { JWTUtil } from '@d8d/shared-utils';
-import { UserEntityMt, RoleMt } from '@d8d/user-module-mt';
-import { FileMt } from '@d8d/file-module-mt';
-import { createFeieMtRoutes } from '../../src/routes/feie.mt.routes';
-import { FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt } from '../../src/entities';
-import { FeieTestFactory } from '../factories/feie-test-factory';
-
-// 设置集成测试钩子
-setupIntegrationDatabaseHooksWithEntities([
-  UserEntityMt, RoleMt, FileMt, FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt
-])
-
-describe('飞鹅打印多租户API集成测试', () => {
-  let client: ReturnType<typeof testClient<ReturnType<typeof createFeieMtRoutes>>>;
-  let testFactory: FeieTestFactory;
-  let userToken: string;
-  let otherUserToken: string;
-  let otherTenantUserToken: string;
-  let testUser: UserEntityMt;
-  let otherUser: UserEntityMt;
-  let otherTenantUser: UserEntityMt;
-
-  beforeEach(async () => {
-    // 获取数据源
-    const dataSource = await IntegrationTestDatabase.getDataSource();
-
-    // 创建测试客户端
-    client = testClient(createFeieMtRoutes(dataSource));
-
-    // 创建测试工厂
-    testFactory = new FeieTestFactory(dataSource);
-
-    // 创建测试用户
-    testUser = await testFactory.createTestUser(1);
-    otherUser = await testFactory.createTestUser(1);
-    otherTenantUser = await testFactory.createTestUser(2);
-
-    // 生成JWT令牌
-    userToken = JWTUtil.generateToken({ id: testUser.id, username: testUser.username, tenantId: 1 });
-    otherUserToken = JWTUtil.generateToken({ id: otherUser.id, username: otherUser.username, tenantId: 1 });
-    otherTenantUserToken = JWTUtil.generateToken({ id: otherTenantUser.id, username: otherTenantUser.username, tenantId: 2 });
-
-    // 创建飞鹅API配置
-    await testFactory.createFullFeieConfig(1);
-    await testFactory.createFullFeieConfig(2);
-  });
-
-  describe('租户数据隔离验证', () => {
-    it('应该只能访问自己租户的打印机', async () => {
-      // 创建租户1的打印机
-      const tenant1Printer = await testFactory.createTestPrinter(1);
-
-      // 创建租户2的打印机
-      const tenant2Printer = await testFactory.createTestPrinter(2);
-
-      // 使用租户1的用户查询打印机列表
-      const response = await client.printers.$get({
-        query: {}
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        // 应该只返回租户1的打印机
-        expect(data.success).toBe(true);
-        expect(data.data.data).toHaveLength(1);
-        expect(data.data.data[0].tenantId).toBe(1);
-        expect(data.data.data[0].printerSn).toBe(tenant1Printer.printerSn);
-      }
-    });
-
-    it('不应该访问其他租户的打印机详情', async () => {
-      // 创建租户2的打印机
-      const otherTenantPrinter = await testFactory.createTestPrinter(2);
-
-      // 使用租户1的用户尝试访问租户2的打印机
-      const response = await client['printers/:printerSn'].$get({
-        param: { printerSn: otherTenantPrinter.printerSn }
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      // 应该返回404，因为打印机不在当前租户
-      expect(response.status).toBe(404);
-    });
-
-    it('应该正确过滤跨租户打印机访问', async () => {
-      // 创建租户1的打印机
-      const tenant1Printer = await testFactory.createTestPrinter(1);
-
-      // 使用租户2的用户尝试访问租户1的打印机
-      const response = await client['printers/:printerSn'].$get({
-        param: { printerSn: tenant1Printer.printerSn }
-      }, {
-        headers: {
-          'Authorization': `Bearer ${otherTenantUserToken}`
-        }
-      });
-
-      // 应该返回404，因为打印机不在当前租户
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe('打印机管理功能验证', () => {
-    it('应该能够查询打印机列表', async () => {
-      // 创建测试打印机
-      const printer1 = await testFactory.createTestPrinter(1, { printerName: '打印机1' });
-      const printer2 = await testFactory.createTestPrinter(1, { printerName: '打印机2' });
-
-      // 查询打印机列表
-      const response = await client.printers.$get({
-        query: {}
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.data).toHaveLength(2);
-        expect(data.data.total).toBe(2);
-      }
-    });
-
-    it('应该能够根据名称搜索打印机', async () => {
-      // 创建测试打印机
-      const printer1 = await testFactory.createTestPrinter(1, { printerName: '测试打印机A' });
-      const printer2 = await testFactory.createTestPrinter(1, { printerName: '其他打印机' });
-
-      // 搜索打印机
-      const response = await client.printers.$get({
-        query: { search: '测试' }
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.data).toHaveLength(1);
-        expect(data.data.data[0].printerName).toBe('测试打印机A');
-      }
-    });
-
-    it('应该能够设置默认打印机', async () => {
-      // 创建两个打印机
-      const printer1 = await testFactory.createTestPrinter(1, { printerName: '打印机1', isDefault: 1 });
-      const printer2 = await testFactory.createTestPrinter(1, { printerName: '打印机2', isDefault: 0 });
-
-      // 设置打印机2为默认
-      const response = await client['printers/:printerSn/set-default'].$post({
-        param: { printerSn: printer2.printerSn }
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.isDefault).toBe(1);
-      }
-
-      // 验证打印机1不再是默认
-      const dataSource = await IntegrationTestDatabase.getDataSource();
-      const updatedPrinter1 = await dataSource.getRepository(FeiePrinterMt).findOne({
-        where: { tenantId: 1, printerSn: printer1.printerSn }
-      });
-      expect(updatedPrinter1?.isDefault).toBe(0);
-    });
-  });
-
-  describe('打印任务管理功能验证', () => {
-    let testPrinter: FeiePrinterMt;
-
-    beforeEach(async () => {
-      // 创建测试打印机
-      testPrinter = await testFactory.createTestPrinter(1);
-    });
-
-    it.skip('应该能够创建打印任务 - 需要实际飞鹅API连接', async () => {
-      const taskData = {
-        printerSn: testPrinter.printerSn,
-        content: '<CB>测试打印内容</CB><BR>',
-        printType: 'RECEIPT',
-        delaySeconds: 0
-      };
-
-      const response = await client.tasks.$post({
-        json: taskData
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      console.debug('创建打印任务响应状态码:', response.status);
-      if (response.status !== 200) {
-        const errorResult = await response.json();
-        console.debug('创建打印任务错误响应:', errorResult);
-      }
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.taskId).toBeDefined();
-        expect(data.data.printerSn).toBe(testPrinter.printerSn);
-        expect(data.data.printType).toBe('RECEIPT');
-      }
-    });
-
-    it('应该能够查询打印任务列表', async () => {
-      // 创建测试打印任务
-      const task1 = await testFactory.createTestPrintTask(1, testPrinter.printerSn);
-      const task2 = await testFactory.createTestPrintTask(1, testPrinter.printerSn);
-
-      // 查询打印任务列表
-      const response = await client.tasks.$get({
-        query: {}
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.data).toHaveLength(2);
-        expect(data.data.total).toBe(2);
-      }
-    });
-
-    it('应该能够根据打印机筛选打印任务', async () => {
-      // 创建另一个打印机
-      const otherPrinter = await testFactory.createTestPrinter(1);
-
-      // 创建测试打印任务
-      const task1 = await testFactory.createTestPrintTask(1, testPrinter.printerSn);
-      const task2 = await testFactory.createTestPrintTask(1, otherPrinter.printerSn);
-
-      // 根据打印机筛选
-      const response = await client.tasks.$get({
-        query: { printerSn: testPrinter.printerSn }
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.data).toHaveLength(1);
-        expect(data.data.data[0].printerSn).toBe(testPrinter.printerSn);
-      }
-    });
-  });
-
-  describe('错误处理验证', () => {
-    it('应该在打印机不存在时创建打印任务失败', async () => {
-      const taskData = {
-        printerSn: 'NONEXISTENT_PRINTER',
-        content: '测试内容',
-        printType: 'RECEIPT'
-      };
-
-      const response = await client.tasks.$post({
-        json: taskData
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      // 应该返回错误
-      expect(response.status).toBe(500);
-      if (response.status === 500) {
-        const data = await response.json();
-        expect(data.success).toBe(false);
-        expect(data.message).toContain('打印机不存在');
-      }
-    });
-
-    it('应该在打印任务不存在时查询状态失败', async () => {
-      const response = await client['tasks/:taskId/status'].$get({
-        param: { taskId: 'NONEXISTENT_TASK' }
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      // 应该返回500（服务层抛出错误）
-      expect(response.status).toBe(500);
-      if (response.status === 500) {
-        const data = await response.json();
-        expect(data.success).toBe(false);
-        expect(data.message).toBe('打印任务不存在');
-      }
-    });
-
-    it('应该在缺少飞鹅API配置时返回错误', async () => {
-      // 清理配置
-      const dataSource = await IntegrationTestDatabase.getDataSource();
-      await dataSource.getRepository(FeieConfigMt).delete({ tenantId: 1 });
-
-      // 尝试查询打印机列表
-      const response = await client.printers.$get({
-        query: {}
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      // 应该返回400，因为缺少配置
-      expect(response.status).toBe(400);
-      if (response.status === 400) {
-        const data = await response.json();
-        expect(data.success).toBe(false);
-        expect(data.message).toBe('飞鹅API配置未找到或配置不完整');
-      }
-    });
-  });
-
-  describe('调度器管理功能验证', () => {
-    it.skip('应该能够获取调度器状态 - 需要实际飞鹅API连接', async () => {
-      const response = await client['scheduler/status'].$get({}, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data).toBeDefined();
-        expect(data.data.isRunning).toBeDefined();
-        expect(data.data.lastRunTime).toBeDefined();
-      }
-    });
-
-    it.skip('应该能够启动和停止调度器 - 需要实际飞鹅API连接', async () => {
-      // 启动调度器
-      const startResponse = await client['scheduler/start'].$post({}, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(startResponse.status).toBe(200);
-      if (startResponse.status === 200) {
-        const data = await startResponse.json();
-        expect(data.success).toBe(true);
-        expect(data.message).toBe('调度器已启动');
-      }
-
-      // 停止调度器
-      const stopResponse = await client['scheduler/stop'].$post({}, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(stopResponse.status).toBe(200);
-      if (stopResponse.status === 200) {
-        const data = await stopResponse.json();
-        expect(data.success).toBe(true);
-        expect(data.message).toBe('调度器已停止');
-      }
-    });
-
-    it.skip('应该能够进行调度器健康检查 - 需要实际飞鹅API连接', async () => {
-      const response = await client['scheduler/health'].$get({}, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data).toBeDefined();
-        expect(data.data.healthy).toBeDefined();
-        expect(data.data.message).toBeDefined();
-      }
-    });
-  });
-
-  describe('配置管理功能验证', () => {
-    it('应该能够获取打印配置', async () => {
-      const response = await client.config.$get({}, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.data).toBeDefined();
-        expect(Array.isArray(data.data.data)).toBe(true);
-
-        // 应该包含飞鹅API配置
-        const feieConfigs = data.data.data.filter((config: any) =>
-          config.configKey.startsWith('feie.api.')
-        );
-        expect(feieConfigs.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('应该能够更新打印配置', async () => {
-      const updateData = {
-        configValue: 'new_test_user'
-      };
-
-      const response = await client['config/:configKey'].$put({
-        param: { configKey: 'feie.api.user' },
-        json: updateData
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      expect(response.status).toBe(200);
-      if (response.status === 200) {
-        const data = await response.json();
-
-        expect(data.success).toBe(true);
-        expect(data.data.configKey).toBe('feie.api.user');
-        expect(data.data.configValue).toBe('new_test_user');
-      }
-
-      // 验证配置已更新
-      const dataSource = await IntegrationTestDatabase.getDataSource();
-      const updatedConfig = await dataSource.getRepository(FeieConfigMt).findOne({
-        where: { tenantId: 1, configKey: 'feie.api.user' }
-      });
-      expect(updatedConfig?.configValue).toBe('new_test_user');
-    });
-
-    it('应该在配置值为空时返回错误', async () => {
-      const updateData = {
-        configValue: ''
-      };
-
-      const response = await client['config/:configKey'].$put({
-        param: { configKey: 'feie.api.user' },
-        json: updateData
-      }, {
-        headers: {
-          'Authorization': `Bearer ${userToken}`
-        }
-      });
-
-      // 应该返回400
-      expect(response.status).toBe(400);
-      if (response.status === 400) {
-        const data = await response.json();
-        expect(data.success).toBe(false);
-        expect(data.message).toBe('配置值不能为空');
-      }
-    });
-  });
-});