✨ feat(feie-printer-module): 增强飞鹅打印模块集成测试

- 新增测试工厂类(FeieTestFactory)，提供用户、打印机、打印任务和配置的创建与清理功能
- 重构集成测试文件，从单元测试模式转为多租户API集成测试模式
- 新增租户数据隔离验证，确保不同租户间的数据访问安全
- 扩展打印机管理功能测试，包括列表查询、搜索和默认打印机设置
- 完善打印任务管理测试，涵盖任务创建、查询和筛选功能
- 新增错误处理验证，测试打印机不存在、任务不存在和配置缺失等场景
- 新增调度器管理功能测试（部分测试需要实际API连接）
- 新增配置管理功能测试，支持配置的获取和更新操作

📦 build(docker): 添加日志目录环境变量

- 在Dockerfile中新增LOG_DIR环境变量，用于生产环境日志存储

🔧 chore(dependencies): 添加模块依赖

- 在feie-printer-module-mt的package.json中添加@d8d/user-module-mt和@d8d/file-module-mt依赖
- 更新pnpm-lock.yaml文件以反映依赖关系变化

Dockerfile

@@ -37,6 +37,7 @@ WORKDIR /workspace
 
 # 设置备份目录环境变量
 ENV BACKUP_DIR=/app/backups-prd/
+ENV LOG_DIR=/app/log-prd/
 
 # 设置MinIO自定义主机环境变量
 ENV MINIO_DIY_HOST=minio.yqingk.d8d.fun

packages/feie-printer-module-mt/package.json

@@ -57,6 +57,8 @@
     "@d8d/orders-module-mt": "workspace:*",
     "@d8d/tenant-module-mt": "workspace:*",
     "@d8d/auth-module-mt": "workspace:*",
+    "@d8d/user-module-mt": "workspace:*",
+    "@d8d/file-module-mt": "workspace:*",
     "@hono/zod-openapi": "^1.0.2",
     "typeorm": "^0.3.20",
     "zod": "^4.1.12",

packages/feie-printer-module-mt/tests/factories/feie-test-factory.ts

