mini-starter/src/server/api/__integration_tests__/users.integration.test.ts

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { OpenAPIHono } from '@hono/zod-openapi';
import { createApiClient, ApiClient } from '../../__test_utils__/api-client';
import { createMockDataSource } from '../../__test_utils__/test-db';

// Mock 数据源
vi.mock('../../../data-source', () => {
  const mockDataSource = createMockDataSource();
  return {
    AppDataSource: mockDataSource
  };
});

// Mock 用户服务
vi.mock('../../modules/users/user.service', () => ({
  UserService: vi.fn().mockImplementation(() => ({
    getUserById: vi.fn().mockResolvedValue(null),
    createUser: vi.fn().mockResolvedValue({ id: 1, username: 'testuser' }),
    updateUser: vi.fn().mockResolvedValue({ affected: 1 }),
    deleteUser: vi.fn().mockResolvedValue({ affected: 1 })
  }))
}));

// Mock 认证中间件
vi.mock('../../middleware/auth.middleware', () => ({
  authMiddleware: vi.fn().mockImplementation((_c, next) => next())
}));

// Mock 通用CRUD服务
vi.mock('../../../utils/generic-crud.service', () => ({
  GenericCrudService: vi.fn().mockImplementation(() => ({
    getList: vi.fn().mockResolvedValue([[], 0]),
    getById: vi.fn().mockResolvedValue(null),
    create: vi.fn().mockResolvedValue({ id: 1, username: 'testuser' }),
    update: vi.fn().mockResolvedValue({ affected: 1 }),
    delete: vi.fn().mockResolvedValue({ affected: 1 })
  }))
}));

describe('Users API Integration Tests', () => {
  let app: OpenAPIHono;
  let apiClient: ApiClient;

  beforeEach(async () => {
    vi.clearAllMocks();

    // 动态导入用户路由
    const userRoutes = await import('../users/index');

    // 使用导入的应用实例
    app = userRoutes.default;

    // 创建API客户端
    apiClient = createApiClient(app, {
      authToken: 'test-token-123'
    });
  });

  afterEach(() => {
    vi.resetAllMocks();
  });

  describe('GET /users', () => {
    it('应该返回用户列表和分页信息', async () => {
      // 模拟通用CRUD服务返回数据
      const mockCrudService = require('../../../utils/generic-crud.service').GenericCrudService();
      const mockUsers = [
        { id: 1, username: 'user1', email: 'user1@example.com' },
        { id: 2, username: 'user2', email: 'user2@example.com' }
      ];
      mockCrudService.getList.mockResolvedValue([mockUsers, 2]);

      const response = await apiClient.get('/users?page=1&pageSize=10');

      expect(response.status).toBe(200);
      expect(response.data).toEqual({
        data: mockUsers,
        pagination: {
          total: 2,
          current: 1,
          pageSize: 10
        }
      });
    });

    it('应该验证分页参数', async () => {
      const response = await apiClient.get('/users?page=0&pageSize=0');

      expect(response.status).toBe(400);
      expect(response.data).toMatchObject({
        success: false,
        error: expect.any(Object)
      });
    });

    it('应该支持关键词搜索', async () => {
      const mockCrudService = require('../../../utils/generic-crud.service').GenericCrudService();
      mockCrudService.getList.mockResolvedValue([[], 0]);

      const response = await apiClient.get('/users?page=1&pageSize=10&keyword=admin');

      expect(response.status).toBe(200);
      expect(mockCrudService.getList).toHaveBeenCalledWith(
        expect.objectContaining({
          page: 1,
          pageSize: 10,
          keyword: 'admin'
        })
      );
    });
  });

  describe('GET /users/:id', () => {
    it('应该返回特定用户信息', async () => {
      const mockUser = { id: 1, username: 'testuser', email: 'test@example.com' };
      const mockCrudService = require('../../../utils/generic-crud.service').GenericCrudService();
      mockCrudService.getById.mockResolvedValue(mockUser);

      const response = await apiClient.get('/users/1');

      expect(response.status).toBe(200);
      expect(response.data).toEqual(mockUser);
      expect(mockCrudService.getById).toHaveBeenCalledWith(1);
    });

    it('应该在用户不存在时返回404', async () => {
      const mockCrudService = require('../../../utils/generic-crud.service').GenericCrudService();
      mockCrudService.getById.mockResolvedValue(null);

      const response = await apiClient.get('/users/999');

      expect(response.status).toBe(404);
      expect(response.data).toMatchObject({
        code: 404,
        message: expect.any(String)
      });
    });

    it('应该验证用户ID格式', async () => {
      const response = await apiClient.get('/users/invalid');

      expect(response.status).toBe(400);
      expect(response.data).toMatchObject({
        success: false,
        error: expect.any(Object)
      });
    });
  });

  describe('错误处理', () => {
    it('应该在服务错误时返回500状态码', async () => {
      const mockCrudService = require('../../../utils/generic-crud.service').GenericCrudService();
      mockCrudService.getList.mockRejectedValue(new Error('Database error'));

      const response = await apiClient.get('/users?page=1&pageSize=10');

      expect(response.status).toBe(500);
      expect(response.data).toMatchObject({
        code: 500,
        message: 'Database error'
      });
    });

    it('应该在未知错误时返回通用错误消息', async () => {
      const mockCrudService = require('../../../utils/generic-crud.service').GenericCrudService();
      mockCrudService.getList.mockRejectedValue('Unknown error');

      const response = await apiClient.get('/users?page=1&pageSize=10');

      expect(response.status).toBe(500);
      expect(response.data).toMatchObject({
        code: 500,
        message: '获取用户列表失败'
      });
    });
  });

  describe('认证和授权', () => {
    it('应该在缺少认证令牌时返回401', async () => {
      apiClient.clearAuthToken();

      const response = await apiClient.get('/users');

      expect(response.status).toBe(401);
      expect(response.data).toMatchObject({
        code: 401,
        message: expect.any(String)
      });
    });

    it('应该在无效令牌时返回401', async () => {
      // 模拟认证中间件验证失败
      const authMiddleware = require('../../middleware/auth.middleware').authMiddleware;
      authMiddleware.mockImplementation((c: any) => {
        return c.json({ error: 'Invalid token' }, 401);
      });

      const response = await apiClient.get('/users');

      expect(response.status).toBe(401);
      expect(response.data).toEqual({ error: 'Invalid token' });
    });
  });
});