brackt/app/models/__tests__/scoring-event-tournament-helpers.test.ts

import { describe, it, expect, vi, beforeEach } from "vitest";

const mockFindMany = vi.fn();
const mockFindFirst = vi.fn();
// Records each db.update(...).set(patch).where(pred) call for assertions.
const updateCalls: Array<{ patch: unknown; where: unknown }> = [];
const mockUpdate = vi.fn(() => ({
  set: (patch: unknown) => ({
    where: (where: unknown) => {
      updateCalls.push({ patch, where });
      return Promise.resolve();
    },
  }),
}));

const mockDb = {
  query: {
    scoringEvents: { findMany: mockFindMany, findFirst: mockFindFirst },
  },
  update: mockUpdate,
};

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

vi.mock("~/database/schema", () => ({
  scoringEvents: {
    id: "se.id",
    sportsSeasonId: "se.sports_season_id",
    tournamentId: "se.tournament_id",
    isPrimary: "se.is_primary",
  },
}));

vi.mock("drizzle-orm", () => ({
  eq: (col: unknown, val: unknown) => ({ type: "eq", col, val }),
  and: (...args: unknown[]) => ({ type: "and", args }),
  isNotNull: (col: unknown) => ({ type: "isNotNull", col }),
  asc: (col: unknown) => ({ type: "asc", col }),
}));

import {
  getTournamentsBySportsSeason,
  getSportsSeasonsByTournament,
  ensurePrimaryEvent,
  setPrimaryEvent,
} from "../scoring-event";

const SEASON_ID = "ss-1";
const TOURNAMENT_ID_A = "t-a";
const TOURNAMENT_ID_B = "t-b";

const mockTournamentA = { id: TOURNAMENT_ID_A, name: "Wimbledon", year: 2026 };
const mockTournamentB = { id: TOURNAMENT_ID_B, name: "US Open", year: 2026 };

beforeEach(() => {
  vi.clearAllMocks();
  updateCalls.length = 0;
});

describe("getTournamentsBySportsSeason", () => {
  it("returns one row per unique tournament, deduplicating multiple events for the same tournament", async () => {
    mockFindMany.mockResolvedValue([
      { id: "e1", sportsSeasonId: SEASON_ID, tournamentId: TOURNAMENT_ID_A, tournament: mockTournamentA },
      { id: "e2", sportsSeasonId: SEASON_ID, tournamentId: TOURNAMENT_ID_A, tournament: mockTournamentA },
      { id: "e3", sportsSeasonId: SEASON_ID, tournamentId: TOURNAMENT_ID_B, tournament: mockTournamentB },
    ]);

    const result = await getTournamentsBySportsSeason(SEASON_ID);

    expect(result).toHaveLength(2);
    expect(result[0].tournamentId).toBe(TOURNAMENT_ID_A);
    expect(result[1].tournamentId).toBe(TOURNAMENT_ID_B);
  });

  it("returns empty array when no events have a tournamentId", async () => {
    mockFindMany.mockResolvedValue([
      { id: "e1", sportsSeasonId: SEASON_ID, tournamentId: null, tournament: null },
    ]);

    const result = await getTournamentsBySportsSeason(SEASON_ID);

    expect(result).toHaveLength(0);
  });

  it("returns empty array when season has no events", async () => {
    mockFindMany.mockResolvedValue([]);

    const result = await getTournamentsBySportsSeason(SEASON_ID);

    expect(result).toHaveLength(0);
  });
});

const SEASON_A_ID = "ss-a";
const SEASON_B_ID = "ss-b";

const mockSeasonA = { id: SEASON_A_ID, name: "Golf June 2026", year: 2026, scoringType: "majors", status: "active", sport: { id: "sp-1", name: "Golf" } };
const mockSeasonB = { id: SEASON_B_ID, name: "Golf Sept 2026", year: 2026, scoringType: "majors", status: "upcoming", sport: { id: "sp-1", name: "Golf" } };

describe("getSportsSeasonsByTournament", () => {
  it("returns one row per unique sports season, deduplicating multiple events in the same season", async () => {
    mockFindMany.mockResolvedValue([
      { id: "e1", sportsSeasonId: SEASON_A_ID, tournamentId: TOURNAMENT_ID_A, sportsSeason: mockSeasonA },
      { id: "e2", sportsSeasonId: SEASON_A_ID, tournamentId: TOURNAMENT_ID_A, sportsSeason: mockSeasonA },
      { id: "e3", sportsSeasonId: SEASON_B_ID, tournamentId: TOURNAMENT_ID_A, sportsSeason: mockSeasonB },
    ]);

    const result = await getSportsSeasonsByTournament(TOURNAMENT_ID_A);

    expect(result).toHaveLength(2);
    expect(result[0].sportsSeasonId).toBe(SEASON_A_ID);
    expect(result[1].sportsSeasonId).toBe(SEASON_B_ID);
  });

  it("returns empty array when no sports seasons use this tournament", async () => {
    mockFindMany.mockResolvedValue([]);

    const result = await getSportsSeasonsByTournament(TOURNAMENT_ID_A);

    expect(result).toHaveLength(0);
  });

  it("passes tournamentId to the query", async () => {
    mockFindMany.mockResolvedValue([]);

    await getSportsSeasonsByTournament(TOURNAMENT_ID_A);

    expect(mockFindMany).toHaveBeenCalledWith(
      expect.objectContaining({
        where: expect.objectContaining({ type: "eq" }),
      })
    );
  });
});

describe("ensurePrimaryEvent", () => {
  it("sets the event primary when the tournament has no primary yet", async () => {
    mockFindFirst.mockResolvedValue(undefined); // no existing primary
    const result = await ensurePrimaryEvent(TOURNAMENT_ID_A, "ev-1");
    expect(result).toBe("ev-1");
    expect(updateCalls).toHaveLength(1);
    expect(updateCalls[0].patch).toMatchObject({ isPrimary: true });
  });

  it("is idempotent: keeps the existing primary and writes nothing", async () => {
    mockFindFirst.mockResolvedValue({ id: "ev-existing" });
    const result = await ensurePrimaryEvent(TOURNAMENT_ID_A, "ev-2");
    expect(result).toBe("ev-existing");
    expect(updateCalls).toHaveLength(0);
  });
});

describe("setPrimaryEvent", () => {
  it("clears siblings then sets the chosen event primary", async () => {
    mockFindFirst.mockResolvedValue({ id: "ev-3", tournamentId: TOURNAMENT_ID_A });
    await setPrimaryEvent("ev-3");
    // Two updates: clear-all (isPrimary:false) then set-one (isPrimary:true).
    expect(updateCalls).toHaveLength(2);
    expect(updateCalls[0].patch).toMatchObject({ isPrimary: false });
    expect(updateCalls[1].patch).toMatchObject({ isPrimary: true });
  });

  it("throws when the event is not linked to a tournament", async () => {
    mockFindFirst.mockResolvedValue({ id: "ev-4", tournamentId: null });
    await expect(setPrimaryEvent("ev-4")).rejects.toThrow(/not linked to a tournament/);
    expect(updateCalls).toHaveLength(0);
  });
});