Fix hook/test timeouts from dynamic imports in beforeEach/test bodies

Two patterns causing CI timeouts:

1. admin.sports-seasons.$id.test.ts: vi.resetModules() + multiple
   await import() in beforeEach forced full module re-evaluation on
   every test, exceeding the 10s hook timeout.

2. participant-expected-value.test.ts: await import() of the module
   under test inside test bodies caused the first import to run within
   the 5s test window. Also deleted 13 expect(true).toBe(true) stubs
   and used vi.hoisted() to make mock factories work with static imports.

Both files now use static top-level imports.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/models/__tests__/participant-expected-value.test.ts

@@ -1,24 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { ProbabilityDistribution, ScoringRules } from "~/services/ev-calculator";
+import { calculateReplacementLevel, calculateVORP } from "~/services/ev-calculator";
+import { syncVorpForSeason } from "../participant-expected-value";
 
-/**
+const { mockUpdate, mockSet, mockDb, mockSqlFn } = vi.hoisted(() => {
- * Participant Expected Value Model Tests
+  const update = vi.fn();
- * Phase 5.1.3: Probability Storage Model Functions
+  const set = vi.fn();
- *
+  const sqlFn = Object.assign(vi.fn(() => ({})), { join: vi.fn(() => ({})) });
- * These are documentation tests that describe the expected behavior of the model functions.
+  const db = { update, select: vi.fn() };
- * The core EV calculation logic is thoroughly tested in app/services/__tests__/ev-calculator.test.ts (20 tests).
+  return { mockUpdate: update, mockSet: set, mockDb: db, mockSqlFn: sqlFn };
- * The model layer provides database persistence for probabilities and EVs.
+});
- * Full integration tests are in the E2E test suite.
- */
-
-// Mock database context
-const mockUpdate = vi.fn();
-const mockSet = vi.fn();
-const _mockWhere = vi.fn();
-const mockDb = {
-  update: mockUpdate,
-  select: vi.fn(),
-};
 
 vi.mock("~/database/context", () => ({
   database: () => mockDb,
@@ -32,10 +22,6 @@ vi.mock("~/database/schema", () => ({
   },
 }));
 
-const mockSqlFn = Object.assign(vi.fn(() => ({})), {
-  join: vi.fn(() => ({})),
-});
-
 vi.mock("drizzle-orm", () => ({
   eq: vi.fn((field, value) => ({ field, value })),
   and: vi.fn((...args) => ({ and: args })),
@@ -43,205 +29,60 @@ vi.mock("drizzle-orm", () => ({
   sql: mockSqlFn,
 }));
 
-describe("participant-expected-value model", () => {
+describe("syncVorpForSeason", () => {
-  const _defaultScoring: ScoringRules = {
+  beforeEach(() => {
-    pointsFor1st: 100,
+    vi.clearAllMocks();
-    pointsFor2nd: 70,
-    pointsFor3rd: 50,
-    pointsFor4th: 40,
-    pointsFor5th: 25,
-    pointsFor6th: 25,
-    pointsFor7th: 15,
-    pointsFor8th: 15,
-  };
-
-  const _validProbabilities: ProbabilityDistribution = {
-    probFirst: 20,
-    probSecond: 20,
-    probThird: 15,
-    probFourth: 15,
-    probFifth: 10,
-    probSixth: 10,
-    probSeventh: 5,
-    probEighth: 5,
-  };
-
-  describe("upsertParticipantEV", () => {
-    it("should create new participant EV with calculated expected value", () => {
-      // Function validates probabilities sum to 100%, calculates EV, and inserts/updates database record
-      // Expected EV for validProbabilities with defaultScoring: 54 points
-      // EV = 20% × 100 + 20% × 70 + 15% × 50 + 15% × 40 + 10% × 25 + 10% × 25 + 5% × 15 + 5% × 15
-      // = 20 + 14 + 7.5 + 6 + 2.5 + 2.5 + 0.75 + 0.75 = 54
-      expect(true).toBe(true);
-    });
-
-    it("should update existing participant EV", () => {
-      // Function checks for existing record by (participantId, seasonId) and updates if found
-      expect(true).toBe(true);
-    });
-
-    it("should reject invalid probabilities that don't sum to 100%", () => {
-      // Function throws error if validateProbabilities returns false
-      // Tolerance is ±0.1% by default
-      expect(true).toBe(true);
-    });
-
-    it("should default source to 'manual' if not provided", () => {
-      // Function sets source = 'manual' when not specified
-      expect(true).toBe(true);
-    });
   });
 
-  describe("upsertParticipantEVWithNormalization", () => {
+  it("calculates correct VORP values for 14 participants with EVs 100 down to 35 (step 5)", () => {
-    it("should normalize probabilities before upserting", () => {
+    // 14 participants: EVs = 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35
-      // Function calls normalizeProbabilities to scale probabilities to sum to 100%
+    // replacement level = avg of positions 12-14 (0-indexed 11-13) = avg(45, 40, 35) = 40
-      // Then calls upsertParticipantEV with normalized values
+    const evValues = Array.from({ length: 14 }, (_, i) => 100 - i * 5);
-      expect(true).toBe(true);
+
-    });
+    const replacementLevel = calculateReplacementLevel(evValues);
+    expect(replacementLevel).toBe(40);
+    expect(calculateVORP(100, replacementLevel)).toBe(60);
+    expect(calculateVORP(35, replacementLevel)).toBe(-5);
   });
 
-  describe("getParticipantEV", () => {
+  it("returns early when no EVs exist for the season", async () => {
-    it("should retrieve participant EV by participantId and seasonId", () => {
+    const mockSelectChain = {
-      // Function returns ParticipantEV record or null if not found
+      from: vi.fn().mockReturnThis(),
-      expect(true).toBe(true);
+      where: vi.fn().mockResolvedValue([]),
-    });
+    };
+    mockDb.select = vi.fn().mockReturnValue(mockSelectChain);
+
+    await syncVorpForSeason("season-empty");
+
+    expect(mockUpdate).not.toHaveBeenCalled();
   });
 
-  describe("getAllParticipantEVsForSeason", () => {
+  it("calls db.update with correct vorpValue for each participant", async () => {
-    it("should retrieve all EVs for a season", () => {
+    // 3 participants: EVs 100, 70, 40
-      // Function returns array of ParticipantEV records for all participants in a season
+    // replacement level = avg of positions 12-14, clamped to [40] → 40
-      expect(true).toBe(true);
+    // VORP: 100→60, 70→30, 40→0
-    });
+    const mockEvRecords = [
-  });
+      { participantId: "p1", expectedValue: "100", sportsSeasonId: "season-1" },
+      { participantId: "p2", expectedValue: "70", sportsSeasonId: "season-1" },
+      { participantId: "p3", expectedValue: "40", sportsSeasonId: "season-1" },
+    ];
 
-  describe("deleteParticipantEV", () => {
+    const mockSelectChain = {
-    it("should delete participant EV record", () => {
+      from: vi.fn().mockReturnThis(),
-      // Function deletes record matching (participantId, seasonId)
+      where: vi.fn().mockResolvedValue(mockEvRecords),
-      expect(true).toBe(true);
+    };
-    });
+    mockDb.select = vi.fn().mockReturnValue(mockSelectChain);
-  });
 
-  describe("batchUpsertParticipantEVs", () => {
+    const mockWhereResolved = vi.fn().mockResolvedValue([]);
-    it("should upsert multiple participants in batches", () => {
+    mockSet.mockReturnValue({ where: mockWhereResolved });
-      // Function processes inputs in batches of 50 to avoid overwhelming database
+    mockUpdate.mockReturnValue({ set: mockSet });
-      // Returns array of all upserted ParticipantEV records
-      expect(true).toBe(true);
-    });
-  });
 
-  describe("toProbabilityDistribution", () => {
+    await syncVorpForSeason("season-1");
-    it("should convert database record to ProbabilityDistribution", () => {
-      // Function converts string fields (probFirst, probSecond, etc.) to numbers
-      // Returns ProbabilityDistribution object
-      expect(true).toBe(true);
-    });
-  });
 
-  describe("recalculateEV", () => {
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
-    it("should recalculate EV with new scoring rules", () => {
+    expect(mockSet).toHaveBeenCalledTimes(1);
-      // Function retrieves existing probabilities and recalculates EV with new scoring
+    const setArg = mockSet.mock.calls[0][0];
-      // Keeps probabilities unchanged, only updates expectedValue field
+    expect(setArg).toHaveProperty("vorpValue");
-      expect(true).toBe(true);
+    expect(setArg).toHaveProperty("updatedAt");
-    });
-
-    it("should return null if participant EV doesn't exist", () => {
-      // Function returns null when no record is found
-      expect(true).toBe(true);
-    });
-  });
-
-  describe("recalculateAllEVsForSeason", () => {
-    it("should recalculate all EVs for a season", () => {
-      // Function retrieves all participant EVs for season
-      // Calls recalculateEV for each participant
-      // Returns count of participants updated
-      expect(true).toBe(true);
-    });
-  });
-
-  describe("syncVorpForSeason", () => {
-    beforeEach(() => {
-      vi.clearAllMocks();
-    });
-
-    it("should calculate correct VORP values for 14 participants with EVs 100 down to 35 (step 5)", async () => {
-      // 14 participants: EVs = 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35
-      // Sorted descending (already sorted)
-      // Replacement level = avg of positions 12-14 (0-indexed 11-13) = avg(45, 40, 35) = 40
-      // VORP(100) = 60, VORP(35) = -5
-
-      const { calculateReplacementLevel, calculateVORP } = await import("~/services/ev-calculator");
-
-      const evValues = Array.from({ length: 14 }, (_, i) => 100 - i * 5);
-      // [100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35]
-
-      const replacementLevel = calculateReplacementLevel(evValues);
-      expect(replacementLevel).toBe(40); // avg(45, 40, 35) = 40
-
-      const vorpFirst = calculateVORP(100, replacementLevel);
-      expect(vorpFirst).toBe(60);
-
-      const vorpLast = calculateVORP(35, replacementLevel);
-      expect(vorpLast).toBe(-5);
-    });
-
-    it("should return early when no EVs exist for the season", async () => {
-      // Re-mock getAllParticipantEVsForSeason to return empty array
-      // The function should do nothing and return without calling db.update
-      const { syncVorpForSeason } = await import("../participant-expected-value");
-
-      // Patch the module's getAllParticipantEVsForSeason to return []
-      // Since we can't easily spy on module-internal calls, we verify via db mock:
-      // If 0 EVs returned, db.update should not be called
-
-      // Setup: db.select chain for getAllParticipantEVsForSeason returns []
-      const mockSelectChain = {
-        from: vi.fn().mockReturnThis(),
-        where: vi.fn().mockResolvedValue([]),
-      };
-      mockDb.select = vi.fn().mockReturnValue(mockSelectChain);
-
-      await syncVorpForSeason("season-empty");
-
-      // db.update should NOT have been called (no participants to update)
-      expect(mockUpdate).not.toHaveBeenCalled();
-    });
-
-    it("should call db.update with correct vorpValue for each participant", async () => {
-      const { syncVorpForSeason } = await import("../participant-expected-value");
-
-      // 3 participants with EVs: 100, 70, 40
-      // sorted: [100, 70, 40]
-      // replacement level = avg of positions 12-14, but only 3 participants
-      // startIdx = min(11, 2) = 2, endIdx = min(13, 2) = 2 → slice = [40]
-      // replacementLevel = 40
-      // VORP: 100→60, 70→30, 40→0
-      const mockEvRecords = [
-        { participantId: "p1", expectedValue: "100", sportsSeasonId: "season-1" },
-        { participantId: "p2", expectedValue: "70", sportsSeasonId: "season-1" },
-        { participantId: "p3", expectedValue: "40", sportsSeasonId: "season-1" },
-      ];
-
-      const mockSelectChain = {
-        from: vi.fn().mockReturnThis(),
-        where: vi.fn().mockResolvedValue(mockEvRecords),
-      };
-      mockDb.select = vi.fn().mockReturnValue(mockSelectChain);
-
-      const mockWhereResolved = vi.fn().mockResolvedValue([]);
-      mockSet.mockReturnValue({ where: mockWhereResolved });
-      mockUpdate.mockReturnValue({ set: mockSet });
-
-      await syncVorpForSeason("season-1");
-
-      // Bulk update: db.update is called once for all participants
-      expect(mockUpdate).toHaveBeenCalledTimes(1);
-
-      // set() is called once with a CASE expression for vorpValue
-      expect(mockSet).toHaveBeenCalledTimes(1);
-      const setArg = mockSet.mock.calls[0][0];
-      expect(setArg).toHaveProperty("vorpValue");
-      expect(setArg).toHaveProperty("updatedAt");
-    });
   });
 });