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 { UserEntityMt, RoleMt } from '@d8d/user-module-mt';
import { FileMt } from '@d8d/file-module-mt';
import { FeieMtRoutes } from '../../src/routes';
import { FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt } from '../../src/entities';
import { FeieTestDataFactory } from '../utils/test-data-factory';

// 设置集成测试钩子
setupIntegrationDatabaseHooksWithEntities([
  UserEntityMt, RoleMt, FileMt, FeiePrinterMt, FeiePrintTaskMt, FeieConfigMt
])

describe('飞鹅打印多租户API集成测试', () => {
  let client: ReturnType<typeof testClient<typeof FeieMtRoutes>>;
  let userToken: string;
  let adminToken: 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(FeieMtRoutes);

    // 创建测试用户
    testUser = await FeieTestDataFactory.createTestUser(dataSource, 1);
    otherUser = await FeieTestDataFactory.createTestUser(dataSource, 1);
    otherTenantUser = await FeieTestDataFactory.createTestUser(dataSource, 2);

    // 生成JWT令牌
    userToken = FeieTestDataFactory.generateUserToken(testUser);
    adminToken = FeieTestDataFactory.generateAdminToken(1);
    otherUserToken = FeieTestDataFactory.generateUserToken(otherUser);
    otherTenantUserToken = FeieTestDataFactory.generateUserToken(otherTenantUser);

    // 创建飞鹅API配置
    await FeieTestDataFactory.createFullFeieConfig(dataSource, 1);
    await FeieTestDataFactory.createFullFeieConfig(dataSource, 2);
  });

  describe('租户数据隔离验证', () => {
    it('应该只能访问自己租户的打印机', async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建租户1的打印机
      const tenant1Printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1);

      // 创建租户2的打印机
      const tenant2Printer = await FeieTestDataFactory.createTestPrinter(dataSource, 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 () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建租户2的打印机
      const otherTenantPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 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 () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建租户1的打印机
      const tenant1Printer = await FeieTestDataFactory.createTestPrinter(dataSource, 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 dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建测试打印机
      const printer1 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '打印机1' });
      const printer2 = await FeieTestDataFactory.createTestPrinter(dataSource, 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 dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建测试打印机
      const printer1 = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerName: '测试打印机A' });
      const printer2 = await FeieTestDataFactory.createTestPrinter(dataSource, 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 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为默认
      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 updatedPrinter1 = await dataSource.getRepository(FeiePrinterMt).findOne({
        where: { tenantId: 1, printerSn: printer1.printerSn }
      });
      expect(updatedPrinter1?.isDefault).toBe(0);
    });
  });

  describe('打印任务管理功能验证', () => {
    let testPrinter: FeiePrinterMt;

    beforeEach(async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();
      // 创建测试打印机
      testPrinter = await FeieTestDataFactory.createTestPrinter(dataSource, 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 dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建测试打印任务
      const task1 = await FeieTestDataFactory.createTestPrintTask(dataSource, 1, testPrinter.printerSn);
      const task2 = await FeieTestDataFactory.createTestPrintTask(dataSource, 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 dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建另一个打印机
      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);

      // 根据打印机筛选
      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('配置值不能为空');
      }
    });
  });

  // 新增：越权访问防护测试
  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);
      }
    });

    it('应该处理打印机状态无效的情况', async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建状态为无效的打印机
      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1, { printerStatus: 'INVALID_STATUS' });

      // 查询打印机列表
      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);
        expect(data.data.data[0].printerStatus).toBe('INVALID_STATUS');
      }
    });
  });

  // 新增：管理员权限测试
  describe('管理员权限验证', () => {
    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' });

      // 管理员查询打印机列表
      const response = await client.printers.$get({
        query: {}
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

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

    it('管理员应该能够更新打印机配置', async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();

      // 创建打印机
      const printer = await FeieTestDataFactory.createTestPrinter(dataSource, 1);

      // 管理员更新打印机
      const updateData = {
        printerName: '管理员更新后的打印机',
        printerType: '80mm'
      };

      const response = await client['printers/:printerSn'].$put({
        param: { printerSn: printer.printerSn },
        json: updateData
      }, {
        headers: {
          'Authorization': `Bearer ${adminToken}`
        }
      });

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