b566c5f1a5
The two Wildcard Round winners were crossed into the Elimination Finals by which game they came out of — the 7v10 winner always met 6th and the 8v9 winner always met 5th. The AFL pairs those games by ladder position, as the classic final eight pairs 5v8 and 6v7: the higher host draws the lower-ranked survivor. So when 10th wins through, 5th should meet 10th, not the 8v9 winner. Placement now resolves both games together. A 7v10 winner is placed as soon as it is decided (7th outranks either possible opponent, 10th is outranked by both), while an 8v9 winner is held until the other game is decided rather than being placed and later moved, so results can be entered in either order. The simulator paired the Elimination Finals the same fixed way, which biased every projection that ran off an undecided Wildcard Round; it now re-seeds too. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VDbHrCce1UhahbkwKkc7hK
685 lines
28 KiB
TypeScript
685 lines
28 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, type MockInstance } from "vitest";
|
||
import { normalizeTeamName } from "~/lib/normalize-team-name";
|
||
import {
|
||
getTeamData,
|
||
eloWinProbability,
|
||
AFLSimulator,
|
||
readAflBracketSeeds,
|
||
simAFLFinals,
|
||
type BracketMatch,
|
||
} from "../afl-simulator";
|
||
import { DEFAULT_SCORING_RULES } from "~/lib/scoring-types";
|
||
import { calculateEV, type ProbabilityDistribution } from "~/services/ev-calculator";
|
||
|
||
// ─── normalizeTeamName ────────────────────────────────────────────────────────
|
||
|
||
describe("normalizeTeamName", () => {
|
||
it("lowercases and trims", () => {
|
||
expect(normalizeTeamName(" Western Bulldogs ")).toBe("western bulldogs");
|
||
});
|
||
|
||
it("collapses internal whitespace", () => {
|
||
expect(normalizeTeamName("Greater Western Sydney")).toBe("greater western sydney");
|
||
});
|
||
|
||
it("is already-normalized identity", () => {
|
||
expect(normalizeTeamName("gold coast")).toBe("gold coast");
|
||
});
|
||
});
|
||
|
||
// ─── getTeamData ──────────────────────────────────────────────────────────────
|
||
|
||
describe("getTeamData", () => {
|
||
it("returns data for an exact match", () => {
|
||
const d = getTeamData("Western Bulldogs");
|
||
expect(d).toBeDefined();
|
||
expect(d?.elo).toBe(1646);
|
||
});
|
||
|
||
it("is case-insensitive", () => {
|
||
expect(getTeamData("western bulldogs")).toEqual(getTeamData("Western Bulldogs"));
|
||
});
|
||
|
||
it("returns undefined for an unknown team", () => {
|
||
expect(getTeamData("Springfield Koalas")).toBeUndefined();
|
||
});
|
||
|
||
it("all 18 AFL clubs are present", () => {
|
||
const allTeams = [
|
||
"Western Bulldogs", "Gold Coast", "Hawthorn", "Geelong",
|
||
"Adelaide", "Sydney", "Fremantle", "Collingwood",
|
||
"Brisbane Lions", "Greater Western Sydney", "Carlton", "Port Adelaide",
|
||
"St Kilda", "North Melbourne", "Melbourne", "Essendon",
|
||
"Richmond", "West Coast",
|
||
];
|
||
for (const name of allTeams) {
|
||
expect(getTeamData(name), `missing team: ${name}`).toBeDefined();
|
||
}
|
||
});
|
||
|
||
it("Western Bulldogs has the highest Elo", () => {
|
||
const bulldogs = getTeamData("Western Bulldogs")?.elo ?? 0;
|
||
const westCoast = getTeamData("West Coast")?.elo ?? 0;
|
||
expect(bulldogs).toBeGreaterThan(westCoast);
|
||
});
|
||
|
||
it("Elo ratings are in the expected range (1250–1750)", () => {
|
||
const allTeams = [
|
||
"Western Bulldogs", "Gold Coast", "Hawthorn", "Geelong",
|
||
"Adelaide", "Sydney", "Fremantle", "Collingwood",
|
||
"Brisbane Lions", "Greater Western Sydney", "Carlton", "Port Adelaide",
|
||
"St Kilda", "North Melbourne", "Melbourne", "Essendon",
|
||
"Richmond", "West Coast",
|
||
];
|
||
for (const name of allTeams) {
|
||
const elo = getTeamData(name)?.elo ?? 0;
|
||
expect(elo, `${name} elo out of range`).toBeGreaterThanOrEqual(1250);
|
||
expect(elo, `${name} elo out of range`).toBeLessThanOrEqual(1750);
|
||
}
|
||
});
|
||
});
|
||
|
||
// ─── eloWinProbability ────────────────────────────────────────────────────────
|
||
|
||
describe("eloWinProbability (PARITY_FACTOR = 450)", () => {
|
||
it("returns 0.5 for equal Elo ratings", () => {
|
||
expect(eloWinProbability(1500, 1500)).toBeCloseTo(0.5, 6);
|
||
});
|
||
|
||
it("favors the higher-rated team", () => {
|
||
expect(eloWinProbability(1706, 1500)).toBeGreaterThan(0.5);
|
||
expect(eloWinProbability(1295, 1500)).toBeLessThan(0.5);
|
||
});
|
||
|
||
it("is anti-symmetric: P(A>B) + P(B>A) = 1", () => {
|
||
const p = eloWinProbability(1706, 1295);
|
||
expect(p + eloWinProbability(1295, 1706)).toBeCloseTo(1.0, 10);
|
||
});
|
||
|
||
it("a 450-pt gap gives ~90.9% win probability", () => {
|
||
// P = 1 / (1 + 10^(-450/450)) = 1 / (1 + 10^-1) = 1/1.1 ≈ 0.909
|
||
const p = eloWinProbability(1950, 1500);
|
||
expect(p).toBeCloseTo(1 / 1.1, 5);
|
||
});
|
||
|
||
it("Bulldogs (1646) vs Essendon (1342): strongly favors Bulldogs", () => {
|
||
// 304-pt gap at parity 450: P = 1/(1+10^(-304/450)) ≈ 0.826
|
||
const p = eloWinProbability(1646, 1342);
|
||
expect(p).toBeGreaterThan(0.80);
|
||
});
|
||
});
|
||
|
||
// ─── AFLSimulator.simulate() integration tests ───────────────────────────────
|
||
|
||
vi.mock("~/database/context", () => ({
|
||
database: vi.fn(),
|
||
}));
|
||
|
||
vi.mock("~/models/regular-season-standings", () => ({
|
||
getRegularSeasonStandings: vi.fn(),
|
||
}));
|
||
|
||
const AFL_TEAMS = [
|
||
"Western Bulldogs", "Gold Coast", "Hawthorn", "Geelong",
|
||
"Adelaide", "Sydney", "Fremantle", "Collingwood",
|
||
"Brisbane Lions", "Greater Western Sydney", "Carlton", "Port Adelaide",
|
||
"St Kilda", "North Melbourne", "Melbourne", "Essendon",
|
||
"Richmond", "West Coast",
|
||
];
|
||
|
||
const PARTICIPANT_ROWS = AFL_TEAMS.map((name, i) => ({
|
||
id: `team-${i + 1}`,
|
||
name,
|
||
}));
|
||
|
||
const PARTICIPANT_IDS = PARTICIPANT_ROWS.map((r) => r.id);
|
||
|
||
/**
|
||
* Build the playoff_matches rows generateAFL10Bracket writes, seeded with `seedIds` in
|
||
* ladder order (index 0 = minor premier). `completed` overrides individual matches with a
|
||
* recorded result.
|
||
*/
|
||
function aflBracketMatches(
|
||
seedIds: string[],
|
||
completed: Array<{ round: string; matchNumber: number; winnerId: string; loserId: string }> = []
|
||
): BracketMatch[] {
|
||
const seed = (n: number) => seedIds[n - 1] ?? null;
|
||
const rows: BracketMatch[] = [
|
||
{ round: "Wildcard Round", matchNumber: 1, participant1Id: seed(7), participant2Id: seed(10) },
|
||
{ round: "Wildcard Round", matchNumber: 2, participant1Id: seed(8), participant2Id: seed(9) },
|
||
{ round: "Qualifying Finals", matchNumber: 1, participant1Id: seed(1), participant2Id: seed(4) },
|
||
{ round: "Qualifying Finals", matchNumber: 2, participant1Id: seed(2), participant2Id: seed(3) },
|
||
// participant2 is TBD until a Wildcard winner advances into it.
|
||
{ round: "Elimination Finals", matchNumber: 1, participant1Id: seed(5), participant2Id: null },
|
||
{ round: "Elimination Finals", matchNumber: 2, participant1Id: seed(6), participant2Id: null },
|
||
{ round: "Semi-Finals", matchNumber: 1, participant1Id: null, participant2Id: null },
|
||
{ round: "Semi-Finals", matchNumber: 2, participant1Id: null, participant2Id: null },
|
||
{ round: "Preliminary Finals", matchNumber: 1, participant1Id: null, participant2Id: null },
|
||
{ round: "Preliminary Finals", matchNumber: 2, participant1Id: null, participant2Id: null },
|
||
{ round: "Grand Final", matchNumber: 1, participant1Id: null, participant2Id: null },
|
||
].map((m) => ({ ...m, winnerId: null, loserId: null, isComplete: false }));
|
||
|
||
for (const done of completed) {
|
||
const row = rows.find((r) => r.round === done.round && r.matchNumber === done.matchNumber);
|
||
if (!row) throw new Error(`no such match: ${done.round} #${done.matchNumber}`);
|
||
row.isComplete = true;
|
||
row.winnerId = done.winnerId;
|
||
row.loserId = done.loserId;
|
||
// A Wildcard winner is advanced into the Elimination Final it feeds.
|
||
if (done.round === "Wildcard Round") {
|
||
const ef = rows.find(
|
||
(r) => r.round === "Elimination Finals" && r.matchNumber === (done.matchNumber === 1 ? 2 : 1)
|
||
);
|
||
if (ef) ef.participant2Id = done.winnerId;
|
||
}
|
||
}
|
||
|
||
return rows;
|
||
}
|
||
|
||
/** The one bracket row for a round/match, failing loudly if the fixture changes shape. */
|
||
function matchIn(matches: BracketMatch[], round: string, matchNumber: number): BracketMatch {
|
||
const found = matches.find((m) => m.round === round && m.matchNumber === matchNumber);
|
||
if (!found) throw new Error(`no such match: ${round} #${matchNumber}`);
|
||
return found;
|
||
}
|
||
|
||
/** Look up one participant's result, failing loudly rather than silently passing on undefined. */
|
||
function resultFor<T extends { participantId: string }>(results: T[], participantId: string): T {
|
||
const found = results.find((r) => r.participantId === participantId);
|
||
if (!found) throw new Error(`no simulation result for ${participantId}`);
|
||
return found;
|
||
}
|
||
|
||
/** EV on the reference scale the runner persists with. */
|
||
function evOf(result: { probabilities: ProbabilityDistribution }): number {
|
||
return calculateEV(result.probabilities, DEFAULT_SCORING_RULES);
|
||
}
|
||
|
||
describe("AFLSimulator.simulate()", () => {
|
||
let mockDb: {
|
||
select: MockInstance;
|
||
query: {
|
||
scoringEvents: { findMany: MockInstance };
|
||
playoffMatches: { findMany: MockInstance };
|
||
};
|
||
};
|
||
|
||
/** Put a seeded afl_10 bracket in front of the simulator. */
|
||
function seedBracket(matches: BracketMatch[]) {
|
||
mockDb.query.scoringEvents.findMany.mockResolvedValue([{ id: "event-1" }]);
|
||
mockDb.query.playoffMatches.findMany.mockResolvedValue(matches);
|
||
}
|
||
|
||
beforeEach(async () => {
|
||
const { database } = await import("~/database/context");
|
||
const { getRegularSeasonStandings } = await import("~/models/regular-season-standings");
|
||
|
||
const participantRows = PARTICIPANT_ROWS;
|
||
|
||
let selectCallCount = 0;
|
||
mockDb = {
|
||
// Default: no bracket generated yet, so the ladder-projection path runs.
|
||
query: {
|
||
scoringEvents: { findMany: vi.fn().mockResolvedValue([]) },
|
||
playoffMatches: { findMany: vi.fn().mockResolvedValue([]) },
|
||
},
|
||
select: vi.fn().mockImplementation(() => {
|
||
selectCallCount++;
|
||
if (selectCallCount === 1) {
|
||
return {
|
||
from: vi.fn().mockReturnValue({
|
||
where: vi.fn().mockResolvedValue(participantRows),
|
||
}),
|
||
};
|
||
}
|
||
// Second call: sourceElo query (no DB Elo by default)
|
||
return {
|
||
from: vi.fn().mockReturnValue({
|
||
where: vi.fn().mockResolvedValue([]),
|
||
}),
|
||
};
|
||
}),
|
||
};
|
||
|
||
(database as unknown as MockInstance).mockReturnValue(mockDb);
|
||
// Default: no standings (pre-season)
|
||
(getRegularSeasonStandings as unknown as MockInstance).mockResolvedValue([]);
|
||
});
|
||
|
||
it("throws if no participants found", async () => {
|
||
let selectCallCount = 0;
|
||
mockDb.select.mockImplementation(() => {
|
||
selectCallCount++;
|
||
if (selectCallCount === 1) {
|
||
return {
|
||
from: vi.fn().mockReturnValue({
|
||
where: vi.fn().mockResolvedValue([]),
|
||
}),
|
||
};
|
||
}
|
||
return {
|
||
from: vi.fn().mockReturnValue({
|
||
where: vi.fn().mockResolvedValue([]),
|
||
}),
|
||
};
|
||
});
|
||
const sim = new AFLSimulator();
|
||
await expect(sim.simulate("season-1")).rejects.toThrow(/No participants found/);
|
||
});
|
||
|
||
it("returns 18 results — one per AFL club", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
expect(results).toHaveLength(18);
|
||
});
|
||
|
||
it("all probability values are non-negative", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
for (const r of results) {
|
||
for (const val of Object.values(r.probabilities)) {
|
||
expect(val).toBeGreaterThanOrEqual(0);
|
||
}
|
||
}
|
||
});
|
||
|
||
it("each column (probFirst through probEighth) sums to 1.0 across all participants", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
const keys = [
|
||
"probFirst", "probSecond", "probThird", "probFourth",
|
||
"probFifth", "probSixth", "probSeventh", "probEighth",
|
||
] as const;
|
||
for (const key of keys) {
|
||
const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
|
||
expect(colSum, `${key} column sum`).toBeCloseTo(1.0, 2);
|
||
}
|
||
});
|
||
|
||
it("P5/P6 and P7/P8 are distinct tiers (separate column sums, not a combined 5–8 pool)", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
// probFifth should sum to 1.0 (SF losers only) — NOT 2.0 (which would happen if EF losers were mixed in)
|
||
const fifthSum = results.reduce((s, r) => s + r.probabilities.probFifth, 0);
|
||
const seventhSum = results.reduce((s, r) => s + r.probabilities.probSeventh, 0);
|
||
expect(fifthSum).toBeCloseTo(1.0, 2);
|
||
expect(seventhSum).toBeCloseTo(1.0, 2);
|
||
});
|
||
|
||
it("probThird === probFourth for every participant (3rd/4th share same points in AFL)", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
for (const r of results) {
|
||
expect(r.probabilities.probThird).toBeCloseTo(r.probabilities.probFourth, 10);
|
||
}
|
||
});
|
||
|
||
it("probFifth === probSixth for every participant (5th/6th share same points in AFL)", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
for (const r of results) {
|
||
expect(r.probabilities.probFifth).toBeCloseTo(r.probabilities.probSixth, 10);
|
||
}
|
||
});
|
||
|
||
it("probSeventh === probEighth for every participant (7th/8th share same points in AFL)", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
for (const r of results) {
|
||
expect(r.probabilities.probSeventh).toBeCloseTo(r.probabilities.probEighth, 10);
|
||
}
|
||
});
|
||
|
||
it("uses source: 'afl_bracket_monte_carlo' on all results", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
for (const r of results) {
|
||
expect(r.source).toBe("afl_bracket_monte_carlo");
|
||
}
|
||
});
|
||
|
||
it("all result participant IDs match input participant IDs", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
const resultIds = new Set(results.map((r) => r.participantId));
|
||
for (const id of PARTICIPANT_IDS) {
|
||
expect(resultIds.has(id), `missing participant: ${id}`).toBe(true);
|
||
}
|
||
});
|
||
|
||
it("Western Bulldogs (highest Elo) has the highest championship probability", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
const bulldogsResult = results.find((r) => r.participantId === "team-1"); // Western Bulldogs (highest Elo)
|
||
const westCoastResult = results.find((r) => r.participantId === "team-18"); // West Coast (near-lowest Elo)
|
||
if (!bulldogsResult || !westCoastResult) throw new Error("Expected results not found");
|
||
|
||
// The #1 Elo team should win the championship more often than the last-ranked team
|
||
expect(bulldogsResult.probabilities.probFirst).toBeGreaterThan(westCoastResult.probabilities.probFirst);
|
||
});
|
||
|
||
it("bottom-ranked teams rarely make finals (low combined probability)", async () => {
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
// West Coast and Richmond (16th/17th Elo) should have very low combined finals probability
|
||
const westCoast = results.find((r) => r.participantId === "team-18");
|
||
const richmond = results.find((r) => r.participantId === "team-17");
|
||
if (!westCoast || !richmond) throw new Error("Expected results not found");
|
||
|
||
const wcTotal = Object.values(westCoast.probabilities).reduce((a, b) => a + b, 0);
|
||
const ricTotal = Object.values(richmond.probabilities).reduce((a, b) => a + b, 0);
|
||
|
||
// Combined probability for a bottom team should be well below 1.0
|
||
expect(wcTotal).toBeLessThan(0.5);
|
||
expect(ricTotal).toBeLessThan(0.5);
|
||
});
|
||
|
||
it("mid-season standings: team with most wins has elevated finals probability", async () => {
|
||
const { getRegularSeasonStandings } = await import("~/models/regular-season-standings");
|
||
|
||
// Give Western Bulldogs (team-1) 15 wins from 18 games — top of ladder
|
||
(getRegularSeasonStandings as unknown as MockInstance).mockResolvedValue([
|
||
{ participantId: "team-1", wins: 15, gamesPlayed: 18, losses: 3 },
|
||
// All other teams have 5 wins
|
||
...PARTICIPANT_IDS.slice(1).map((id) => ({ participantId: id, wins: 5, gamesPlayed: 18, losses: 13 })),
|
||
]);
|
||
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
const leader = results.find((r) => r.participantId === "team-1");
|
||
const bottom = results.find((r) => r.participantId === "team-18");
|
||
if (!leader || !bottom) throw new Error("Expected results not found");
|
||
|
||
expect(leader.probabilities.probFirst).toBeGreaterThan(bottom.probabilities.probFirst);
|
||
});
|
||
|
||
it("DB sourceElo overrides hardcoded TEAMS_DATA values", async () => {
|
||
// Set DB Elo for West Coast (team-18) to 1800 (higher than Bulldogs)
|
||
let selectCallCount = 0;
|
||
mockDb.select.mockImplementation(() => {
|
||
selectCallCount++;
|
||
if (selectCallCount === 1) {
|
||
return {
|
||
from: vi.fn().mockReturnValue({
|
||
where: vi.fn().mockResolvedValue(PARTICIPANT_ROWS),
|
||
}),
|
||
};
|
||
}
|
||
return {
|
||
from: vi.fn().mockReturnValue({
|
||
where: vi.fn().mockResolvedValue([
|
||
{ participantId: "team-18", sourceElo: 1800 },
|
||
]),
|
||
}),
|
||
};
|
||
});
|
||
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
const westCoast = results.find((r) => r.participantId === "team-18");
|
||
const bulldogs = results.find((r) => r.participantId === "team-1");
|
||
if (!westCoast || !bulldogs) throw new Error("Expected results not found");
|
||
|
||
// With DB Elo 1800, West Coast should now be favored over Bulldogs (1646)
|
||
expect(westCoast.probabilities.probFirst).toBeGreaterThan(bulldogs.probabilities.probFirst);
|
||
});
|
||
|
||
it("falls back to hardcoded TEAMS_DATA when no DB sourceElo exists", async () => {
|
||
// Default mock already returns no sourceElo rows — should use TEAMS_DATA
|
||
const sim = new AFLSimulator();
|
||
const results = await sim.simulate("season-1");
|
||
|
||
const bulldogs = results.find((r) => r.participantId === "team-1");
|
||
const westCoast = results.find((r) => r.participantId === "team-18");
|
||
if (!bulldogs || !westCoast) throw new Error("Expected results not found");
|
||
|
||
// Bulldogs (1646) should still be favored over West Coast (1362) from hardcoded data
|
||
expect(bulldogs.probabilities.probFirst).toBeGreaterThan(westCoast.probabilities.probFirst);
|
||
});
|
||
|
||
// ─── Bracket-aware mode ─────────────────────────────────────────────────────
|
||
//
|
||
// afl_10 banks points on seeding alone (entryFloor 5 for seeds 1-4, 7 for seeds 5-6) and
|
||
// on winning a non-scoring round (nonScoringWinnerFloor 7 for the Wildcard Round, 3 for a
|
||
// Qualifying Final). Those floors are paid out as real fantasy points, so a simulator that
|
||
// re-draws the ladder every iteration — putting a seeded team back in the Wildcard Round or
|
||
// out of the finals, where it scores 0 — reports an EV below points already awarded. Each
|
||
// EV assertion below is that floor.
|
||
|
||
describe("bracket-aware mode", () => {
|
||
/**
|
||
* Seeds 1-10 in ladder order, drawn from the ten *weakest* clubs by Elo. Seeding the
|
||
* strongest ten would let the ladder-projection path produce much the same field by
|
||
* accident, so the floor assertions below would pass even with the bracket ignored.
|
||
*/
|
||
const SEEDS = PARTICIPANT_IDS.slice(8);
|
||
|
||
it("never values a seed below the entry floor its seeding already banked", async () => {
|
||
seedBracket(aflBracketMatches(SEEDS));
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
// Seeds 1-4 enter a Qualifying Final: lose it, lose the Semi-Final, still 5th-6th (25).
|
||
for (const seed of [1, 2, 3, 4]) {
|
||
expect(evOf(resultFor(results, SEEDS[seed - 1])), `seed ${seed}`).toBeGreaterThanOrEqual(25);
|
||
}
|
||
// Seeds 5-6 enter an Elimination Final: lose it and they are 7th-8th (15).
|
||
for (const seed of [5, 6]) {
|
||
expect(evOf(resultFor(results, SEEDS[seed - 1])), `seed ${seed}`).toBeGreaterThanOrEqual(15);
|
||
}
|
||
});
|
||
|
||
it("keeps a Qualifying Final entrant out of the 7th-8th tier entirely", async () => {
|
||
seedBracket(aflBracketMatches(SEEDS));
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
// A seed 1-4 loses the QF into a Semi-Final, so 5th-6th is its worst finish. The
|
||
// 7th-8th tier is reachable only by losing an Elimination Final.
|
||
for (const seed of [1, 2, 3, 4]) {
|
||
expect(resultFor(results, SEEDS[seed - 1]).probabilities.probSeventh, `seed ${seed}`).toBe(0);
|
||
}
|
||
// Seeds 5-10 all reach an Elimination Final only by playing one, so they can.
|
||
expect(resultFor(results, SEEDS[4]).probabilities.probSeventh).toBeGreaterThan(0);
|
||
});
|
||
|
||
it("uses the bracket's draw rather than a re-projected ladder", async () => {
|
||
// Deliberately inverted: the weakest club is the minor premier and the strongest
|
||
// scrapes in 10th. On the ladder-projection path Elo decides the seeding, so this only
|
||
// holds if the bracket's own slots are being read.
|
||
const inverted = [
|
||
"team-18", "team-17", "team-16", "team-15", "team-14",
|
||
"team-13", "team-12", "team-11", "team-10", "team-1",
|
||
];
|
||
seedBracket(aflBracketMatches(inverted));
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
// West Coast (weakest Elo) is seeded 1, so it holds the double chance and can never
|
||
// finish 7th-8th, and its EV clears the seed 1-4 floor.
|
||
expect(resultFor(results, "team-18").probabilities.probSeventh).toBe(0);
|
||
expect(evOf(resultFor(results, "team-18"))).toBeGreaterThanOrEqual(25);
|
||
|
||
// Western Bulldogs (strongest Elo) is seeded 10, so it starts in the Wildcard Round
|
||
// with nothing banked and can be knocked out for 0.
|
||
expect(resultFor(results, "team-1").probabilities.probSeventh).toBeGreaterThan(0);
|
||
});
|
||
|
||
it("zeroes every participant outside the bracket", async () => {
|
||
seedBracket(aflBracketMatches(SEEDS));
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
for (const r of results.filter((x) => !SEEDS.includes(x.participantId))) {
|
||
expect(evOf(r), r.participantId).toBe(0);
|
||
}
|
||
expect(results).toHaveLength(18);
|
||
});
|
||
|
||
it("still normalizes every column to 1.0 and the field to 340 total EV", async () => {
|
||
seedBracket(aflBracketMatches(SEEDS));
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
const keys = [
|
||
"probFirst", "probSecond", "probThird", "probFourth",
|
||
"probFifth", "probSixth", "probSeventh", "probEighth",
|
||
] as const;
|
||
for (const key of keys) {
|
||
const colSum = results.reduce((s, r) => s + r.probabilities[key], 0);
|
||
expect(colSum, `${key} column sum`).toBeCloseTo(1.0, 6);
|
||
}
|
||
expect(results.reduce((s, r) => s + evOf(r), 0)).toBeCloseTo(340, 4);
|
||
});
|
||
|
||
it("replays a completed Wildcard Round instead of re-simulating it", async () => {
|
||
// Seed 10 beat seed 7, which banks seed 10 a 7th-place floor (15 points).
|
||
seedBracket(
|
||
aflBracketMatches(SEEDS, [
|
||
{ round: "Wildcard Round", matchNumber: 1, winnerId: SEEDS[9], loserId: SEEDS[6] },
|
||
])
|
||
);
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
expect(evOf(resultFor(results, SEEDS[9]))).toBeGreaterThanOrEqual(15);
|
||
// The loser is out with nothing, in every iteration.
|
||
expect(evOf(resultFor(results, SEEDS[6]))).toBe(0);
|
||
});
|
||
|
||
it("replays a completed Qualifying Final, banking the winner's 3rd-4th floor", async () => {
|
||
// Seed 1 beat seed 4: the winner byes into a Preliminary Final (floor 3rd, 45 points)
|
||
// and the loser drops into a Semi-Final (floor 5th, 25 points).
|
||
seedBracket(
|
||
aflBracketMatches(SEEDS, [
|
||
{ round: "Qualifying Finals", matchNumber: 1, winnerId: SEEDS[0], loserId: SEEDS[3] },
|
||
])
|
||
);
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
const winner = resultFor(results, SEEDS[0]);
|
||
expect(evOf(winner)).toBeGreaterThanOrEqual(45);
|
||
// Already through to a Preliminary Final, so the 5th-6th tier is behind it.
|
||
expect(winner.probabilities.probFifth).toBe(0);
|
||
|
||
expect(evOf(resultFor(results, SEEDS[3]))).toBeGreaterThanOrEqual(25);
|
||
});
|
||
|
||
it("falls back to the ladder projection when the bracket carries no seeds", async () => {
|
||
seedBracket(aflBracketMatches([]));
|
||
const results = await new AFLSimulator().simulate("season-1");
|
||
|
||
// Every club is back in contention, so nobody is structurally zeroed.
|
||
expect(results.filter((r) => evOf(r) > 0).length).toBeGreaterThan(10);
|
||
});
|
||
});
|
||
});
|
||
|
||
// ─── readAflBracketSeeds ──────────────────────────────────────────────────────
|
||
|
||
describe("readAflBracketSeeds", () => {
|
||
const teamsById = new Map(
|
||
PARTICIPANT_IDS.map((id) => [id, { id, name: id, elo: 1500, currentWins: 0, remainingGames: 0, winProb: 0.5 }])
|
||
);
|
||
const SEEDS = PARTICIPANT_IDS.slice(0, 10);
|
||
|
||
it("returns null when there is no bracket at all", () => {
|
||
expect(readAflBracketSeeds([], teamsById as never)).toBeNull();
|
||
});
|
||
|
||
it("returns null for a generated but unseeded bracket", () => {
|
||
expect(readAflBracketSeeds(aflBracketMatches([]), teamsById as never)).toBeNull();
|
||
});
|
||
|
||
it("reads the 10 seeds in ladder order", () => {
|
||
const bracket = readAflBracketSeeds(aflBracketMatches(SEEDS), teamsById as never);
|
||
expect(bracket?.seeds.map((t) => t.id)).toEqual(SEEDS);
|
||
});
|
||
|
||
it("does not treat the TBD Elimination Final slots as missing seeds", () => {
|
||
const matches = aflBracketMatches(SEEDS);
|
||
for (const m of matches.filter((r) => r.round === "Elimination Finals")) {
|
||
expect(m.participant2Id).toBeNull();
|
||
}
|
||
expect(readAflBracketSeeds(matches, teamsById as never)).not.toBeNull();
|
||
});
|
||
|
||
it("throws on a partially seeded bracket rather than discarding the draw", () => {
|
||
const matches = aflBracketMatches(SEEDS);
|
||
// ON DELETE SET NULL empties a slot when a participant is removed and re-added.
|
||
matchIn(matches, "Qualifying Finals", 1).participant2Id = null;
|
||
expect(() => readAflBracketSeeds(matches, teamsById as never)).toThrow(/partially seeded.*seed\(s\) 4/s);
|
||
});
|
||
|
||
it("throws when one participant holds two slots", () => {
|
||
const matches = aflBracketMatches(SEEDS);
|
||
matchIn(matches, "Wildcard Round", 1).participant2Id = SEEDS[0];
|
||
expect(() => readAflBracketSeeds(matches, teamsById as never)).toThrow(/more than one slot/);
|
||
});
|
||
|
||
it("throws when the bracket references a participant outside the season", () => {
|
||
const matches = aflBracketMatches(SEEDS);
|
||
matchIn(matches, "Wildcard Round", 1).participant2Id = "ghost";
|
||
expect(() => readAflBracketSeeds(matches, teamsById as never)).toThrow(/not in this sports season/);
|
||
});
|
||
});
|
||
|
||
// ─── simAFLFinals ─────────────────────────────────────────────────────────────
|
||
|
||
describe("simAFLFinals Elimination Finals re-seeding", () => {
|
||
const finalists = Array.from({ length: 10 }, (_, i) => ({
|
||
id: `s${i + 1}`,
|
||
name: `s${i + 1}`,
|
||
elo: 1500,
|
||
currentWins: 0,
|
||
remainingGames: 0,
|
||
winProb: 0.5,
|
||
}));
|
||
|
||
/**
|
||
* Play the finals with the Wildcard Round forced to the given winners (every other
|
||
* game goes to whoever was routed in first), and report who met whom.
|
||
*/
|
||
function pairingsWith(wc1Winner: string, wc2Winner: string): Map<string, [string, string]> {
|
||
const pairings = new Map<string, [string, string]>();
|
||
const play = (
|
||
round: string,
|
||
matchNumber: number,
|
||
t1: { id: string },
|
||
t2: { id: string }
|
||
) => {
|
||
pairings.set(`${round}#${matchNumber}`, [t1.id, t2.id]);
|
||
if (round === "Wildcard Round") {
|
||
const forced = matchNumber === 1 ? wc1Winner : wc2Winner;
|
||
return t1.id === forced ? { winner: t1, loser: t2 } : { winner: t2, loser: t1 };
|
||
}
|
||
return { winner: t1, loser: t2 };
|
||
};
|
||
|
||
simAFLFinals(finalists as never, play as never);
|
||
return pairings;
|
||
}
|
||
|
||
it("draws the Wildcard Round 7v10 and 8v9", () => {
|
||
const pairings = pairingsWith("s7", "s8");
|
||
expect(pairings.get("Wildcard Round#1")).toEqual(["s7", "s10"]);
|
||
expect(pairings.get("Wildcard Round#2")).toEqual(["s8", "s9"]);
|
||
});
|
||
|
||
it.each([
|
||
{ wc1: "s7", wc2: "s8", ef1: "s8", ef2: "s7" },
|
||
{ wc1: "s7", wc2: "s9", ef1: "s9", ef2: "s7" },
|
||
// 10th beating 7th is where a fixed crossover misfires: it would send 10th to 6th
|
||
// and leave 5th with the stronger survivor.
|
||
{ wc1: "s10", wc2: "s8", ef1: "s10", ef2: "s8" },
|
||
{ wc1: "s10", wc2: "s9", ef1: "s10", ef2: "s9" },
|
||
])(
|
||
"pairs 5th with $ef1 and 6th with $ef2 when $wc1 and $wc2 win through",
|
||
({ wc1, wc2, ef1, ef2 }) => {
|
||
const pairings = pairingsWith(wc1, wc2);
|
||
expect(pairings.get("Elimination Finals#1")).toEqual(["s5", ef1]);
|
||
expect(pairings.get("Elimination Finals#2")).toEqual(["s6", ef2]);
|
||
}
|
||
);
|
||
});
|