216 lines
5.5 KiB
TypeScript
216 lines
5.5 KiB
TypeScript
import {
|
|
assertReversalPreview,
|
|
buildReversalFacts,
|
|
previewSeriesReversal,
|
|
} from './competition-reversal';
|
|
|
|
describe('Competition reversal planning', () => {
|
|
const graph = [
|
|
series('series-parent', [team('team-8'), team('team-3')]),
|
|
series('series-child', [winner('series-parent'), loser('series-parent')]),
|
|
];
|
|
const facts = [
|
|
accepted('fact-parent', 'series-parent', 'slot-parent', 'team-8', 'team-3'),
|
|
accepted('fact-child', 'series-child', 'slot-child', 'team-8', 'team-3'),
|
|
];
|
|
const assignments = [
|
|
assignment('assignment-parent', 'series-parent', 'slot-parent', 'used'),
|
|
assignment('assignment-child', 'series-child', 'slot-child', 'reserved'),
|
|
];
|
|
|
|
it('rejects strict reversal when a descendant has result activity', () => {
|
|
expect(() =>
|
|
previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'strict',
|
|
graph,
|
|
facts,
|
|
assignments,
|
|
}),
|
|
).toThrow(
|
|
expect.objectContaining({ code: 'REVERSAL_DESCENDANT_ACTIVITY' }),
|
|
);
|
|
});
|
|
|
|
it('builds a deterministic cascade impact from graph descendants', () => {
|
|
const first = previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments,
|
|
});
|
|
const second = previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments,
|
|
});
|
|
const extraAssignments = [
|
|
...assignments,
|
|
assignment('assignment-extra-z', 'series-child', 'slot-z', 'reserved'),
|
|
assignment('assignment-extra-a', 'series-child', 'slot-a', 'reserved'),
|
|
];
|
|
const unorderedFirst = previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments: extraAssignments,
|
|
});
|
|
const unorderedSecond = previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments: [...extraAssignments].reverse(),
|
|
});
|
|
|
|
expect(second).toEqual(first);
|
|
expect(unorderedSecond).toEqual(unorderedFirst);
|
|
expect(first).toEqual({
|
|
sourceRevision: 2,
|
|
impactHash: expect.stringMatching(/^[a-f0-9]{64}$/),
|
|
impact: {
|
|
seriesIds: ['series-parent', 'series-child'],
|
|
factIds: ['fact-parent', 'fact-child'],
|
|
gameSlotIds: ['slot-child', 'slot-parent'],
|
|
teamIds: ['team-3', 'team-8'],
|
|
releasesReservedCodes: 1,
|
|
voidsUsedCodes: 1,
|
|
requiresStatsRebuild: true,
|
|
},
|
|
});
|
|
});
|
|
|
|
it('rejects a stale or changed preview before emitting reversal facts', () => {
|
|
const preview = previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments,
|
|
});
|
|
|
|
expect(() =>
|
|
assertReversalPreview(
|
|
{
|
|
competitionId: 'competition-1',
|
|
revision: 3,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments,
|
|
},
|
|
preview.impactHash,
|
|
),
|
|
).toThrow(expect.objectContaining({ code: 'REVERSAL_PREVIEW_STALE' }));
|
|
});
|
|
|
|
it('emits one append-only reversal fact for every active result fact', () => {
|
|
const preview = previewSeriesReversal({
|
|
competitionId: 'competition-1',
|
|
revision: 2,
|
|
seriesId: 'series-parent',
|
|
mode: 'cascade',
|
|
graph,
|
|
facts,
|
|
assignments,
|
|
});
|
|
|
|
expect(
|
|
buildReversalFacts({
|
|
preview,
|
|
facts,
|
|
competitionId: 'competition-1',
|
|
commandId: 'command-reverse',
|
|
nextRevision: 3,
|
|
actor: { type: 'user', userId: 'admin-1' },
|
|
reason: '잘못 수집된 게임',
|
|
occurredAt: new Date('2026-07-12T01:00:00.000Z'),
|
|
}),
|
|
).toEqual([
|
|
expect.objectContaining({
|
|
type: 'game-voided',
|
|
gameAcceptedFactId: 'fact-parent',
|
|
revision: 3,
|
|
ordinalWithinRevision: 1,
|
|
}),
|
|
expect.objectContaining({
|
|
type: 'game-voided',
|
|
gameAcceptedFactId: 'fact-child',
|
|
revision: 3,
|
|
ordinalWithinRevision: 2,
|
|
}),
|
|
]);
|
|
});
|
|
});
|
|
|
|
function series(id: string, sources: Array<Record<string, unknown>>) {
|
|
return {
|
|
id,
|
|
stage: { type: 'upper' as const, displayOrder: 1 },
|
|
slots: [
|
|
{ position: 'A' as const, source: sources[0] },
|
|
{ position: 'B' as const, source: sources[1] },
|
|
],
|
|
rule: { type: 'first-to' as const, winsRequired: 1, maxGames: 1 },
|
|
gameSlots: [{ id: id.replace('series', 'slot'), seriesId: id, ordinal: 1 }],
|
|
};
|
|
}
|
|
|
|
function team(teamId: string) {
|
|
return { type: 'team', teamId };
|
|
}
|
|
|
|
function winner(seriesId: string) {
|
|
return { type: 'series-outcome', seriesId, select: 'winner' };
|
|
}
|
|
|
|
function loser(seriesId: string) {
|
|
return { type: 'series-outcome', seriesId, select: 'loser' };
|
|
}
|
|
|
|
function accepted(
|
|
id: string,
|
|
seriesId: string,
|
|
gameSlotId: string,
|
|
winnerTeamId: string,
|
|
loserTeamId: string,
|
|
) {
|
|
return {
|
|
id,
|
|
type: 'game-accepted',
|
|
seriesId,
|
|
gameSlotId,
|
|
mapping: {
|
|
blueTeamId: winnerTeamId,
|
|
redTeamId: loserTeamId,
|
|
winnerTeamId,
|
|
},
|
|
};
|
|
}
|
|
|
|
function assignment(
|
|
id: string,
|
|
seriesId: string,
|
|
gameSlotId: string,
|
|
state: 'reserved' | 'used',
|
|
) {
|
|
return { id, seriesId, gameSlotId, state };
|
|
}
|