@@ -0,0 +1,174 @@
+import { DataSource } from 'typeorm';
+import { UserEntityMt } from '@d8d/user-module-mt';
+import { FileMt } from '@d8d/file-module-mt';
+import { FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt } from '../../src/entities';
+
+export class FeieTestFactory {
+  private dataSource: DataSource;
+
+  constructor(dataSource: DataSource) {
+    this.dataSource = dataSource;
+  }
+
+  /**
+   * 创建测试用户
+   */
+  async createTestUser(tenantId: number = 1, overrides: Partial<UserEntityMt> = {}): Promise<UserEntityMt> {
+    const userRepository = this.dataSource.getRepository(UserEntityMt);
+    const user = userRepository.create({
+      tenantId,
+      username: `test_user_${Math.floor(Math.random() * 100000)}`,
+      password: 'test_password',
+      nickname: '测试用户',
+      registrationSource: 'web',
+      ...overrides
+    });
+    return await userRepository.save(user);
+  }
+
+  /**
+   * 创建测试打印机
+   */
+  async createTestPrinter(tenantId: number = 1, overrides: Partial<FeiePrinterMt> = {}): Promise<FeiePrinterMt> {
+    const printerRepository = this.dataSource.getRepository(FeiePrinterMt);
+    const printer = printerRepository.create({
+      tenantId,
+      printerSn: `TEST_SN_${Math.floor(Math.random() * 100000)}`,
+      printerKey: `TEST_KEY_${Math.floor(Math.random() * 100000)}`,
+      printerName: '测试打印机',
+      printerType: '58mm',
+      printerStatus: 'ACTIVE',
+      isDefault: 0,
+      ...overrides
+    });
+    return await printerRepository.save(printer);
+  }
+
+  /**
+   * 创建测试打印任务
+   */
+  async createTestPrintTask(tenantId: number = 1, printerSn: string, overrides: Partial<FeiePrintTaskMt> = {}): Promise<FeiePrintTaskMt> {
+    const taskRepository = this.dataSource.getRepository(FeiePrintTaskMt);
+    const task = taskRepository.create({
+      tenantId,
+      taskId: `TASK_${Date.now()}`,
+      printerSn,
+      content: '<CB>测试打印内容</CB><BR>',
+      printType: 'RECEIPT',
+      printStatus: 'PENDING',
+      retryCount: 0,
+      ...overrides
+    });
+    return await taskRepository.save(task);
+  }
+
+  /**
+   * 创建测试飞鹅配置
+   */
+  async createTestFeieConfig(tenantId: number = 1, overrides: Partial<FeieConfigMt> = {}): Promise<FeieConfigMt> {
+    const configRepository = this.dataSource.getRepository(FeieConfigMt);
+    const config = configRepository.create({
+      tenantId,
+      configKey: 'feie.api.user',
+      configValue: 'test_user',
+      configType: 'STRING',
+      description: '飞鹅API用户',
+      ...overrides
+    });
+    return await configRepository.save(config);
+  }
+
+  /**
+   * 创建完整的飞鹅API配置
+   */
+  async createFullFeieConfig(tenantId: number = 1): Promise<void> {
+    const configRepository = this.dataSource.getRepository(FeieConfigMt);
+
+    const configs = [
+      {
+        tenantId,
+        configKey: 'feie.api.user',
+        configValue: 'test_user',
+        configType: 'STRING',
+        description: '飞鹅API用户'
+      },
+      {
+        tenantId,
+        configKey: 'feie.api.ukey',
+        configValue: 'test_ukey',
+        configType: 'STRING',
+        description: '飞鹅API密钥'
+      },
+      {
+        tenantId,
+        configKey: 'feie.api.base_url',
+        configValue: 'https://api.feieyun.cn/Api/Open/',
+        configType: 'STRING',
+        description: '飞鹅API基础URL'
+      },
+      {
+        tenantId,
+        configKey: 'feie.api.timeout',
+        configValue: '10000',
+        configType: 'NUMBER',
+        description: 'API超时时间'
+      },
+      {
+        tenantId,
+        configKey: 'feie.api.max_retries',
+        configValue: '3',
+        configType: 'NUMBER',
+        description: '最大重试次数'
+      }
+    ];
+
+    for (const config of configs) {
+      await configRepository.save(configRepository.create(config));
+    }
+  }
+
+  /**
+   * 创建跨租户测试环境
+   */
+  async createCrossTenantTestEnvironment() {
+    const tenant1User = await this.createTestUser(1);
+    const tenant2User = await this.createTestUser(2);
+
+    const tenant1Printer = await this.createTestPrinter(1);
+    const tenant2Printer = await this.createTestPrinter(2);
+
+    const tenant1Task = await this.createTestPrintTask(1, tenant1Printer.printerSn);
+    const tenant2Task = await this.createTestPrintTask(2, tenant2Printer.printerSn);
+
+    // 创建配置
+    await this.createFullFeieConfig(1);
+    await this.createFullFeieConfig(2);
+
+    return {
+      tenant1User,
+      tenant2User,
+      tenant1Printer,
+      tenant2Printer,
+      tenant1Task,
+      tenant2Task
+    };
+  }
+
+  /**
+   * 清理测试数据
+   */
+  async cleanup() {
+    const repositories = {
+      printTask: this.dataSource.getRepository(FeiePrintTaskMt),
+      printer: this.dataSource.getRepository(FeiePrinterMt),
+      config: this.dataSource.getRepository(FeieConfigMt),
+      user: this.dataSource.getRepository(UserEntityMt)
+    };
+
+    // 按依赖关系顺序删除数据
+    await repositories.printTask.delete({});
+    await repositories.printer.delete({});
+    await repositories.config.delete({});
+    await repositories.user.delete({});
+  }
+}

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

