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

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import {
  NotFoundException,
  ForbiddenException,
  BadRequestException,
} from '@nestjs/common';
import { SchedulesService } from './schedules.service';
import { Schedule } from '../../entities/schedule.entity';
import { Group } from '../../entities/group.entity';
import { GroupMember } from '../../entities/group-member.entity';
import { TimeSlotDto } from './dto/schedule.dto';

describe('SchedulesService', () => {
  let service: SchedulesService;
  let mockScheduleRepository: any;
  let mockGroupRepository: any;
  let mockGroupMemberRepository: any;

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

  const mockTimeSlots: TimeSlotDto[] = [
    {
      startTime: new Date('2024-01-20T19:00:00Z'),
      endTime: new Date('2024-01-20T21:00:00Z'),
      note: '晚上空闲',
    },
    {
      startTime: new Date('2024-01-21T14:00:00Z'),
      endTime: new Date('2024-01-21T17:00:00Z'),
      note: '下午空闲',
    },
  ];

  const mockSchedule = {
    id: 'schedule-1',
    userId: 'user-1',
    groupId: 'group-1',
    availableSlots: mockTimeSlots,
    createdAt: new Date(),
    updatedAt: new Date(),
  };

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

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

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

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        SchedulesService,
        {
          provide: getRepositoryToken(Schedule),
          useValue: mockScheduleRepository,
        },
        {
          provide: getRepositoryToken(Group),
          useValue: mockGroupRepository,
        },
        {
          provide: getRepositoryToken(GroupMember),
          useValue: mockGroupMemberRepository,
        },
      ],
    }).compile();

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

  describe('create', () => {
    it('应该成功创建排班', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockScheduleRepository.create.mockReturnValue(mockSchedule);
      mockScheduleRepository.save.mockResolvedValue(mockSchedule);
      mockScheduleRepository.findOne.mockResolvedValue({
        ...mockSchedule,
        user: mockUser,
        group: mockGroup,
      });

      const result = await service.create('user-1', {
        groupId: 'group-1',
        title: '测试排班',
        availableSlots: mockTimeSlots,
      });

      expect(result).toHaveProperty('id');
      expect(mockScheduleRepository.save).toHaveBeenCalled();
    });

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

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          title: '测试排班',
          availableSlots: mockTimeSlots,
        }),
      ).rejects.toThrow(NotFoundException);
    });

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

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          title: '测试排班',
          availableSlots: mockTimeSlots,
        }),
      ).rejects.toThrow(ForbiddenException);
    });

    it('应该在时间段为空时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          title: '测试排班',
          availableSlots: [],
        }),
      ).rejects.toThrow(BadRequestException);
    });

    it('应该在时间段无效时抛出异常', async () => {
      mockGroupRepository.findOne.mockResolvedValue(mockGroup);
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);

      await expect(
        service.create('user-1', {
          groupId: 'group-1',
          title: '测试排班',
          availableSlots: [
            {
              startTime: new Date('2024-01-20T21:00:00Z'),
              endTime: new Date('2024-01-20T19:00:00Z'), // 结束时间早于开始时间
            },
          ],
        }),
      ).rejects.toThrow(BadRequestException);
    });
  });

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

      mockScheduleRepository.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);
      expect(result.total).toBe(1);
    });

    it('应该在指定小组且用户不在小组时抛出异常', async () => {
      const mockQueryBuilder = {
        leftJoinAndSelect: jest.fn().mockReturnThis(),
        andWhere: jest.fn().mockReturnThis(),
        orderBy: jest.fn().mockReturnThis(),
        skip: jest.fn().mockReturnThis(),
        take: jest.fn().mockReturnThis(),
        getManyAndCount: jest
          .fn()
          .mockResolvedValue([[mockSchedule], 1]),
      };

      mockScheduleRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
      mockGroupMemberRepository.findOne.mockResolvedValue(null);

      await expect(
        service.findAll('user-1', {
          groupId: 'group-1',
        }),
      ).rejects.toThrow(ForbiddenException);
    });

    it('应该在无小组ID时返回用户所在所有小组的排班', async () => {
      const mockQueryBuilder = {
        leftJoinAndSelect: jest.fn().mockReturnThis(),
        andWhere: jest.fn().mockReturnThis(),
        orderBy: jest.fn().mockReturnThis(),
        skip: jest.fn().mockReturnThis(),
        take: jest.fn().mockReturnThis(),
        getManyAndCount: jest
          .fn()
          .mockResolvedValue([[mockSchedule], 1]),
      };

      mockScheduleRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
      mockGroupMemberRepository.find.mockResolvedValue([
        { groupId: 'group-1' },
        { groupId: 'group-2' },
      ]);

      const result = await service.findAll('user-1', {});

      expect(result.items).toHaveLength(1);
      expect(mockGroupMemberRepository.find).toHaveBeenCalled();
    });
  });

  describe('findOne', () => {
    it('应该成功获取排班详情', async () => {
      mockScheduleRepository.findOne.mockResolvedValue({
        ...mockSchedule,
        user: mockUser,
        group: mockGroup,
      });

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

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

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

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

  describe('update', () => {
    it('应该成功更新排班', async () => {
      mockScheduleRepository.findOne
        .mockResolvedValueOnce(mockSchedule)
        .mockResolvedValueOnce({
          ...mockSchedule,
          user: mockUser,
          group: mockGroup,
        });
      mockScheduleRepository.save.mockResolvedValue(mockSchedule);

      const result = await service.update('user-1', 'schedule-1', {
        availableSlots: mockTimeSlots,
      });

      expect(result).toHaveProperty('id');
      expect(mockScheduleRepository.save).toHaveBeenCalled();
    });

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

      await expect(
        service.update('user-1', 'schedule-1', { availableSlots: mockTimeSlots }),
      ).rejects.toThrow(NotFoundException);
    });

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

      await expect(
        service.update('user-2', 'schedule-1', { availableSlots: mockTimeSlots }),
      ).rejects.toThrow(ForbiddenException);
    });
  });

  describe('remove', () => {
    it('应该成功删除排班', async () => {
      mockScheduleRepository.findOne.mockResolvedValue(mockSchedule);
      mockScheduleRepository.remove.mockResolvedValue(mockSchedule);

      const result = await service.remove('user-1', 'schedule-1');

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

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

      await expect(service.remove('user-1', 'schedule-1')).rejects.toThrow(
        NotFoundException,
      );
    });

    it('应该在非创建者删除时抛出异常', async () => {
      mockScheduleRepository.findOne.mockResolvedValue(mockSchedule);

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

  describe('findCommonSlots', () => {
    it('应该成功查找共同空闲时间', async () => {
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockScheduleRepository.find.mockResolvedValue([
        {
          ...mockSchedule,
          userId: 'user-1',
          user: { id: 'user-1' },
        },
        {
          ...mockSchedule,
          id: 'schedule-2',
          userId: 'user-2',
          user: { id: 'user-2' },
          availableSlots: [
            {
              startTime: new Date('2024-01-20T19:30:00Z'),
              endTime: new Date('2024-01-20T22:00:00Z'),
            },
          ],
        },
      ]);

      const result = await service.findCommonSlots('user-1', {
        groupId: 'group-1',
        startTime: new Date('2024-01-20T00:00:00Z'),
        endTime: new Date('2024-01-22T00:00:00Z'),
        minParticipants: 2,
      });

      expect(result).toHaveProperty('commonSlots');
      expect(result).toHaveProperty('totalParticipants');
      expect(result.totalParticipants).toBe(2);
    });

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

      await expect(
        service.findCommonSlots('user-1', {
          groupId: 'group-1',
          startTime: new Date('2024-01-20T00:00:00Z'),
          endTime: new Date('2024-01-22T00:00:00Z'),
        }),
      ).rejects.toThrow(ForbiddenException);
    });

    it('应该在没有排班数据时返回空结果', async () => {
      mockGroupMemberRepository.findOne.mockResolvedValue(mockMembership);
      mockScheduleRepository.find.mockResolvedValue([]);

      const result = await service.findCommonSlots('user-1', {
        groupId: 'group-1',
        startTime: new Date('2024-01-20T00:00:00Z'),
        endTime: new Date('2024-01-22T00:00:00Z'),
      });

      expect(result.commonSlots).toEqual([]);
      expect(result.message).toBe('暂无排班数据');
    });
  });
});