初始化游戏小组管理系统后端项目

- 基于 NestJS + TypeScript + MySQL + Redis 架构
- 完整的模块化设计(认证、用户、小组、游戏、预约等)
- JWT 认证和 RBAC 权限控制系统
- Docker 容器化部署支持
- 添加 CLAUDE.md 项目开发指南
- 配置 .gitignore 忽略文件

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
UGREEN USER
2026-01-28 10:42:06 +08:00
commit b25aa5b143
134 changed files with 30536 additions and 0 deletions

View File

@@ -0,0 +1,394 @@
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('暂无排班数据');
});
});
});