@@ -1,254 +1,500 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { DataSource } from 'typeorm';
-import { createTestDataSource } from '@d8d/shared-test-util';
-import { FeieApiService } from '../../src/services/feie-api.service';
-import { PrinterService } from '../../src/services/printer.service';
-import { PrintTaskService } from '../../src/services/print-task.service';
-import { FeiePrinterMt } from '../../src/entities/feie-printer.mt.entity';
-import { FeiePrintTaskMt } from '../../src/entities/feie-print-task.mt.entity';
-import { FeieConfigMt } from '../../src/entities/feie-config.mt.entity';
-import type { FeieApiConfig, PrinterDto, CreatePrintTaskDto } from '../../src/types/feie.types';
-
-describe('飞鹅打印模块集成测试', () => {
-  let dataSource: DataSource;
-  let feieApiService: FeieApiService;
-  let printerService: PrinterService;
-  let printTaskService: PrintTaskService;
-
-  // 测试配置 - 使用模拟配置，实际测试应该使用测试环境的飞鹅账号
-  const testFeieConfig: FeieApiConfig = {
-    baseUrl: process.env.TEST_FEIE_API_BASE_URL || 'http://api.feieyun.cn/Api/Open/',
-    user: process.env.TEST_FEIE_API_USER || 'test_user',
-    ukey: process.env.TEST_FEIE_API_UKEY || 'test_ukey',
-    timeout: 5000,
-    maxRetries: 1
-  };
-
-  beforeAll(async () => {
-    // 创建测试数据库连接
-    dataSource = await createTestDataSource({
-      entities: [FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt],
-      synchronize: true,
-      dropSchema: true
-    });
-
-    // 初始化服务
-    feieApiService = new FeieApiService(testFeieConfig);
-    printerService = new PrinterService(dataSource, testFeieConfig);
-    printTaskService = new PrintTaskService(dataSource, testFeieConfig);
+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 createFeieRoutes from '../../src/routes/feie.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 createFeieRoutes>>>;
+  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(createFeieRoutes(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);
   });
 
-  afterAll(async () => {
-    if (dataSource && dataSource.isInitialized) {
-      await dataSource.destroy();
-    }
-  });
+  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();
 
-  describe('数据库连接', () => {
-    it('应该成功连接数据库', () => {
-      expect(dataSource.isInitialized).toBe(true);
+        // 应该只返回租户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('应该能够访问实体仓库', () => {
-      const printerRepository = dataSource.getRepository(FeiePrinterMt);
-      const taskRepository = dataSource.getRepository(FeiePrintTaskMt);
-      const configRepository = dataSource.getRepository(FeieConfigMt);
+    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}`
+        }
+      });
 
-      expect(printerRepository).toBeDefined();
-      expect(taskRepository).toBeDefined();
-      expect(configRepository).toBeDefined();
+      // 应该返回404，因为打印机不在当前租户
+      expect(response.status).toBe(404);
     });
-  });
 
-  describe('打印机管理', () => {
-    const tenantId = 1;
-    const testPrinter: PrinterDto = {
-      printerSn: 'TEST_SN_' + Date.now(),
-      printerKey: 'TEST_KEY_' + Date.now(),
-      printerName: '测试打印机',
-      printerType: '58mm',
-      isDefault: true
-    };
-
-    it('应该能够添加打印机（模拟）', async () => {
-      // 注意：实际测试需要有效的飞鹅账号
-      // 这里我们主要测试服务层的逻辑，API调用会被模拟
-      console.log('打印机添加测试（使用模拟配置）');
-
-      // 由于我们使用测试配置，实际API调用会失败
-      // 我们主要验证服务层的错误处理
-      try {
-        await printerService.addPrinter(tenantId, testPrinter);
-        // 如果成功，验证打印机被创建
-        const printers = await printerService.getPrinters(tenantId);
-        expect(printers.length).toBeGreaterThan(0);
-      } catch (error) {
-        // 预期会失败，因为测试配置无效
-        console.log('预期中的API调用失败:', error.message);
-        expect(error).toBeDefined();
-      }
+    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 printerRepository = dataSource.getRepository(FeiePrinterMt);
+      // 创建测试打印机
+      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}`
+        }
+      });
 
-      // 创建测试数据
-      const testPrinterData = printerRepository.create({
-        tenantId,
-        printerSn: 'TEST_QUERY_SN',
-        printerKey: 'TEST_QUERY_KEY',
-        printerName: '查询测试打印机',
-        printerType: '80mm',
-        printerStatus: 'ACTIVE',
-        isDefault: 0
+      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}`
+        }
       });
 
-      await printerRepository.save(testPrinterData);
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
 
-      // 查询
-      const printers = await printerService.getPrinters(tenantId);
-      expect(Array.isArray(printers)).toBe(true);
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(1);
+        expect(data.data.data[0].printerName).toBe('测试打印机A');
+      }
     });
 
     it('应该能够设置默认打印机', async () => {
       // 创建两个打印机
-      const printerRepository = dataSource.getRepository(FeiePrinterMt);
+      const printer1 = await testFactory.createTestPrinter(1, { printerName: '打印机1', isDefault: 1 });
+      const printer2 = await testFactory.createTestPrinter(1, { printerName: '打印机2', isDefault: 0 });
 
-      const printer1 = printerRepository.create({
-        tenantId,
-        printerSn: 'DEFAULT_TEST_1',
-        printerKey: 'KEY1',
-        printerName: '打印机1',
-        printerType: '58mm',
-        printerStatus: 'ACTIVE',
-        isDefault: 1
-      });
-
-      const printer2 = printerRepository.create({
-        tenantId,
-        printerSn: 'DEFAULT_TEST_2',
-        printerKey: 'KEY2',
-        printerName: '打印机2',
-        printerType: '80mm',
-        printerStatus: 'ACTIVE',
-        isDefault: 0
+      // 设置打印机2为默认
+      const response = await client['printers/:printerSn/set-default'].$post({
+        param: { printerSn: printer2.printerSn }
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
       });
 
-      await printerRepository.save([printer1, printer2]);
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
 
-      // 设置打印机2为默认
-      await printerService.setDefaultPrinter(tenantId, 'DEFAULT_TEST_2');
+        expect(data.success).toBe(true);
+        expect(data.data.isDefault).toBe(1);
+      }
 
-      // 验证
-      const defaultPrinter = await printerService.getDefaultPrinter(tenantId);
-      expect(defaultPrinter).toBeDefined();
-      expect(defaultPrinter?.printerSn).toBe('DEFAULT_TEST_2');
-      expect(defaultPrinter?.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('打印任务管理', () => {
-    const tenantId = 2;
-    let testPrinterSn: string;
+  describe('打印任务管理功能验证', () => {
+    let testPrinter: FeiePrinterMt;
 
-    beforeAll(async () => {
+    beforeEach(async () => {
       // 创建测试打印机
-      const printerRepository = dataSource.getRepository(FeiePrinterMt);
-      testPrinterSn = 'TASK_TEST_SN_' + Date.now();
-
-      const testPrinter = printerRepository.create({
-        tenantId,
-        printerSn: testPrinterSn,
-        printerKey: 'TASK_TEST_KEY',
-        printerName: '任务测试打印机',
-        printerType: '58mm',
-        printerStatus: 'ACTIVE',
-        isDefault: 1
-      });
-
-      await printerRepository.save(testPrinter);
+      testPrinter = await testFactory.createTestPrinter(1);
     });
 
-    it('应该能够创建立即打印任务', async () => {
-      const taskDto: CreatePrintTaskDto = {
-        printerSn: testPrinterSn,
+    it.skip('应该能够创建打印任务 - 需要实际飞鹅API连接', async () => {
+      const taskData = {
+        printerSn: testPrinter.printerSn,
         content: '<CB>测试打印内容</CB><BR>',
         printType: 'RECEIPT',
         delaySeconds: 0
       };
 
-      const task = await printTaskService.createPrintTask(tenantId, taskDto);
+      const response = await client.tasks.$post({
+        json: taskData
+      }, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
 
-      expect(task).toBeDefined();
-      expect(task.taskId).toBeDefined();
-      expect(task.printerSn).toBe(testPrinterSn);
-      expect(task.printType).toBe('RECEIPT');
-      expect(task.printStatus).toBe('PENDING'); // 立即打印任务状态为PENDING
+      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 taskDto: CreatePrintTaskDto = {
-        printerSn: testPrinterSn,
-        content: '<CB>延迟打印测试</CB><BR>',
-        printType: 'RECEIPT',
-        delaySeconds: 10 // 10秒延迟
-      };
+    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}`
+        }
+      });
 
-      const task = await printTaskService.createPrintTask(tenantId, taskDto);
+      expect(response.status).toBe(200);
+      if (response.status === 200) {
+        const data = await response.json();
 
-      expect(task).toBeDefined();
-      expect(task.printStatus).toBe('DELAYED');
-      expect(task.scheduledAt).toBeDefined();
-      expect(task.scheduledAt).toBeInstanceOf(Date);
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(2);
+        expect(data.data.total).toBe(2);
+      }
     });
 
