feat(api): implement auction workflows

This commit is contained in:
dahyeon committed 2026-04-16 03:28:00 +09:00
1 parent b62a3d5edb
commit 7c4e968c5d
6 files changed
+1267

No files matched your search

@@ -0,0 +1,262 @@
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);
});
});