test(web): specify team progress presentation

This commit is contained in:
dahyeon committed 2026-07-13 21:16:23 -07:00
1 parent 96bae0ce28
commit 81b951889f
4 files changed
+657

No files matched your search

@@ -0,0 +1,228 @@
import assert from "node:assert/strict";
import test from "node:test";
import type {
BracketRoundView,
CompetitionFactId,
GameSlotId,
SeriesId,
SeriesProjection,
TeamId,
TeamTournamentCodeView,
} from "@lolympus/contracts";
import {
copyTournamentCode,
createTeamSeriesGroups,
getTeamSeriesDisplayLabel,
getTournamentCodeCopyLabel,
getTournamentCodePresentation,
sortCompletedTeamSeries,
} from "../src/pages/match-team-progress-view.ts";
const TEAM_A = "team-a" as TeamId;
const TEAM_B = "team-b" as TeamId;
test("groups only matching tournament codes under each active Series", () => {
const earlier = readySeries("series-earlier", 1);
const later = readySeries("series-later", 2);
const groups = createTeamSeriesGroups(
[later, earlier],
[
tournamentCode("later-2", later.seriesId, 2, 20),
tournamentCode("orphan", "series-orphan" as SeriesId, 1, 99),
tournamentCode("earlier-1", earlier.seriesId, 1, 17),
tournamentCode("later-1", later.seriesId, 1, 19),
],
);
assert.deepEqual(
groups.map(({ series, codes }) => ({
seriesId: series.seriesId,
gameSlotIds: codes.map(({ gameSlotId }) => gameSlotId),
})),
[
{ seriesId: earlier.seriesId, gameSlotIds: ["earlier-1"] },
{ seriesId: later.seriesId, gameSlotIds: ["later-1", "later-2"] },
],
);
});
test("uses Korean round names while keeping global game numbers secondary", () => {
const opening = readySeries("upper-opening-2", 1, "WB_R1_M2");
const final = readySeries("upper-final", 3, "WB_FINAL");
const rounds: BracketRoundView[] = [
round("upper", 1, 1, ["upper-opening-1", opening.seriesId]),
round("upper", 3, 3, [final.seriesId]),
];
assert.equal(
getTeamSeriesDisplayLabel(opening, rounds),
"승자조 1라운드 · 2경기",
);
assert.equal(getTeamSeriesDisplayLabel(final, rounds), "승자조 결승");
const assignment = tournamentCode("final-1", final.seriesId, 1, 19);
assert.equal(
getTournamentCodeCopyLabel(assignment, "승자조 결승"),
"승자조 결승 1세트 토너먼트 코드 복사 (전체 19번 게임)",
);
});
test("distinguishes pending, available, expired, and used code states", () => {
const now = Date.parse("2026-07-13T12:00:00.000Z");
const pending = tournamentCode("pending", "series-a" as SeriesId, 1, 1, {
state: "pending",
code: null,
});
const available = tournamentCode(
"available",
"series-a" as SeriesId,
2,
2,
{ expiresAt: "2026-07-13T13:00:00.000Z" },
);
const expired = tournamentCode(
"expired",
"series-a" as SeriesId,
3,
3,
{ expiresAt: "2026-07-13T11:00:00.000Z" },
);
const used = tournamentCode("used", "series-a" as SeriesId, 4, 4, {
state: "used",
expiresAt: "2026-07-13T11:00:00.000Z",
});
assert.deepEqual(getTournamentCodePresentation(pending, now), {
label: "발급 대기",
tone: "pending",
canCopy: false,
});
assert.deepEqual(getTournamentCodePresentation(available, now), {
label: "사용 가능",
tone: "available",
canCopy: true,
});
assert.deepEqual(getTournamentCodePresentation(expired, now), {
label: "만료",
tone: "expired",
canCopy: false,
});
assert.deepEqual(getTournamentCodePresentation(used, now), {
label: "사용 완료",
tone: "used",
canCopy: false,
});
});
test("returns explicit game-specific clipboard success and failure feedback", async () => {
const writes: string[] = [];
const success = await copyTournamentCode(
async (value) => {
writes.push(value);
},
"KR-CODE-19",
"승자조 결승 1세트",
);
const failure = await copyTournamentCode(
async () => {
throw new Error("clipboard denied");
},
"KR-CODE-20",
"승자조 결승 2세트",
);
assert.deepEqual(writes, ["KR-CODE-19"]);
assert.deepEqual(success, {
kind: "success",
message: "승자조 결승 1세트 코드를 복사했습니다.",
});
assert.deepEqual(failure, {
kind: "error",
message:
"승자조 결승 2세트 코드를 복사하지 못했습니다. 코드를 직접 선택해 복사해 주세요.",
});
});
test("sorts completed Series by most recent decision time", () => {
const older = completedSeries("older", "2026-07-12T10:00:00.000Z", 1);
const newer = completedSeries("newer", "2026-07-13T10:00:00.000Z", 2);
assert.deepEqual(
sortCompletedTeamSeries([older, newer]).map(({ seriesId }) => seriesId),
[newer.seriesId, older.seriesId],
);
});
function readySeries(
id: string,
displayOrder: number,
code = id.toUpperCase(),
): SeriesProjection {
return {
seriesId: id as SeriesId,
code,
stage: { type: "upper", roundNumber: displayOrder, displayOrder },
rule: { type: "first-to", winsRequired: 2, maxGames: 3 },
status: "ready",
entries: [
{ slot: "A", teamId: TEAM_A, gameWins: 0 },
{ slot: "B", teamId: TEAM_B, gameWins: 0 },
],
};
}
function completedSeries(
id: string,
completedAt: string,
displayOrder: number,
): Extract<SeriesProjection, { status: "completed" }> {
return {
...readySeries(id, displayOrder),
status: "completed",
entries: [
{ slot: "A", teamId: TEAM_A, gameWins: 0 },
{ slot: "B", teamId: TEAM_B, gameWins: 0 },
],
outcome: {
type: "walkover",
winnerTeamId: TEAM_A,
loserTeamId: TEAM_B,
decisionFactId: `${id}-fact` as CompetitionFactId,
completedAt,
},
};
}
function tournamentCode(
id: string,
seriesId: SeriesId,
ordinal: number,
displayNumber: number,
overrides: Partial<TeamTournamentCodeView> = {},
): TeamTournamentCodeView {
return {
gameSlotId: id as GameSlotId,
seriesId,
ordinal,
displayNumber,
state: "reserved",
code: `KR-${id}`,
expiresAt: null,
...overrides,
};
}
function round(
stage: BracketRoundView["stage"],
roundNumber: number,
displayOrder: number,
seriesIds: Array<string | SeriesId>,
): BracketRoundView {
return {
stage,
roundNumber,
displayOrder,
label: `${stage}-${roundNumber}`,
seriesIds: seriesIds.map((id) => id as SeriesId),
};
}