-    it('应该能够查询打印任务列表', async () => {
-      const result = await printTaskService.getPrintTasks(tenantId, {}, 1, 10);
+    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(result).toBeDefined();
-      expect(result.tasks).toBeInstanceOf(Array);
-      expect(result.total).toBeGreaterThanOrEqual(0);
+        expect(data.success).toBe(true);
+        expect(data.data.data).toHaveLength(1);
+        expect(data.data.data[0].printerSn).toBe(testPrinter.printerSn);
+      }
     });
+  });
 
-    it('应该能够根据条件筛选打印任务', async () => {
-      const filters = {
-        printerSn: testPrinterSn,
-        printType: 'RECEIPT' as const
+  describe('错误处理验证', () => {
+    it('应该在打印机不存在时创建打印任务失败', async () => {
+      const taskData = {
+        printerSn: 'NONEXISTENT_PRINTER',
+        content: '测试内容',
+        printType: 'RECEIPT'
       };
 
-      const result = await printTaskService.getPrintTasks(tenantId, filters, 1, 10);
+      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}`
+        }
+      });
 
-      expect(result).toBeDefined();
-      // 验证筛选条件
-      if (result.tasks.length > 0) {
-        result.tasks.forEach(task => {
-          expect(task.printerSn).toBe(testPrinterSn);
-          expect(task.printType).toBe('RECEIPT');
-        });
+      // 应该返回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('错误处理', () => {
-    const tenantId = 3;
+  describe('调度器管理功能验证', () => {
+    it.skip('应该能够获取调度器状态 - 需要实际飞鹅API连接', async () => {
+      const response = await client['scheduler/status'].$get({}, {
+        headers: {
+          'Authorization': `Bearer ${userToken}`
+        }
+      });
 
-    it('应该在打印机不存在时抛出错误', async () => {
-      const taskDto: CreatePrintTaskDto = {
-        printerSn: 'NONEXISTENT_PRINTER',
-        content: '测试内容',
-        printType: 'RECEIPT'
+      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'
       };
 
-      await expect(printTaskService.createPrintTask(tenantId, taskDto))
-        .rejects
-        .toThrow('打印机不存在');
+      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 () => {
-      await expect(printTaskService.getPrintTaskStatus(tenantId, 'NONEXISTENT_TASK'))
-        .rejects
-        .toThrow('打印任务不存在');
+    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('配置值不能为空');
+      }
     });
   });
 });

pnpm-lock.yaml

@@ -1905,6 +1905,9 @@ importers:
       '@d8d/auth-module-mt':
         specifier: workspace:*
         version: link:../auth-module-mt
+      '@d8d/file-module-mt':
+        specifier: workspace:*
+        version: link:../file-module-mt
       '@d8d/orders-module-mt':
         specifier: workspace:*
         version: link:../orders-module-mt
@@ -1920,6 +1923,9 @@ importers:
       '@d8d/tenant-module-mt':
         specifier: workspace:*
         version: link:../tenant-module-mt
+      '@d8d/user-module-mt':
+        specifier: workspace:*
+        version: link:../user-module-mt
       '@hono/zod-openapi':
         specifier: ^1.0.2
         version: 1.0.2(hono@4.8.5)(zod@4.1.12)