mini-starter/packages/tenant-module-mt/tests/integration/tenant-routes.integration.test.ts

import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
import { testClient } from 'hono/testing';
import { IntegrationTestDatabase, setupIntegrationDatabaseHooksWithEntities } from '@d8d/shared-test-util';
import { JWTUtil } from '@d8d/shared-utils';
import { tenantRoutes } from '../../src/routes';
import { TenantEntityMt } from '../../src/entities';

// 设置集成测试钩子
setupIntegrationDatabaseHooksWithEntities([TenantEntityMt])

describe('租户管理API集成测试', () => {
  let client: ReturnType<typeof testClient<typeof tenantRoutes>>;
  let superAdminToken: string;
  let regularUserToken: string;

  beforeEach(async () => {
    // 创建测试客户端
    client = testClient(tenantRoutes);

    // 生成模拟的token
    // 超级管理员用户ID为1（租户中间件要求）
    superAdminToken = JWTUtil.generateToken({
      id: 1,
      username: 'superadmin',
      tenantId: 1
    });

    // 普通用户（ID不为1，会被中间件拒绝）
    regularUserToken = JWTUtil.generateToken({
      id: 2,
      username: 'testuser',
      tenantId: 1
    });
  });

  afterEach(async () => {
    vi.clearAllMocks();
  });

  describe('创建租户', () => {
    it('超级管理员应该能够创建租户', async () => {
      const response = await client.index.$post({
        json: {
          name: '测试租户',
          code: 'test-tenant',
          contactName: '联系人',
          phone: '13800138000',
          status: 1
        }
      }, {
        headers: {
          Authorization: `Bearer ${superAdminToken}`
        }
      });

      expect(response.status).toBe(201);
      if (response.status === 201) {
        const data = await response.json();
        expect(data.name).toBe('测试租户');
        expect(data.code).toBe('test-tenant');
        expect(data.status).toBe(1);
      }
    });

    it('普通用户不应该能够创建租户', async () => {
      const response = await client.index.$post({
        json: {
          name: '测试租户',
          code: 'test-tenant',
          contactName: '联系人',
          phone: '13800138000',
          status: 1
        }
      }, {
        headers: {
          Authorization: `Bearer ${regularUserToken}`
        }
      });

      expect(response.status).toBe(403);
      if (response.status === 403) {
        const data = await response.json();
        expect(data.message).toContain('Access denied');
      }
    });

    it('未认证用户不应该能够创建租户', async () => {
      const response = await client.index.$post({
        json: {
          name: '测试租户',
          code: 'test-tenant',
          contactName: '联系人',
          phone: '13800138000',
          status: 1
        }
      });

      expect(response.status).toBe(401);
    });
  });

  describe('获取租户列表', () => {
    beforeEach(async () => {
      // 创建测试租户数据
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const tenantRepository = dataSource.getRepository(TenantEntityMt);

      await tenantRepository.save([
        {
          name: '租户A',
          code: 'tenant-a',
          contactName: '联系人A',
          phone: '13800138001',
          status: 1,
          createdBy: 1
        },
        {
          name: '租户B',
          code: 'tenant-b',
          contactName: '联系人B',
          phone: '13800138002',
          status: 2,
          createdBy: 1
        }
      ]);
    });

    it('超级管理员应该能够获取租户列表', async () => {
      const response = await client.index.$get({
        query: {}
      }, {
        headers: {
          Authorization: `Bearer ${superAdminToken}`
        }
      });

      console.debug('列表查询响应状态:', response.status);
      if (response.status !== 200) {
        const errorData = await response.json();
        console.debug('错误响应:', errorData);
      }

      expect(response.status).toBe(200);
      if (response.status === 200) {
        const data = await response.json();
        expect(data.data).toHaveLength(2);
        expect(data.pagination.total).toBe(2);
      }
    });

    it('普通用户不应该能够获取租户列表', async () => {
      const response = await client.index.$get({
        query: {}
      }, {
        headers: {
          Authorization: `Bearer ${regularUserToken}`
        }
      });

      expect(response.status).toBe(403);
    });
  });

  describe('获取单个租户', () => {
    let testTenant: TenantEntityMt;

    beforeEach(async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const tenantRepository = dataSource.getRepository(TenantEntityMt);

      testTenant = await tenantRepository.save({
        name: '测试租户',
        code: 'test-tenant',
        contactName: '联系人',
        phone: '13800138000',
        status: 1,
        createdBy: 1
      });
    });

    it('超级管理员应该能够获取租户详情', async () => {
      const response = await client[':id'].$get({
        param: { id: testTenant.id }
      }, {
        headers: {
          Authorization: `Bearer ${superAdminToken}`
        }
      });

      expect(response.status).toBe(200);
      if (response.status === 200) {
        const data = await response.json();
        expect(data.name).toBe('测试租户');
        expect(data.code).toBe('test-tenant');
      }
    });

    it('普通用户不应该能够获取租户详情', async () => {
      const response = await client[':id'].$get({
        param: { id: testTenant.id }
      }, {
        headers: {
          Authorization: `Bearer ${regularUserToken}`
        }
      });

      expect(response.status).toBe(403);
    });
  });

  describe('更新租户', () => {
    let testTenant: TenantEntityMt;

    beforeEach(async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const tenantRepository = dataSource.getRepository(TenantEntityMt);

      testTenant = await tenantRepository.save({
        name: '测试租户',
        code: 'test-tenant',
        contactName: '联系人',
        phone: '13800138000',
        status: 1,
        createdBy: 1
      });
    });

    it('超级管理员应该能够更新租户', async () => {
      const response = await client[':id'].$put({
        param: { id: testTenant.id },
        json: {
          name: '更新后的租户',
          contactName: '新联系人',
          phone: '13900139000',
          status: 2
        }
      }, {
        headers: {
          Authorization: `Bearer ${superAdminToken}`
        }
      });

      expect(response.status).toBe(200);
      if (response.status === 200) {
        const data = await response.json();
        expect(data.name).toBe('更新后的租户');
        expect(data.contactName).toBe('新联系人');
        expect(data.status).toBe(2);
      }
    });

    it('普通用户不应该能够更新租户', async () => {
      const response = await client[':id'].$put({
        param: { id: testTenant.id },
        json: {
          name: '更新后的租户'
        }
      }, {
        headers: {
          Authorization: `Bearer ${regularUserToken}`
        }
      });

      expect(response.status).toBe(403);
    });
  });

  describe('删除租户', () => {
    let testTenant: TenantEntityMt;

    beforeEach(async () => {
      const dataSource = await IntegrationTestDatabase.getDataSource();
      const tenantRepository = dataSource.getRepository(TenantEntityMt);

      testTenant = await tenantRepository.save({
        name: '测试租户',
        code: 'test-tenant',
        contactName: '联系人',
        phone: '13800138000',
        status: 1,
        createdBy: 1
      });
    });

    it('超级管理员应该能够删除租户', async () => {
      const response = await client[':id'].$delete({
        param: { id: testTenant.id }
      }, {
        headers: {
          Authorization: `Bearer ${superAdminToken}`
        }
      });

      expect(response.status).toBe(204);
    });

    it('普通用户不应该能够删除租户', async () => {
      const response = await client[':id'].$delete({
        param: { id: testTenant.id }
      }, {
        headers: {
          Authorization: `Bearer ${regularUserToken}`
        }
      });

      expect(response.status).toBe(403);
    });
  });
});