brackt/app/models/__tests__/simulator-inputs.test.ts

import { describe, expect, it, vi, beforeEach } from "vitest";
import { getParticipantSimulatorInputs } from "../simulator";

const mockDb = vi.hoisted(() => ({
  query: {
    seasonParticipants: { findMany: vi.fn() },
    seasonParticipantSimulatorInputs: { findMany: vi.fn() },
    seasonParticipantExpectedValues: { findMany: vi.fn() },
  },
}));

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

describe("simulator input model", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("does not treat previously generated ratings as direct rating inputs", async () => {
    mockDb.query.seasonParticipants.findMany.mockResolvedValue([
      { id: "direct-rating" },
      { id: "generated-rating" },
      { id: "legacy-direct-rating" },
    ]);
    mockDb.query.seasonParticipantSimulatorInputs.findMany.mockResolvedValue([
      {
        participantId: "direct-rating",
        sourceOdds: 750,
        sourceElo: null,
        worldRanking: null,
        rating: "31.2500",
        projectedWins: null,
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: { ratingMethod: "direct" },
      },
      {
        participantId: "generated-rating",
        sourceOdds: 750,
        sourceElo: null,
        worldRanking: null,
        rating: "35.0000",
        projectedWins: null,
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: { ratingMethod: "sourceOdds" },
      },
      {
        participantId: "legacy-direct-rating",
        sourceOdds: null,
        sourceElo: null,
        worldRanking: null,
        rating: "27.5000",
        projectedWins: null,
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: null,
      },
    ]);
    mockDb.query.seasonParticipantExpectedValues.findMany.mockResolvedValue([]);

    const inputs = await getParticipantSimulatorInputs("season-1");
    const byParticipant = new Map(inputs.map((input) => [input.participantId, input]));

    expect(byParticipant.get("direct-rating")?.rating).toBe(31.25);
    expect(byParticipant.get("generated-rating")?.rating).toBeNull();
    expect(byParticipant.get("legacy-direct-rating")?.rating).toBe(27.5);
  });

  it("keeps direct sourceElo but suppresses generated sourceElo", async () => {
    mockDb.query.seasonParticipants.findMany.mockResolvedValue([
      { id: "direct-elo" },
      { id: "generated-elo" },
    ]);
    mockDb.query.seasonParticipantSimulatorInputs.findMany.mockResolvedValue([
      {
        participantId: "direct-elo",
        sourceOdds: null,
        sourceElo: 1600,
        worldRanking: null,
        rating: null,
        projectedWins: null,
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: { sourceEloMethod: "direct" },
      },
      {
        participantId: "generated-elo",
        sourceOdds: 750,
        sourceElo: 1480,
        worldRanking: null,
        rating: null,
        projectedWins: null,
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: { sourceEloMethod: "sourceOdds" },
      },
    ]);
    mockDb.query.seasonParticipantExpectedValues.findMany.mockResolvedValue([]);

    const inputs = await getParticipantSimulatorInputs("season-1");
    const byParticipant = new Map(inputs.map((input) => [input.participantId, input]));

    expect(byParticipant.get("direct-elo")?.sourceElo).toBe(1600);
    expect(byParticipant.get("generated-elo")?.sourceElo).toBeNull();
  });

  it("hides an Elo flagged as projection-derived so the projection is re-derived", async () => {
    // This is what stops a stale Elo from winning the baseEloPriority race. A row
    // carrying projectedWins and a projectedWins method flag must surface with a
    // null sourceElo, so resolveSourceElos falls through to the projection rather
    // than reusing an Elo that was itself derived from an older projection.
    mockDb.query.seasonParticipants.findMany.mockResolvedValue([
      { id: "projected" },
      { id: "hand-entered" },
    ]);
    mockDb.query.seasonParticipantSimulatorInputs.findMany.mockResolvedValue([
      {
        participantId: "projected",
        sourceOdds: null,
        sourceElo: 1561,
        worldRanking: null,
        rating: null,
        projectedWins: "95.00",
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: { sourceEloMethod: "projectedWins" },
      },
      {
        participantId: "hand-entered",
        sourceOdds: null,
        sourceElo: 1561,
        worldRanking: null,
        rating: null,
        projectedWins: "95.00",
        projectedTablePoints: null,
        seed: null,
        region: null,
        metadata: {},
      },
    ]);
    mockDb.query.seasonParticipantExpectedValues.findMany.mockResolvedValue([]);

    const inputs = await getParticipantSimulatorInputs("season-1");
    const byParticipant = new Map(inputs.map((input) => [input.participantId, input]));

    expect(byParticipant.get("projected")?.sourceElo).toBeNull();
    expect(byParticipant.get("projected")?.projectedWins).toBe(95);
    // No flag means the admin entered that Elo themselves — it is trusted as direct.
    expect(byParticipant.get("hand-entered")?.sourceElo).toBe(1561);
  });
});