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

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);
  });

  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('配置值不能为空');
      }
    });
  });
});