chrisp/brackt
1
1
Fork 0
Code Issues 42 Pull requests Projects Releases Packages Wiki Activity Actions

Remove flaky context menu click tests #81

Merged
chrisp merged 4 commits from fix/remove-flaky-context-menu-tests into main 2026-06-10 05:59:50 +00:00
Conversation 0 Commits 4 Files changed 5 +54 -213
1 changed files with 54 additions and 213 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files
Showing only changes of commit 8ca1c9cf94 - Show all commits

267
app/models/__tests__/participant-expected-value.test.ts
View file

@ -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";
/**
* Participant Expected Value Model Tests
* Phase 5.1.3: Probability Storage Model Functions
*
* These are documentation tests that describe the expected behavior of the model functions.
* The core EV calculation logic is thoroughly tested in app/services/__tests__/ev-calculator.test.ts (20 tests).
* 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(),
};
const { mockUpdate, mockSet, mockDb, mockSqlFn } = vi.hoisted(() => {
const update = vi.fn();
const set = vi.fn();
const sqlFn = Object.assign(vi.fn(() => ({})), { join: vi.fn(() => ({})) });
const db = { update, select: vi.fn() };
return { mockUpdate: update, mockSet: set, mockDb: db, mockSqlFn: sqlFn };
});
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", () => {
const _defaultScoring: ScoringRules = {
pointsFor1st: 100,
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("syncVorpForSeason", () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe("upsertParticipantEVWithNormalization", () => {
it("should normalize probabilities before upserting", () => {
// Function calls normalizeProbabilities to scale probabilities to sum to 100%
// Then calls upsertParticipantEV with normalized values
expect(true).toBe(true);
});
it("calculates correct VORP values for 14 participants with EVs 100 down to 35 (step 5)", () => {
// 14 participants: EVs = 100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40, 35
// replacement level = avg of positions 12-14 (0-indexed 11-13) = avg(45, 40, 35) = 40
const evValues = Array.from({ length: 14 }, (_, i) => 100 - i * 5);
const replacementLevel = calculateReplacementLevel(evValues);
expect(replacementLevel).toBe(40);
expect(calculateVORP(100, replacementLevel)).toBe(60);
expect(calculateVORP(35, replacementLevel)).toBe(-5);
});
describe("getParticipantEV", () => {
it("should retrieve participant EV by participantId and seasonId", () => {
// Function returns ParticipantEV record or null if not found
expect(true).toBe(true);
});
it("returns early when no EVs exist for the season", async () => {
const mockSelectChain = {
from: vi.fn().mockReturnThis(),
where: vi.fn().mockResolvedValue([]),
};
mockDb.select = vi.fn().mockReturnValue(mockSelectChain);
await syncVorpForSeason("season-empty");
expect(mockUpdate).not.toHaveBeenCalled();
});
describe("getAllParticipantEVsForSeason", () => {
it("should retrieve all EVs for a season", () => {
// Function returns array of ParticipantEV records for all participants in a season
expect(true).toBe(true);
});
});
it("calls db.update with correct vorpValue for each participant", async () => {
// 3 participants: EVs 100, 70, 40
// replacement level = avg of positions 12-14, clamped to [40] → 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" },
];
describe("deleteParticipantEV", () => {
it("should delete participant EV record", () => {
// Function deletes record matching (participantId, seasonId)
expect(true).toBe(true);
});
});
const mockSelectChain = {
from: vi.fn().mockReturnThis(),
where: vi.fn().mockResolvedValue(mockEvRecords),
};
mockDb.select = vi.fn().mockReturnValue(mockSelectChain);
describe("batchUpsertParticipantEVs", () => {
it("should upsert multiple participants in batches", () => {
// Function processes inputs in batches of 50 to avoid overwhelming database
// Returns array of all upserted ParticipantEV records
expect(true).toBe(true);
});
});
const mockWhereResolved = vi.fn().mockResolvedValue([]);
mockSet.mockReturnValue({ where: mockWhereResolved });
mockUpdate.mockReturnValue({ set: mockSet });
describe("toProbabilityDistribution", () => {
it("should convert database record to ProbabilityDistribution", () => {
// Function converts string fields (probFirst, probSecond, etc.) to numbers
// Returns ProbabilityDistribution object
expect(true).toBe(true);
});
});
await syncVorpForSeason("season-1");
describe("recalculateEV", () => {
it("should recalculate EV with new scoring rules", () => {
// Function retrieves existing probabilities and recalculates EV with new scoring
// Keeps probabilities unchanged, only updates expectedValue field
expect(true).toBe(true);
});
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");
});
expect(mockUpdate).toHaveBeenCalledTimes(1);
expect(mockSet).toHaveBeenCalledTimes(1);
const setArg = mockSet.mock.calls[0][0];
expect(setArg).toHaveProperty("vorpValue");
expect(setArg).toHaveProperty("updatedAt");
});
});