import mongoose from 'mongoose'; import { AuctionService } from './auction.service'; describe('AuctionService', () => { function createService(models: Record) { const auctionHistoryModel = { findOne: jest.fn().mockReturnValue({ sort: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue(null), }), }), }), }), create: jest.fn().mockResolvedValue(undefined), deleteMany: jest.fn().mockReturnValue({ session: jest.fn().mockResolvedValue(undefined), }), }; const allModels = { auctionHistory: auctionHistoryModel, ...models, }; const connectionService = { getModel: jest.fn((name: string) => allModels[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), cancelPolling: jest.fn().mockResolvedValue(undefined), }; const auctionRedisService = { acquireTokenLock: jest.fn().mockResolvedValue(true), getCurrentRedisTimestampMS: jest.fn().mockResolvedValue(1780000000000), releaseTokenLock: jest.fn().mockResolvedValue(true), raw: jest.fn().mockReturnValue({ sendCommand: jest.fn().mockResolvedValue(1), }), }; const auctionRedisCommandService = { applyTransition: jest.fn().mockResolvedValue({ auctionStateTransitionId: 'transition-1', currentServerTimestampMS: 1780000000000, ok: true, revision: 2, }), reserveActionRequest: jest.fn().mockImplementation( async ( _matchId: string, input: { auctionActionRequestId: string; auctionStateTransitionId: string; clientObservedAuctionLifecycleId: string; }, ) => ({ actionRequestScopeKey: `${input.clientObservedAuctionLifecycleId}:${input.auctionActionRequestId}`, auctionStateTransitionId: input.auctionStateTransitionId, currentServerTimestampMS: 1780000000000, newAuctionLifecycleId: '', observedProcessingLeaseVersion: 1, reserved: true, wasLeaseExpired: false, }), ), hydrateState: jest.fn().mockResolvedValue({ currentServerTimestampMS: 1780000000000, hydrated: true, revision: 1, }), placeBid: jest.fn().mockResolvedValue({ auctionBidHistoryEntry: { bidPointAmount: 20 }, bidRequestId: 'bid-1', currentBidRoundDeadlineTimestampMS: 1780000030000, currentHighestBidderTeamIndex: 1, currentHighestBidPointAmount: 20, currentServerTimestampMS: 1780000000000, ok: true, revision: 3, }), }; const auctionRedisStateReaderService = { readLiveStateIdentity: jest.fn().mockResolvedValue({ auctionLifecycleId: 'life-1', revision: 1, }), readBidContext: jest.fn().mockResolvedValue(null), readAuctionStateView: jest.fn().mockResolvedValue(null), }; return { service: new AuctionService( connectionService as never, enrichmentService as never, tournamentCodeService as never, tournamentResultService as never, auctionRedisService as never, auctionRedisCommandService as never, auctionRedisStateReaderService as never, ), connectionService, tournamentCodeService, tournamentResultService, auctionHistoryModel, auctionRedisCommandService, auctionRedisService, auctionRedisStateReaderService, }; } function createFullTeam(teamIndex: number) { return { teamIndex, captainUserId: new mongoose.Types.ObjectId(), points: 100, members: Array.from({ length: 4 }, () => ({ userId: new mongoose.Types.ObjectId(), assignedPosition: 'MID', cost: 10, })), }; } afterEach(() => { jest.restoreAllMocks(); jest.useRealTimers(); }); it('rejects live operations for migrated legacy auctions', async () => { const matchId = new mongoose.Types.ObjectId(); const auction = { auctionEngineVersion: 'legacy-renamed', matchId, phase: 'bidding', }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await expect( service.placeBid({ amount: 10, matchId, teamIndex: 1, }), ).rejects.toThrow('Legacy auction live operations are not supported.'); }); it('rejects non-positive or fractional bid amounts before loading auction state', async () => { const matchId = new mongoose.Types.ObjectId(); const auctionFindOne = jest.fn(); const { service, auctionRedisCommandService, auctionRedisService } = createService({ auction: { findOne: auctionFindOne, }, }); await expect( service.placeBid({ amount: 0, matchId, teamIndex: 1, }), ).rejects.toThrow('Bid amount must be a positive integer.'); await expect( service.placeBid({ amount: 10.5, matchId, teamIndex: 1, }), ).rejects.toThrow('Bid amount must be a positive integer.'); expect(auctionFindOne).not.toHaveBeenCalled(); expect(auctionRedisCommandService.placeBid).not.toHaveBeenCalled(); }); it('starts an auction without reserving tournament codes before teams are complete', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const userIds = Array.from( { length: 10 }, () => new mongoose.Types.ObjectId(), ); const participants = userIds.map((userId, index) => ({ userId, preferredPositions: [{ position: 'MID', priority: 1 }], joinedAt: new Date(index), excluded: false, })); const match = { _id: matchId, communityId, participants, status: 'recruiting', teamBuiltAt: undefined, save: jest.fn().mockResolvedValue(undefined), }; const users = userIds.slice(2).map((userId, index) => ({ _id: userId, riotAccounts: [ { puuid: `puuid-${index}`, gameName: `Player${index}`, tagLine: 'KR1', profileIconId: index, tiers: [], championMasteries: [], recentStatsSummary: undefined, lastRefreshRequestedAt: new Date(), isPrimary: true, }, ], })); const auction = { _id: new mongoose.Types.ObjectId(), matchId, toObject: jest.fn().mockReturnValue({ matchId }), }; const { service, tournamentCodeService, tournamentResultService } = createService({ match: { findById: jest.fn().mockResolvedValue(match), }, user: { find: jest.fn().mockResolvedValue(users), }, auction: { findOne: jest.fn().mockResolvedValue(null), create: jest.fn().mockResolvedValue(auction), }, community: { findById: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ riotPlatform: 'kr', riotRegion: 'asia', }), }), }), }), }, }); await service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000001', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }); expect(match.status).toBe('team-built'); expect(match.teamBuiltAt).toBeInstanceOf(Date); expect(match.save).toHaveBeenCalledTimes(1); expect(tournamentCodeService.reserveForMatch).not.toHaveBeenCalled(); expect(tournamentResultService.scheduleInitialPoll).not.toHaveBeenCalled(); }); it('creates redis-v1 auction fields and bootstraps Redis state when starting', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const userIds = Array.from( { length: 10 }, () => new mongoose.Types.ObjectId(), ); const participants = userIds.map((userId, index) => ({ userId, preferredPositions: [{ position: 'MID', priority: 1 }], joinedAt: new Date(index), excluded: false, })); const match = { _id: matchId, communityId, participants, status: 'recruiting', teamBuiltAt: undefined, save: jest.fn().mockResolvedValue(undefined), }; const users = userIds.slice(2).map((userId, index) => ({ _id: userId, riotAccounts: [ { puuid: `puuid-${index}`, gameName: `Player${index}`, tagLine: 'KR1', profileIconId: index, tiers: [], championMasteries: [], recentStatsSummary: undefined, lastRefreshRequestedAt: new Date(), isPrimary: true, }, ], })); const auctionCreate = jest.fn().mockImplementation(async (payload) => ({ _id: payload._id, matchId, ...payload, toObject: jest.fn().mockReturnValue({ matchId, ...payload }), })); const { service, auctionRedisCommandService, auctionRedisService } = createService({ match: { findById: jest.fn().mockResolvedValue(match), }, user: { find: jest.fn().mockResolvedValue(users), }, auction: { findOne: jest.fn().mockResolvedValue(null), create: auctionCreate, }, community: { findById: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ riotPlatform: 'kr', riotRegion: 'asia', }), }), }), }), }, }); await service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000011', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1], initialTeamBidPointAmount: 1200, }, ], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }); const createdPayload = auctionCreate.mock.calls[0][0]; expect(auctionRedisService.getCurrentRedisTimestampMS).toHaveBeenCalled(); expect(createdPayload).toMatchObject({ auctionEngineVersion: 'redis-v1', currentAuctionHistorySequence: 1, currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, currentHighestBidPointAmount: 0, initialTeamBidPointAmount: 1000, matchSideEffectRevision: 0, matchSideEffectStatus: 'none', phase: 'presenting', revision: 1, }); expect(createdPayload.auctionTeams).toEqual([ expect.objectContaining({ remainingBidPointAmount: 1000, teamIndex: 1, }), expect.objectContaining({ remainingBidPointAmount: 1200, teamIndex: 2, }), ]); expect(createdPayload.auctionStartedAtTimestampMS).toBe(1780000000000); expect(createdPayload.startedAt).toEqual(new Date(1780000000000)); expect(auctionRedisCommandService.hydrateState).toHaveBeenCalledWith( matchId.toString(), expect.objectContaining({ auctionHistorySequence: 1, maximumBidRoundDurationSeconds: 30, matchId: matchId.toString(), phase: 'presenting', revision: 0, }), ); }); it('replays start when the same startAuctionRequestId already created the auction', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const existingAuction = { _id: new mongoose.Types.ObjectId(), matchId, startAuctionRequestId: '00000000-0000-4000-8000-000000000010', }; const auctionCreate = jest.fn(); const { service } = createService({ match: { findById: jest.fn().mockResolvedValue({ _id: matchId, communityId, }), }, user: { find: jest.fn(), }, auction: { findOne: jest.fn().mockResolvedValue(existingAuction), create: auctionCreate, }, community: { findById: jest.fn(), }, }); await expect( service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000010', captains: [], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }), ).resolves.toBe(existingAuction); expect(auctionCreate).not.toHaveBeenCalled(); }); it('rejects start while a redis reset side effect is still applying', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const existingAuction = { _id: new mongoose.Types.ObjectId(), auctionEngineVersion: 'redis-v1', matchSideEffectStatus: 'pending', phase: 'waiting', startAuctionRequestId: '00000000-0000-4000-8000-000000000020', }; const auctionCreate = jest.fn(); const { service } = createService({ match: { findById: jest.fn().mockResolvedValue({ _id: matchId, communityId, }), }, user: { find: jest.fn(), }, auction: { findOne: jest.fn().mockResolvedValue(existingAuction), create: auctionCreate, }, community: { findById: jest.fn(), }, }); await expect( service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000021', captains: [], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }), ).rejects.toThrow('Auction reset is still being applied.'); expect(auctionCreate).not.toHaveBeenCalled(); }); it('removes a completed redis reset auction before starting again', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const oldAuctionId = new mongoose.Types.ObjectId(); const userIds = Array.from( { length: 10 }, () => new mongoose.Types.ObjectId(), ); const participants = userIds.map((userId, index) => ({ userId, preferredPositions: [{ position: 'MID', priority: 1 }], joinedAt: new Date(index), excluded: false, })); const users = userIds.slice(2).map((userId, index) => ({ _id: userId, riotAccounts: [ { puuid: `puuid-${index}`, gameName: `Player${index}`, tagLine: 'KR1', profileIconId: index, tiers: [], championMasteries: [], recentStatsSummary: undefined, lastRefreshRequestedAt: new Date(), isPrimary: true, }, ], })); const existingAuction = { _id: oldAuctionId, auctionEngineVersion: 'redis-v1', auctionLifecycleId: 'old-life-1', matchSideEffectStatus: 'completed', phase: 'waiting', startAuctionRequestId: '00000000-0000-4000-8000-000000000022', }; const match = { _id: matchId, communityId, participants, status: 'recruiting', teamBuiltAt: undefined, save: jest.fn().mockResolvedValue(undefined), }; const auctionCreate = jest.fn().mockImplementation(async (payload) => ({ _id: payload._id, matchId, ...payload, toObject: jest.fn().mockReturnValue({ matchId, ...payload }), })); const auctionDeleteOne = jest.fn().mockResolvedValue({ deletedCount: 1 }); const historyDeleteMany = jest.fn().mockResolvedValue({ deletedCount: 2 }); const { service, auctionRedisCommandService, auctionRedisService } = createService({ match: { findById: jest.fn().mockResolvedValue(match), }, user: { find: jest.fn().mockResolvedValue(users), }, auction: { create: auctionCreate, deleteOne: auctionDeleteOne, findOne: jest.fn().mockResolvedValue(existingAuction), }, auctionHistory: { create: jest.fn().mockResolvedValue(undefined), deleteMany: historyDeleteMany, findOne: jest.fn().mockReturnValue({ sort: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue(null), }), }), }), }), }, community: { findById: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ riotPlatform: 'kr', riotRegion: 'asia', }), }), }), }), }, }); await service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000023', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }); expect(historyDeleteMany).toHaveBeenCalledWith({ auctionId: oldAuctionId }); expect(auctionDeleteOne).toHaveBeenCalledWith({ _id: oldAuctionId }); expect(auctionRedisService.raw().sendCommand).toHaveBeenCalledWith([ 'EVAL', expect.stringContaining('currentAuctionLifecycleId'), '11', `auction:${matchId.toString()}:liveAuctionState`, 'auction:bidRoundDeadlineQueue', `auction:${matchId.toString()}:auctionStructureState`, `auction:${matchId.toString()}:appliedAuctionStateTransitionIds`, `auction:${matchId.toString()}:auctionBidHistory`, `auction:${matchId.toString()}:bidRequestResults`, `auction:${matchId.toString()}:bidRequestResultOrder`, `auction:${matchId.toString()}:auctionActionRequestResults`, `auction:${matchId.toString()}:auctionActionRequestResultOrder`, `auction:${matchId.toString()}:rehydrateLock`, `auction:${matchId.toString()}:auctionStateTransitionLock`, matchId.toString(), 'old-life-1', ]); expect(auctionCreate).toHaveBeenCalledTimes(1); expect(auctionRedisCommandService.hydrateState).toHaveBeenCalled(); }); it('replays start after a concurrent create wins with the same request id', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const userIds = Array.from( { length: 10 }, () => new mongoose.Types.ObjectId(), ); const participants = userIds.map((userId, index) => ({ userId, preferredPositions: [{ position: 'MID', priority: 1 }], joinedAt: new Date(index), excluded: false, })); const users = userIds.slice(2).map((userId, index) => ({ _id: userId, riotAccounts: [ { puuid: `puuid-${index}`, gameName: `Player${index}`, tagLine: 'KR1', profileIconId: index, tiers: [], championMasteries: [], recentStatsSummary: undefined, lastRefreshRequestedAt: new Date(), isPrimary: true, }, ], })); const raceWinner = { _id: new mongoose.Types.ObjectId(), matchId, startAuctionRequestId: '00000000-0000-4000-8000-000000000012', }; const match = { _id: matchId, communityId, participants, status: 'recruiting', save: jest.fn().mockResolvedValue(undefined), }; const auctionFindOne = jest .fn() .mockResolvedValueOnce(null) .mockResolvedValueOnce(raceWinner); const auctionCreate = jest.fn().mockRejectedValue({ code: 11000 }); const { service, auctionRedisCommandService } = createService({ match: { findById: jest.fn().mockResolvedValue(match), }, user: { find: jest.fn().mockResolvedValue(users), }, auction: { findOne: auctionFindOne, create: auctionCreate, }, community: { findById: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ riotPlatform: 'kr', riotRegion: 'asia', }), }), }), }), }, }); await expect( service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000012', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }), ).resolves.toBe(raceWinner); expect(auctionCreate).toHaveBeenCalledTimes(1); expect(auctionRedisCommandService.hydrateState).not.toHaveBeenCalled(); expect(match.save).not.toHaveBeenCalled(); }); it('reads Redis state view for redis-v1 auctions', async () => { const matchId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, auctionEngineVersion: 'redis-v1', chatMessages: [{ id: 'chat-1' }], toObject: jest.fn().mockReturnValue({ matchId, phase: 'presenting', revision: 1, }), }; const { service, auctionRedisStateReaderService } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue({ phase: 'bidding', revision: 2, currentServerTimestampMS: 1000, }); await expect(service.getStateByMatchId(matchId)).resolves.toMatchObject({ chatMessages: [{ id: 'chat-1' }], currentServerTimestampMS: 1000, phase: 'bidding', revision: 2, }); expect( auctionRedisStateReaderService.readAuctionStateView, ).toHaveBeenCalledWith(matchId.toString()); }); it('rehydrates Redis state from Mongo projection when live state is missing', async () => { const matchId = new mongoose.Types.ObjectId(); const playerUserId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, auctionEngineVersion: 'redis-v1', auctionLifecycleId: 'life-1', phase: 'presenting', revision: 4, currentAuctionHistorySequence: 3, auctionTeams: [ { teamIndex: 1, captainUserId: captainUserId.toString(), remainingBidPointAmount: 1000, members: [], }, ], auctionPlayerOrder: [{ userId: playerUserId.toString() }], passedAuctionPlayerQueue: [], currentAuctionRound: 1, currentAuctionPlayerOrderIndex: 0, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, initialTeamBidPointAmount: 1000, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], chatMessages: [], toObject: jest.fn().mockReturnValue({ matchId, phase: 'presenting', revision: 4, }), }; const redisState = { auctionLifecycleId: 'life-1', phase: 'presenting', revision: 5, shouldForceAuctionStateResync: true, }; const { service, auctionRedisCommandService, auctionRedisService, auctionRedisStateReaderService, } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); auctionRedisStateReaderService.readLiveStateIdentity.mockResolvedValue(null); auctionRedisStateReaderService.readAuctionStateView.mockResolvedValue( redisState, ); await expect(service.getStateByMatchId(matchId)).resolves.toMatchObject({ phase: 'presenting', revision: 5, shouldForceAuctionStateResync: true, }); expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith( `auction:${matchId.toString()}:rehydrateLock`, expect.any(String), 5000, ); expect(auctionRedisCommandService.hydrateState).toHaveBeenCalledWith( matchId.toString(), expect.objectContaining({ auctionLifecycleId: 'life-1', phase: 'presenting', revision: 4, }), ); expect( auctionRedisStateReaderService.readAuctionStateView, ).toHaveBeenCalledWith(matchId.toString(), { shouldForceAuctionStateResync: true, }); }); it('opens bidding through Redis for redis-v1 auctions', async () => { const matchId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, auctionEngineVersion: 'redis-v1', }; const presentingState = { auctionLifecycleId: 'life-1', auctionTeams: [ { teamIndex: 1, captainUserId: new mongoose.Types.ObjectId().toString(), remainingBidPointAmount: 1000, members: [], }, ], auctionPlayerOrder: [ { userId: new mongoose.Types.ObjectId().toString(), preferredPositions: [{ position: 'MID', priority: 1 }], }, ], bidRoundExtensionSeconds: 5, currentAuctionHistorySequence: 1, currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, passedAuctionPlayerQueue: [], phase: 'presenting', revision: 1, topTierAuctionPriorityThreshold: 'NONE', }; const biddingState = { ...presentingState, currentBidRoundDeadlineTimestampMS: 1780000030000, phase: 'bidding', revision: 2, }; const { service, auctionRedisCommandService, auctionRedisStateReaderService } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); auctionRedisStateReaderService.readAuctionStateView .mockResolvedValueOnce(presentingState) .mockResolvedValueOnce(biddingState); await expect( service.openBidding(matchId, { auctionActionRequestId: '00000000-0000-4000-8000-000000000060', clientObservedAuctionLifecycleId: 'life-1', clientObservedCurrentAuctionPlayerOrderIndex: 0, clientObservedPhase: 'presenting', clientObservedRevision: 1, }), ).resolves.toMatchObject({ phase: 'bidding', revision: 2, }); expect( auctionRedisCommandService.reserveActionRequest, ).toHaveBeenCalledWith( matchId.toString(), expect.objectContaining({ auctionActionRequestId: '00000000-0000-4000-8000-000000000060', auctionActionType: 'open-bidding', auctionStateTransitionId: 'open-bidding:life-1:00000000-0000-4000-8000-000000000060', clientObservedAuctionLifecycleId: 'life-1', clientObservedCurrentAuctionPlayerOrderIndex: 0, clientObservedPhase: 'presenting', clientObservedRevision: 1, }), ); expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledWith( matchId.toString(), expect.objectContaining({ actionRequest: expect.objectContaining({ observedProcessingLeaseVersion: 1, scopeKey: 'life-1:00000000-0000-4000-8000-000000000060', }), auctionStateTransitionId: 'open-bidding:life-1:00000000-0000-4000-8000-000000000060', deadline: { durationSeconds: 30, mode: 'set-relative' }, expectedPhase: 'presenting', expectedRevision: 1, liveStatePatch: expect.objectContaining({ currentHighestBidPointAmount: 0, currentHighestBidderTeamIndex: -1, phase: 'bidding', 'team:1:assignedAuctionTeamMemberCount': 1, 'team:1:remainingBidPointAmount': 1000, }), }), ); const transitionInput = auctionRedisCommandService.applyTransition.mock.calls[0][1]; expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({ afterAuctionMongoProjection: expect.objectContaining({ phase: 'bidding', revision: 2, }), auctionActionType: 'open-bidding', historyMutation: { type: 'append' }, matchSideEffectMutation: { type: 'none' }, snapshotBefore: expect.objectContaining({ phase: 'presenting', }), }); }); it('places bids through Redis for redis-v1 auctions', async () => { const matchId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const playerUserId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, auctionEngineVersion: 'redis-v1', }; const biddingState = { auctionLifecycleId: 'life-1', auctionTeams: [ { teamIndex: 1, captainUserId: captainUserId.toString(), remainingBidPointAmount: 1000, members: [], }, ], currentBidRoundPlayerUserId: playerUserId.toString(), phase: 'bidding', revision: 2, }; const afterBidState = { ...biddingState, currentHighestBidderTeamIndex: 1, currentHighestBidPointAmount: 120, revision: 3, }; const { service, auctionRedisCommandService, auctionRedisStateReaderService } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); auctionRedisStateReaderService.readAuctionStateView .mockResolvedValueOnce(biddingState) .mockResolvedValueOnce(afterBidState); await expect( service.placeBid({ amount: 120, bidRequestId: '00000000-0000-4000-8000-000000000050', matchId, teamIndex: 1, }), ).resolves.toMatchObject({ currentHighestBidderTeamIndex: 1, currentHighestBidPointAmount: 120, revision: 3, }); expect(auctionRedisCommandService.placeBid).toHaveBeenCalledWith( matchId.toString(), expect.objectContaining({ bidPointAmount: 120, bidderTeamIndex: 1, bidderUserId: captainUserId.toString(), clientObservedAuctionLifecycleId: 'life-1', clientObservedCurrentBidRoundPlayerUserId: playerUserId.toString(), }), ); }); it('returns bid deltas without re-reading the full Redis state', async () => { const matchId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const playerUserId = new mongoose.Types.ObjectId(); const biddingContext = { auctionLifecycleId: 'life-1', bidderTeamCaptainUserId: captainUserId.toString(), currentBidRoundPlayerUserId: playerUserId.toString(), phase: 'bidding', }; const auctionBidHistoryEntry = { bidderTeamIndex: 1, bidderUserId: captainUserId.toString(), bidPlacedAtTimestampMS: 1780000000000, bidPointAmount: 120, }; const { connectionService, service, auctionRedisCommandService, auctionRedisStateReaderService, } = createService({}); auctionRedisStateReaderService.readBidContext.mockResolvedValueOnce( biddingContext, ); auctionRedisCommandService.placeBid.mockResolvedValueOnce({ auctionBidHistoryEntry, bidRequestId: '00000000-0000-4000-8000-000000000050', currentBidRoundDeadlineTimestampMS: 1780000030000, currentHighestBidderTeamIndex: 1, currentHighestBidPointAmount: 120, currentServerTimestampMS: 1780000000000, ok: true, revision: 3, }); await expect( service.placeBidDelta({ amount: 120, bidRequestId: '00000000-0000-4000-8000-000000000050', matchId, teamIndex: 1, }), ).resolves.toEqual( expect.objectContaining({ auctionBidHistoryEntry, auctionLifecycleId: 'life-1', bidRequestId: '00000000-0000-4000-8000-000000000050', bidServerTiming: expect.objectContaining({ redisBidCommandDurationMS: expect.any(Number), redisBidContextReadDurationMS: expect.any(Number), serviceTotalDurationMS: expect.any(Number), }), currentBidRoundDeadlineTimestampMS: 1780000030000, currentHighestBidderTeamIndex: 1, currentHighestBidPointAmount: 120, currentServerTimestampMS: 1780000000000, revision: 3, }), ); expect( auctionRedisStateReaderService.readAuctionStateView, ).not.toHaveBeenCalled(); expect(connectionService.getModel).not.toHaveBeenCalledWith('auction'); }); it('includes redis bid diagnostics and timing on realtime bid rejection', async () => { const matchId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const playerUserId = new mongoose.Types.ObjectId(); const { service, auctionRedisCommandService, auctionRedisStateReaderService, } = createService({}); auctionRedisStateReaderService.readBidContext.mockResolvedValueOnce({ auctionLifecycleId: 'life-1', bidderTeamCaptainUserId: captainUserId.toString(), currentBidRoundPlayerUserId: playerUserId.toString(), phase: 'bidding', }); auctionRedisCommandService.placeBid.mockResolvedValueOnce({ bidRequestId: 'bid-1', code: 'EXPIRED', currentBidRoundDeadlineTimestampMS: 1780000002500, currentServerTimestampMS: 1780000003000, rejected: true, }); try { await service.placeBidDelta({ amount: 120, bidRequestId: 'bid-1', matchId, teamIndex: 1, }); throw new Error('Expected bid rejection.'); } catch (error) { const response = (error as { getResponse: () => unknown }).getResponse(); expect(response).toEqual( expect.objectContaining({ bidDiagnostics: { currentBidRoundDeadlineTimestampMS: 1780000002500, currentServerTimestampMS: 1780000003000, }, bidServerTiming: expect.objectContaining({ redisBidCommandDurationMS: expect.any(Number), redisBidContextReadDurationMS: expect.any(Number), serviceTotalDurationMS: expect.any(Number), }), code: 'EXPIRED', message: 'Bid deadline has already expired.', }), ); } }); it('syncs match teams when a redis-v1 auction completes', async () => { const matchId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const memberUserId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, auctionEngineVersion: 'redis-v1', }; const soldState = { auctionLifecycleId: 'life-1', auctionTeams: [ { teamIndex: 1, captainUserId: captainUserId.toString(), remainingBidPointAmount: 970, members: [ { userId: memberUserId.toString(), assignedPosition: 'ADC', memberAcquisitionBidPointAmount: 30, }, ], }, ], auctionPlayerOrder: [{ userId: memberUserId.toString() }], bidRoundExtensionSeconds: 5, currentAuctionHistorySequence: 2, currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, passedAuctionPlayerQueue: [], phase: 'sold', revision: 3, topTierAuctionPriorityThreshold: 'NONE', }; const completeState = { ...soldState, auctionCompletedAtTimestampMS: 1780000100000, phase: 'complete', revision: 4, }; const match = { participants: [ { userId: captainUserId, preferredPositions: [{ position: 'TOP', priority: 1 }], }, { userId: memberUserId, preferredPositions: [{ position: 'ADC', priority: 1 }], }, ], status: 'team-built', teams: [], teamBuiltAt: undefined, save: jest.fn().mockResolvedValue(undefined), }; const { service, auctionRedisCommandService, auctionRedisStateReaderService, tournamentCodeService, tournamentResultService, } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, match: { findById: jest.fn().mockResolvedValue(match), }, }); auctionRedisStateReaderService.readAuctionStateView .mockResolvedValueOnce(soldState) .mockResolvedValueOnce(completeState); await expect(service.next(matchId)).resolves.toMatchObject({ phase: 'complete', revision: 4, }); const [, transitionInput] = auctionRedisCommandService.applyTransition.mock.calls.at(-1) ?? []; expect(JSON.parse(transitionInput.durabilityPayloadJson)).toMatchObject({ afterAuctionMongoProjection: { matchSideEffectStatus: 'pending', phase: 'complete', }, auctionActionType: 'complete', matchSideEffectMutation: { type: 'syncMatchTeamsAfterComplete' }, }); expect(match.teams).toEqual([]); expect(match.save).not.toHaveBeenCalled(); expect(tournamentCodeService.reserveForMatch).not.toHaveBeenCalled(); expect(tournamentResultService.scheduleInitialPoll).not.toHaveBeenCalled(); }); it('appends a chat message and keeps only the latest 200 messages', async () => { const matchId = new mongoose.Types.ObjectId(); const userId = new mongoose.Types.ObjectId(); const oldMessages = Array.from({ length: 200 }, (_, index) => ({ id: `old-${index}`, displayName: 'Old', message: `old message ${index}`, sentAt: new Date(index), })); const auction = { matchId, chatMessages: oldMessages, save: jest.fn().mockResolvedValue(undefined), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); const appended = await service.appendChatMessage({ matchId, userId, displayName: ' Captain One ', message: ' 좋은 픽입니다 ', }); expect(appended.message).toMatchObject({ userId, displayName: 'Captain One', message: '좋은 픽입니다', }); expect(appended.message.id).toHaveLength(36); expect(appended.message.sentAt).toBeInstanceOf(Date); expect(auction.chatMessages).toHaveLength(200); expect(auction.chatMessages[0].id).toBe('old-1'); expect(auction.chatMessages.at(-1)).toBe(appended.message); expect(auction.save).toHaveBeenCalledTimes(1); }); it('rejects blank and overly long chat messages', async () => { const matchId = new mongoose.Types.ObjectId(); const auction = { matchId, chatMessages: [], save: jest.fn().mockResolvedValue(undefined), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await expect( service.appendChatMessage({ matchId, displayName: 'Spectator', message: ' ', }), ).rejects.toThrow('Chat message is required.'); await expect( service.appendChatMessage({ matchId, displayName: 'Spectator', message: 'a'.repeat(301), }), ).rejects.toThrow('Chat message must be 300 characters or less.'); expect(auction.save).not.toHaveBeenCalled(); }); it('randomizes the non-captain player order when starting an auction', async () => { const randomSpy = jest.spyOn(Math, 'random').mockReturnValue(0); const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const userIds = Array.from( { length: 10 }, () => new mongoose.Types.ObjectId(), ); const participants = userIds.map((userId, index) => ({ userId, preferredPositions: [{ position: 'MID', priority: 1 }], joinedAt: new Date(index), excluded: false, })); const match = { _id: matchId, communityId, participants, status: 'recruiting', teamBuiltAt: undefined, save: jest.fn().mockResolvedValue(undefined), }; const users = userIds.slice(2).map((userId, index) => ({ _id: userId, riotAccounts: [ { puuid: `puuid-${index}`, gameName: `Player${index}`, tagLine: 'KR1', profileIconId: index, tiers: [], championMasteries: [], recentStatsSummary: undefined, lastRefreshRequestedAt: new Date(), isPrimary: true, }, ], })); const auctionCreate = jest.fn().mockImplementation(async (payload) => ({ _id: new mongoose.Types.ObjectId(), matchId, toObject: jest.fn().mockReturnValue({ matchId, ...payload }), })); const { service } = createService({ match: { findById: jest.fn().mockResolvedValue(match), }, user: { find: jest.fn().mockResolvedValue(users), }, auction: { findOne: jest.fn().mockResolvedValue(null), create: auctionCreate, }, community: { findById: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ riotPlatform: 'kr', riotRegion: 'asia', }), }), }), }), }, }); await service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000002', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }); const signupOrder = userIds.slice(2).map((userId) => userId.toString()); const auctionOrder = auctionCreate.mock.calls[0][0].order.map( (player: { userId: mongoose.Types.ObjectId }) => player.userId.toString(), ); expect(auctionOrder).not.toEqual(signupOrder); expect([...auctionOrder].sort()).toEqual([...signupOrder].sort()); expect(randomSpy).toHaveBeenCalled(); }); it('includes tier history in auction player snapshots when starting an auction', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const userIds = Array.from( { length: 10 }, () => new mongoose.Types.ObjectId(), ); const participants = userIds.map((userId, index) => ({ userId, preferredPositions: [{ position: 'MID', priority: 1 }], joinedAt: new Date(index), excluded: false, })); const match = { _id: matchId, communityId, participants, status: 'recruiting', teamBuiltAt: undefined, save: jest.fn().mockResolvedValue(undefined), }; const tierHistory = [ { queueType: 'RANKED_SOLO_5x5', tier: 'GOLD', rank: 'II', leaguePoints: 42, wins: 30, losses: 24, recordedAt: new Date('2026-05-01T00:00:00.000Z'), }, { queueType: 'RANKED_SOLO_5x5', tier: 'PLATINUM', rank: 'IV', leaguePoints: 15, wins: 34, losses: 27, recordedAt: new Date('2026-05-08T00:00:00.000Z'), }, ]; const users = userIds.slice(2).map((userId, index) => ({ _id: userId, riotAccounts: [ { puuid: `puuid-${index}`, gameName: `Player${index}`, tagLine: 'KR1', profileIconId: index, tiers: [], tierHistory: index === 0 ? tierHistory : [], championMasteries: [], recentStatsSummary: undefined, lastRefreshRequestedAt: new Date(), isPrimary: true, }, ], })); const auctionCreate = jest.fn().mockImplementation(async (payload) => ({ _id: new mongoose.Types.ObjectId(), matchId, toObject: jest.fn().mockReturnValue({ matchId, ...payload }), })); const { service } = createService({ match: { findById: jest.fn().mockResolvedValue(match), }, user: { find: jest.fn().mockResolvedValue(users), }, auction: { findOne: jest.fn().mockResolvedValue(null), create: auctionCreate, }, community: { findById: jest.fn().mockReturnValue({ select: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ riotPlatform: 'kr', riotRegion: 'asia', }), }), }), }), }, }); await service.start({ matchId, communityId, startAuctionRequestId: '00000000-0000-4000-8000-000000000003', captains: [ { teamIndex: 1, userId: userIds[0] }, { teamIndex: 2, userId: userIds[1] }, ], initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, bidRoundExtensionSeconds: 5, topTierAuctionPriorityThreshold: 'NONE', manualTopTierAuctionPriorityUserIds: [], }); const firstPlayerSnapshot = auctionCreate.mock.calls[0][0].order.find( (player: { userId: mongoose.Types.ObjectId }) => player.userId.equals(userIds[2]), ); expect(firstPlayerSnapshot).toMatchObject({ userId: userIds[2], tierHistory, }); }); 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(1), createFullTeam(2)], currentBid: 10, save: jest.fn().mockResolvedValue(undefined), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await expect( service.placeBid({ matchId, teamIndex: 1, amount: 20, }), ).rejects.toThrow('Team already has maximum members.'); expect(auction.save).not.toHaveBeenCalled(); }); it('rejects bids that do not reserve minimum points for remaining team slots', async () => { const matchId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, phase: 'bidding', teams: [ { teamIndex: 1, captainUserId: new mongoose.Types.ObjectId(), points: 1000, members: [], }, ], currentBid: 100, currentDeadline: new Date(), maxTimerSeconds: 30, bidExtensionSeconds: 5, bids: [], save: jest.fn().mockResolvedValue(undefined), toObject: jest.fn().mockReturnValue({ _id: 'auction', matchId }), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await expect( service.placeBid({ matchId, teamIndex: 1, amount: 980, }), ).rejects.toThrow('Bid must reserve minimum points for remaining slots.'); expect(auction.save).not.toHaveBeenCalled(); }); it('allows bids up to the maximum after reserving minimum points', async () => { const matchId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, phase: 'bidding', teams: [ { teamIndex: 1, captainUserId, points: 1000, members: [], }, ], currentBid: 100, currentDeadline: new Date(), maxTimerSeconds: 30, bidExtensionSeconds: 5, bids: [], save: jest.fn().mockResolvedValue(undefined), toObject: jest.fn().mockReturnValue({ _id: 'auction', matchId }), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await service.placeBid({ matchId, teamIndex: 1, amount: 970, }); expect(auction.currentBid).toBe(970); expect(auction.currentBidderTeamIndex).toBe(1); expect(auction.bids).toEqual([ expect.objectContaining({ teamIndex: 1, amount: 970, bidderUserId: captainUserId, }), ]); expect(auction.save).toHaveBeenCalledTimes(1); }); it('extends a short bid deadline using the configured bid extension seconds', async () => { const now = new Date('2026-05-02T00:00:00.000Z'); jest.useFakeTimers().setSystemTime(now); const matchId = new mongoose.Types.ObjectId(); const captainUserId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, phase: 'bidding', teams: [ { teamIndex: 1, captainUserId, points: 1000, members: [], }, ], currentBid: 10, currentDeadline: new Date(now.getTime() + 2000), maxTimerSeconds: 30, bidExtensionSeconds: 12, bids: [], save: jest.fn().mockResolvedValue(undefined), toObject: jest.fn().mockReturnValue({ _id: 'auction', matchId }), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await service.placeBid({ matchId, teamIndex: 1, amount: 20, }); expect(auction.currentDeadline).toEqual( new Date(now.getTime() + 12000), ); expect(auction.save).toHaveBeenCalledTimes(1); }); it('rejects sold confirmation when the winning team is already full', async () => { const matchId = new mongoose.Types.ObjectId(); const auction = { phase: 'bidding', currentBidderTeamIndex: 1, currentBid: 20, currentIndex: 0, order: [ { userId: new mongoose.Types.ObjectId(), preferredPositions: [{ position: 'ADC', priority: 1 }], }, ], teams: [createFullTeam(1), createFullTeam(2)], 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('marks a zero-bid player as passed and queues them for another round', async () => { const matchId = new mongoose.Types.ObjectId(); const playerId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, phase: 'bidding', currentBid: 0, currentIndex: 0, auctionRound: 1, order: [ { userId: playerId, preferredPositions: [{ position: 'MID', priority: 1 }], passCount: 0, }, ], passedQueue: [], save: jest.fn().mockResolvedValue(undefined), toObject: jest.fn().mockReturnValue({ _id: 'auction', matchId }), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await service.markPassed(matchId); expect(auction.phase).toBe('passed'); expect(auction.order[0].passCount).toBe(1); expect(auction.passedQueue).toHaveLength(1); expect(auction.save).toHaveBeenCalledTimes(1); }); it('queues zero-bid passes after the first auction round', async () => { const matchId = new mongoose.Types.ObjectId(); const playerId = new mongoose.Types.ObjectId(); const auction = { _id: new mongoose.Types.ObjectId(), matchId, phase: 'bidding', currentBid: 0, currentIndex: 0, auctionRound: 2, order: [ { userId: playerId, preferredPositions: [{ position: 'MID', priority: 1 }], passCount: 1, }, ], passedQueue: [], save: jest.fn().mockResolvedValue(undefined), toObject: jest.fn().mockReturnValue({ _id: 'auction', matchId }), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await service.markPassed(matchId); expect(auction.phase).toBe('passed'); expect(auction.order[0].passCount).toBe(2); expect(auction.passedQueue).toHaveLength(1); expect(auction.passedQueue[0]).toMatchObject({ userId: playerId.toString(), preferredPositions: [{ position: 'MID', priority: 1 }], passCount: 2, }); }); it('requeues second-pass players instead of force-assigning them', async () => { const matchId = new mongoose.Types.ObjectId(); const captainOneId = new mongoose.Types.ObjectId(); const captainTwoId = new mongoose.Types.ObjectId(); const passedPlayerId = new mongoose.Types.ObjectId(); const passedPlayer = { userId: passedPlayerId, preferredPositions: [{ position: 'SUP', priority: 1 }], passCount: 2, }; const auction = { _id: new mongoose.Types.ObjectId(), matchId, phase: 'passed', currentIndex: 0, auctionRound: 2, order: [passedPlayer], passedQueue: [passedPlayer], teams: [ { teamIndex: 1, captainUserId: captainOneId, points: 10, members: [], }, { teamIndex: 2, captainUserId: captainTwoId, points: 50, members: [], }, ], save: jest.fn().mockResolvedValue(undefined), toObject: jest.fn().mockReturnValue({ _id: 'auction', matchId }), }; const { service } = createService({ auction: { findOne: jest.fn().mockResolvedValue(auction), }, }); await service.next(matchId); expect(auction.phase).toBe('presenting'); expect(auction.auctionRound).toBe(3); expect(auction.currentIndex).toBe(1); expect(auction.order).toHaveLength(2); expect(auction.order[1]).toMatchObject({ userId: passedPlayerId.toString(), preferredPositions: [{ position: 'SUP', priority: 1 }], passCount: 2, }); expect(auction.passedQueue).toEqual([]); expect(auction.teams[0].members).toEqual([]); expect(auction.teams[1].members).toEqual([]); expect(auction.teams[0].points).toBe(10); expect(auction.teams[1].points).toBe(50); }); 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: [ { teamIndex: 1, captainUserId: blueCaptainId, points: 970, members: [ { userId: blueMemberId, assignedPosition: 'ADC', cost: 30, }, ], }, { teamIndex: 2, 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, tournamentCodeService, tournamentResultService } = 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([ { teamIndex: 1, name: '1팀', captainUserId: blueCaptainId, members: [ { userId: blueCaptainId, assignedPosition: 'TOP', cost: 0, }, { userId: blueMemberId, assignedPosition: 'ADC', cost: 30, }, ], }, { teamIndex: 2, name: '2팀', captainUserId: redCaptainId, members: [ { userId: redCaptainId, assignedPosition: 'MID', cost: 0, }, { userId: redMemberId, assignedPosition: 'JGL', cost: 60, }, ], }, ]); expect(tournamentCodeService.reserveForMatch).toHaveBeenCalledWith(match); expect(tournamentResultService.scheduleInitialPoll).toHaveBeenCalledWith( match, ); }); 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: [ { teamIndex: 1, name: '1팀', members: [], }, ], tournamentCodeIds: [new mongoose.Types.ObjectId()], gameSchedule: [{ gameNumber: 1, teamAIndex: 1, teamBIndex: 2 }], participants: [], 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.tournamentCodeIds).toEqual([]); expect(match.gameSchedule).toEqual([]); expect(match.save).toHaveBeenCalledWith({ session }); expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); it('fully deletes redis-v1 auction data when cancelling an auction', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const auctionId = 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 = { _id: auctionId, auctionEngineVersion: 'redis-v1', auctionLifecycleId: 'life-1', matchId, matchSideEffectRevision: 0, deleteOne: jest.fn().mockResolvedValue(undefined), }; const match = { gameSchedule: [{ gameNumber: 1, teamAIndex: 1, teamBIndex: 2 }], communityId, status: 'team-built', teams: [{ teamIndex: 1 }], tournamentCodeIds: [new mongoose.Types.ObjectId()], participants: [{ excluded: true }, { excluded: false }], result: { games: [] }, resultPollState: { state: 'polling' }, teamBuiltAt: new Date(), save: jest.fn().mockResolvedValue(undefined), }; const sideEffectDeleteMany = jest.fn().mockReturnValue({ session: jest.fn().mockResolvedValue(undefined), }); const { service, connectionService, tournamentCodeService, tournamentResultService, auctionHistoryModel, auctionRedisCommandService, auctionRedisService, } = createService({ auction: { findOne: jest.fn().mockReturnValue({ session: jest.fn().mockResolvedValue(auction), }), }, auctionSideEffectApplication: { deleteMany: sideEffectDeleteMany, }, match: { findById: jest.fn().mockReturnValue({ session: jest.fn().mockResolvedValue(match), }), }, }); connectionService.createSession.mockResolvedValue(session); const redisClient = auctionRedisService.raw(); redisClient.sendCommand .mockResolvedValueOnce(1) .mockResolvedValueOnce(['0', []]); await service.reset({ auctionActionRequestId: '00000000-0000-4000-8000-000000000080', clientObservedAuctionLifecycleId: 'life-1', clientObservedCurrentAuctionPlayerOrderIndex: 0, clientObservedCurrentBidRoundPlayerUserId: 'player-1', clientObservedPhase: 'bidding', clientObservedRevision: 4, matchId, communityId, }); expect( auctionRedisCommandService.reserveActionRequest, ).not.toHaveBeenCalled(); expect(auctionRedisCommandService.applyTransition).not.toHaveBeenCalled(); expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match); expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(match); expect(match).toMatchObject({ gameSchedule: [], result: undefined, resultPollState: undefined, status: 'recruiting', teamBuiltAt: undefined, teams: [], tournamentCodeIds: [], }); expect(match.participants).toEqual([ { excluded: false }, { excluded: false }, ]); expect(match.save).toHaveBeenCalledWith({ session }); expect(sideEffectDeleteMany).toHaveBeenCalledWith({ auctionId }); expect(auctionHistoryModel.deleteMany).toHaveBeenCalledWith({ auctionId, }); expect(auction.deleteOne).toHaveBeenCalledWith({ session }); expect(redisClient.sendCommand).toHaveBeenCalledWith( expect.arrayContaining([ 'auction:bidRoundDeadlineQueue', matchId.toString(), 'life-1', ]), ); expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); it('undoes to a history snapshot and releases resources when leaving complete', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const auctionId = 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 = { _id: auctionId, matchId, completedAt: new Date(), }; const snapshot = { _id: auctionId.toString(), matchId: matchId.toString(), phase: 'bidding', order: [], teams: [], }; const restored = { _id: auctionId, phase: 'bidding' }; const match = { communityId, status: 'finished', result: { games: [] }, save: jest.fn().mockResolvedValue(undefined), }; const auctionFindOneQuery = { session: jest.fn().mockResolvedValue(auction), }; const matchFindByIdQuery = { session: jest.fn().mockResolvedValue(match), }; const historyFindOneQuery = { session: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ auctionId, matchId, sequence: 3, snapshotBefore: snapshot, }), }), }), }; const historyDeleteManyQuery = { session: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue(undefined), }), }; const auctionReplaceOne = jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue(undefined), }); const { service, connectionService, tournamentCodeService, tournamentResultService } = createService({ auction: { findOne: jest.fn().mockReturnValue(auctionFindOneQuery), replaceOne: auctionReplaceOne, findById: jest.fn().mockResolvedValue(restored), }, auctionHistory: { findOne: jest.fn().mockReturnValue(historyFindOneQuery), deleteMany: jest.fn().mockReturnValue(historyDeleteManyQuery), }, match: { findById: jest.fn().mockReturnValue(matchFindByIdQuery), }, }); connectionService.createSession.mockResolvedValue(session); await expect( service.undoTo({ matchId, communityId, sequence: 3 }), ).resolves.toBe(restored); expect(tournamentCodeService.releaseFromMatch).toHaveBeenCalledWith(match); expect(tournamentResultService.cancelPolling).toHaveBeenCalledWith(match); expect(match.status).toBe('team-built'); expect(match.result).toBeUndefined(); expect(auctionReplaceOne).toHaveBeenCalledWith( { _id: auctionId }, snapshot, { session }, ); expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); it('uses Redis transition when undoing a redis-v1 auction', async () => { const matchId = new mongoose.Types.ObjectId(); const communityId = new mongoose.Types.ObjectId(); const auctionId = 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 = { _id: auctionId, auctionEngineVersion: 'redis-v1', auctionLifecycleId: 'life-1', completedAt: new Date(), matchId, matchSideEffectRevision: 0, }; const snapshot = { _id: auctionId.toString(), auctionLifecycleId: 'life-1', auctionPlayerOrder: [{ userId: 'player-1', passCount: 0 }], auctionTeams: [], bidRoundExtensionSeconds: 5, currentAuctionHistorySequence: 3, currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, currentHighestBidPointAmount: 0, currentHighestBidderTeamIndex: -1, initialTeamBidPointAmount: 1000, matchId: matchId.toString(), maximumBidRoundDurationSeconds: 30, passedAuctionPlayerQueue: [], phase: 'bidding', revision: 4, topTierAuctionPriorityThreshold: 'NONE', }; const match = { communityId, }; const currentRedisState = { auctionLifecycleId: 'life-1', auctionPlayerOrder: [{ userId: 'player-2', passCount: 0 }], auctionTeams: [], bidRoundExtensionSeconds: 5, currentAuctionHistorySequence: 5, currentAuctionPlayerOrderIndex: 0, currentAuctionRound: 1, currentBidRoundPlayerUserId: 'player-2', currentHighestBidPointAmount: 0, currentHighestBidderTeamIndex: -1, initialTeamBidPointAmount: 1000, maximumBidRoundDurationSeconds: 30, passedAuctionPlayerQueue: [], phase: 'complete', revision: 5, topTierAuctionPriorityThreshold: 'NONE', }; const restoredRedisState = { ...snapshot, currentServerTimestampMS: 1780000000000, phase: 'bidding', revision: 6, }; const historyFindOneQuery = { session: jest.fn().mockReturnValue({ lean: jest.fn().mockReturnValue({ exec: jest.fn().mockResolvedValue({ auctionId, matchId, sequence: 3, snapshotBefore: snapshot, }), }), }), }; const auctionReplaceOne = jest.fn(); const { service, connectionService, auctionRedisCommandService, auctionRedisStateReaderService } = createService({ auction: { findOne: jest.fn().mockReturnValue({ session: jest.fn().mockResolvedValue(auction), }), replaceOne: auctionReplaceOne, }, auctionHistory: { findOne: jest.fn().mockReturnValue(historyFindOneQuery), }, match: { findById: jest.fn().mockReturnValue({ session: jest.fn().mockResolvedValue(match), }), }, }); connectionService.createSession.mockResolvedValue(session); auctionRedisStateReaderService.readAuctionStateView .mockResolvedValueOnce(currentRedisState) .mockResolvedValueOnce(restoredRedisState); await expect( service.undoTo({ auctionActionRequestId: '00000000-0000-4000-8000-000000000070', clientObservedAuctionLifecycleId: 'life-1', clientObservedCurrentAuctionPlayerOrderIndex: 0, clientObservedCurrentBidRoundPlayerUserId: 'player-2', clientObservedPhase: 'complete', clientObservedRevision: 5, matchId, communityId, sequence: 3, }), ).resolves.toBe(restoredRedisState); expect(auctionReplaceOne).not.toHaveBeenCalled(); expect(auctionRedisCommandService.reserveActionRequest).toHaveBeenCalledWith( matchId.toString(), expect.objectContaining({ auctionActionRequestId: '00000000-0000-4000-8000-000000000070', auctionStateTransitionId: 'undo:life-1:00000000-0000-4000-8000-000000000070', clientObservedAuctionLifecycleId: 'life-1', clientObservedCurrentAuctionPlayerOrderIndex: 0, clientObservedCurrentBidRoundPlayerUserId: 'player-2', clientObservedPhase: 'complete', clientObservedRevision: 5, }), ); expect(auctionRedisCommandService.applyTransition).toHaveBeenCalledTimes(1); const transitionInput = auctionRedisCommandService.applyTransition.mock.calls[0][1]; expect(transitionInput.expectedPhase).toBe('complete'); expect(transitionInput.deadline).toEqual({ durationSeconds: 30, mode: 'set-relative', }); const durabilityPayload = JSON.parse( transitionInput.durabilityPayloadJson, ); expect(durabilityPayload).toMatchObject({ auctionActionType: 'undo', historyMutation: { targetHistorySequence: 3, type: 'deleteAfterSequenceAndAppendUndo', }, matchSideEffectMutation: { type: 'undoCompletedAuctionSideEffects', }, }); expect(session.commitTransaction).toHaveBeenCalledTimes(1); }); });