gamegroup/src/modules/appointments/appointments.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import {
  NotFoundException,
  BadRequestException,
  ForbiddenException,
} from '@nestjs/common';
import { AppointmentsService } from './appointments.service';
import { Appointment } from '../../entities/appointment.entity';
import { AppointmentParticipant } from '../../entities/appointment-participant.entity';
import { Group } from '../../entities/group.entity';
import { GroupMember } from '../../entities/group-member.entity';
import { Game } from '../../entities/game.entity';
import { User } from '../../entities/user.entity';
import { CacheService } from '../../common/services/cache.service';

enum AppointmentStatus {
  PENDING = 'pending',
  CONFIRMED = 'confirmed',
  CANCELLED = 'cancelled',
  COMPLETED = 'completed',
}

describe('AppointmentsService', () => {
  let service: AppointmentsService;
  let mockAppointmentRepository: any;
  let mockParticipantRepository: any;
  let mockGroupRepository: any;
  let mockGroupMemberRepository: any;
  let mockGameRepository: any;
  let mockUserRepository: any;

  const mockUser = { id: 'user-1', username: 'testuser' };
  const mockGroup = { id: 'group-1', name: '测试小组', isActive: true };
  const mockGame = { id: 'game-1', name: '测试游戏' };
  const mockMembership = {
    id: 'member-1',
    userId: 'user-1',
    groupId: 'group-1',
    role: 'member',
    isActive: true,
  };

  const mockAppointment = {
    id: 'appointment-1',
    groupId: 'group-1',
    gameId: 'game-1',
    creatorId: 'user-1',
    title: '周末开黑',
    description: '描述',
    startTime: new Date('2024-01-20T19:00:00Z'),
    endTime: new Date('2024-01-20T23:00:00Z'),
    maxParticipants: 5,
    status: AppointmentStatus.PENDING,
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  const mockParticipant = {
    id: 'participant-1',
    appointmentId: 'appointment-1',
    userId: 'user-1',
    status: 'accepted',
    joinedAt: new Date(),
  };

  beforeEach(async () => {
    mockAppointmentRepository = {
      create: jest.fn(),
      save: jest.fn(),
      findOne: jest.fn(),
      remove: jest.fn(),
      createQueryBuilder: jest.fn(),
    };

    mockParticipantRepository = {
      create: jest.fn(),
      save: jest.fn(),
      findOne: jest.fn(),
      find: jest.fn(),
      count: jest.fn(),
      remove: jest.fn(),
      createQueryBuilder: jest.fn(),
    };

    mockGroupRepository = {
      findOne: jest.fn(),
    };

    mockGroupMemberRepository = {
      findOne: jest.fn(),
      find: jest.fn(),
    };

    mockGameRepository = {
      findOne: jest.fn(),
    };

    mockUserRepository = {
      findOne: jest.fn(),
    };

    const mockCacheService = {
      get: jest.fn(),
      set: jest.fn(),
      del: jest.fn(),
      clear: jest.fn(),
      clearByPrefix: jest.fn(),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AppointmentsService,
        {
          provide: getRepositoryToken(Appointment),
          useValue: mockAppointmentRepository,
        },
        {
          provide: getRepositoryToken(AppointmentParticipant),
          useValue: mockParticipantRepository,
        },
        {
          provide: getRepositoryToken(Group),
          useValue: mockGroupRepository,
        },
        {
          provide: getRepositoryToken(GroupMember),
          useValue: mockGroupMemberRepository,
        },
        {
          provide: getRepositoryToken(Game),
          useValue: mockGameRepository,
        },
        {
          provide: getRepositoryToken(User),
          useValue: mockUserRepository,
        },
        {
          provide: CacheService,
          useValue: mockCacheService,
        },
      ],
    }).compile();

    service = module.get<AppointmentsService>(AppointmentsService);
  });

  describe('create', () => {
    it('应该成功创建预约', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockGameRepository.findOne.mockResolvedValue(mockGame);
      mockAppointmentRepository.create.mockReturnValue(mockAppointment);
      mockAppointmentRepository.save.mockResolvedValue(mockAppointment);
      mockParticipantRepository.create.mockReturnValue(mockParticipant);
      mockParticipantRepository.save.mockResolvedValue(mockParticipant);
      mockAppointmentRepository.findOne.mockResolvedValue({
        ...mockAppointment,
        group: mockGroup,
        game: mockGame,
        creator: mockUser,
        participants: [mockParticipant],
      });

      const result = await service.create('user-1', {
        groupId: 'group-1',
        gameId: 'game-1',
        title: '周末开黑',
        startTime: new Date('2024-01-20T19:00:00Z'),
        maxParticipants: 5,
      });

      expect(result).toHaveProperty('id');
      expect(result.title).toBe('周末开黑');
      expect(mockAppointmentRepository.save).toHaveBeenCalled();
      expect(mockParticipantRepository.save).toHaveBeenCalled();
    });

    it('应该在小组不存在时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(null);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          gameId: 'game-1',
          title: '周末开黑',
          startTime: new Date('2024-01-20T19:00:00Z'),
          maxParticipants: 5,
        }),
      ).rejects.toThrow(NotFoundException);
    });

    it('应该在用户不在小组中时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(null);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          gameId: 'game-1',
          title: '周末开黑',
          startTime: new Date('2024-01-20T19:00:00Z'),
          maxParticipants: 5,
        }),
      ).rejects.toThrow(ForbiddenException);
    });

    it('应该在游戏不存在时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockGameRepository.findOne.mockResolvedValue(null);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          gameId: 'game-1',
          title: '周末开黑',
          startTime: new Date('2024-01-20T19:00:00Z'),
          maxParticipants: 5,
        }),
      ).rejects.toThrow(NotFoundException);
    });
  });

  describe('findAll', () => {
    it('应该成功获取预约列表', async () => {
      const mockQueryBuilder = {
        leftJoinAndSelect: jest.fn().mockReturnThis(),
        where: jest.fn().mockReturnThis(),
        andWhere: jest.fn().mockReturnThis(),
        orderBy: jest.fn().mockReturnThis(),
        skip: jest.fn().mockReturnThis(),
        take: jest.fn().mockReturnThis(),
        getManyAndCount: jest.fn().mockResolvedValue([[mockAppointment], 1]),
      };

      mockAppointmentRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      const result = await service.findAll('user-1', {
        groupId: 'group-1',
        page: 1,
        limit: 10,
      });

      expect(result).toHaveProperty('items');
      expect(result).toHaveProperty('total');
      expect(result.items).toHaveLength(1);
    });
  });

  describe('findOne', () => {
    it('应该成功获取预约详情', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue({
        ...mockAppointment,
        group: mockGroup,
        game: mockGame,
        creator: mockUser,
      });

      const result = await service.findOne('appointment-1');

      expect(result).toHaveProperty('id');
      expect(result.id).toBe('appointment-1');
    });

    it('应该在预约不存在时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(null);

      await expect(service.findOne('appointment-1')).rejects.toThrow(
        NotFoundException,
      );
    });
  });

  describe('update', () => {
    it('应该成功更新预约', async () => {
      mockAppointmentRepository.findOne
        .mockResolvedValueOnce(mockAppointment)
        .mockResolvedValueOnce({
          ...mockAppointment,
          title: '更新后的标题',
          group: mockGroup,
          game: mockGame,
          creator: mockUser,
        });
      mockAppointmentRepository.save.mockResolvedValue({
        ...mockAppointment,
        title: '更新后的标题',
      });

      const result = await service.update('user-1', 'appointment-1', {
        title: '更新后的标题',
      });

      expect(result.title).toBe('更新后的标题');
    });

    it('应该在非创建者更新时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);

      await expect(
        service.update('user-2', 'appointment-1', { title: '新标题' }),
      ).rejects.toThrow(ForbiddenException);
    });
  });

  describe('cancel', () => {
    it('应该成功取消预约', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);
      mockAppointmentRepository.save.mockResolvedValue({
        ...mockAppointment,
        status: AppointmentStatus.CANCELLED,
      });

      const result = await service.cancel('user-1', 'appointment-1');

      expect(result).toHaveProperty('message');
    });

    it('应该在非创建者取消时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);

      await expect(
        service.cancel('user-2', 'appointment-1'),
      ).rejects.toThrow(ForbiddenException);
    });
  });

  describe('join', () => {
    it('应该成功加入预约', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockParticipantRepository.findOne.mockResolvedValue(null);
      mockParticipantRepository.count.mockResolvedValue(3);
      mockParticipantRepository.create.mockReturnValue(mockParticipant);
      mockParticipantRepository.save.mockResolvedValue(mockParticipant);

      const result = await service.join('user-2', 'appointment-1');

      expect(result).toHaveProperty('message');
      expect(mockParticipantRepository.save).toHaveBeenCalled();
    });

    it('应该在预约已满时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockParticipantRepository.findOne.mockResolvedValue(null);
      mockParticipantRepository.count.mockResolvedValue(5);

      await expect(
        service.join('user-2', 'appointment-1'),
      ).rejects.toThrow(BadRequestException);
    });

    it('应该在已加入时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockParticipantRepository.findOne.mockResolvedValue(mockParticipant);

      await expect(
        service.join('user-1', 'appointment-1'),
      ).rejects.toThrow(BadRequestException);
    });
  });

  describe('leave', () => {
    it('应该成功离开预约', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);
      mockParticipantRepository.findOne.mockResolvedValue(mockParticipant);
      mockParticipantRepository.remove.mockResolvedValue(mockParticipant);

      const result = await service.leave('user-1', 'appointment-1');

      expect(result).toHaveProperty('message');
      expect(mockParticipantRepository.remove).toHaveBeenCalled();
    });

    it('应该在创建者尝试离开时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);

      await expect(
        service.leave('user-1', 'appointment-1'),
      ).rejects.toThrow(BadRequestException);
    });

    it('应该在未加入时抛出异常', async () => {
      mockAppointmentRepository.findOne.mockResolvedValue(mockAppointment);
      mockParticipantRepository.findOne.mockResolvedValue(null);

      await expect(
        service.leave('user-2', 'appointment-1'),
      ).rejects.toThrow(BadRequestException);
    });
  });
});