307 lines
9.5 KiB
TypeScript
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]);
|
|
});
|
|
});
|