brackt/app/services/simulations/__tests__/llws-simulator.test.ts

import { describe, it, expect, vi, beforeEach, type MockInstance } from "vitest";
import { LLWSSimulator } from "../llws-simulator";

vi.mock("~/database/context", () => ({
  database: vi.fn(),
}));

vi.mock("~/services/probability-engine", async (importOriginal) => {
  const actual = await importOriginal() as Record<string, unknown>;
  return { ...actual };
});

// ─── Fixtures ─────────────────────────────────────────────────────────────────

const US_IDS = Array.from({ length: 10 }, (_, i) => `us-${i + 1}`);
const INTL_IDS = Array.from({ length: 10 }, (_, i) => `intl-${i + 1}`);
const ALL_IDS = [...US_IDS, ...INTL_IDS];

/**
 * Build EV rows with descending odds favouring the first team per side.
 * ids[0] is the strongest (best odds → lowest American number for favorites).
 */
function makeEvRows(ids: string[], opts: { includeOdds?: boolean } = {}) {
  return ids.map((participantId, i) => ({
    participantId,
    sourceOdds: opts.includeOdds ? (i === 0 ? -300 : 200 + i * 100) : null,
  }));
}

// ─── Tests ────────────────────────────────────────────────────────────────────

describe("LLWSSimulator", () => {
  let mockDb: { select: MockInstance };
  let selectCallCount: number;

  beforeEach(async () => {
    selectCallCount = 0;
    const { database } = await import("~/database/context");
    mockDb = { select: vi.fn() };
    (database as unknown as MockInstance).mockReturnValue(mockDb);
  });

  function setupMockDb(
    participants: { id: string; name?: string; externalId: string | null }[],
    evRows: { participantId: string; sourceOdds: number | null }[]
  ) {
    mockDb.select.mockImplementation(() => {
      const callIndex = selectCallCount++;
      const data = callIndex === 0 ? participants : evRows;
      return { from: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(data) }) };
    });
  }

  function defaultParticipants(mode: "randomized" | "fixed" = "randomized") {
    if (mode === "fixed") {
      const usA = US_IDS.slice(0, 5).map((id) => ({ id, name: `US Team ${id}`, externalId: "US:A" }));
      const usB = US_IDS.slice(5).map((id) => ({ id, name: `US Team ${id}`, externalId: "US:B" }));
      const intlA = INTL_IDS.slice(0, 5).map((id) => ({ id, name: `Team ${id}`, externalId: "Intl:A" }));
      const intlB = INTL_IDS.slice(5).map((id) => ({ id, name: `Team ${id}`, externalId: "Intl:B" }));
      return [...usA, ...usB, ...intlA, ...intlB];
    }
    return [
      ...US_IDS.map((id) => ({ id, name: `US Team ${id}`, externalId: "US" })),
      ...INTL_IDS.map((id) => ({ id, name: `Team ${id}`, externalId: "Intl" })),
    ];
  }

  // ── Core output structure ─────────────────────────────────────────────────

  describe("output structure", () => {
    it("returns one result per participant (20 total)", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      expect(results).toHaveLength(20);
    });

    it("every result has source 'llws_monte_carlo'", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      for (const r of results) {
        expect(r.source).toBe("llws_monte_carlo");
      }
    });

    it("all probability values are between 0 and 1", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      for (const r of results) {
        const p = r.probabilities;
        for (const v of Object.values(p)) {
          expect(v).toBeGreaterThanOrEqual(0);
          expect(v).toBeLessThanOrEqual(1);
        }
      }
    });
  });

  // ── Probability conservation ──────────────────────────────────────────────

  describe("probability conservation (one winner per sim)", () => {
    it("probFirst sums to ~1.0 across all participants", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probFirst, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("probSecond sums to ~1.0 across all participants", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probSecond, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("probThird sums to ~1.0 across all participants", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probThird, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("probFourth sums to ~1.0 across all participants", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probFourth, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("probFifth sums to ~1.0 (2 Elimination Final losers per sim, split over 5th/6th)", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probFifth, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("probSeventh sums to ~1.0 (2 Elimination Round 4 losers per sim, split over 7th/8th)", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probSeventh, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("ties 5th with 6th and 7th with 8th, but keeps the two tiers separate", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS, { includeOdds: true }));
      const results = await new LLWSSimulator(2_000).simulate("season-1");
      for (const r of results) {
        const p = r.probabilities;
        // Within a tier the two positions are tied.
        expect(p.probFifth).toBeCloseTo(p.probSixth, 10);
        expect(p.probSeventh).toBeCloseTo(p.probEighth, 10);
      }
      // The tiers are distinct outcomes (losing the Elimination Final vs losing
      // Elimination Round 4), so they must not be forced equal across the field.
      const differs = results.some(
        (r) => Math.abs(r.probabilities.probFifth - r.probabilities.probSeventh) > 1e-9
      );
      expect(differs).toBe(true);
    });

    it("gives every team a total placement probability of at most 1", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      for (const r of results) {
        const p = r.probabilities;
        // Each sim assigns a team at most one placement, so summing the distinct
        // tiers (5th/6th and 7th/8th each count once) cannot exceed 1.
        const total =
          p.probFirst + p.probSecond + p.probThird + p.probFourth +
          p.probFifth * 2 + p.probSeventh * 2;
        expect(total).toBeLessThanOrEqual(1 + 1e-9);
      }
    });
  });

  // ── Odds-driven probability ───────────────────────────────────────────────

  describe("odds-driven win probability", () => {
    it("strong favourite (us-1) has higher probFirst than a weak team", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS, { includeOdds: true }));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const byId = new Map(results.map((r) => [r.participantId, r]));
      const us1prob = byId.get("us-1")?.probabilities.probFirst ?? 0;
      const us10prob = byId.get("us-10")?.probabilities.probFirst ?? 0;
      expect(us1prob).toBeGreaterThan(us10prob);
    });

    it("works when no odds are entered (all 50/50 fallback)", async () => {
      setupMockDb(defaultParticipants(), makeEvRows(ALL_IDS)); // no odds
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      const total = results.reduce((s, r) => s + r.probabilities.probFirst, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("with equal odds, each team wins the championship roughly equally", async () => {
      // Equal positive odds (+5000 for every team) → vig-removed prob ≈ 1/20 each.
      const eqOddsRows = ALL_IDS.map((id) => ({ participantId: id, sourceOdds: 5000 }));
      setupMockDb(defaultParticipants(), eqOddsRows);
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      for (const r of results) {
        // With equal odds and random pools, each team should win ~5% of the time.
        // Allow a generous band given Monte Carlo variance.
        expect(r.probabilities.probFirst).toBeGreaterThan(0.01);
        expect(r.probabilities.probFirst).toBeLessThan(0.15);
      }
    });
  });

  // ── Legacy externalId formats ─────────────────────────────────────────────
  //
  // The tournament no longer has pool play, but seasons configured for the old
  // format still carry pool suffixes. Those must keep loading, read as the side alone.

  describe("legacy pool-suffix externalIds", () => {
    it("accepts US:A / US:B / Intl:A / Intl:B, ignoring the pool part", async () => {
      setupMockDb(defaultParticipants("fixed"), makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      expect(results).toHaveLength(20);
      const total = results.reduce((s, r) => s + r.probabilities.probFirst, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("accepts a mix of suffixed and bare side ids", async () => {
      const participants = [
        ...US_IDS.slice(0, 5).map((id) => ({ id, name: `US Team ${id}`, externalId: "US:A" })),
        ...US_IDS.slice(5).map((id) => ({ id, name: `US Team ${id}`, externalId: "US" })),
        ...INTL_IDS.map((id) => ({ id, name: `Team ${id}`, externalId: "Intl" })),
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      expect(results).toHaveLength(20);
      const total = results.reduce((s, r) => s + r.probabilities.probFirst, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("accepts an uneven suffix split (pools no longer constrain anything)", async () => {
      const participants = [
        ...US_IDS.slice(0, 6).map((id) => ({ id, name: `US Team ${id}`, externalId: "US:A" })),
        ...US_IDS.slice(6).map((id) => ({ id, name: `US Team ${id}`, externalId: "US:B" })),
        ...INTL_IDS.map((id) => ({ id, name: `Team ${id}`, externalId: "Intl" })),
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      expect(results).toHaveLength(20);
    });
  });

  // ── Error cases ───────────────────────────────────────────────────────────

  describe("error cases", () => {
    it("throws when participant count is not 20", async () => {
      const nineteen = [...US_IDS, ...INTL_IDS.slice(0, 9)];
      const participants = nineteen.map((id, i) => ({
        id,
        name: i < 10 ? `US Team ${id}` : `Team ${id}`,
        externalId: i < 10 ? "US" : "Intl",
      }));
      setupMockDb(participants, makeEvRows(nineteen));
      await expect(new LLWSSimulator(1_000).simulate("season-1")).rejects.toThrow(/exactly 20/);
    });

    it("infers US side from name prefix when externalId is null", async () => {
      const participants = [
        ...US_IDS.map((id) => ({ id, name: `US Team ${id}`, externalId: null })),
        ...INTL_IDS.map((id) => ({ id, name: `Japan ${id}`, externalId: null })),
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      expect(results).toHaveLength(20);
      const total = results.reduce((s, r) => s + r.probabilities.probFirst, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("infers US side from exact name 'US' when externalId is null", async () => {
      const participants = [
        ...US_IDS.map((id) => ({ id, name: "US", externalId: null })),
        ...INTL_IDS.map((id) => ({ id, name: `Team ${id}`, externalId: null })),
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      const results = await new LLWSSimulator(1_000).simulate("season-1");
      expect(results).toHaveLength(20);
      const total = results.reduce((s, r) => s + r.probabilities.probFirst, 0);
      expect(total).toBeCloseTo(1.0, 1);
    });

    it("throws when a participant has an unrecognized non-null externalId", async () => {
      const participants = [
        ...US_IDS.map((id) => ({ id, name: `US Team ${id}`, externalId: "US" })),
        ...INTL_IDS.slice(0, 9).map((id) => ({ id, name: `Team ${id}`, externalId: "Intl" })),
        { id: "intl-10", name: "Team intl-10", externalId: "CANADA" }, // unrecognized
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      await expect(new LLWSSimulator(1_000).simulate("season-1")).rejects.toThrow(/invalid externalId/);
    });

    it("throws when US team count is not 10", async () => {
      // 11 US teams, 9 International
      const participants = [
        ...Array.from({ length: 11 }, (_, i) => ({ id: `us-${i + 1}`, name: `US Team ${i + 1}`, externalId: "US" })),
        ...Array.from({ length: 9 }, (_, i) => ({ id: `intl-${i + 1}`, name: `Team ${i + 1}`, externalId: "Intl" })),
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      await expect(new LLWSSimulator(1_000).simulate("season-1")).rejects.toThrow(/10 US teams/);
    });

    it("throws when International team count is not 10", async () => {
      const participants = [
        ...Array.from({ length: 9 }, (_, i) => ({ id: `us-${i + 1}`, name: `US Team ${i + 1}`, externalId: "US" })),
        ...Array.from({ length: 11 }, (_, i) => ({ id: `intl-${i + 1}`, name: `Team ${i + 1}`, externalId: "Intl" })),
      ];
      setupMockDb(participants, makeEvRows(ALL_IDS));
      await expect(new LLWSSimulator(1_000).simulate("season-1")).rejects.toThrow(/10 US teams/);
    });
  });
});