import { generateSeriesGraph } from './series-graph'; type GraphInput = Parameters[0]; type ExplicitRoundRobinPairing = { roundNumber: number; matchNumber: number; teamAId: string; teamBId: string; }; type ExplicitRoundRobinGraphInput = Omit & { format: Extract & { pairings: readonly ExplicitRoundRobinPairing[]; }; }; describe('generateSeriesGraph', () => { it('generates a deterministic graph with stable opaque ids', () => { const input = { competitionId: 'competition-deterministic', teams: Array.from({ length: 8 }, (_, index) => ({ teamId: `team-${index + 1}`, displayOrder: index + 1, seedNumber: index + 1, })), format: { type: 'double-elimination' as const, resetFinalEnabled: true, rules: { upper: firstTo(2, 3), lower: firstTo(1, 1), grandFinal: firstTo(1, 1), resetFinal: firstTo(1, 1), }, }, }; const first = generateSeriesGraph(input); const second = generateSeriesGraph(input); expect(second).toEqual(first); expect(first.map((series) => series.id)).toHaveLength(15); expect(new Set(first.map((series) => series.id))).toHaveProperty( 'size', 15, ); expect(first.every((series) => series.id.length > 0)).toBe(true); }); it('predefines a conditional grand-final reset node using only slot sources', () => { const graph = generateSeriesGraph({ competitionId: 'competition-reset-node', teams: Array.from({ length: 4 }, (_, index) => ({ teamId: `team-${index + 1}`, displayOrder: index + 1, seedNumber: index + 1, })), format: { type: 'double-elimination' as const, resetFinalEnabled: true, rules: { upper: firstTo(2, 3), lower: firstTo(1, 1), grandFinal: firstTo(1, 1), resetFinal: firstTo(1, 1), }, }, }); const grandFinal = graph.find((series) => series.code === 'GF'); const resetFinal = graph.find((series) => series.code === 'GF_RESET'); expect(grandFinal).toBeDefined(); expect(resetFinal).toMatchObject({ stage: { type: 'reset-final' }, activation: { type: 'grand-final-reset-required', grandFinalSeriesId: grandFinal!.id, }, slots: [ { position: 'A', source: { type: 'series-slot', seriesId: grandFinal!.id, slot: 'A', }, }, { position: 'B', source: { type: 'series-slot', seriesId: grandFinal!.id, slot: 'B', }, }, ], }); for (const series of graph) { expect(series).not.toHaveProperty('winnerAdvancesTo'); expect(series).not.toHaveProperty('loserAdvancesTo'); } }); it('rejects a first-to rule that can exhaust every GameSlot without a winner', () => { try { generateSeriesGraph({ competitionId: 'competition-unfinishable-first-to', teams: Array.from({ length: 4 }, (_, index) => ({ teamId: `team-${index + 1}`, displayOrder: index + 1, seedNumber: index + 1, })), format: { type: 'double-elimination', resetFinalEnabled: false, rules: { upper: firstTo(2, 2), lower: firstTo(1, 1), grandFinal: firstTo(1, 1), resetFinal: firstTo(1, 1), }, }, }); throw new Error('Expected INVALID_FIRST_TO_RULE'); } catch (error) { expect(error).toMatchObject({ code: 'INVALID_FIRST_TO_RULE' }); } }); it('reproduces an explicit persisted round-robin schedule by TeamId and pairing position', () => { const input: ExplicitRoundRobinGraphInput = { competitionId: 'competition-persisted-round-robin', teams: Array.from({ length: 8 }, (_, index) => ({ teamId: `team-${index + 1}`, displayOrder: 8 - index, seedNumber: index + 1, })), format: { type: 'round-robin', rule: fixedGames(1), maxRounds: 3, tieBreakers: ['series-wins', 'game-diff', 'head-to-head'], // Persisted schedules need not arrive in display order. Their explicit // round/match positions, rather than array position, define identity. pairings: [ pairing(3, 4, 'team-6', 'team-7'), pairing(1, 2, 'team-3', 'team-4'), pairing(2, 1, 'team-1', 'team-3'), pairing(1, 4, 'team-7', 'team-8'), pairing(3, 1, 'team-1', 'team-4'), pairing(2, 3, 'team-5', 'team-7'), pairing(1, 1, 'team-1', 'team-2'), pairing(3, 3, 'team-5', 'team-8'), pairing(2, 4, 'team-6', 'team-8'), pairing(1, 3, 'team-5', 'team-6'), pairing(3, 2, 'team-2', 'team-3'), pairing(2, 2, 'team-2', 'team-4'), ], }, }; const first = generateSeriesGraph(input); const second = generateSeriesGraph({ ...input, format: { ...input.format, pairings: [...input.format.pairings].reverse(), }, }); expect(second).toEqual(first); expect( first.map((series) => ({ code: series.code, roundNumber: series.stage.roundNumber, displayOrder: series.stage.displayOrder, sources: series.slots.map((slot) => slot.source), })), ).toEqual([ roundRobinSeries('RR_R1_M1', 1, 1, 'team-1', 'team-2'), roundRobinSeries('RR_R1_M2', 1, 2, 'team-3', 'team-4'), roundRobinSeries('RR_R1_M3', 1, 3, 'team-5', 'team-6'), roundRobinSeries('RR_R1_M4', 1, 4, 'team-7', 'team-8'), roundRobinSeries('RR_R2_M1', 2, 5, 'team-1', 'team-3'), roundRobinSeries('RR_R2_M2', 2, 6, 'team-2', 'team-4'), roundRobinSeries('RR_R2_M3', 2, 7, 'team-5', 'team-7'), roundRobinSeries('RR_R2_M4', 2, 8, 'team-6', 'team-8'), roundRobinSeries('RR_R3_M1', 3, 9, 'team-1', 'team-4'), roundRobinSeries('RR_R3_M2', 3, 10, 'team-2', 'team-3'), roundRobinSeries('RR_R3_M3', 3, 11, 'team-5', 'team-8'), roundRobinSeries('RR_R3_M4', 3, 12, 'team-6', 'team-7'), ]); }); it.each([ { name: 'a TeamId that is absent from the Competition', replacement: pairing(1, 1, 'team-1', 'team-9'), }, { name: 'the same TeamId in both slots', replacement: pairing(1, 1, 'team-1', 'team-1'), }, { name: 'a non-positive round number', replacement: pairing(0, 1, 'team-1', 'team-2'), }, { name: 'a non-positive match number', replacement: pairing(1, 0, 'team-1', 'team-2'), }, ])( 'rejects an explicit round-robin pairing with $name', ({ replacement }) => { const input = explicitRoundRobinInput([ replacement, pairing(1, 2, 'team-3', 'team-4'), ]); expectGraphError(input, 'INVALID_ROUND_ROBIN_PAIRING'); }, ); it.each([ { name: 'round and match position', pairings: [ pairing(1, 1, 'team-1', 'team-2'), pairing(1, 1, 'team-3', 'team-4'), ], code: 'DUPLICATE_ROUND_ROBIN_PAIRING_POSITION', }, { name: 'opponents with reversed slots', pairings: [ pairing(1, 1, 'team-1', 'team-2'), pairing(2, 1, 'team-2', 'team-1'), ], code: 'DUPLICATE_ROUND_ROBIN_OPPONENTS', }, ])('rejects a duplicate explicit $name', ({ pairings, code }) => { expectGraphError(explicitRoundRobinInput(pairings), code); }); it('keeps distinct opponent pairs when opaque TeamIds contain delimiters', () => { const input = explicitRoundRobinInput([ pairing(1, 1, 'a', 'b:c'), pairing(1, 2, 'a:b', 'c'), ]); input.format.maxRounds = 1; input.teams = ['a', 'b:c', 'a:b', 'c'].map((teamId, index) => ({ teamId, displayOrder: index + 1, seedNumber: index + 1, })); expect(generateSeriesGraph(input)).toHaveLength(2); }); it('validates complete odd-team rounds and clamps maxRounds to the full schedule', () => { const pairings = [ pairing(1, 1, 'team-2', 'team-5'), pairing(1, 2, 'team-3', 'team-4'), pairing(2, 1, 'team-1', 'team-5'), pairing(2, 2, 'team-2', 'team-3'), pairing(3, 1, 'team-1', 'team-4'), pairing(3, 2, 'team-3', 'team-5'), pairing(4, 1, 'team-1', 'team-3'), pairing(4, 2, 'team-2', 'team-4'), pairing(5, 1, 'team-1', 'team-2'), pairing(5, 2, 'team-4', 'team-5'), ]; const input = explicitRoundRobinInput(pairings); input.teams = Array.from({ length: 5 }, (_, index) => ({ teamId: `team-${index + 1}`, displayOrder: index + 1, seedNumber: index + 1, })); input.format.maxRounds = 10; expect(generateSeriesGraph(input)).toHaveLength(10); }); it.each([ { name: 'an expected round', pairings: [ pairing(1, 1, 'team-1', 'team-2'), pairing(1, 2, 'team-3', 'team-4'), ], }, { name: 'a match from an expected round', pairings: [ pairing(1, 1, 'team-1', 'team-2'), pairing(1, 2, 'team-3', 'team-4'), pairing(2, 1, 'team-1', 'team-3'), ], }, ])('rejects explicit pairings missing $name', ({ pairings }) => { expectGraphError( explicitRoundRobinInput(pairings), 'INCOMPLETE_ROUND_ROBIN_PAIRINGS', ); }); }); function firstTo(winsRequired: number, maxGames: number) { return { type: 'first-to' as const, winsRequired, maxGames }; } function expectGraphError(input: GraphInput, code: string): void { try { generateSeriesGraph(input); throw new Error(`Expected graph error ${code}.`); } catch (error) { expect(error).toMatchObject({ code }); } } function fixedGames(gameCount: number) { return { type: 'fixed-games' as const, gameCount, drawPolicy: 'allow' as const, }; } function pairing( roundNumber: number, matchNumber: number, teamAId: string, teamBId: string, ): ExplicitRoundRobinPairing { return { roundNumber, matchNumber, teamAId, teamBId, }; } function explicitRoundRobinInput( pairings: readonly ExplicitRoundRobinPairing[], ): ExplicitRoundRobinGraphInput { return { competitionId: 'competition-explicit-round-robin-validation', teams: Array.from({ length: 4 }, (_, index) => ({ teamId: `team-${index + 1}`, displayOrder: index + 1, seedNumber: index + 1, })), format: { type: 'round-robin', rule: fixedGames(1), maxRounds: 2, tieBreakers: ['series-wins', 'game-diff', 'head-to-head'], pairings, }, }; } function roundRobinSeries( code: string, roundNumber: number, displayOrder: number, teamAId: string, teamBId: string, ) { return { code, roundNumber, displayOrder, sources: [ { type: 'team', teamId: teamAId }, { type: 'team', teamId: teamBId }, ], }; }