Files
lolympus-tournament-support/apps/api/src/modules/tournament-code/tournament-code.service.spec.ts
T

1010 lines
31 KiB
TypeScript

import {
TournamentCodeSchema,
type MatchDocument,
} from '../global/database/schema';
import { Logger } from '@nestjs/common';
import mongoose from 'mongoose';
import { TournamentCodeService } from './tournament-code.service';
import { buildDoubleEliminationBracket } from '../double-elimination/double-elimination.util';
type TournamentCodeServiceInternals = TournamentCodeService & {
resolveRequiredSlots(match: MatchDocument): number;
resolveSeriesRefForGameNumber(
match: MatchDocument,
gameNumber: number,
): { teamAIndex: number; teamBIndex: number };
ensureGameSchedule(match: MatchDocument): void;
attachPendingMatches(communityId?: mongoose.Types.ObjectId): Promise<number>;
};
function createAuctionRedisService() {
return {
acquireTokenLock: jest.fn().mockResolvedValue(true),
releaseTokenLock: jest.fn().mockResolvedValue(true),
};
}
function createSession() {
return {
startTransaction: jest.fn(),
commitTransaction: jest.fn().mockResolvedValue(undefined),
abortTransaction: jest.fn().mockResolvedValue(undefined),
endSession: jest.fn().mockResolvedValue(undefined),
};
}
function mongoQuery<T>(value: T) {
const query = {
exec: jest.fn().mockResolvedValue(value),
lean: jest.fn(),
limit: jest.fn(),
select: jest.fn(),
session: jest.fn(),
};
query.lean.mockReturnValue(query);
query.limit.mockReturnValue(query);
query.select.mockReturnValue(query);
query.session.mockReturnValue(query);
return query;
}
function createService() {
return new TournamentCodeService(
{} as never,
createAuctionRedisService() as never,
) as unknown as TournamentCodeServiceInternals;
}
interface MatchOverrides {
gameCount?: number;
gameMode?: 'pair' | 'bracket' | 'round-robin' | 'double-elimination';
roundRobinMaxRounds?: number;
participants?: Array<{ excluded?: boolean }>;
teams?: Array<{ teamIndex: number }>;
doubleElimination?: MatchDocument['doubleElimination'];
tournamentCodeIds?: mongoose.Types.ObjectId[];
gameSchedule?: Array<{
gameNumber: number;
roundNumber?: number;
teamAIndex: number;
teamBIndex: number;
}>;
}
function createMatch(overrides: MatchOverrides): MatchDocument {
return {
_id: new mongoose.Types.ObjectId(),
status: 'in-progress',
gameCount: 1,
gameMode: 'pair',
participants: [],
teams: [],
tournamentCodeIds: [],
gameSchedule: [],
save: jest.fn().mockResolvedValue(undefined),
markModified: jest.fn(),
...overrides,
} as unknown as MatchDocument;
}
describe('TournamentCodeService round-robin scheduling', () => {
it('keeps pair slot calculation unchanged', () => {
const service = createService();
const match = createMatch({
gameCount: 3,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
participants: Array.from({ length: 30 }, () => ({})),
});
expect(service.resolveRequiredSlots(match)).toBe(9);
expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({
teamAIndex: 1,
teamBIndex: 2,
});
expect(service.resolveSeriesRefForGameNumber(match, 4)).toEqual({
teamAIndex: 3,
teamBIndex: 4,
});
expect(service.resolveSeriesRefForGameNumber(match, 7)).toEqual({
teamAIndex: 5,
teamBIndex: 6,
});
});
it('calculates round-robin slots from team pairs and per-pair game count', () => {
const service = createService();
expect(
service.resolveRequiredSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
}),
),
).toBe(15);
expect(
service.resolveRequiredSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 2,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
}),
),
).toBe(30);
expect(
service.resolveRequiredSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: [],
participants: Array.from({ length: 30 }, () => ({})),
}),
),
).toBe(15);
});
it('calculates limited round-robin slots from max rounds', () => {
const service = createService();
expect(
service.resolveRequiredSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
roundRobinMaxRounds: 3,
teams: Array.from({ length: 8 }, (_, index) => ({
teamIndex: index + 1,
})),
}),
),
).toBe(12);
});
it('uses persisted round-robin game schedule for game refs', () => {
const service = createService();
const match = createMatch({
gameMode: 'round-robin',
gameCount: 2,
gameSchedule: [
{ gameNumber: 1, roundNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 2, roundNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 3, roundNumber: 2, teamAIndex: 1, teamBIndex: 4 },
],
});
expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({
teamAIndex: 2,
teamBIndex: 5,
});
expect(service.resolveSeriesRefForGameNumber(match, 3)).toEqual({
teamAIndex: 1,
teamBIndex: 4,
});
});
it('falls back to round-based pairs before schedule is persisted', () => {
const service = createService();
const match = createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 4 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [],
});
expect(service.resolveSeriesRefForGameNumber(match, 1)).toEqual({
teamAIndex: 1,
teamBIndex: 4,
});
expect(service.resolveSeriesRefForGameNumber(match, 2)).toEqual({
teamAIndex: 2,
teamBIndex: 3,
});
});
it('creates a round-robin schedule once and leaves pair matches empty', () => {
const service = createService();
const roundRobin = createMatch({
gameMode: 'round-robin',
gameCount: 2,
teams: Array.from({ length: 4 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [],
});
service.ensureGameSchedule(roundRobin);
expect(roundRobin.gameSchedule).toHaveLength(12);
const persisted = [...roundRobin.gameSchedule];
service.ensureGameSchedule(roundRobin);
expect(roundRobin.gameSchedule).toEqual(persisted);
const pair = createMatch({
gameMode: 'pair',
teams: Array.from({ length: 4 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [],
});
service.ensureGameSchedule(pair);
expect(pair.gameSchedule).toEqual([]);
});
it('creates a double-elimination bracket from built teams', () => {
const service = createService();
const match = createMatch({
gameMode: 'double-elimination',
gameCount: 3,
teams: Array.from({ length: 4 }, (_, index) => ({
teamIndex: index + 1,
})),
doubleElimination: {
teamCount: 4,
resetFinalEnabled: true,
resetFinalCreated: false,
seeds: [],
bracketMatches: [],
placements: {},
events: [],
},
});
service.ensureGameSchedule(match);
expect(match.doubleElimination?.seeds).toHaveLength(4);
expect(match.doubleElimination?.bracketMatches).toHaveLength(6);
expect(
match.doubleElimination?.bracketMatches.filter(
(bracketMatch) => bracketMatch.state === 'ready',
),
).toHaveLength(2);
expect(
match.doubleElimination?.bracketMatches.find(
(bracketMatch) => bracketMatch.bracketMatchId === 'WB_R1_M1',
),
).toMatchObject({ gameCount: 3, requiredWins: 2 });
});
it('builds a missing bracket from already-persisted authoritative seeds', () => {
const service = createService();
const match = createMatch({
gameMode: 'double-elimination',
gameCount: 3,
teams: Array.from({ length: 4 }, (_, index) => ({
teamIndex: index + 1,
})),
doubleElimination: {
teamCount: 4,
resetFinalEnabled: true,
resetFinalCreated: false,
seeds: [
{ seedNumber: 1, teamIndex: 3 },
{ seedNumber: 2, teamIndex: 1 },
{ seedNumber: 3, teamIndex: 4 },
{ seedNumber: 4, teamIndex: 2 },
],
bracketMatches: [],
placements: {},
events: [],
},
});
const random = jest.spyOn(Math, 'random').mockReturnValue(0);
service.ensureGameSchedule(match);
expect(match.doubleElimination?.seeds).toEqual([
{ seedNumber: 1, teamIndex: 3 },
{ seedNumber: 2, teamIndex: 1 },
{ seedNumber: 3, teamIndex: 4 },
{ seedNumber: 4, teamIndex: 2 },
]);
expect(random).not.toHaveBeenCalled();
random.mockRestore();
});
it('expands double-elimination winner bracket series into code slots', async () => {
const TournamentCodeModel = {
find: jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue([]),
}),
};
const service = new TournamentCodeService(
{ getModel: jest.fn().mockResolvedValue(TournamentCodeModel) } as never,
createAuctionRedisService() as never,
) as unknown as TournamentCodeServiceInternals;
const match = createMatch({
gameMode: 'double-elimination',
gameCount: 3,
teams: Array.from({ length: 4 }, (_, index) => ({
teamIndex: index + 1,
})),
doubleElimination: buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: true,
}),
});
const slots = await service.buildSlots(match);
expect(slots.slice(0, 6)).toEqual([
expect.objectContaining({
gameNumber: 1,
seriesGameNumber: 1,
seriesGameCount: 3,
seriesRequiredWins: 2,
bracketMatchId: 'WB_R1_M1',
}),
expect.objectContaining({
gameNumber: 2,
seriesGameNumber: 2,
bracketMatchId: 'WB_R1_M1',
}),
expect.objectContaining({
gameNumber: 3,
seriesGameNumber: 3,
bracketMatchId: 'WB_R1_M1',
}),
expect.objectContaining({
gameNumber: 4,
seriesGameNumber: 1,
bracketMatchId: 'WB_R1_M2',
}),
expect.objectContaining({
gameNumber: 5,
seriesGameNumber: 2,
bracketMatchId: 'WB_R1_M2',
}),
expect.objectContaining({
gameNumber: 6,
seriesGameNumber: 3,
bracketMatchId: 'WB_R1_M2',
}),
]);
});
it('creates a limited round-robin schedule grouped by playable rounds', () => {
const service = createService();
const roundRobin = createMatch({
gameMode: 'round-robin',
gameCount: 1,
roundRobinMaxRounds: 3,
teams: Array.from({ length: 8 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [],
});
service.ensureGameSchedule(roundRobin);
expect(roundRobin.gameSchedule).toHaveLength(12);
for (const roundNumber of [1, 2, 3]) {
const round = roundRobin.gameSchedule.filter(
(game) => game.roundNumber === roundNumber,
);
expect(round).toHaveLength(4);
expect(
new Set(round.flatMap((game) => [game.teamAIndex, game.teamBIndex]))
.size,
).toBe(8);
}
});
it('leaves legacy round-robin schedules without round numbers unchanged', () => {
const service = createService();
const roundRobin = createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [
{ gameNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 2, teamAIndex: 1, teamBIndex: 2 },
{ gameNumber: 3, teamAIndex: 4, teamBIndex: 5 },
{ gameNumber: 4, teamAIndex: 1, teamBIndex: 6 },
{ gameNumber: 5, teamAIndex: 5, teamBIndex: 6 },
{ gameNumber: 6, teamAIndex: 4, teamBIndex: 6 },
],
});
const persisted = [...roundRobin.gameSchedule];
service.ensureGameSchedule(roundRobin);
expect(roundRobin.gameSchedule).toEqual(persisted);
});
it('does not expose round numbers for legacy round-robin slots', async () => {
const codeFindExec = jest.fn().mockResolvedValue([]);
const connectionService = {
getModel: jest.fn().mockResolvedValue({
find: jest.fn().mockReturnValue({ exec: codeFindExec }),
}),
};
const service = new TournamentCodeService(
connectionService as never,
createAuctionRedisService() as never,
) as unknown as TournamentCodeServiceInternals;
const slots = await service.buildSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [
{ gameNumber: 1, teamAIndex: 2, teamBIndex: 5 },
{ gameNumber: 2, teamAIndex: 1, teamBIndex: 2 },
{ gameNumber: 3, teamAIndex: 4, teamBIndex: 5 },
{ gameNumber: 4, teamAIndex: 1, teamBIndex: 6 },
{ gameNumber: 5, teamAIndex: 5, teamBIndex: 6 },
{ gameNumber: 6, teamAIndex: 4, teamBIndex: 6 },
{ gameNumber: 7, teamAIndex: 2, teamBIndex: 6 },
{ gameNumber: 8, teamAIndex: 3, teamBIndex: 5 },
{ gameNumber: 9, teamAIndex: 2, teamBIndex: 3 },
{ gameNumber: 10, teamAIndex: 1, teamBIndex: 4 },
{ gameNumber: 11, teamAIndex: 3, teamBIndex: 6 },
{ gameNumber: 12, teamAIndex: 1, teamBIndex: 3 },
{ gameNumber: 13, teamAIndex: 3, teamBIndex: 4 },
{ gameNumber: 14, teamAIndex: 1, teamBIndex: 5 },
{ gameNumber: 15, teamAIndex: 2, teamBIndex: 4 },
],
}),
);
expect(slots).toHaveLength(15);
expect(slots[0]).toEqual(
expect.objectContaining({
gameNumber: 1,
roundNumber: undefined,
teamAIndex: 2,
teamBIndex: 5,
}),
);
expect(slots.every((slot) => slot.roundNumber === undefined)).toBe(true);
});
it('does not expose fallback round-robin slots before the schedule is persisted', async () => {
const service = createService();
const slots = await service.buildSlots(
createMatch({
gameMode: 'round-robin',
gameCount: 1,
teams: Array.from({ length: 6 }, (_, index) => ({
teamIndex: index + 1,
})),
gameSchedule: [],
}),
);
expect(slots).toEqual([]);
});
it('shows the active replacement when a reversed terminal code shares its game number', async () => {
const oldCodeId = new mongoose.Types.ObjectId();
const replacementCodeId = new mongoose.Types.ObjectId();
const TournamentCodeModel = {
find: jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue([
{
_id: replacementCodeId,
code: 'NEW-CODE',
gameNumber: 1,
state: 'reserved',
expiresAt: new Date('2026-07-13T00:00:00.000Z'),
},
{
_id: oldCodeId,
code: 'OLD-CODE',
gameNumber: 1,
state: 'released',
expiresAt: new Date('2026-07-13T00:00:00.000Z'),
},
]),
}),
};
const service = new TournamentCodeService(
{ getModel: jest.fn().mockResolvedValue(TournamentCodeModel) } as never,
createAuctionRedisService() as never,
) as unknown as TournamentCodeServiceInternals;
const match = createMatch({
gameCount: 1,
teams: [{ teamIndex: 1 }, { teamIndex: 2 }],
tournamentCodeIds: [oldCodeId, replacementCodeId],
});
const slots = await service.buildSlots(match);
expect(slots[0]).toEqual(
expect.objectContaining({
gameNumber: 1,
code: 'NEW-CODE',
state: 'reserved',
}),
);
});
});
describe('TournamentCodeService bulk upload', () => {
it('defines slot and riot match indexes for multi-instance safety', () => {
const indexes = TournamentCodeSchema.indexes();
expect(indexes).toContainEqual([
{ matchId: 1, gameNumber: 1 },
expect.objectContaining({
unique: true,
partialFilterExpression: {
matchId: { $exists: true },
gameNumber: { $exists: true },
state: { $in: ['reserved', 'used'] },
},
}),
]);
expect(indexes).toContainEqual([
{ matchId: 1, bracketMatchId: 1 },
expect.objectContaining({
partialFilterExpression: {
matchId: { $exists: true },
bracketMatchId: { $exists: true },
state: { $in: ['reserved', 'used'] },
},
}),
]);
expect(indexes).toContainEqual([
{ riotMatchId: 1 },
expect.objectContaining({
unique: true,
partialFilterExpression: { riotMatchId: { $type: 'string' } },
}),
]);
});
it('preserves tournament code casing at the schema layer', async () => {
const connection = mongoose.createConnection();
try {
const TournamentCodeModel = connection.model(
'TournamentCodeCasingSpec',
TournamentCodeSchema,
);
const code = new TournamentCodeModel({
code: ' AbC-12345 ',
expiresAt: new Date(Date.now() + 60 * 60 * 1000),
uploadedBy: new mongoose.Types.ObjectId(),
});
expect(code.code).toBe('AbC-12345');
} finally {
await connection.close();
}
});
it('stores tournament codes with the exact casing from input', async () => {
const insertMany = jest.fn().mockResolvedValue(undefined);
const TournamentCodeModel = {
find: jest.fn().mockReturnValue({
select: jest.fn().mockReturnValue({
lean: jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue([]),
}),
}),
}),
insertMany,
};
const connectionService = {
getModel: jest.fn().mockResolvedValue(TournamentCodeModel),
};
const service = new TournamentCodeService(
connectionService as never,
createAuctionRedisService() as never,
) as unknown as TournamentCodeServiceInternals;
service.attachPendingMatches = jest.fn().mockResolvedValue(0);
await service.bulkUpload({
communityId: new mongoose.Types.ObjectId(),
uploadedBy: new mongoose.Types.ObjectId(),
codes: [
{
code: ' AbC-12345 ',
expiresAt: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
},
],
});
expect(insertMany).toHaveBeenCalledWith(
[
expect.objectContaining({
code: 'AbC-12345',
}),
],
{ ordered: false },
);
});
});
describe('TournamentCodeService pool stats', () => {
it('counts only available codes that are usable beyond the expiry margin', async () => {
const countDocuments = jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue(12),
});
const connectionService = {
getModel: jest.fn().mockResolvedValue({ countDocuments }),
};
const service = new TournamentCodeService(
connectionService as never,
createAuctionRedisService() as never,
);
await expect(service.countUsableAvailable()).resolves.toBe(12);
expect(countDocuments).toHaveBeenCalledWith({
state: 'available',
expiresAt: {
$gt: expect.any(Date),
},
});
});
});
describe('TournamentCodeService pending match attachment', () => {
it('does not attach tournament codes before match teams are built', async () => {
const invalidMatch = {
...createMatch({
status: 'team-built',
teams: [],
tournamentCodeIds: [],
} as unknown as MatchOverrides),
isModified: jest.fn().mockReturnValue(false),
};
const validMatch = {
...createMatch({
status: 'team-built',
teams: [
{
teamIndex: 1,
members: [{ userId: new mongoose.Types.ObjectId() }],
},
{
teamIndex: 2,
members: [{ userId: new mongoose.Types.ObjectId() }],
},
],
tournamentCodeIds: [],
} as unknown as MatchOverrides),
isModified: jest.fn().mockReturnValue(false),
};
const codeId = new mongoose.Types.ObjectId();
const MatchModel = {
find: jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue([invalidMatch, validMatch]),
}),
findById: jest.fn().mockResolvedValue(validMatch),
};
const TournamentCodeModel = {
findOneAndUpdate: jest.fn().mockReturnValue({
exec: jest.fn().mockResolvedValue({ _id: codeId }),
}),
};
const session = createSession();
const connectionService = {
createSession: jest.fn().mockResolvedValue(session),
getModel: jest.fn().mockImplementation((modelName: string) => {
if (modelName === 'match') return Promise.resolve(MatchModel);
if (modelName === 'tournamentCode') {
return Promise.resolve(TournamentCodeModel);
}
throw new Error(`Unexpected model: ${modelName}`);
}),
};
const auctionRedisService = createAuctionRedisService();
const service = new TournamentCodeService(
connectionService as never,
auctionRedisService as never,
);
const matches = await service.attachPendingMatchDocuments();
expect(matches).toEqual([validMatch]);
expect(MatchModel.findById).toHaveBeenCalledTimes(1);
expect(MatchModel.findById).toHaveBeenCalledWith(validMatch._id);
expect(TournamentCodeModel.findOneAndUpdate).toHaveBeenCalledTimes(1);
expect(auctionRedisService.acquireTokenLock).toHaveBeenCalledWith(
`tournament-code:match:${validMatch._id.toString()}:lock`,
expect.any(String),
expect.any(Number),
);
expect(session.startTransaction).toHaveBeenCalledTimes(1);
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
expect(auctionRedisService.releaseTokenLock).toHaveBeenCalledWith(
`tournament-code:match:${validMatch._id.toString()}:lock`,
expect.any(String),
);
expect(validMatch.tournamentCodeIds.map((id) => id.toString())).toEqual([
codeId.toString(),
]);
expect(invalidMatch.tournamentCodeIds).toEqual([]);
});
});
describe('TournamentCodeService Competition assignment safety', () => {
it('does not restore an actively reserved code outside Competition commands', async () => {
const code = {
_id: new mongoose.Types.ObjectId(),
state: 'reserved',
save: jest.fn(),
};
const connectionService = {
getModel: jest.fn().mockImplementation((name: string) => {
if (name === 'tournamentCode') {
return Promise.resolve({
findById: jest.fn().mockResolvedValue(code),
});
}
if (name === 'match') return Promise.resolve({});
throw new Error(`Unexpected model ${name}`);
}),
};
const service = new TournamentCodeService(
connectionService as never,
createAuctionRedisService() as never,
);
await expect(service.restoreToAvailable(code._id)).rejects.toThrow(
'Active Competition assignments',
);
expect(code.save).not.toHaveBeenCalled();
});
it('expires a reserved code and releases its assignment and Match binding atomically', async () => {
const codeId = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
const competitionId = new mongoose.Types.ObjectId();
const assignmentId = new mongoose.Types.ObjectId();
const session = createSession();
const code = { _id: codeId, state: 'reserved', matchId };
const codeUpdate = jest.fn().mockReturnValue(mongoQuery(code));
const assignmentUpdate = jest
.fn()
.mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 }));
const matchUpdate = jest
.fn()
.mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 }));
const models = {
tournamentCode: {
find: jest.fn().mockReturnValue(mongoQuery([{ _id: codeId }])),
findOne: jest.fn().mockReturnValue(mongoQuery(code)),
findOneAndUpdate: codeUpdate,
},
tournamentCodeAssignment: {
find: jest.fn().mockReturnValue(
mongoQuery([
{
_id: assignmentId,
competitionId,
state: 'reserved',
},
]),
),
updateOne: assignmentUpdate,
},
competition: {
findById: jest.fn().mockReturnValue(mongoQuery({ matchId })),
},
match: { updateOne: matchUpdate },
};
const service = new TournamentCodeService(
{
createSession: jest.fn().mockResolvedValue(session),
getModel: jest.fn((name: keyof typeof models) =>
Promise.resolve(models[name]),
),
} as never,
createAuctionRedisService() as never,
);
await expect(service.markExpired()).resolves.toEqual({
affectedMatchIds: [matchId],
expiredCount: 1,
failedCount: 0,
});
expect(codeUpdate).toHaveBeenCalledWith(
{
_id: codeId,
expiresAt: { $lte: expect.any(Date) as Date },
state: 'reserved',
},
{
$set: { state: 'expired' },
$unset: {
bracketMatchId: 1,
gameNumber: 1,
matchId: 1,
reservedAt: 1,
},
},
{ returnDocument: 'before', session },
);
expect(assignmentUpdate).toHaveBeenCalledWith(
{ _id: assignmentId, state: 'reserved' },
{
$set: { releasedAt: expect.any(Date) as Date, state: 'released' },
},
{ session },
);
expect(matchUpdate).toHaveBeenCalledWith(
{ _id: matchId },
{ $pull: { tournamentCodeIds: codeId } },
{ session },
);
expect(session.commitTransaction).toHaveBeenCalledTimes(1);
});
it('isolates a used-assignment corruption and still expires the next valid candidate', async () => {
const corruptCodeId = new mongoose.Types.ObjectId();
const validCodeId = new mongoose.Types.ObjectId();
const corruptMatchId = new mongoose.Types.ObjectId();
const validMatchId = new mongoose.Types.ObjectId();
const competitionId = new mongoose.Types.ObjectId();
const validAssignmentId = new mongoose.Types.ObjectId();
const sessions = [createSession(), createSession()];
const codeById = new Map([
[
corruptCodeId.toString(),
{ _id: corruptCodeId, state: 'reserved', matchId: corruptMatchId },
],
[
validCodeId.toString(),
{ _id: validCodeId, state: 'reserved', matchId: validMatchId },
],
]);
const codeUpdate = jest.fn((filter: { _id: mongoose.Types.ObjectId }) =>
mongoQuery(codeById.get(filter._id.toString())),
);
const assignmentUpdate = jest
.fn()
.mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 }));
const matchUpdate = jest
.fn()
.mockReturnValue(mongoQuery({ matchedCount: 1, modifiedCount: 1 }));
const models = {
tournamentCode: {
find: jest
.fn()
.mockReturnValue(
mongoQuery([{ _id: corruptCodeId }, { _id: validCodeId }]),
),
findOne: jest.fn((filter: { _id: mongoose.Types.ObjectId }) =>
mongoQuery(codeById.get(filter._id.toString())),
),
findOneAndUpdate: codeUpdate,
},
tournamentCodeAssignment: {
find: jest.fn((filter: { tournamentCodeId: mongoose.Types.ObjectId }) =>
mongoQuery(
filter.tournamentCodeId.equals(corruptCodeId)
? [
{
_id: new mongoose.Types.ObjectId(),
competitionId,
state: 'used',
},
]
: [
{
_id: validAssignmentId,
competitionId,
state: 'reserved',
},
],
),
),
updateOne: assignmentUpdate,
},
competition: {
findById: jest
.fn()
.mockReturnValue(mongoQuery({ matchId: validMatchId })),
},
match: { updateOne: matchUpdate },
};
const errorLog = jest
.spyOn(Logger.prototype, 'error')
.mockImplementation(() => undefined);
const service = new TournamentCodeService(
{
createSession: jest
.fn()
.mockImplementation(() => Promise.resolve(sessions.shift())),
getModel: jest.fn((name: keyof typeof models) =>
Promise.resolve(models[name]),
),
} as never,
createAuctionRedisService() as never,
);
await expect(service.markExpired()).resolves.toEqual({
affectedMatchIds: [validMatchId],
expiredCount: 1,
failedCount: 1,
});
expect(codeUpdate).toHaveBeenCalledTimes(1);
expect(codeUpdate.mock.calls[0][0]).toMatchObject({ _id: validCodeId });
expect(assignmentUpdate).toHaveBeenCalledWith(
{ _id: validAssignmentId, state: 'reserved' },
expect.any(Object),
expect.any(Object),
);
expect(errorLog).toHaveBeenCalledWith(
expect.stringContaining('used Competition assignment'),
);
errorLog.mockRestore();
});
it('leaves a foreign Competition assignment unchanged and reports the candidate failure', async () => {
const codeId = new mongoose.Types.ObjectId();
const matchId = new mongoose.Types.ObjectId();
const foreignMatchId = new mongoose.Types.ObjectId();
const competitionId = new mongoose.Types.ObjectId();
const code = { _id: codeId, state: 'reserved', matchId };
const codeUpdate = jest.fn();
const session = createSession();
const models = {
tournamentCode: {
find: jest.fn().mockReturnValue(mongoQuery([{ _id: codeId }])),
findOne: jest.fn().mockReturnValue(mongoQuery(code)),
findOneAndUpdate: codeUpdate,
},
tournamentCodeAssignment: {
find: jest.fn().mockReturnValue(
mongoQuery([
{
_id: new mongoose.Types.ObjectId(),
competitionId,
state: 'reserved',
},
]),
),
updateOne: jest.fn(),
},
competition: {
findById: jest
.fn()
.mockReturnValue(mongoQuery({ matchId: foreignMatchId })),
},
match: { updateOne: jest.fn() },
};
const errorLog = jest
.spyOn(Logger.prototype, 'error')
.mockImplementation(() => undefined);
const service = new TournamentCodeService(
{
createSession: jest.fn().mockResolvedValue(session),
getModel: jest.fn((name: keyof typeof models) =>
Promise.resolve(models[name]),
),
} as never,
createAuctionRedisService() as never,
);
await expect(service.markExpired()).resolves.toEqual({
affectedMatchIds: [],
expiredCount: 0,
failedCount: 1,
});
expect(codeUpdate).not.toHaveBeenCalled();
expect(session.abortTransaction).toHaveBeenCalledTimes(1);
expect(errorLog).toHaveBeenCalledWith(
expect.stringContaining('ownership does not match'),
);
errorLog.mockRestore();
});
});