263 lines
7.1 KiB
TypeScript
263 lines
7.1 KiB
TypeScript
import mongoose from 'mongoose';
|
|
import { AuctionService } from './auction.service';
|
|
|
|
describe('AuctionService', () => {
|
|
function createService(models: Record<string, unknown>) {
|
|
const connectionService = {
|
|
getModel: jest.fn((name: string) => models[name]),
|
|
createSession: jest.fn(),
|
|
};
|
|
const enrichmentService = {
|
|
enrichRiotAccount: jest.fn(),
|
|
};
|
|
const tournamentCodeService = {
|
|
reserveForMatch: jest.fn().mockResolvedValue(undefined),
|
|
releaseFromMatch: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const tournamentResultService = {
|
|
scheduleInitialPoll: jest.fn().mockResolvedValue(null),
|
|
};
|
|
|
|
return {
|
|
service: new AuctionService(
|
|
connectionService as never,
|
|
enrichmentService as never,
|
|
tournamentCodeService as never,
|
|
tournamentResultService as never,
|
|
),
|
|
connectionService,
|
|
tournamentCodeService,
|
|
tournamentResultService,
|
|
};
|
|
}
|
|
|
|
function createFullTeam(side: 'blue' | 'red') {
|
|
return {
|
|
side,
|
|
captainUserId: new mongoose.Types.ObjectId(),
|
|
points: 100,
|
|
members: Array.from({ length: 4 }, () => ({
|
|
userId: new mongoose.Types.ObjectId(),
|
|
assignedPosition: 'MID',
|
|
cost: 10,
|
|
})),
|
|
};
|
|
}
|
|
|
|
it('rejects bids when the team already has 5 members including captain', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const auction = {
|
|
phase: 'bidding',
|
|
teams: [createFullTeam('blue'), createFullTeam('red')],
|
|
currentBid: 10,
|
|
save: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const { service } = createService({
|
|
auction: {
|
|
findOne: jest.fn().mockResolvedValue(auction),
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
service.placeBid({
|
|
matchId,
|
|
side: 'blue',
|
|
amount: 20,
|
|
}),
|
|
).rejects.toThrow('Team already has maximum members.');
|
|
expect(auction.save).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('rejects sold confirmation when the winning team is already full', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const auction = {
|
|
phase: 'bidding',
|
|
currentBidder: 'blue',
|
|
currentBid: 20,
|
|
currentIndex: 0,
|
|
order: [
|
|
{
|
|
userId: new mongoose.Types.ObjectId(),
|
|
preferredPositions: [{ position: 'ADC', priority: 1 }],
|
|
},
|
|
],
|
|
teams: [createFullTeam('blue'), createFullTeam('red')],
|
|
save: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const { service } = createService({
|
|
auction: {
|
|
findOne: jest.fn().mockResolvedValue(auction),
|
|
},
|
|
});
|
|
|
|
await expect(service.markSold({ matchId })).rejects.toThrow(
|
|
'Team already has maximum members.',
|
|
);
|
|
expect(auction.save).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('syncs completed auction teams into the match document', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const blueCaptainId = new mongoose.Types.ObjectId();
|
|
const redCaptainId = new mongoose.Types.ObjectId();
|
|
const blueMemberId = new mongoose.Types.ObjectId();
|
|
const redMemberId = new mongoose.Types.ObjectId();
|
|
|
|
const auction = {
|
|
matchId,
|
|
phase: 'sold',
|
|
currentIndex: 1,
|
|
order: [{ userId: blueMemberId }, { userId: redMemberId }],
|
|
teams: [
|
|
{
|
|
side: 'blue',
|
|
captainUserId: blueCaptainId,
|
|
points: 970,
|
|
members: [
|
|
{
|
|
userId: blueMemberId,
|
|
assignedPosition: 'ADC',
|
|
cost: 30,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
side: 'red',
|
|
captainUserId: redCaptainId,
|
|
points: 940,
|
|
members: [
|
|
{
|
|
userId: redMemberId,
|
|
assignedPosition: 'JGL',
|
|
cost: 60,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
save: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const match = {
|
|
participants: [
|
|
{
|
|
userId: blueCaptainId,
|
|
preferredPositions: [{ position: 'TOP', priority: 1 }],
|
|
},
|
|
{
|
|
userId: redCaptainId,
|
|
preferredPositions: [{ position: 'MID', priority: 1 }],
|
|
},
|
|
{
|
|
userId: blueMemberId,
|
|
preferredPositions: [{ position: 'ADC', priority: 1 }],
|
|
},
|
|
{
|
|
userId: redMemberId,
|
|
preferredPositions: [{ position: 'JGL', priority: 1 }],
|
|
},
|
|
],
|
|
status: 'team-built',
|
|
teams: [],
|
|
save: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const { service } = createService({
|
|
auction: {
|
|
findOne: jest.fn().mockResolvedValue(auction),
|
|
},
|
|
match: {
|
|
findById: jest.fn().mockResolvedValue(match),
|
|
},
|
|
});
|
|
|
|
await service.next(matchId);
|
|
|
|
expect(auction.phase).toBe('complete');
|
|
expect(auction.completedAt).toBeInstanceOf(Date);
|
|
expect(auction.save).toHaveBeenCalledTimes(1);
|
|
expect(match.save).toHaveBeenCalledTimes(1);
|
|
expect(match.teams).toEqual([
|
|
{
|
|
side: 'blue',
|
|
name: '블루팀',
|
|
captainUserId: blueCaptainId,
|
|
members: [
|
|
{
|
|
userId: blueCaptainId,
|
|
assignedPosition: 'TOP',
|
|
cost: 0,
|
|
},
|
|
{
|
|
userId: blueMemberId,
|
|
assignedPosition: 'ADC',
|
|
cost: 30,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
side: 'red',
|
|
name: '레드팀',
|
|
captainUserId: redCaptainId,
|
|
members: [
|
|
{
|
|
userId: redCaptainId,
|
|
assignedPosition: 'MID',
|
|
cost: 0,
|
|
},
|
|
{
|
|
userId: redMemberId,
|
|
assignedPosition: 'JGL',
|
|
cost: 60,
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('clears match teams when resetting an auction', async () => {
|
|
const matchId = new mongoose.Types.ObjectId();
|
|
const communityId = new mongoose.Types.ObjectId();
|
|
const session = {
|
|
startTransaction: jest.fn(),
|
|
commitTransaction: jest.fn().mockResolvedValue(undefined),
|
|
abortTransaction: jest.fn().mockResolvedValue(undefined),
|
|
endSession: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const auction = {
|
|
deleteOne: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const match = {
|
|
communityId,
|
|
status: 'team-built',
|
|
teams: [
|
|
{
|
|
side: 'blue',
|
|
name: '블루팀',
|
|
members: [],
|
|
},
|
|
],
|
|
save: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const auctionFindOneQuery = {
|
|
session: jest.fn().mockResolvedValue(auction),
|
|
};
|
|
const matchFindByIdQuery = {
|
|
session: jest.fn().mockResolvedValue(match),
|
|
};
|
|
const { service, connectionService } = createService({
|
|
auction: {
|
|
findOne: jest.fn().mockReturnValue(auctionFindOneQuery),
|
|
},
|
|
match: {
|
|
findById: jest.fn().mockReturnValue(matchFindByIdQuery),
|
|
},
|
|
});
|
|
connectionService.createSession.mockResolvedValue(session);
|
|
|
|
await service.reset({ matchId, communityId });
|
|
|
|
expect(match.status).toBe('recruiting');
|
|
expect(match.teams).toEqual([]);
|
|
expect(match.save).toHaveBeenCalledWith({ session });
|
|
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
|
|
});
|
|
});
|