Files
lolympus-tournament-support/apps/api/src/modules/double-elimination/double-elimination.util.spec.ts
T

307 lines
9.5 KiB
TypeScript

import {
buildDoubleEliminationGameSlots,
buildDoubleEliminationBracket,
cancelDoubleEliminationBracketMatch,
completeDoubleEliminationBracketMatch,
resolveDoubleEliminationSeriesWinner,
reshuffleDoubleEliminationSeeds,
swapDoubleEliminationSeeds,
} from './double-elimination.util';
function mongooseSubdocumentLike<T extends object>(value: T): T {
const wrapper = {
toObject: () => value,
} as T & { toObject: () => T };
for (const [key, entryValue] of Object.entries(value)) {
Object.defineProperty(wrapper, key, {
enumerable: false,
get: () => entryValue,
});
}
return wrapper;
}
describe('double-elimination util', () => {
it('builds a 4-team bracket with winner, loser, and grand final matches', () => {
const bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: true,
});
expect(bracket.bracketMatches.map((match) => match.bracketMatchId)).toEqual(
['WB_R1_M1', 'WB_R1_M2', 'WB_FINAL', 'LB_R1_M1', 'LB_FINAL', 'GF'],
);
expect(
bracket.bracketMatches.find(
(match) => match.bracketMatchId === 'WB_R1_M1',
),
).toMatchObject({
teamAIndex: 1,
teamBIndex: 4,
winnerAdvancesTo: { bracketMatchId: 'WB_FINAL', position: 'A' },
loserAdvancesTo: { bracketMatchId: 'LB_R1_M1', position: 'A' },
state: 'ready',
});
});
it('assigns extensible series rules to winner-bracket matches', () => {
const bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: true,
winnerBracketGameCount: 5,
});
expect(
bracket.bracketMatches
.filter((match) => match.bracketSide === 'winner')
.map((match) => ({
bracketMatchId: match.bracketMatchId,
gameCount: match.gameCount,
requiredWins: match.requiredWins,
})),
).toEqual([
{ bracketMatchId: 'WB_R1_M1', gameCount: 5, requiredWins: 3 },
{ bracketMatchId: 'WB_R1_M2', gameCount: 5, requiredWins: 3 },
{ bracketMatchId: 'WB_FINAL', gameCount: 5, requiredWins: 3 },
]);
expect(
bracket.bracketMatches.find(
(match) => match.bracketMatchId === 'LB_R1_M1',
),
).toMatchObject({ gameCount: 1, requiredWins: 1 });
expect(
bracket.bracketMatches.find((match) => match.bracketMatchId === 'GF'),
).toMatchObject({ gameCount: 1, requiredWins: 1 });
});
it('expands bracket match series into game slots', () => {
const bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: true,
});
expect(
buildDoubleEliminationGameSlots(bracket.bracketMatches).slice(0, 7),
).toEqual([
expect.objectContaining({
gameNumber: 1,
seriesGameNumber: 1,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_R1_M1' }),
}),
expect.objectContaining({
gameNumber: 2,
seriesGameNumber: 2,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_R1_M1' }),
}),
expect.objectContaining({
gameNumber: 3,
seriesGameNumber: 3,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_R1_M1' }),
}),
expect.objectContaining({
gameNumber: 4,
seriesGameNumber: 1,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_R1_M2' }),
}),
expect.objectContaining({
gameNumber: 5,
seriesGameNumber: 2,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_R1_M2' }),
}),
expect.objectContaining({
gameNumber: 6,
seriesGameNumber: 3,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_R1_M2' }),
}),
expect.objectContaining({
gameNumber: 7,
seriesGameNumber: 1,
bracketMatch: expect.objectContaining({ bracketMatchId: 'WB_FINAL' }),
}),
]);
});
it('requires the configured number of wins before resolving a series winner', () => {
const bracketMatch = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: true,
}).bracketMatches.find((match) => match.bracketMatchId === 'WB_R1_M1');
expect(
resolveDoubleEliminationSeriesWinner(
{ teamAIndex: 1, teamBIndex: 4, teamAWins: 1, teamBWins: 0 },
bracketMatch!,
),
).toBeUndefined();
expect(
resolveDoubleEliminationSeriesWinner(
{ teamAIndex: 1, teamBIndex: 4, teamAWins: 2, teamBWins: 1 },
bracketMatch!,
),
).toBe(1);
});
it('completes a hydrated Mongoose-style bracket without losing subdocument fields', () => {
const bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: false,
});
const hydratedLikeBracket = {
...bracket,
seeds: bracket.seeds.map(mongooseSubdocumentLike),
bracketMatches: bracket.bracketMatches.map(mongooseSubdocumentLike),
events: bracket.events.map(mongooseSubdocumentLike),
};
const next = completeDoubleEliminationBracketMatch(hydratedLikeBracket, {
bracketMatchId: 'WB_R1_M1',
winnerTeamIndex: 1,
completedBy: 'riot-result',
});
expect(
next.bracketMatches.find((match) => match.bracketMatchId === 'WB_FINAL'),
).toMatchObject({ teamAIndex: 1 });
expect(
next.bracketMatches.find((match) => match.bracketMatchId === 'LB_R1_M1'),
).toMatchObject({ teamAIndex: 4 });
});
it('moves winners and losers through a 4-team bracket and records top 3', () => {
let bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: false,
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_R1_M1',
winnerTeamIndex: 1,
completedBy: 'riot-result',
completedAt: new Date('2026-06-01T10:00:00.000Z'),
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_R1_M2',
winnerTeamIndex: 2,
completedBy: 'riot-result',
completedAt: new Date('2026-06-01T10:30:00.000Z'),
});
expect(
bracket.bracketMatches.find(
(match) => match.bracketMatchId === 'WB_FINAL',
),
).toMatchObject({ teamAIndex: 1, teamBIndex: 2, state: 'ready' });
expect(
bracket.bracketMatches.find(
(match) => match.bracketMatchId === 'LB_R1_M1',
),
).toMatchObject({ teamAIndex: 4, teamBIndex: 3, state: 'ready' });
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_FINAL',
winnerTeamIndex: 1,
completedBy: 'riot-result',
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'LB_R1_M1',
winnerTeamIndex: 3,
completedBy: 'riot-result',
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'LB_FINAL',
winnerTeamIndex: 2,
completedBy: 'riot-result',
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'GF',
winnerTeamIndex: 1,
completedBy: 'riot-result',
});
expect(bracket.placements).toEqual({
firstTeamIndex: 1,
secondTeamIndex: 2,
thirdTeamIndex: 3,
});
});
it('creates reset final only when the loser bracket finalist wins grand final', () => {
let bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: true,
});
for (const [bracketMatchId, winnerTeamIndex] of [
['WB_R1_M1', 1],
['WB_R1_M2', 2],
['WB_FINAL', 1],
['LB_R1_M1', 3],
['LB_FINAL', 2],
['GF', 2],
] as const) {
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId,
winnerTeamIndex,
completedBy: 'riot-result',
});
}
expect(bracket.resetFinalCreated).toBe(true);
expect(bracket.placements).toEqual({ thirdTeamIndex: 3 });
expect(
bracket.bracketMatches.find(
(match) => match.bracketMatchId === 'GF_RESET',
),
).toMatchObject({
gameNumber: 7,
bracketSide: 'reset-final',
teamAIndex: 1,
teamBIndex: 2,
state: 'ready',
});
});
it('rejects completion cancellation when downstream matches are already completed', () => {
let bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: false,
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_R1_M1',
winnerTeamIndex: 1,
completedBy: 'riot-result',
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_R1_M2',
winnerTeamIndex: 2,
completedBy: 'riot-result',
});
bracket = completeDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_FINAL',
winnerTeamIndex: 1,
completedBy: 'riot-result',
});
expect(() =>
cancelDoubleEliminationBracketMatch(bracket, {
bracketMatchId: 'WB_R1_M1',
}),
).toThrow('downstream');
});
it('allows changing seeds before the bracket has completed matches', () => {
const bracket = buildDoubleEliminationBracket([1, 2, 3, 4], {
resetFinalEnabled: false,
});
const swapped = swapDoubleEliminationSeeds(bracket, {
leftSeedNumber: 1,
rightSeedNumber: 4,
});
expect(swapped.seeds).toEqual([
{ seedNumber: 1, teamIndex: 4 },
{ seedNumber: 2, teamIndex: 2 },
{ seedNumber: 3, teamIndex: 3 },
{ seedNumber: 4, teamIndex: 1 },
]);
expect(
reshuffleDoubleEliminationSeeds(bracket, () => 0).seeds.map(
(seed) => seed.teamIndex,
),
).toEqual([2, 3, 4, 1]);
});
});