Sessions 5-7a: 955 tests, deployment ready
This commit is contained in:
+1
File diff suppressed because one or more lines are too long
@@ -0,0 +1,193 @@
|
||||
/**
|
||||
* Grading pipeline end-to-end integration.
|
||||
*
|
||||
* 1. Mock SharpAPI returning 3 player props (one A-tier shaped, one
|
||||
* neutral, one trap-heavy that should downgrade).
|
||||
* 2. Mock feature cache returning features.
|
||||
* 3. Mock trap detection — return high composite for the trap prop.
|
||||
* 4. Run the orchestrator.
|
||||
* 5. Assert: all 3 props get a grade_history insert.
|
||||
* 6. Assert: A-tier prop queued for Engine 2, D/C-tier not queued.
|
||||
* 7. Assert: trap composite > 0.5 downgrades the trap prop's grade.
|
||||
*/
|
||||
|
||||
process.env.ENGINE2_ENABLED = 'true';
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args), post: jest.fn() }));
|
||||
|
||||
const mockGetPlayerProps = jest.fn();
|
||||
jest.mock('../../src/services/adapters/sharpApiAdapter', () => ({
|
||||
configured: () => true,
|
||||
getPlayerProps: (...args) => mockGetPlayerProps(...args),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/adapters/openRouterAdapter', () => ({
|
||||
configured: () => false, analyze: async () => null, getUsage: () => ({ requestsToday: 0 }),
|
||||
}));
|
||||
|
||||
// Feature vectors per player — vary to drive different grades.
|
||||
const mockFeatures = { current: new Map() };
|
||||
jest.mock('../../src/services/intelligence/featureCache', () => ({
|
||||
getFeatures: async ({ playerName }) => {
|
||||
const f = mockFeatures.current.get(playerName) || {};
|
||||
return { features: f, meta: { features_available: Object.keys(f), features_missing: [] } };
|
||||
},
|
||||
}));
|
||||
|
||||
const mockTrapScores = { current: new Map() };
|
||||
jest.mock('../../src/services/intelligence/trapDetection', () => ({
|
||||
getTrapScore: async ({ playerName }) => mockTrapScores.current.get(playerName) || {
|
||||
composite: 0, signals: {}, active_count: 0, recommendation: 'proceed',
|
||||
},
|
||||
normalizeName: (n) => n,
|
||||
detectReturningTeammate: () => null,
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/intelligence/consistencyScore', () => ({
|
||||
getConsistency: async () => ({ consistency: 'reliable', cv: 0.18, score: 0.7, games: 20 }),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/intelligence/gameLogService', () => ({
|
||||
getGameLogs: async () => [
|
||||
{ points: 30 }, { points: 28 }, { points: 32 }, { points: 27 }, { points: 31 },
|
||||
],
|
||||
getCareerPlayoffGames: async () => 50,
|
||||
getWithWithoutStats: async () => null,
|
||||
}));
|
||||
|
||||
const mockInserts = [];
|
||||
const mockUpdates = [];
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const proxy = {
|
||||
insert(row) {
|
||||
mockInserts.push({ table, row });
|
||||
return {
|
||||
select() {
|
||||
return { single: () => Promise.resolve({ data: { id: `gid-${mockInserts.length}` }, error: null }) };
|
||||
},
|
||||
};
|
||||
},
|
||||
update(patch) {
|
||||
mockUpdates.push({ table, patch });
|
||||
return { eq() { return Promise.resolve({ error: null }); } };
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const orchestrator = require('../../src/services/intelligence/gradingOrchestrator');
|
||||
const engine2 = require('../../src/services/intelligence/engine2');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockGetPlayerProps.mockReset();
|
||||
mockInserts.length = 0;
|
||||
mockUpdates.length = 0;
|
||||
mockFeatures.current.clear();
|
||||
mockTrapScores.current.clear();
|
||||
engine2.clearQueue();
|
||||
});
|
||||
|
||||
describe('grading pipeline — end-to-end through orchestrator', () => {
|
||||
test('three props grade through, A-tier queued, trap-heavy downgraded', async () => {
|
||||
// ESPN scoreboard with one game.
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
events: [{
|
||||
id: 'ev-mix',
|
||||
date: '2026-06-08T23:30Z',
|
||||
status: { type: { state: 'pre' } },
|
||||
competitions: [{
|
||||
competitors: [
|
||||
{ homeAway: 'home', id: '1', team: { abbreviation: 'NYK', displayName: 'Knicks' } },
|
||||
{ homeAway: 'away', id: '2', team: { abbreviation: 'BOS', displayName: 'Celtics' } },
|
||||
],
|
||||
}],
|
||||
}],
|
||||
},
|
||||
});
|
||||
|
||||
// Three props:
|
||||
// A-tier: hot recent form, weak D, rested, home — should grade A or A-
|
||||
// neutral: average everything — should land C-ish
|
||||
// trap-heavy: hot recent form BUT trap composite 0.7 → downgrade
|
||||
mockGetPlayerProps.mockResolvedValue([
|
||||
{ player: 'A-Player', team: 'NYK', statType: 'points', line: 25.5, direction: 'over' },
|
||||
{ player: 'C-Player', team: 'NYK', statType: 'points', line: 25.5, direction: 'over' },
|
||||
{ player: 'Trap-Player', team: 'NYK', statType: 'points', line: 25.5, direction: 'over' },
|
||||
]);
|
||||
|
||||
mockFeatures.current.set('A-Player', {
|
||||
l5_avg: 32, l20_avg: 28, opp_rank_stat: 0.85, home_away: 1.0, rest_days: 2,
|
||||
});
|
||||
mockFeatures.current.set('C-Player', { l5_avg: 25, l20_avg: 25.5 });
|
||||
mockFeatures.current.set('Trap-Player', {
|
||||
l5_avg: 32, l20_avg: 28, opp_rank_stat: 0.85, home_away: 1.0, rest_days: 2,
|
||||
});
|
||||
|
||||
// Only the trap-heavy prop has a high trap composite.
|
||||
mockTrapScores.current.set('Trap-Player', { composite: 0.7, signals: {}, active_count: 4, recommendation: 'avoid' });
|
||||
|
||||
const summary = await orchestrator.runPipeline('nba', { skipEngine2: true });
|
||||
|
||||
expect(summary.props_graded).toBe(3);
|
||||
expect(mockInserts.length).toBe(3);
|
||||
|
||||
// All inserts went to grade_history.
|
||||
expect(mockInserts.every((i) => i.table === 'grade_history')).toBe(true);
|
||||
|
||||
// factors column is stored as an array.
|
||||
for (const i of mockInserts) {
|
||||
expect(Array.isArray(i.row.factors) || i.row.factors === null).toBe(true);
|
||||
}
|
||||
|
||||
// A-Player grade is in A range; Trap-Player is downgraded BELOW A.
|
||||
const aRow = mockInserts.find((i) => i.row.player_name === 'A-Player');
|
||||
const cRow = mockInserts.find((i) => i.row.player_name === 'C-Player');
|
||||
const trapRow = mockInserts.find((i) => i.row.player_name === 'Trap-Player');
|
||||
const GRADE_ORDER = ['F','D','C-','C','C+','B-','B','B+','A-','A','A+'];
|
||||
const idx = (g) => GRADE_ORDER.indexOf(g);
|
||||
|
||||
expect(idx(aRow.row.grade)).toBeGreaterThan(idx('B+'));
|
||||
expect(idx(trapRow.row.grade)).toBeLessThan(idx(aRow.row.grade));
|
||||
expect(idx(cRow.row.grade)).toBeLessThan(idx(aRow.row.grade));
|
||||
|
||||
// Engine 2 queue: A-Player qualifies (A range); Trap-Player downgraded
|
||||
// out of A/B range so should not be queued; C-Player C-tier excluded.
|
||||
const queued = engine2.getQueueSize();
|
||||
expect(queued).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
test('p_over and factors get persisted on the row', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
events: [{
|
||||
id: 'ev-store',
|
||||
competitions: [{ competitors: [
|
||||
{ homeAway: 'home', id: '1', team: { abbreviation: 'NYK' } },
|
||||
{ homeAway: 'away', id: '2', team: { abbreviation: 'BOS' } },
|
||||
] }],
|
||||
}],
|
||||
},
|
||||
});
|
||||
mockGetPlayerProps.mockResolvedValue([
|
||||
{ player: 'P', team: 'NYK', statType: 'points', line: 25.5, direction: 'over' },
|
||||
]);
|
||||
mockFeatures.current.set('P', {
|
||||
l5_avg: 30, l20_avg: 28, opp_rank_stat: 0.85, home_away: 1.0,
|
||||
});
|
||||
await orchestrator.runPipeline('nba', { skipEngine2: true });
|
||||
const row = mockInserts[0].row;
|
||||
expect(row.factors).not.toBeNull();
|
||||
expect(Array.isArray(row.factors)).toBe(true);
|
||||
expect(row.factors.length).toBeGreaterThan(0);
|
||||
expect(Number.isFinite(row.p_over)).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,242 @@
|
||||
/**
|
||||
* End-to-end learning-loop test.
|
||||
*
|
||||
* 1. Resolve a prop (hit) through the existing /api/grading/resolve path.
|
||||
* 2. Assert CLV computed and stored.
|
||||
* 3. Assert accuracy tracker incremented.
|
||||
* 4. Assert weight adjuster fired (or correctly skipped because the
|
||||
* sample is thin).
|
||||
* 5. Assert the JSONL training logger wrote a line.
|
||||
*
|
||||
* Stubs all upstream services so the test runs in isolation. The actual
|
||||
* Supabase calls land in an in-memory mock that records every operation.
|
||||
*/
|
||||
|
||||
process.env.VYNDR_INTERNAL_KEY = 'lf-test-key';
|
||||
process.env.NODE_ENV = 'test';
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const mockState = {
|
||||
unresolved: [],
|
||||
inserts: [],
|
||||
updates: [],
|
||||
closing: null,
|
||||
resolutionCount: 100, // enough to pass weight adjuster gate
|
||||
accuracyRows: new Map(),
|
||||
weightHistory: [],
|
||||
};
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const ctx = { table, filters: {}, countMode: null, head: false };
|
||||
const proxy = {
|
||||
select(_cols, opts) { ctx.head = !!opts?.head; ctx.countMode = opts?.count; return proxy; },
|
||||
eq(col, val) { ctx.filters[col] = val; return proxy; },
|
||||
is() { return Promise.resolve({ data: mockState.unresolved, error: null }); },
|
||||
in() { return Promise.resolve({ error: null }); },
|
||||
gte() { return Promise.resolve({ data: [], error: null }); },
|
||||
not() { return proxy; },
|
||||
order() { return proxy; },
|
||||
limit() { return proxy; },
|
||||
single() { return Promise.resolve({ data: { id: 'gid-new' }, error: null }); },
|
||||
maybeSingle() {
|
||||
if (ctx.table === 'closing_lines') return Promise.resolve({ data: mockState.closing, error: null });
|
||||
if (ctx.table === 'grade_history') {
|
||||
return Promise.resolve({
|
||||
data: { id: ctx.filters.id, sport: 'nba', stat_type: 'points', line: 25.5, direction: 'over', player_id: '1', game_id: 'gm-1' },
|
||||
error: null,
|
||||
});
|
||||
}
|
||||
if (ctx.table === 'accuracy_tracking') {
|
||||
const k = `${ctx.filters.sport}|${ctx.filters.grade}|${ctx.filters.period}`;
|
||||
return Promise.resolve({ data: mockState.accuracyRows.get(k) || null, error: null });
|
||||
}
|
||||
return Promise.resolve({ data: null, error: null });
|
||||
},
|
||||
insert(row) { mockState.inserts.push({ table: ctx.table, row }); return Promise.resolve({ error: null }); },
|
||||
update(patch) {
|
||||
mockState.updates.push({ table: ctx.table, patch, filters: { ...ctx.filters } });
|
||||
return {
|
||||
eq() { return Promise.resolve({ error: null }); },
|
||||
in() { return Promise.resolve({ error: null }); },
|
||||
};
|
||||
},
|
||||
upsert(row) {
|
||||
if (ctx.table === 'accuracy_tracking') {
|
||||
mockState.accuracyRows.set(`${row.sport}|${row.grade}|${row.period}`, { ...row });
|
||||
}
|
||||
return Promise.resolve({ error: null });
|
||||
},
|
||||
then(resolve) {
|
||||
if (ctx.table === 'resolution_results' && ctx.countMode === 'exact') {
|
||||
return resolve({ count: mockState.resolutionCount, error: null });
|
||||
}
|
||||
if (ctx.table === 'engine1_weights') {
|
||||
const matches = mockState.weightHistory.filter((r) => {
|
||||
for (const [k, v] of Object.entries(ctx.filters)) {
|
||||
if (r[k] !== v) return false;
|
||||
}
|
||||
return true;
|
||||
}).sort((a, b) => b.version - a.version);
|
||||
return resolve({ data: matches, error: null });
|
||||
}
|
||||
return resolve({ data: [], error: null });
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/distribution/webPush', () => ({
|
||||
configured: () => false, sendPushToSport: async () => ({ ok: true, sent: 0 }),
|
||||
}));
|
||||
jest.mock('../../src/services/distribution/telegram', () => ({
|
||||
configured: () => false, postToTelegram: async () => ({ ok: true }),
|
||||
}));
|
||||
jest.mock('../../src/services/distribution/discord', () => ({
|
||||
webhookFor: () => null, postToDiscord: async () => ({ ok: true }),
|
||||
}));
|
||||
|
||||
const express = require('express');
|
||||
const gradingRoutes = require('../../src/routes/grading');
|
||||
|
||||
const fixture = JSON.parse(fs.readFileSync(
|
||||
path.join(__dirname, '..', 'fixtures', 'nba-boxscore-sample.json'),
|
||||
'utf8',
|
||||
));
|
||||
|
||||
function pickAthletes(box, n) {
|
||||
const out = [];
|
||||
for (const team of box.boxscore.players) {
|
||||
for (const a of team.statistics[0].athletes) {
|
||||
out.push({ id: String(a.athlete.id), name: a.athlete.displayName, stats: a.stats });
|
||||
if (out.length === n) return out;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function makeApp() {
|
||||
const app = express();
|
||||
app.use(express.json({ limit: '2mb' }));
|
||||
app.use('/api/grading', gradingRoutes);
|
||||
return app;
|
||||
}
|
||||
|
||||
function request(app, body, headers = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const http = require('http');
|
||||
const server = app.listen(0, '127.0.0.1', () => {
|
||||
const port = server.address().port;
|
||||
const data = JSON.stringify(body);
|
||||
const req = http.request({
|
||||
host: '127.0.0.1', port, path: '/api/grading/resolve', method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json', ...headers },
|
||||
}, (res) => {
|
||||
const chunks = [];
|
||||
res.on('data', (c) => chunks.push(c));
|
||||
res.on('end', () => {
|
||||
server.close();
|
||||
const raw = Buffer.concat(chunks).toString('utf8');
|
||||
let parsed; try { parsed = JSON.parse(raw); } catch { parsed = raw; }
|
||||
resolve({ status: res.statusCode, body: parsed });
|
||||
});
|
||||
});
|
||||
req.on('error', (err) => { server.close(); reject(err); });
|
||||
req.write(data);
|
||||
req.end();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
mockState.unresolved = [];
|
||||
mockState.inserts.length = 0;
|
||||
mockState.updates.length = 0;
|
||||
mockState.closing = { id: 'cl-1', pinnacle_line: 27.5 };
|
||||
mockState.resolutionCount = 100;
|
||||
mockState.accuracyRows.clear();
|
||||
mockState.weightHistory.length = 0;
|
||||
});
|
||||
|
||||
describe('learning loop — post-resolution side effects', () => {
|
||||
test('hit on an A-grade prop drives CLV + accuracy + weights', async () => {
|
||||
const [p1] = pickAthletes(fixture, 1);
|
||||
const p1Points = Number(p1.stats[1]);
|
||||
mockState.unresolved = [{
|
||||
id: 'gh-A',
|
||||
player_id: p1.id,
|
||||
player_name: p1.name,
|
||||
stat_type: 'points',
|
||||
line: p1Points - 0.5,
|
||||
direction: 'over',
|
||||
grade: 'A',
|
||||
sport: 'nba',
|
||||
projection: p1Points,
|
||||
factors: ['l5_hot_vs_line', 'home_game'],
|
||||
}];
|
||||
|
||||
const app = makeApp();
|
||||
const res = await request(app, {
|
||||
gameId: '401859964',
|
||||
sport: 'nba',
|
||||
boxScore: fixture,
|
||||
}, { 'X-VYNDR-Internal-Key': 'lf-test-key' });
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.resolved).toBe(1);
|
||||
|
||||
// Side effects are fire-and-forget; give them a tick to settle.
|
||||
await new Promise((r) => setImmediate(r));
|
||||
await new Promise((r) => setTimeout(r, 30));
|
||||
|
||||
// Accuracy upserted for all three periods.
|
||||
const periods = Array.from(mockState.accuracyRows.keys());
|
||||
expect(periods).toContain('nba|A|all_time');
|
||||
expect(periods).toContain('nba|A|last_30d');
|
||||
expect(periods).toContain('nba|A|last_7d');
|
||||
const allTime = mockState.accuracyRows.get('nba|A|all_time');
|
||||
expect(allTime.total_hit + allTime.total_miss).toBeGreaterThan(0);
|
||||
|
||||
// CLV: an update on grade_history with a clv field was queued by the
|
||||
// computeCLV path.
|
||||
const clvUpdates = mockState.updates.filter((u) => 'clv' in (u.patch || {}));
|
||||
expect(clvUpdates.length).toBeGreaterThan(0);
|
||||
expect(clvUpdates[0].patch.clv).toBeGreaterThan(0); // graded line was lower → positive CLV
|
||||
|
||||
// Weight adjuster inserts at least one engine1_weights row (factors > 0).
|
||||
const weightInserts = mockState.inserts.filter((i) => i.table === 'engine1_weights');
|
||||
expect(weightInserts.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('void result records accuracy but not CLV / weights', async () => {
|
||||
mockState.unresolved = [{
|
||||
id: 'gh-void',
|
||||
player_id: '99999',
|
||||
player_name: 'Phantom',
|
||||
stat_type: 'points',
|
||||
line: 10.5,
|
||||
direction: 'over',
|
||||
grade: 'B',
|
||||
sport: 'nba',
|
||||
}];
|
||||
const app = makeApp();
|
||||
await request(app, {
|
||||
gameId: '401859964',
|
||||
sport: 'nba',
|
||||
boxScore: fixture,
|
||||
}, { 'X-VYNDR-Internal-Key': 'lf-test-key' });
|
||||
await new Promise((r) => setTimeout(r, 30));
|
||||
|
||||
expect(mockState.accuracyRows.get('nba|B|all_time')).toBeTruthy();
|
||||
// CLV + weight adjustments should not have fired on a void.
|
||||
const clvUpdates = mockState.updates.filter((u) => 'clv' in (u.patch || {}));
|
||||
expect(clvUpdates.length).toBe(0);
|
||||
const weightInserts = mockState.inserts.filter((i) => i.table === 'engine1_weights');
|
||||
expect(weightInserts.length).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -205,7 +205,7 @@ describe('GET /api/odds/nba', () => {
|
||||
const res = await request(app).get('/api/odds/nba').expect(200);
|
||||
|
||||
expect(res.body.source).toBe('cache');
|
||||
expect(res.headers['x-betonblk-stale']).toBe('true');
|
||||
expect(res.headers['x-vyndr-stale']).toBe('true');
|
||||
});
|
||||
|
||||
it('returns 503 when API fails and no cache', async () => {
|
||||
|
||||
@@ -0,0 +1,258 @@
|
||||
/**
|
||||
* Resolution route integration test — uses a real ESPN NBA box score
|
||||
* fetched from
|
||||
* https://site.api.espn.com/apis/site/v2/sports/basketball/nba/summary?event=401859964
|
||||
*
|
||||
* Workflow:
|
||||
* 1. Mock supabase to return three fake unresolved props that match
|
||||
* players in the real fixture.
|
||||
* 2. Drive the resolution route with the real box-score JSON.
|
||||
* 3. Assert the actual stats were extracted correctly and the
|
||||
* hit/miss/push verdict matches what the line + direction imply.
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
process.env.VYNDR_INTERNAL_KEY = 'int-test-key';
|
||||
process.env.NODE_ENV = 'test';
|
||||
|
||||
// Capture writes the route makes for assertion.
|
||||
const mockState = {
|
||||
unresolved: [],
|
||||
inserts: [],
|
||||
updates: [],
|
||||
};
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const ctx = { table };
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq() { return proxy; },
|
||||
in() { return Promise.resolve({ error: null }); },
|
||||
is() { return Promise.resolve({ data: mockState.unresolved, error: null }); },
|
||||
insert(rows) {
|
||||
mockState.inserts.push({ table, rows });
|
||||
return Promise.resolve({ error: null });
|
||||
},
|
||||
update(patch) {
|
||||
mockState.updates.push({ table, patch });
|
||||
// chain to .eq()/.in() — both close out the call with a resolved promise.
|
||||
return {
|
||||
eq() { return Promise.resolve({ error: null }); },
|
||||
in() { return Promise.resolve({ error: null }); },
|
||||
};
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
// Distribution services — stubbed configured=false so side effects are no-ops.
|
||||
jest.mock('../../src/services/distribution/webPush', () => ({
|
||||
configured: () => false,
|
||||
sendPushToSport: async () => ({ ok: true, sent: 0 }),
|
||||
}));
|
||||
jest.mock('../../src/services/distribution/telegram', () => ({
|
||||
configured: () => false,
|
||||
postToTelegram: async () => ({ ok: true }),
|
||||
}));
|
||||
jest.mock('../../src/services/distribution/discord', () => ({
|
||||
webhookFor: () => null,
|
||||
postToDiscord: async () => ({ ok: true }),
|
||||
}));
|
||||
|
||||
const express = require('express');
|
||||
const gradingRoutes = require('../../src/routes/grading');
|
||||
|
||||
const fixture = JSON.parse(fs.readFileSync(
|
||||
path.join(__dirname, '..', 'fixtures', 'nba-boxscore-sample.json'),
|
||||
'utf8',
|
||||
));
|
||||
|
||||
// Find a couple of real athletes in the fixture so we can build deterministic
|
||||
// fake unresolved props. The first team's first athlete is OG Anunoby in the
|
||||
// saved sample; selecting two players from the fixture removes any need to
|
||||
// hand-author expected stats — we read them straight from the box.
|
||||
function pickAthletes(box, n) {
|
||||
const out = [];
|
||||
for (const team of box.boxscore.players) {
|
||||
for (const a of team.statistics[0].athletes) {
|
||||
out.push({
|
||||
id: String(a.athlete.id),
|
||||
name: a.athlete.displayName,
|
||||
stats: a.stats,
|
||||
starter: !!a.starter,
|
||||
});
|
||||
if (out.length === n) return out;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
const [p1, p2, p3] = pickAthletes(fixture, 3);
|
||||
// labels: ['MIN','PTS','FG','3PT','FT','REB','AST','TO','STL','BLK',...]
|
||||
const p1Points = Number(p1.stats[1]);
|
||||
const p2Rebounds = Number(p2.stats[5]);
|
||||
const p3PRA = Number(p3.stats[1]) + Number(p3.stats[5]) + Number(p3.stats[6]);
|
||||
|
||||
function makeApp() {
|
||||
const app = express();
|
||||
app.use(express.json({ limit: '2mb' }));
|
||||
app.use('/api/grading', gradingRoutes);
|
||||
return app;
|
||||
}
|
||||
|
||||
function request(app, method, url, body, headers = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const http = require('http');
|
||||
const server = app.listen(0, '127.0.0.1', () => {
|
||||
const port = server.address().port;
|
||||
const data = body ? JSON.stringify(body) : '';
|
||||
const req = http.request({
|
||||
host: '127.0.0.1',
|
||||
port,
|
||||
path: url,
|
||||
method,
|
||||
headers: { 'Content-Type': 'application/json', ...headers },
|
||||
}, (res) => {
|
||||
const chunks = [];
|
||||
res.on('data', (c) => chunks.push(c));
|
||||
res.on('end', () => {
|
||||
server.close();
|
||||
const raw = Buffer.concat(chunks).toString('utf8');
|
||||
let parsed; try { parsed = JSON.parse(raw); } catch { parsed = raw; }
|
||||
resolve({ status: res.statusCode, body: parsed });
|
||||
});
|
||||
});
|
||||
req.on('error', (err) => { server.close(); reject(err); });
|
||||
if (data) req.write(data);
|
||||
req.end();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
mockState.unresolved = [];
|
||||
mockState.inserts = [];
|
||||
mockState.updates = [];
|
||||
});
|
||||
|
||||
describe('POST /api/grading/resolve — auth', () => {
|
||||
test('rejects without key', async () => {
|
||||
const app = makeApp();
|
||||
const res = await request(app, 'POST', '/api/grading/resolve', { gameId: 'g', sport: 'nba' });
|
||||
expect(res.status).toBe(401);
|
||||
});
|
||||
|
||||
test('rejects from non-loopback (handled in real-world by Express trust proxy)', async () => {
|
||||
// We can't easily spoof a non-loopback IP locally; auth covers the
|
||||
// primary defense. Leaving this stub so the dependency on the IP check
|
||||
// is visible if anyone ever rips it out.
|
||||
expect(typeof gradingRoutes.__helpers.requireInternal).toBe('function');
|
||||
});
|
||||
});
|
||||
|
||||
describe('POST /api/grading/resolve — real ESPN box', () => {
|
||||
test('resolves three props against the real box score, returning correct verdicts', async () => {
|
||||
mockState.unresolved = [
|
||||
{ id: 'gh-1', player_id: p1.id, player_name: p1.name, stat_type: 'points', line: p1Points - 0.5, direction: 'over', grade: 'A-', sport: 'nba', projection: p1Points },
|
||||
{ id: 'gh-2', player_id: p2.id, player_name: p2.name, stat_type: 'rebounds', line: p2Rebounds + 0.5, direction: 'under', grade: 'B+', sport: 'nba', projection: p2Rebounds },
|
||||
{ id: 'gh-3', player_id: p3.id, player_name: p3.name, stat_type: 'pts_reb_ast', line: p3PRA + 0.5, direction: 'over', grade: 'C', sport: 'nba', projection: p3PRA },
|
||||
];
|
||||
|
||||
const app = makeApp();
|
||||
const res = await request(app, 'POST', '/api/grading/resolve',
|
||||
{ gameId: '401859964', sport: 'nba', boxScore: fixture },
|
||||
{ 'X-VYNDR-Internal-Key': 'int-test-key' },
|
||||
);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.resolved + res.body.voided).toBe(3);
|
||||
|
||||
// p1: line is points - 0.5, direction over → actual > line → HIT
|
||||
const r1 = res.body.results.find((r) => r.id === 'gh-1');
|
||||
expect(r1.actual_value).toBe(p1Points);
|
||||
expect(r1.result).toBe('hit');
|
||||
|
||||
// p2: line is rebounds + 0.5, direction under → actual < line → HIT
|
||||
const r2 = res.body.results.find((r) => r.id === 'gh-2');
|
||||
expect(r2.actual_value).toBe(p2Rebounds);
|
||||
expect(r2.result).toBe('hit');
|
||||
|
||||
// p3: combo over, line is sum + 0.5 → actual < line → MISS
|
||||
const r3 = res.body.results.find((r) => r.id === 'gh-3');
|
||||
expect(r3.actual_value).toBe(p3PRA);
|
||||
expect(r3.result).toBe('miss');
|
||||
});
|
||||
|
||||
test('marks DNP as void with correction_note', async () => {
|
||||
mockState.unresolved = [
|
||||
{ id: 'dnp', player_id: '999999999', player_name: 'Phantom Player', stat_type: 'points', line: 10.5, direction: 'over', grade: 'C', sport: 'nba' },
|
||||
];
|
||||
const app = makeApp();
|
||||
const res = await request(app, 'POST', '/api/grading/resolve',
|
||||
{ gameId: '401859964', sport: 'nba', boxScore: fixture },
|
||||
{ 'X-VYNDR-Internal-Key': 'int-test-key' },
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.voided).toBe(1);
|
||||
expect(res.body.results[0].result).toBe('void');
|
||||
});
|
||||
|
||||
test('void: true marks all unresolved props', async () => {
|
||||
mockState.unresolved = [
|
||||
{ id: 'vp-1', player_id: '1', player_name: 'A', stat_type: 'points', line: 10, direction: 'over', grade: 'B', sport: 'nba' },
|
||||
{ id: 'vp-2', player_id: '2', player_name: 'B', stat_type: 'points', line: 12, direction: 'under', grade: 'C', sport: 'nba' },
|
||||
];
|
||||
const app = makeApp();
|
||||
const res = await request(app, 'POST', '/api/grading/resolve',
|
||||
{ gameId: 'pp-game', sport: 'nba', void: true, reason: 'postponed' },
|
||||
{ 'X-VYNDR-Internal-Key': 'int-test-key' },
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.voided).toBe(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('calculateStat unit cases', () => {
|
||||
const { calculateStat } = gradingRoutes.__helpers ?? {};
|
||||
const { getSportConfig } = require('../../src/config/sports');
|
||||
|
||||
test('NBA points (index)', () => {
|
||||
expect(calculateStat([null, '25', null, null, null], 'points', getSportConfig('nba'))).toBe(25);
|
||||
});
|
||||
|
||||
test('NBA threes_made parses makes-attempts string', () => {
|
||||
expect(calculateStat([null, null, null, '3-7'], 'threes_made', getSportConfig('nba'))).toBe(3);
|
||||
expect(calculateStat([null, null, null, ''], 'threes_made', getSportConfig('nba'))).toBe(0);
|
||||
expect(calculateStat([null, null, null, null], 'threes_made', getSportConfig('nba'))).toBe(0);
|
||||
});
|
||||
|
||||
test('NBA pts_reb_ast combo', () => {
|
||||
const stats = [];
|
||||
stats[1] = 22; stats[5] = 9; stats[6] = 5;
|
||||
expect(calculateStat(stats, 'pts_reb_ast', getSportConfig('nba'))).toBe(36);
|
||||
});
|
||||
|
||||
test('MLB totalBases (mlbField)', () => {
|
||||
expect(calculateStat({ totalBases: 4 }, 'totalBases', getSportConfig('mlb'))).toBe(4);
|
||||
});
|
||||
|
||||
test('MLB inningsPitched parses "5.1" → 5.33', () => {
|
||||
expect(calculateStat({ inningsPitched: '5.1' }, 'inningsPitched', getSportConfig('mlb'))).toBeCloseTo(5.333, 2);
|
||||
});
|
||||
|
||||
test('NFL passing_yards (category + field)', () => {
|
||||
expect(calculateStat({ passing: { passingYards: 287 } }, 'passing_yards', getSportConfig('nfl'))).toBe(287);
|
||||
});
|
||||
|
||||
test('defensive — undefined/null/empty all return 0', () => {
|
||||
expect(calculateStat(undefined, 'points', getSportConfig('nba'))).toBe(0);
|
||||
expect(calculateStat([], 'points', getSportConfig('nba'))).toBe(0);
|
||||
expect(calculateStat({ inningsPitched: null }, 'inningsPitched', getSportConfig('mlb'))).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,118 @@
|
||||
const mockState = { rows: new Map(), upserts: [] };
|
||||
|
||||
function mockKeyOf(s, g, p) { return `${s}|${g}|${p}`; }
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const ctx = { filters: {} };
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq(col, val) { ctx.filters[col] = val; return proxy; },
|
||||
maybeSingle() {
|
||||
const row = mockState.rows.get(mockKeyOf(ctx.filters.sport, ctx.filters.grade, ctx.filters.period));
|
||||
return Promise.resolve({ data: row || null, error: null });
|
||||
},
|
||||
upsert(row) {
|
||||
mockState.upserts.push(row);
|
||||
mockState.rows.set(mockKeyOf(row.sport, row.grade, row.period), { ...row });
|
||||
return Promise.resolve({ error: null });
|
||||
},
|
||||
then(resolve) {
|
||||
// For getAccuracyDashboard — list all rows with period filter.
|
||||
const period = ctx.filters.period;
|
||||
const all = Array.from(mockState.rows.values()).filter((r) => !period || r.period === period);
|
||||
return resolve({ data: all, error: null });
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const at = require('../../src/services/intelligence/accuracyTracker');
|
||||
|
||||
beforeEach(() => {
|
||||
mockState.rows.clear();
|
||||
mockState.upserts.length = 0;
|
||||
});
|
||||
|
||||
describe('accuracyTracker.recordResolution', () => {
|
||||
test('increments hit + total_graded across all three periods', async () => {
|
||||
await at.recordResolution('nba', 'A', 'hit');
|
||||
expect(mockState.upserts).toHaveLength(3); // all_time + 30d + 7d
|
||||
for (const u of mockState.upserts) {
|
||||
expect(u.total_graded).toBe(1);
|
||||
expect(u.total_hit).toBe(1);
|
||||
expect(u.total_miss).toBe(0);
|
||||
}
|
||||
});
|
||||
|
||||
test('push/void don\'t count toward hit rate', async () => {
|
||||
await at.recordResolution('nba', 'A', 'push');
|
||||
await at.recordResolution('nba', 'A', 'void');
|
||||
const row = mockState.rows.get('nba|A|all_time');
|
||||
expect(row.total_hit).toBe(0);
|
||||
expect(row.total_miss).toBe(0);
|
||||
expect(row.total_push).toBe(1);
|
||||
expect(row.total_void).toBe(1);
|
||||
expect(row.hit_rate).toBeNull();
|
||||
});
|
||||
|
||||
test('hit_rate is hits/(hits+misses) only', async () => {
|
||||
for (let i = 0; i < 7; i += 1) await at.recordResolution('nba', 'A', 'hit');
|
||||
for (let i = 0; i < 3; i += 1) await at.recordResolution('nba', 'A', 'miss');
|
||||
const row = mockState.rows.get('nba|A|all_time');
|
||||
expect(row.hit_rate).toBeCloseTo(0.7, 5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('accuracyTracker — baseline lock', () => {
|
||||
test('baseline locks at 100 decisive resolutions', async () => {
|
||||
for (let i = 0; i < 99; i += 1) await at.recordResolution('nba', 'A', 'hit');
|
||||
let row = mockState.rows.get('nba|A|all_time');
|
||||
expect(row.baseline_locked).toBe(false);
|
||||
await at.recordResolution('nba', 'A', 'hit');
|
||||
row = mockState.rows.get('nba|A|all_time');
|
||||
expect(row.baseline_locked).toBe(true);
|
||||
expect(row.baseline_hit_rate).toBe(1.0);
|
||||
});
|
||||
|
||||
test('only locks the all_time period', async () => {
|
||||
for (let i = 0; i < 100; i += 1) await at.recordResolution('nba', 'A', 'hit');
|
||||
expect(mockState.rows.get('nba|A|all_time').baseline_locked).toBe(true);
|
||||
expect(mockState.rows.get('nba|A|last_30d').baseline_locked).toBe(false);
|
||||
});
|
||||
|
||||
test('pushes do not contribute to baseline trigger', async () => {
|
||||
for (let i = 0; i < 99; i += 1) await at.recordResolution('nba', 'A', 'hit');
|
||||
await at.recordResolution('nba', 'A', 'push');
|
||||
expect(mockState.rows.get('nba|A|all_time').baseline_locked).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('accuracyTracker.getAccuracy', () => {
|
||||
test('reports expected hit rate by grade', async () => {
|
||||
const r = await at.getAccuracy('nba', 'A+', 'all_time');
|
||||
expect(r.expected).toBe(0.65);
|
||||
});
|
||||
|
||||
test('returns deltas relative to baseline once locked', async () => {
|
||||
for (let i = 0; i < 80; i += 1) await at.recordResolution('nba', 'A', 'hit');
|
||||
for (let i = 0; i < 20; i += 1) await at.recordResolution('nba', 'A', 'miss');
|
||||
const r = await at.getAccuracy('nba', 'A', 'all_time');
|
||||
expect(r.locked).toBe(true);
|
||||
expect(r.baseline).toBeCloseTo(0.8, 5);
|
||||
expect(r.delta).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('accuracyTracker.getAllAccuracy', () => {
|
||||
test('returns one entry per known grade tier', async () => {
|
||||
const all = await at.getAllAccuracy('nba');
|
||||
const tiers = all.map((r) => r.grade);
|
||||
expect(tiers).toContain('A+');
|
||||
expect(tiers).toContain('F');
|
||||
expect(all.length).toBe(Object.keys(at.EXPECTED_HIT_RATES).length);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,70 @@
|
||||
process.env.CFBD_KEY = 'test-key';
|
||||
process.env.CFBD_BASE_URL = 'https://api.cfbd.test';
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args) }));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
const adapter = require('../../src/services/adapters/cfbdAdapter');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('cfbdAdapter.configured', () => {
|
||||
test('reflects CFBD_KEY presence', () => {
|
||||
expect(adapter.configured()).toBe(true);
|
||||
delete process.env.CFBD_KEY;
|
||||
expect(adapter.configured()).toBe(false);
|
||||
process.env.CFBD_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('cfbdAdapter endpoints', () => {
|
||||
test('getTeamStats returns array from CFBD payload', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: [{ team: 'Michigan', statName: 'passingYards', statValue: 3500 }],
|
||||
});
|
||||
const stats = await adapter.getTeamStats('Michigan', 2025);
|
||||
expect(stats).toHaveLength(1);
|
||||
});
|
||||
|
||||
test('getTalentComposite picks the right team from full-year payload', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: [
|
||||
{ school: 'Alabama', talent: 980 },
|
||||
{ school: 'Michigan', talent: 870 },
|
||||
{ school: 'Ohio State', talent: 940 },
|
||||
],
|
||||
});
|
||||
const t = await adapter.getTalentComposite('Michigan', 2025);
|
||||
expect(t).toMatchObject({ school: 'Michigan', talent: 870 });
|
||||
});
|
||||
|
||||
test('uses Bearer token header (key never embedded in query)', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: [] });
|
||||
await adapter.getTeamStats('Michigan', 2025);
|
||||
expect(mockAxiosGet).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
expect.objectContaining({
|
||||
headers: expect.objectContaining({ Authorization: 'Bearer test-key' }),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
test('returns [] / null when unconfigured', async () => {
|
||||
delete process.env.CFBD_KEY;
|
||||
expect(await adapter.getTeamStats('Michigan', 2025)).toEqual([]);
|
||||
expect(await adapter.getTalentComposite('Michigan', 2025)).toBeNull();
|
||||
process.env.CFBD_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,95 @@
|
||||
const mockState = { grade: null, closing: null, updated: [] };
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq() { return proxy; },
|
||||
gte() { return Promise.resolve({ data: mockState.summaryRows || [], error: null }); },
|
||||
not() { return proxy; },
|
||||
maybeSingle() {
|
||||
if (table === 'grade_history') return Promise.resolve({ data: mockState.grade, error: null });
|
||||
if (table === 'closing_lines') return Promise.resolve({ data: mockState.closing, error: null });
|
||||
return Promise.resolve({ data: null, error: null });
|
||||
},
|
||||
update(patch) {
|
||||
mockState.updated.push({ table, patch });
|
||||
return { eq() { return Promise.resolve({ error: null }); } };
|
||||
},
|
||||
then(resolve) { return resolve({ data: mockState.summaryRows || [], error: null }); },
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const clv = require('../../src/services/intelligence/clvTracker');
|
||||
|
||||
beforeEach(() => {
|
||||
mockState.grade = null;
|
||||
mockState.closing = null;
|
||||
mockState.summaryRows = [];
|
||||
mockState.updated.length = 0;
|
||||
});
|
||||
|
||||
describe('rawCLV', () => {
|
||||
test('over: closing > graded → positive CLV', () => {
|
||||
expect(clv.rawCLV('over', 25.5, 27.5)).toBe(2.0);
|
||||
});
|
||||
test('over: closing < graded → negative CLV', () => {
|
||||
expect(clv.rawCLV('over', 25.5, 24.5)).toBe(-1.0);
|
||||
});
|
||||
test('under: closing < graded → positive CLV (we were right, line moved our way)', () => {
|
||||
expect(clv.rawCLV('under', 25.5, 23.5)).toBe(2.0);
|
||||
});
|
||||
test('under: closing > graded → negative', () => {
|
||||
expect(clv.rawCLV('under', 25.5, 27.5)).toBe(-2.0);
|
||||
});
|
||||
test('invalid input → null', () => {
|
||||
expect(clv.rawCLV('over', null, 27)).toBeNull();
|
||||
expect(clv.rawCLV('over', 25, 'abc')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('computeCLV', () => {
|
||||
test('returns null when grade not found', async () => {
|
||||
mockState.grade = null;
|
||||
const result = await clv.computeCLV('missing');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('returns clv:null with reason when no closing line', async () => {
|
||||
mockState.grade = { id: 'g1', game_id: 'gm', sport: 'nba', stat_type: 'points', line: 25.5, direction: 'over', player_id: '1' };
|
||||
mockState.closing = null;
|
||||
const result = await clv.computeCLV('g1');
|
||||
expect(result.clv).toBeNull();
|
||||
expect(result.reason).toBe('no_closing_line');
|
||||
});
|
||||
|
||||
test('persists CLV when both lines exist', async () => {
|
||||
mockState.grade = { id: 'g2', game_id: 'gm', sport: 'nba', stat_type: 'points', line: 25.5, direction: 'over', player_id: '1' };
|
||||
mockState.closing = { id: 'cl-1', pinnacle_line: 27.5 };
|
||||
const result = await clv.computeCLV('g2');
|
||||
expect(result.clv).toBe(2.0);
|
||||
expect(mockState.updated.some((u) => u.patch.clv === 2.0)).toBe(true);
|
||||
expect(mockState.updated[0].patch.closing_line_id).toBe('cl-1');
|
||||
});
|
||||
|
||||
test('falls back to player_name when player_id missing', async () => {
|
||||
mockState.grade = { id: 'g3', game_id: 'gm', sport: 'nba', stat_type: 'points', line: 25.5, direction: 'under', player_id: null, player_name: 'Test' };
|
||||
mockState.closing = { id: 'cl-2', pinnacle_line: 23.5 };
|
||||
const result = await clv.computeCLV('g3');
|
||||
expect(result.clv).toBe(2.0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('batchComputeCLV', () => {
|
||||
test('returns one entry per id, continues on individual failures', async () => {
|
||||
mockState.grade = { id: 'gx', game_id: 'gm', sport: 'nba', stat_type: 'points', line: 25.5, direction: 'over', player_id: '1' };
|
||||
mockState.closing = { id: 'cl-x', pinnacle_line: 26.5 };
|
||||
const out = await clv.batchComputeCLV(['gx', 'gx', 'gx']);
|
||||
expect(out).toHaveLength(3);
|
||||
expect(out[0].clv).toBe(1.0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,80 @@
|
||||
jest.mock('../../src/services/intelligence/gameLogService', () => ({
|
||||
getGameLogs: async () => null,
|
||||
}));
|
||||
|
||||
const cs = require('../../src/services/intelligence/consistencyScore');
|
||||
|
||||
describe('consistencyScore.classify', () => {
|
||||
test('cv < 0.15 → elite', () => {
|
||||
expect(cs.classify(0.10)).toEqual({ consistency: 'elite', score: 1.0 });
|
||||
});
|
||||
test('cv 0.15-0.30 → reliable', () => {
|
||||
expect(cs.classify(0.20)).toEqual({ consistency: 'reliable', score: 0.7 });
|
||||
});
|
||||
test('cv 0.30-0.50 → volatile', () => {
|
||||
expect(cs.classify(0.40)).toEqual({ consistency: 'volatile', score: 0.4 });
|
||||
});
|
||||
test('cv >= 0.50 → boom_bust', () => {
|
||||
expect(cs.classify(0.80)).toEqual({ consistency: 'boom_bust', score: 0.1 });
|
||||
});
|
||||
});
|
||||
|
||||
describe('consistencyScore.statsFor', () => {
|
||||
test('null for fewer than 2 samples', () => {
|
||||
expect(cs.statsFor([])).toBeNull();
|
||||
expect(cs.statsFor([25])).toBeNull();
|
||||
});
|
||||
|
||||
test('null when mean is zero (can\'t divide)', () => {
|
||||
expect(cs.statsFor([0, 0, 0])).toBeNull();
|
||||
});
|
||||
|
||||
test('computes mean / stddev / cv for tight values', () => {
|
||||
const s = cs.statsFor([25, 24, 26, 25, 24]);
|
||||
expect(s.mean).toBeCloseTo(24.8, 1);
|
||||
expect(s.cv).toBeLessThan(0.05);
|
||||
});
|
||||
|
||||
test('computes wide cv for volatile sample', () => {
|
||||
const s = cs.statsFor([5, 30, 35, 8, 28, 12]);
|
||||
expect(s.cv).toBeGreaterThan(0.4);
|
||||
});
|
||||
});
|
||||
|
||||
describe('consistencyScore.getConsistency', () => {
|
||||
test('classifies an elite scorer', async () => {
|
||||
const logs = [
|
||||
{ points: 25 }, { points: 24 }, { points: 26 }, { points: 25 }, { points: 24 },
|
||||
{ points: 25 }, { points: 26 }, { points: 24 }, { points: 25 }, { points: 25 },
|
||||
];
|
||||
const out = await cs.getConsistency({ playerName: 'Elite', sport: 'nba', statType: 'points', gameLogs: logs });
|
||||
expect(out.consistency).toBe('elite');
|
||||
expect(out.games).toBe(10);
|
||||
});
|
||||
|
||||
test('classifies boom/bust', async () => {
|
||||
const logs = [
|
||||
{ points: 5 }, { points: 32 }, { points: 8 }, { points: 35 }, { points: 6 },
|
||||
{ points: 28 }, { points: 4 }, { points: 30 }, { points: 9 }, { points: 26 },
|
||||
];
|
||||
const out = await cs.getConsistency({ playerName: 'Wild', sport: 'nba', statType: 'points', gameLogs: logs });
|
||||
expect(out.consistency).toBe('boom_bust');
|
||||
});
|
||||
|
||||
test('returns unknown when game logs empty', async () => {
|
||||
const out = await cs.getConsistency({ playerName: 'NoData', sport: 'nba', statType: 'points', gameLogs: [] });
|
||||
expect(out.consistency).toBe('unknown');
|
||||
expect(out.score).toBeNull();
|
||||
});
|
||||
|
||||
test('combo stat (pts_reb_ast) summed before measuring', async () => {
|
||||
const logs = [
|
||||
{ points: 20, rebounds: 5, assists: 5 },
|
||||
{ points: 22, rebounds: 5, assists: 4 },
|
||||
{ points: 18, rebounds: 6, assists: 5 },
|
||||
{ points: 21, rebounds: 5, assists: 5 },
|
||||
];
|
||||
const out = await cs.getConsistency({ playerName: 'Combo', sport: 'nba', statType: 'pts_reb_ast', gameLogs: logs });
|
||||
expect(out.consistency).toBe('elite');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,133 @@
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const mockRefAssignments = { current: null };
|
||||
const mockRefProfiles = { current: [] };
|
||||
const mockCoachProfile = { current: null };
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq() { return proxy; },
|
||||
in() { return Promise.resolve({ data: mockRefProfiles.current, error: null }); },
|
||||
maybeSingle() {
|
||||
if (table === 'game_ref_assignments') return Promise.resolve({ data: mockRefAssignments.current, error: null });
|
||||
if (table === 'coach_profiles') return Promise.resolve({ data: mockCoachProfile.current, error: null });
|
||||
return Promise.resolve({ data: null, error: null });
|
||||
},
|
||||
upsert() { return Promise.resolve({ error: null }); },
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const refSignals = require('../../src/services/intelligence/refSignals');
|
||||
const coachSignals = require('../../src/services/intelligence/coachSignals');
|
||||
const lineupSignals = require('../../src/services/intelligence/lineupSignals');
|
||||
|
||||
beforeEach(() => {
|
||||
mockRefAssignments.current = null;
|
||||
mockRefProfiles.current = [];
|
||||
mockCoachProfile.current = null;
|
||||
});
|
||||
|
||||
describe('refSignals', () => {
|
||||
test('getRefImpact returns null when no assignment', async () => {
|
||||
expect(await refSignals.getRefImpact('g-nope')).toBeNull();
|
||||
});
|
||||
|
||||
test('uses precomputed crew values if present on assignment row', async () => {
|
||||
mockRefAssignments.current = {
|
||||
ref1_name: 'Scott Foster',
|
||||
ref2_name: 'Tony Brothers',
|
||||
ref3_name: null,
|
||||
ref_crew_avg_fouls: 22.5,
|
||||
ref_crew_pace_impact: -0.3,
|
||||
};
|
||||
const r = await refSignals.getRefImpact('g-fast');
|
||||
expect(r.avg_fouls).toBe(22.5);
|
||||
expect(r.pace_impact).toBe(-0.3);
|
||||
expect(r.crew).toHaveLength(2);
|
||||
});
|
||||
|
||||
test('averages ref_profiles when assignment has no precomputed values', async () => {
|
||||
mockRefAssignments.current = {
|
||||
ref1_name: 'Foster', ref2_name: 'Brothers', ref3_name: 'Goble',
|
||||
ref_crew_avg_fouls: null, ref_crew_pace_impact: null,
|
||||
};
|
||||
mockRefProfiles.current = [
|
||||
{ ref_name: 'Foster', avg_fouls_per_game: 22, avg_free_throws_per_game: 24, pace_impact: -0.5, home_whistle_bias: 0.1 },
|
||||
{ ref_name: 'Brothers', avg_fouls_per_game: 20, avg_free_throws_per_game: 22, pace_impact: 0.2, home_whistle_bias: 0.0 },
|
||||
];
|
||||
const r = await refSignals.getRefImpact('g-avg');
|
||||
expect(r.avg_fouls).toBe(21);
|
||||
expect(r.pace_impact).toBeCloseTo(-0.15, 5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('coachSignals', () => {
|
||||
test('returns null when coach not in DB nor seed', async () => {
|
||||
expect(await coachSignals.getCoachImpact('nba', 'GHOST')).toBeNull();
|
||||
});
|
||||
|
||||
test('falls back to seed when DB has no record (NYK is in seed)', async () => {
|
||||
const impact = await coachSignals.getCoachImpact('nba', 'NYK');
|
||||
expect(impact).not.toBeNull();
|
||||
expect(impact.coach_name).toBe('Tom Thibodeau');
|
||||
expect(impact.pace_delta).toBeCloseTo(96.5 - 98.1, 5);
|
||||
expect(impact.adjusted_pace_delta).toBe(impact.pace_delta * impact.tenure_adjustment);
|
||||
});
|
||||
|
||||
test('returns system_override when primary player is out', async () => {
|
||||
const impact = await coachSignals.getCoachImpact('nba', 'NYK', { primary_player_status: 'out' });
|
||||
expect(impact.system_override).toBe('motion');
|
||||
expect(impact.without_primary_pace_shift).toBe(1.5);
|
||||
});
|
||||
|
||||
test('tenureAdjustment maps tenure to 0..1 linearly capped', () => {
|
||||
expect(coachSignals.tenureAdjustment(0)).toBe(0);
|
||||
expect(coachSignals.tenureAdjustment(20)).toBeCloseTo(0.5, 5);
|
||||
expect(coachSignals.tenureAdjustment(40)).toBe(1);
|
||||
expect(coachSignals.tenureAdjustment(400)).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('lineupSignals', () => {
|
||||
test('classifyByUsage thresholds', () => {
|
||||
expect(lineupSignals.classifyByUsage(0.32)).toBe('primary_handler');
|
||||
expect(lineupSignals.classifyByUsage(0.22)).toBe('secondary');
|
||||
expect(lineupSignals.classifyByUsage(0.12)).toBe('role_player');
|
||||
expect(lineupSignals.classifyByUsage(undefined)).toBe('role_player');
|
||||
});
|
||||
|
||||
test('roleValue maps role labels to 1.0/0.5/0.0', () => {
|
||||
expect(lineupSignals.roleValue('primary_handler')).toBe(1.0);
|
||||
expect(lineupSignals.roleValue('secondary')).toBe(0.5);
|
||||
expect(lineupSignals.roleValue('role_player')).toBe(0.0);
|
||||
});
|
||||
|
||||
test('getProjectedStarters walks the box score', async () => {
|
||||
// Use the fixture from 6a — real ESPN box.
|
||||
const fixture = JSON.parse(fs.readFileSync(
|
||||
path.join(__dirname, '..', 'fixtures', 'nba-boxscore-sample.json'),
|
||||
'utf8',
|
||||
));
|
||||
const out = await lineupSignals.getProjectedStarters('nba', 'g', fixture);
|
||||
expect(out.home.length).toBeGreaterThan(0);
|
||||
expect(out.away.length).toBeGreaterThan(0);
|
||||
expect(out.home[0].role).toBe('primary_handler');
|
||||
});
|
||||
});
|
||||
|
||||
describe('coaches.json seed', () => {
|
||||
test('seed file is valid JSON with the expected shape', () => {
|
||||
const seed = coachSignals.loadSeed();
|
||||
expect(seed.coaches).toBeDefined();
|
||||
expect(Array.isArray(seed.coaches)).toBe(true);
|
||||
expect(seed.coaches[0]).toHaveProperty('coach_name');
|
||||
expect(seed.coaches[0]).toHaveProperty('team');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,205 @@
|
||||
process.env.VYNDR_INTERNAL_KEY = 'corr-test-key';
|
||||
|
||||
const mockState = {
|
||||
resolutions: [],
|
||||
updates: [],
|
||||
};
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const ctx = { table };
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
gte() { return Promise.resolve({ data: mockState.resolutions, error: null }); },
|
||||
update(patch) {
|
||||
mockState.updates.push({ table, patch });
|
||||
return {
|
||||
eq() { return Promise.resolve({ error: null }); },
|
||||
in() { return Promise.resolve({ error: null }); },
|
||||
};
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/utils/rateLimiter', () => ({
|
||||
createLimiter: () => ({ waitForToken: async () => true, snapshot: () => ({}) }),
|
||||
createCircuitBreaker: () => ({ call: async (fn) => fn(), snapshot: () => ({}) }),
|
||||
API_BUDGETS: {
|
||||
espn: { tokensPerInterval: 100, interval: 60_000 },
|
||||
mlbStats: { tokensPerInterval: 100, interval: 60_000 },
|
||||
oddsPapi: { tokensPerInterval: 100, interval: 60_000 },
|
||||
sharpApi: { tokensPerInterval: 100, interval: 60_000 },
|
||||
openRouter: { tokensPerInterval: 100, interval: 60_000 },
|
||||
},
|
||||
}));
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({
|
||||
get: (...args) => mockAxiosGet(...args),
|
||||
post: jest.fn().mockResolvedValue({ status: 200, data: {} }),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/distribution/telegram', () => ({
|
||||
configured: () => false,
|
||||
postToTelegram: async () => ({ ok: true }),
|
||||
}));
|
||||
|
||||
const express = require('express');
|
||||
const corrections = require('../../src/routes/corrections');
|
||||
|
||||
function makeApp() {
|
||||
const app = express();
|
||||
app.use(express.json());
|
||||
app.use('/api/grading', corrections);
|
||||
return app;
|
||||
}
|
||||
|
||||
function call(app, body, headers = {}) {
|
||||
return new Promise((resolve) => {
|
||||
const http = require('http');
|
||||
const server = app.listen(0, '127.0.0.1', () => {
|
||||
const port = server.address().port;
|
||||
const req = http.request({
|
||||
host: '127.0.0.1',
|
||||
port,
|
||||
path: '/api/grading/correct',
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json', ...headers },
|
||||
}, (res) => {
|
||||
const chunks = [];
|
||||
res.on('data', (c) => chunks.push(c));
|
||||
res.on('end', () => {
|
||||
server.close();
|
||||
const raw = Buffer.concat(chunks).toString('utf8');
|
||||
let parsed; try { parsed = JSON.parse(raw); } catch { parsed = raw; }
|
||||
resolve({ status: res.statusCode, body: parsed });
|
||||
});
|
||||
});
|
||||
req.write(JSON.stringify(body || {}));
|
||||
req.end();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
mockState.resolutions = [];
|
||||
mockState.updates = [];
|
||||
mockAxiosGet.mockReset();
|
||||
});
|
||||
|
||||
describe('POST /api/grading/correct', () => {
|
||||
test('rejects without internal key', async () => {
|
||||
const app = makeApp();
|
||||
const res = await call(app, { hours: 24 });
|
||||
expect(res.status).toBe(401);
|
||||
});
|
||||
|
||||
test('no-ops when no resolutions in window', async () => {
|
||||
mockState.resolutions = [];
|
||||
const app = makeApp();
|
||||
const res = await call(app, { hours: 24 }, { 'X-VYNDR-Internal-Key': 'corr-test-key' });
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toMatchObject({ checked: 0, corrected: 0 });
|
||||
});
|
||||
|
||||
test('detects a flipped result and updates both tables', async () => {
|
||||
// Stored: hit at actual=10 (line 9.5 over). Box now reports actual=9 → miss.
|
||||
mockState.resolutions = [{
|
||||
id: 'res-1', grade_id: 'gh-1', game_id: 'g-correct', sport: 'nba',
|
||||
player_espn_id: '999', player_name: 'Test Player', stat_type: 'points',
|
||||
line: 9.5, direction: 'over', actual_value: 10, result: 'hit', margin: 0.5,
|
||||
}];
|
||||
// Build a minimal basketball box-score with the player's points now at 9.
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
data: {
|
||||
boxscore: {
|
||||
players: [
|
||||
{
|
||||
statistics: [{
|
||||
labels: ['MIN','PTS','FG','3PT','FT','REB','AST','TO','STL','BLK'],
|
||||
athletes: [{ athlete: { id: 999 }, starter: true, stats: ['33','9','3-7','1-4','2-2','5','4','1','1','0'] }],
|
||||
}],
|
||||
},
|
||||
{ statistics: [{ athletes: [] }] },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
const app = makeApp();
|
||||
const res = await call(app, { hours: 24 }, { 'X-VYNDR-Internal-Key': 'corr-test-key' });
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.checked).toBe(1);
|
||||
expect(res.body.corrected).toBe(1);
|
||||
expect(res.body.details[0]).toMatchObject({
|
||||
flipped: true,
|
||||
old: { actual: 10, result: 'hit' },
|
||||
new: { actual: 9, result: 'miss' },
|
||||
});
|
||||
// Both tables updated (resolution_results + grade_history).
|
||||
expect(mockState.updates.some((u) => u.table === 'resolution_results')).toBe(true);
|
||||
expect(mockState.updates.some((u) => u.table === 'grade_history')).toBe(true);
|
||||
});
|
||||
|
||||
test('value change without result flip is a silent update', async () => {
|
||||
// Stored: hit at actual=12 (line 9.5 over). Box now reports actual=11 → still HIT, just lower margin.
|
||||
mockState.resolutions = [{
|
||||
id: 'res-2', grade_id: 'gh-2', game_id: 'g-silent', sport: 'nba',
|
||||
player_espn_id: '111', player_name: 'Silent', stat_type: 'points',
|
||||
line: 9.5, direction: 'over', actual_value: 12, result: 'hit', margin: 2.5,
|
||||
}];
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
data: {
|
||||
boxscore: {
|
||||
players: [
|
||||
{
|
||||
statistics: [{
|
||||
labels: ['MIN','PTS','FG','3PT','FT','REB','AST','TO','STL','BLK'],
|
||||
athletes: [{ athlete: { id: 111 }, starter: true, stats: ['30','11','5-9','1-2','0-0','3','2','0','0','0'] }],
|
||||
}],
|
||||
},
|
||||
{ statistics: [{ athletes: [] }] },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
const app = makeApp();
|
||||
const res = await call(app, { hours: 24 }, { 'X-VYNDR-Internal-Key': 'corr-test-key' });
|
||||
expect(res.body.checked).toBe(1);
|
||||
expect(res.body.corrected).toBe(0);
|
||||
expect(res.body.details[0]).toMatchObject({ flipped: false, new: { actual: 11, result: 'hit' } });
|
||||
});
|
||||
|
||||
test('no change at all is a no-op (no updates queued)', async () => {
|
||||
mockState.resolutions = [{
|
||||
id: 'res-3', grade_id: 'gh-3', game_id: 'g-noop', sport: 'nba',
|
||||
player_espn_id: '222', player_name: 'NoChange', stat_type: 'points',
|
||||
line: 9.5, direction: 'over', actual_value: 10, result: 'hit', margin: 0.5,
|
||||
}];
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
data: {
|
||||
boxscore: {
|
||||
players: [
|
||||
{
|
||||
statistics: [{
|
||||
labels: ['MIN','PTS','FG','3PT','FT','REB','AST','TO','STL','BLK'],
|
||||
athletes: [{ athlete: { id: 222 }, starter: true, stats: ['30','10','5-9','1-2','0-0','3','2','0','0','0'] }],
|
||||
}],
|
||||
},
|
||||
{ statistics: [{ athletes: [] }] },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
const app = makeApp();
|
||||
const res = await call(app, { hours: 24 }, { 'X-VYNDR-Internal-Key': 'corr-test-key' });
|
||||
expect(res.body.checked).toBe(1);
|
||||
expect(res.body.corrected).toBe(0);
|
||||
expect(res.body.details).toHaveLength(0);
|
||||
expect(mockState.updates).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,98 @@
|
||||
const engine1 = require('../../src/services/intelligence/engine1');
|
||||
|
||||
function withProp(features = {}, trap = {}, consistency = {}, prop = { line: 25.5, direction: 'over' }) {
|
||||
return engine1.gradeProp({ features, trap, consistency, prop });
|
||||
}
|
||||
|
||||
describe('engine1.gradeProp', () => {
|
||||
test('hot recent form + weak D + home + rested → A-tier', () => {
|
||||
const result = withProp(
|
||||
{ l5_avg: 32, l20_avg: 27, opp_rank_stat: 0.85, home_away: 1.0, rest_days: 2 },
|
||||
{ composite: 0.1 },
|
||||
{ consistency: 'reliable', score: 0.7 },
|
||||
);
|
||||
expect(['A+', 'A', 'A-']).toContain(result.grade);
|
||||
expect(result.top_factors.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('cold L5 + strong opponent D + back-to-back → D/F tier', () => {
|
||||
const result = withProp(
|
||||
{ l5_avg: 18, l20_avg: 21, opp_rank_stat: 0.1, home_away: 0.0, rest_days: 0 },
|
||||
{ composite: 0.6 },
|
||||
{ consistency: 'boom_bust', score: 0.1 },
|
||||
);
|
||||
expect(['F', 'D', 'C-']).toContain(result.grade);
|
||||
});
|
||||
|
||||
test('high trap composite downgrades a hot prop to C-tier', () => {
|
||||
const hotNoTrap = withProp(
|
||||
{ l5_avg: 30, l20_avg: 26, opp_rank_stat: 0.8, home_away: 1.0, rest_days: 2 },
|
||||
{ composite: 0.1 },
|
||||
{ consistency: 'reliable' },
|
||||
);
|
||||
const hotWithTrap = withProp(
|
||||
{ l5_avg: 30, l20_avg: 26, opp_rank_stat: 0.8, home_away: 1.0, rest_days: 2 },
|
||||
{ composite: 0.7 },
|
||||
{ consistency: 'reliable' },
|
||||
);
|
||||
// The trap version should land at least one step lower on the scale.
|
||||
const idxHigh = engine1.GRADE_SCALE.indexOf(hotNoTrap.grade);
|
||||
const idxLow = engine1.GRADE_SCALE.indexOf(hotWithTrap.grade);
|
||||
expect(idxLow).toBeLessThan(idxHigh);
|
||||
});
|
||||
|
||||
test('UNDER direction inverts the L5 polarity', () => {
|
||||
// Player averaging 18 with line 25.5 over → cold for OVER.
|
||||
const over = withProp(
|
||||
{ l5_avg: 18, l20_avg: 19 },
|
||||
{ composite: 0.1 },
|
||||
{ consistency: 'reliable' },
|
||||
{ line: 25.5, direction: 'over' },
|
||||
);
|
||||
const under = withProp(
|
||||
{ l5_avg: 18, l20_avg: 19 },
|
||||
{ composite: 0.1 },
|
||||
{ consistency: 'reliable' },
|
||||
{ line: 25.5, direction: 'under' },
|
||||
);
|
||||
const overIdx = engine1.GRADE_SCALE.indexOf(over.grade);
|
||||
const underIdx = engine1.GRADE_SCALE.indexOf(under.grade);
|
||||
expect(underIdx).toBeGreaterThan(overIdx);
|
||||
});
|
||||
|
||||
test('returns confidence proportional to grade', () => {
|
||||
const a = withProp({ l5_avg: 32, l20_avg: 27, opp_rank_stat: 0.85, home_away: 1.0, rest_days: 2 },
|
||||
{ composite: 0.05 }, { consistency: 'elite', score: 1.0 });
|
||||
const c = withProp({}, {}, {});
|
||||
expect(a.confidence).toBeGreaterThan(c.confidence);
|
||||
});
|
||||
|
||||
test('with no features at all, returns neutral C', () => {
|
||||
const result = withProp({}, {}, {});
|
||||
expect(result.grade).toBe('C');
|
||||
expect(result.top_factors).toEqual([]);
|
||||
});
|
||||
|
||||
test('all_factors lists every contributing factor, top_factors slices to 3', () => {
|
||||
const result = withProp(
|
||||
{ l5_avg: 32, l20_avg: 27, opp_rank_stat: 0.85, home_away: 1.0, rest_days: 2, coach_pace_delta: 1.2 },
|
||||
{ composite: 0.1 },
|
||||
{ consistency: 'elite', score: 1.0 },
|
||||
);
|
||||
expect(result.top_factors.length).toBeLessThanOrEqual(3);
|
||||
expect(result.all_factors.length).toBeGreaterThanOrEqual(result.top_factors.length);
|
||||
});
|
||||
});
|
||||
|
||||
describe('GRADE_SCALE invariants', () => {
|
||||
test('11 grades in ascending order F → A+', () => {
|
||||
expect(engine1.GRADE_SCALE).toEqual(['F', 'D', 'C-', 'C', 'C+', 'B-', 'B', 'B+', 'A-', 'A', 'A+']);
|
||||
});
|
||||
|
||||
test('confidence values strictly ascending', () => {
|
||||
const conf = engine1.GRADE_SCALE.map((g) => engine1.GRADE_TO_CONFIDENCE[g]);
|
||||
for (let i = 1; i < conf.length; i += 1) {
|
||||
expect(conf[i]).toBeGreaterThan(conf[i - 1]);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,204 @@
|
||||
process.env.ENGINE2_ENABLED = 'true';
|
||||
|
||||
const mockAnalyze = jest.fn();
|
||||
jest.mock('../../src/services/adapters/openRouterAdapter', () => ({
|
||||
configured: () => true,
|
||||
analyze: (...args) => mockAnalyze(...args),
|
||||
getUsage: () => ({ requestsToday: 0, requestsRemaining: 1000 }),
|
||||
}));
|
||||
|
||||
const mockUpdates = [];
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const proxy = {
|
||||
update(patch) {
|
||||
mockUpdates.push(patch);
|
||||
return {
|
||||
eq() { return Promise.resolve({ error: null }); },
|
||||
};
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const engine2 = require('../../src/services/intelligence/engine2');
|
||||
|
||||
beforeEach(() => {
|
||||
engine2.clearQueue();
|
||||
mockAnalyze.mockReset();
|
||||
mockUpdates.length = 0;
|
||||
});
|
||||
|
||||
function sampleContext(overrides = {}) {
|
||||
return {
|
||||
player_name: 'Jalen Brunson',
|
||||
team: 'NYK',
|
||||
sport: 'nba',
|
||||
direction: 'over',
|
||||
line: 26.5,
|
||||
stat_type: 'points',
|
||||
home_team: 'NYK',
|
||||
away_team: 'BOS',
|
||||
game_date: '2026-06-08',
|
||||
engine1_grade: 'A-',
|
||||
engine1_factors: ['l5_avg', 'opp_rank_stat', 'home_away'],
|
||||
features: { l5_avg: 30.4, l20_avg: 26.1, home_away: 1.0 },
|
||||
trap: { composite: 0.18, recommendation: 'proceed', signals: {} },
|
||||
consistency: { consistency: 'reliable', cv: 0.18, score: 0.7 },
|
||||
recentGames: [
|
||||
{ date: '2026-06-05', value: 32, opponent: 'BOS', home: true },
|
||||
{ date: '2026-06-03', value: 28, opponent: 'MIA', home: false },
|
||||
],
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
describe('engine2 — eligibility', () => {
|
||||
test('queues A/B tier grades', () => {
|
||||
engine2.queueAnalysis('g1', sampleContext({ engine1_grade: 'A-' }));
|
||||
engine2.queueAnalysis('g2', sampleContext({ engine1_grade: 'B+' }));
|
||||
expect(engine2.getQueueSize()).toBe(2);
|
||||
});
|
||||
|
||||
test('SKIPS C/D/F grades', () => {
|
||||
engine2.queueAnalysis('c1', sampleContext({ engine1_grade: 'C' }));
|
||||
engine2.queueAnalysis('d1', sampleContext({ engine1_grade: 'D' }));
|
||||
engine2.queueAnalysis('f1', sampleContext({ engine1_grade: 'F' }));
|
||||
expect(engine2.getQueueSize()).toBe(0);
|
||||
});
|
||||
|
||||
test('respects ENGINE2_ENABLED=false', () => {
|
||||
process.env.ENGINE2_ENABLED = 'false';
|
||||
jest.resetModules();
|
||||
const fresh = require('../../src/services/intelligence/engine2');
|
||||
fresh.queueAnalysis('g3', sampleContext({ engine1_grade: 'A' }));
|
||||
expect(fresh.getQueueSize()).toBe(0);
|
||||
process.env.ENGINE2_ENABLED = 'true';
|
||||
});
|
||||
});
|
||||
|
||||
describe('engine2 — prompt construction', () => {
|
||||
test('buildPrompt includes player, features, traps, and recent games', () => {
|
||||
const prompt = engine2.__internals.buildPrompt(sampleContext());
|
||||
expect(prompt).toContain('Jalen Brunson');
|
||||
expect(prompt).toContain('PROP: over 26.5 points');
|
||||
expect(prompt).toContain('l5_avg');
|
||||
expect(prompt).toContain('Trap composite: 0.18');
|
||||
expect(prompt).toContain('cv=0.18');
|
||||
});
|
||||
|
||||
test('prompt never contains the literal string "VYNDR"', () => {
|
||||
const prompt = engine2.__internals.buildPrompt(sampleContext());
|
||||
expect(prompt).not.toMatch(/VYNDR/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('engine2 — response parsing', () => {
|
||||
test('parseResponse handles raw JSON', () => {
|
||||
const r = engine2.__internals.parseResponse('{"grade":"A","confidence":0.7,"narrative":"..."}');
|
||||
expect(r.grade).toBe('A');
|
||||
});
|
||||
|
||||
test('parseResponse handles markdown fenced JSON', () => {
|
||||
const r = engine2.__internals.parseResponse('Here you go:\n```json\n{"grade":"B"}\n```');
|
||||
expect(r.grade).toBe('B');
|
||||
});
|
||||
|
||||
test('parseResponse extracts JSON from chatty preamble', () => {
|
||||
const r = engine2.__internals.parseResponse('Sure! Here is the analysis: {"grade":"B+","confidence":0.6}');
|
||||
expect(r.grade).toBe('B+');
|
||||
});
|
||||
|
||||
test('parseResponse returns null when no JSON found', () => {
|
||||
expect(engine2.__internals.parseResponse('no json here')).toBeNull();
|
||||
expect(engine2.__internals.parseResponse(null)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('engine2 — validation', () => {
|
||||
test('rejects unknown grade values', () => {
|
||||
expect(engine2.__internals.validateAnalysis({
|
||||
grade: 'AAA', confidence: 0.7, narrative: 'x',
|
||||
})).toBeNull();
|
||||
});
|
||||
|
||||
test('rejects out-of-range confidence', () => {
|
||||
expect(engine2.__internals.validateAnalysis({
|
||||
grade: 'A', confidence: 1.5, narrative: 'x',
|
||||
})).toBeNull();
|
||||
});
|
||||
|
||||
test('rejects empty narrative', () => {
|
||||
expect(engine2.__internals.validateAnalysis({
|
||||
grade: 'A', confidence: 0.7, narrative: '',
|
||||
})).toBeNull();
|
||||
});
|
||||
|
||||
test('truncates narrative + concern + key_factor to caps', () => {
|
||||
const out = engine2.__internals.validateAnalysis({
|
||||
grade: 'A',
|
||||
confidence: 0.7,
|
||||
narrative: 'x'.repeat(800),
|
||||
trap_concern: 'y'.repeat(500),
|
||||
key_factor: 'z'.repeat(300),
|
||||
agrees_with_engine1: true,
|
||||
});
|
||||
expect(out.narrative.length).toBe(500);
|
||||
expect(out.trap_concern.length).toBe(300);
|
||||
expect(out.key_factor.length).toBe(200);
|
||||
});
|
||||
|
||||
test('passes explicit null grade through', () => {
|
||||
const out = engine2.__internals.validateAnalysis({ grade: null, reason: 'not enough data' });
|
||||
expect(out).toEqual({ grade: null, reason: 'not enough data' });
|
||||
});
|
||||
});
|
||||
|
||||
describe('engine2 — processQueue', () => {
|
||||
test('processes queued analysis, persists to grade_history', async () => {
|
||||
mockAnalyze.mockResolvedValue({
|
||||
response: JSON.stringify({
|
||||
grade: 'A',
|
||||
confidence: 0.78,
|
||||
agrees_with_engine1: true,
|
||||
narrative: 'Brunson trending up + weak D matchup + rested.',
|
||||
trap_concern: null,
|
||||
key_factor: 'opp_rank_stat',
|
||||
}),
|
||||
modelUsed: 'deepseek/deepseek-chat',
|
||||
latencyMs: 4200,
|
||||
});
|
||||
engine2.queueAnalysis('grade-1', sampleContext());
|
||||
const summary = await engine2.processQueue();
|
||||
expect(summary).toMatchObject({ processed: 1, succeeded: 1, failed: 0 });
|
||||
expect(mockUpdates).toHaveLength(1);
|
||||
expect(mockUpdates[0].engine2_grade).toBe('A');
|
||||
expect(mockUpdates[0].engine2_confidence).toBe(0.78);
|
||||
expect(mockUpdates[0].engine2_model).toBe('deepseek/deepseek-chat');
|
||||
});
|
||||
|
||||
test('records failures without crashing', async () => {
|
||||
mockAnalyze.mockResolvedValue(null); // adapter unavailable
|
||||
engine2.queueAnalysis('grade-2', sampleContext());
|
||||
const summary = await engine2.processQueue();
|
||||
expect(summary).toMatchObject({ processed: 1, succeeded: 0, failed: 1 });
|
||||
});
|
||||
|
||||
test('respects BATCH_SIZE — leaves remaining items for next call', async () => {
|
||||
mockAnalyze.mockResolvedValue({
|
||||
response: JSON.stringify({ grade: 'A', confidence: 0.7, agrees_with_engine1: true, narrative: 'x' }),
|
||||
modelUsed: 'deepseek/deepseek-chat',
|
||||
latencyMs: 100,
|
||||
});
|
||||
// Queue more than BATCH_SIZE items.
|
||||
for (let i = 0; i < engine2.__internals.BATCH_SIZE + 3; i += 1) {
|
||||
engine2.queueAnalysis(`g-${i}`, sampleContext());
|
||||
}
|
||||
const summary = await engine2.processQueue();
|
||||
expect(summary.processed).toBe(engine2.__internals.BATCH_SIZE);
|
||||
expect(summary.remaining).toBe(3);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,221 @@
|
||||
// Mocked deps for the feature cache. Every sub-service is replaced so we
|
||||
// can verify the cache OMITS features whose source returns null.
|
||||
|
||||
const mockGameLogs = { logs: null, careerPlayoff: null };
|
||||
jest.mock('../../src/services/intelligence/gameLogService', () => ({
|
||||
getGameLogs: async () => mockGameLogs.logs,
|
||||
getCareerPlayoffGames: async () => mockGameLogs.careerPlayoff,
|
||||
getWithWithoutStats: async () => null,
|
||||
}));
|
||||
|
||||
const mockTeam = { stats: null, rank: null };
|
||||
jest.mock('../../src/services/intelligence/teamStatsCache', () => ({
|
||||
getTeamStats: async () => mockTeam.stats,
|
||||
getOpponentRank: async () => mockTeam.rank,
|
||||
refreshTeamStats: async () => ({ captured: 0 }),
|
||||
}));
|
||||
|
||||
const mockRef = { impact: null };
|
||||
jest.mock('../../src/services/intelligence/refSignals', () => ({
|
||||
getRefImpact: async () => mockRef.impact,
|
||||
setRefAssignment: async () => ({ ok: true }),
|
||||
}));
|
||||
|
||||
const mockCoach = { impact: null };
|
||||
jest.mock('../../src/services/intelligence/coachSignals', () => ({
|
||||
getCoachImpact: async () => mockCoach.impact,
|
||||
getCoachProfile: async () => null,
|
||||
tenureAdjustment: () => 0.5,
|
||||
loadSeed: () => ({ coaches: [] }),
|
||||
}));
|
||||
|
||||
const mockLineup = { roleValue: 1.0 };
|
||||
jest.mock('../../src/services/intelligence/lineupSignals', () => ({
|
||||
roleValue: () => mockLineup.roleValue,
|
||||
classifyByUsage: () => 'primary_handler',
|
||||
getProjectedStarters: async () => ({ home: [], away: [] }),
|
||||
}));
|
||||
|
||||
const mockInjuries = { list: [] };
|
||||
jest.mock('../../src/services/intelligence/injuryParser', () => ({
|
||||
getTeamInjuries: async () => mockInjuries.list,
|
||||
isPlayerOut: async () => false,
|
||||
getMissingStarters: async () => [],
|
||||
}));
|
||||
|
||||
const mockLineMovement = { lm: null };
|
||||
jest.mock('../../src/services/intelligence/lineMovement', () => ({
|
||||
getLineMovement: async () => mockLineMovement.lm,
|
||||
}));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
const fc = require('../../src/services/intelligence/featureCache');
|
||||
|
||||
beforeEach(() => {
|
||||
mockGameLogs.logs = null;
|
||||
mockGameLogs.careerPlayoff = null;
|
||||
mockTeam.stats = null;
|
||||
mockTeam.rank = null;
|
||||
mockRef.impact = null;
|
||||
mockCoach.impact = null;
|
||||
mockLineup.roleValue = 1.0;
|
||||
mockInjuries.list = [];
|
||||
mockLineMovement.lm = null;
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('feature cache — missing data omits features', () => {
|
||||
test('with no upstream data, only context + injury_severity_score (=0) populate', async () => {
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p1',
|
||||
playerName: 'P',
|
||||
statType: 'points',
|
||||
sport: 'nba',
|
||||
gameId: 'g1',
|
||||
gameContext: { home_away: 'home', rest_days: 1 },
|
||||
teamId: 18,
|
||||
});
|
||||
expect(payload.features.home_away).toBe(1.0);
|
||||
expect(payload.features.rest_days).toBe(1);
|
||||
expect(payload.features.injury_severity_score).toBe(0);
|
||||
// Missing because upstreams returned null:
|
||||
expect(payload.features.l5_avg).toBeUndefined();
|
||||
expect(payload.features.opp_rank_stat).toBeUndefined();
|
||||
expect(payload.features.ref_pace_adjustment).toBeUndefined();
|
||||
expect(payload.meta.features_missing).toContain('l5_avg');
|
||||
expect(payload.meta.features_missing).toContain('ref_pace_adjustment');
|
||||
expect(payload.meta.features_available).toContain('home_away');
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — game log features', () => {
|
||||
test('computes l5_avg, l20_avg, l10_stddev from a 10-game log', async () => {
|
||||
mockGameLogs.logs = [
|
||||
{ points: 30 }, { points: 25 }, { points: 28 }, { points: 22 }, { points: 35 },
|
||||
{ points: 20 }, { points: 18 }, { points: 26 }, { points: 31 }, { points: 24 },
|
||||
];
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p2', playerName: 'P', statType: 'points',
|
||||
sport: 'nba', gameId: 'g2', gameContext: {},
|
||||
});
|
||||
expect(payload.features.l5_avg).toBeCloseTo(28.0, 1);
|
||||
expect(payload.features.l20_avg).toBeCloseTo(25.9, 1);
|
||||
expect(payload.features.l10_stddev).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('combo stats (pts_reb_ast) sum components per game', async () => {
|
||||
mockGameLogs.logs = [
|
||||
{ points: 25, rebounds: 5, assists: 7 },
|
||||
{ points: 22, rebounds: 6, assists: 8 },
|
||||
{ points: 30, rebounds: 4, assists: 5 },
|
||||
];
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p3', playerName: 'P', statType: 'pts_reb_ast',
|
||||
sport: 'nba', gameId: 'g3', gameContext: {},
|
||||
});
|
||||
// (37 + 36 + 39) / 3 = 37.33
|
||||
expect(payload.features.l5_avg).toBeCloseTo(37.33, 1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — team features', () => {
|
||||
test('opp_rank_stat + pace_factor + team_pace come from team cache', async () => {
|
||||
mockTeam.stats = { pace: 102.4 };
|
||||
mockTeam.rank = 7;
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p4', playerName: 'P', statType: 'points',
|
||||
sport: 'nba', gameId: 'g4', opponentAbbr: 'BOS', gameContext: {},
|
||||
});
|
||||
expect(payload.features.opp_rank_stat).toBe(7);
|
||||
expect(payload.features.pace_factor).toBe(102.4);
|
||||
expect(payload.features.team_pace).toBe(102.4);
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — injury features', () => {
|
||||
test('counts missing starters', async () => {
|
||||
mockInjuries.list = [
|
||||
{ playerId: '1', playerName: 'A', status: 'OUT' },
|
||||
{ playerId: '2', playerName: 'B', status: 'OUT' },
|
||||
{ playerId: '3', playerName: 'C', status: 'QUESTIONABLE' },
|
||||
];
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p5', playerName: 'P', statType: 'points',
|
||||
sport: 'nba', gameId: 'g5', teamId: 18,
|
||||
knownStarterIds: ['1', '2', '3', '4'],
|
||||
gameContext: {},
|
||||
});
|
||||
// Only OUT counts as missing starter (status=QUESTIONABLE skipped).
|
||||
expect(payload.features.injury_severity_score).toBe(2);
|
||||
expect(payload.features.teammate_absence_bump).toBeCloseTo(0.10, 5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — context features cover all knobs', () => {
|
||||
test('every documented context field round-trips', async () => {
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p6', playerName: 'P', statType: 'points',
|
||||
sport: 'nba', gameId: 'g6',
|
||||
gameContext: {
|
||||
home_away: 'away',
|
||||
rest_days: 0,
|
||||
game_count_in_7d: 4,
|
||||
season_type: 2,
|
||||
game_in_series: 1,
|
||||
season_phase: 0.95,
|
||||
},
|
||||
});
|
||||
const f = payload.features;
|
||||
expect(f.home_away).toBe(0.0);
|
||||
expect(f.rest_days).toBe(0);
|
||||
expect(f.game_count_in_7d).toBe(4);
|
||||
expect(f.season_type).toBe(2);
|
||||
expect(f.game_in_series).toBe(1);
|
||||
expect(f.season_phase).toBe(0.95);
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — cache key reuse', () => {
|
||||
test('second call returns the cached vector', async () => {
|
||||
const args = { playerId: 'p7', playerName: 'P', statType: 'points', sport: 'nba', gameId: 'g7', gameContext: {} };
|
||||
const first = await fc.getFeatures(args);
|
||||
mockGameLogs.logs = [{ points: 99 }]; // upstream changes
|
||||
const second = await fc.getFeatures(args);
|
||||
expect(second).toEqual(first);
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — coach + ref + lineup features', () => {
|
||||
test('coach delta + ref pace + lineup role pass through', async () => {
|
||||
mockCoach.impact = { adjusted_pace_delta: 1.4, without_primary_pace_shift: 0.5 };
|
||||
mockRef.impact = { pace_impact: 0.6, foul_adjustment: 22 };
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p8', playerName: 'P', statType: 'points', sport: 'nba',
|
||||
gameId: 'g8', teamAbbr: 'NYK',
|
||||
role: 'primary_handler',
|
||||
gameContext: {},
|
||||
});
|
||||
expect(payload.features.coach_pace_delta).toBe(1.4);
|
||||
expect(payload.features.coach_player_interaction).toBe(0.5);
|
||||
expect(payload.features.ref_pace_adjustment).toBe(0.6);
|
||||
expect(payload.features.ref_foul_adjustment).toBe(22);
|
||||
expect(payload.features.lineup_ball_handler_role).toBe(1.0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('feature cache — line movement', () => {
|
||||
test('line_delta surfaces the movement value', async () => {
|
||||
mockLineMovement.lm = { movement: -0.5 };
|
||||
const payload = await fc.getFeatures({
|
||||
playerId: 'p9', playerName: 'P', statType: 'points',
|
||||
sport: 'nba', gameId: 'g9', gameContext: {},
|
||||
});
|
||||
expect(payload.features.line_delta).toBe(-0.5);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,23 @@
|
||||
const { FOUNDER_NOTE } = require('../../src/constants/founderNote');
|
||||
|
||||
describe('FOUNDER_NOTE immutability', () => {
|
||||
test('starts with "VYNDR is a bet"', () => {
|
||||
expect(FOUNDER_NOTE.trimStart().startsWith('VYNDR is a bet')).toBe(true);
|
||||
});
|
||||
|
||||
test('contains "Bet on Black"', () => {
|
||||
expect(FOUNDER_NOTE).toContain('Bet on Black');
|
||||
});
|
||||
|
||||
test('is not empty', () => {
|
||||
expect(FOUNDER_NOTE.trim().length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('content hash matches original', () => {
|
||||
// Exact line count check — any modification breaks this
|
||||
const lines = FOUNDER_NOTE.trim().split('\n');
|
||||
expect(lines.length).toBe(26);
|
||||
expect(FOUNDER_NOTE).toContain('Draw your own conclusions.');
|
||||
expect(FOUNDER_NOTE).toContain('reverse that flow');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,215 @@
|
||||
process.env.ENGINE2_ENABLED = 'false'; // queue but don't drain in unit tests
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args), post: jest.fn() }));
|
||||
|
||||
const mockGetPlayerProps = jest.fn();
|
||||
jest.mock('../../src/services/adapters/sharpApiAdapter', () => ({
|
||||
configured: () => true,
|
||||
getPlayerProps: (...args) => mockGetPlayerProps(...args),
|
||||
getGameOdds: async () => null,
|
||||
getConsensusLine: async () => null,
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/adapters/openRouterAdapter', () => ({
|
||||
configured: () => false,
|
||||
analyze: async () => null,
|
||||
getUsage: () => ({ requestsToday: 0, requestsRemaining: 1000 }),
|
||||
}));
|
||||
|
||||
// Feature/trap/consistency stubs — orchestrator owns the wiring; we
|
||||
// verify that wiring with deterministic returns rather than re-testing
|
||||
// every sub-service.
|
||||
jest.mock('../../src/services/intelligence/featureCache', () => ({
|
||||
getFeatures: async () => ({
|
||||
features: { l5_avg: 30, l20_avg: 26, home_away: 1.0, opp_rank_stat: 0.85, rest_days: 2 },
|
||||
meta: { features_available: [], features_missing: [] },
|
||||
}),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/intelligence/trapDetection', () => ({
|
||||
getTrapScore: async () => ({
|
||||
composite: 0.1,
|
||||
signals: {},
|
||||
active_count: 0,
|
||||
recommendation: 'proceed',
|
||||
}),
|
||||
normalizeName: (n) => String(n || '').toLowerCase(),
|
||||
detectReturningTeammate: () => null,
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/intelligence/consistencyScore', () => ({
|
||||
getConsistency: async () => ({ consistency: 'reliable', cv: 0.18, score: 0.7, games: 20 }),
|
||||
}));
|
||||
|
||||
jest.mock('../../src/services/intelligence/gameLogService', () => ({
|
||||
getGameLogs: async () => [{ points: 30 }, { points: 28 }],
|
||||
getCareerPlayoffGames: async () => null,
|
||||
getWithWithoutStats: async () => null,
|
||||
}));
|
||||
|
||||
const mockInserts = [];
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const proxy = {
|
||||
insert(row) {
|
||||
mockInserts.push(row);
|
||||
const inserted = { id: `gid-${mockInserts.length}` };
|
||||
return {
|
||||
select() { return { single: () => Promise.resolve({ data: inserted, error: null }) }; },
|
||||
};
|
||||
},
|
||||
update() {
|
||||
return { eq() { return Promise.resolve({ error: null }); } };
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const orchestrator = require('../../src/services/intelligence/gradingOrchestrator');
|
||||
const engine2 = require('../../src/services/intelligence/engine2');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockGetPlayerProps.mockReset();
|
||||
mockInserts.length = 0;
|
||||
engine2.clearQueue();
|
||||
});
|
||||
|
||||
describe('runPipeline', () => {
|
||||
test('empty slate → summary with zeros', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { events: [] } });
|
||||
const summary = await orchestrator.runPipeline('nba');
|
||||
expect(summary).toMatchObject({
|
||||
sport: 'nba',
|
||||
games_processed: 0,
|
||||
props_graded: 0,
|
||||
});
|
||||
});
|
||||
|
||||
test('one game with three props → 3 grades inserted', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
events: [{
|
||||
id: 'ev-1',
|
||||
date: '2026-06-08T23:30Z',
|
||||
status: { type: { state: 'pre' } },
|
||||
competitions: [{
|
||||
competitors: [
|
||||
{ homeAway: 'home', id: '1', team: { abbreviation: 'NYK', displayName: 'Knicks' } },
|
||||
{ homeAway: 'away', id: '2', team: { abbreviation: 'BOS', displayName: 'Celtics' } },
|
||||
],
|
||||
}],
|
||||
}],
|
||||
},
|
||||
});
|
||||
mockGetPlayerProps.mockResolvedValue([
|
||||
{ player: 'Jalen Brunson', team: 'NYK', statType: 'points', line: 26.5, direction: 'over' },
|
||||
{ player: 'Jayson Tatum', team: 'BOS', statType: 'points', line: 28.5, direction: 'over' },
|
||||
{ player: 'OG Anunoby', team: 'NYK', statType: 'rebounds', line: 6.5, direction: 'under' },
|
||||
]);
|
||||
|
||||
const summary = await orchestrator.runPipeline('nba', { skipEngine2: true });
|
||||
expect(summary.games_processed).toBe(1);
|
||||
expect(summary.props_graded).toBe(3);
|
||||
expect(mockInserts).toHaveLength(3);
|
||||
});
|
||||
|
||||
test('SharpAPI failure on one game increments errors, other games continue', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
events: [
|
||||
{ id: 'ev-a', competitions: [{ competitors: [{ homeAway: 'home', team: { abbreviation: 'A' } }, { homeAway: 'away', team: { abbreviation: 'B' } }] }] },
|
||||
{ id: 'ev-b', competitions: [{ competitors: [{ homeAway: 'home', team: { abbreviation: 'C' } }, { homeAway: 'away', team: { abbreviation: 'D' } }] }] },
|
||||
],
|
||||
},
|
||||
});
|
||||
mockGetPlayerProps
|
||||
.mockRejectedValueOnce(new Error('upstream down'))
|
||||
.mockResolvedValueOnce([{ player: 'X', team: 'C', statType: 'points', line: 10, direction: 'over' }]);
|
||||
const summary = await orchestrator.runPipeline('nba', { skipEngine2: true });
|
||||
expect(summary.errors).toBe(1);
|
||||
expect(summary.props_graded).toBe(1);
|
||||
});
|
||||
|
||||
test('A-tier grades queued for engine2; C-tier not queued', async () => {
|
||||
process.env.ENGINE2_ENABLED = 'true';
|
||||
jest.resetModules();
|
||||
// Re-require with fresh ENGINE2_ENABLED.
|
||||
jest.doMock('axios', () => ({ get: (...args) => mockAxiosGet(...args), post: jest.fn() }));
|
||||
jest.doMock('../../src/services/adapters/sharpApiAdapter', () => ({
|
||||
configured: () => true, getPlayerProps: (...args) => mockGetPlayerProps(...args),
|
||||
}));
|
||||
jest.doMock('../../src/services/adapters/openRouterAdapter', () => ({
|
||||
configured: () => false, analyze: async () => null, getUsage: () => ({ requestsToday: 0, requestsRemaining: 1000 }),
|
||||
}));
|
||||
jest.doMock('../../src/services/intelligence/featureCache', () => ({
|
||||
getFeatures: async () => ({ features: { l5_avg: 32, l20_avg: 27, opp_rank_stat: 0.85, home_away: 1.0, rest_days: 2 }, meta: {} }),
|
||||
}));
|
||||
jest.doMock('../../src/services/intelligence/trapDetection', () => ({
|
||||
getTrapScore: async () => ({ composite: 0.05, signals: {} }),
|
||||
normalizeName: (n) => n,
|
||||
}));
|
||||
jest.doMock('../../src/services/intelligence/consistencyScore', () => ({
|
||||
getConsistency: async () => ({ consistency: 'elite', score: 1.0 }),
|
||||
}));
|
||||
jest.doMock('../../src/services/intelligence/gameLogService', () => ({
|
||||
getGameLogs: async () => null, getCareerPlayoffGames: async () => null,
|
||||
}));
|
||||
jest.doMock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const proxy = {
|
||||
insert(row) {
|
||||
mockInserts.push(row);
|
||||
return { select() { return { single: () => Promise.resolve({ data: { id: `gid-${mockInserts.length}` }, error: null }) }; } };
|
||||
},
|
||||
update() { return { eq() { return Promise.resolve({ error: null }); } }; },
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const orch = require('../../src/services/intelligence/gradingOrchestrator');
|
||||
const e2 = require('../../src/services/intelligence/engine2');
|
||||
e2.clearQueue();
|
||||
mockInserts.length = 0;
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
events: [{
|
||||
id: 'ev-q',
|
||||
competitions: [{ competitors: [
|
||||
{ homeAway: 'home', team: { abbreviation: 'NYK' } },
|
||||
{ homeAway: 'away', team: { abbreviation: 'BOS' } },
|
||||
] }],
|
||||
}],
|
||||
},
|
||||
});
|
||||
mockGetPlayerProps.mockResolvedValue([
|
||||
{ player: 'A-tier player', team: 'NYK', statType: 'points', line: 25.5, direction: 'over' },
|
||||
]);
|
||||
|
||||
const summary = await orch.runPipeline('nba', { skipEngine2: true });
|
||||
expect(summary.props_graded).toBe(1);
|
||||
// The grade should have been A/A-/A+ given those features, so engine2
|
||||
// queue should have grown.
|
||||
expect(summary.engine2_queued).toBe(1);
|
||||
process.env.ENGINE2_ENABLED = 'false';
|
||||
});
|
||||
});
|
||||
|
||||
describe('getEngineStatus', () => {
|
||||
test('returns adapter configuration and queue size', () => {
|
||||
const status = orchestrator.getEngineStatus();
|
||||
expect(status.adapters_configured).toHaveProperty('sharp_api');
|
||||
expect(status.adapters_configured).toHaveProperty('open_router');
|
||||
expect(typeof status.engine2_queue_size).toBe('number');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,120 @@
|
||||
process.env.VYNDR_INTERNAL_KEY = 'health-test-key';
|
||||
|
||||
const mockPing = jest.fn();
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
getRedisClient: () => ({ ping: mockPing }),
|
||||
isDegraded: () => false,
|
||||
cacheGet: async () => null,
|
||||
cacheSet: async () => true,
|
||||
cacheDel: async () => true,
|
||||
}));
|
||||
|
||||
const mockSupabaseLimit = jest.fn();
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
limit() { return mockSupabaseLimit(); },
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args), post: jest.fn() }));
|
||||
|
||||
// Adapter configured() helpers — fixed boolean returns are enough for the
|
||||
// detailed branch assertions.
|
||||
jest.mock('../../src/services/adapters/sharpApiAdapter', () => ({ configured: () => true }));
|
||||
jest.mock('../../src/services/adapters/propOddsAdapter', () => ({ configured: () => false }));
|
||||
jest.mock('../../src/services/adapters/parlayApiAdapter', () => ({ configured: () => true }));
|
||||
jest.mock('../../src/services/adapters/oddsPapiAdapter', () => ({ configured: () => false }));
|
||||
jest.mock('../../src/services/adapters/cfbdAdapter', () => ({ configured: () => false }));
|
||||
jest.mock('../../src/services/adapters/openRouterAdapter', () => ({ configured: () => true }));
|
||||
|
||||
const app = require('../../src/app');
|
||||
const http = require('http');
|
||||
|
||||
function call(path, headers = {}) {
|
||||
return new Promise((resolve) => {
|
||||
const server = app.listen(0, '127.0.0.1', () => {
|
||||
const port = server.address().port;
|
||||
const req = http.request({ host: '127.0.0.1', port, path, method: 'GET', headers }, (res) => {
|
||||
const chunks = [];
|
||||
res.on('data', (c) => chunks.push(c));
|
||||
res.on('end', () => {
|
||||
server.close();
|
||||
const raw = Buffer.concat(chunks).toString('utf8');
|
||||
let parsed; try { parsed = JSON.parse(raw); } catch { parsed = raw; }
|
||||
resolve({ status: res.statusCode, body: parsed });
|
||||
});
|
||||
});
|
||||
req.end();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
mockPing.mockReset();
|
||||
mockSupabaseLimit.mockReset();
|
||||
mockAxiosGet.mockReset();
|
||||
});
|
||||
|
||||
describe('GET /api/health', () => {
|
||||
test('public response is minimal when no internal key', async () => {
|
||||
mockPing.mockResolvedValue('PONG');
|
||||
mockSupabaseLimit.mockResolvedValue({ error: null });
|
||||
const res = await call('/api/health');
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toEqual({ status: 'healthy' });
|
||||
});
|
||||
|
||||
test('reports 503 when Redis is down', async () => {
|
||||
mockPing.mockRejectedValue(new Error('econnrefused'));
|
||||
mockSupabaseLimit.mockResolvedValue({ error: null });
|
||||
const res = await call('/api/health');
|
||||
expect(res.status).toBe(503);
|
||||
expect(res.body.status).toBe('degraded');
|
||||
});
|
||||
|
||||
test('reports 503 when Supabase errors', async () => {
|
||||
mockPing.mockResolvedValue('PONG');
|
||||
mockSupabaseLimit.mockResolvedValue({ error: { message: 'bad' } });
|
||||
const res = await call('/api/health');
|
||||
expect(res.status).toBe(503);
|
||||
});
|
||||
|
||||
test('detailed branch with valid internal key includes adapters + python', async () => {
|
||||
mockPing.mockResolvedValue('PONG');
|
||||
mockSupabaseLimit.mockResolvedValue({ error: null });
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { status: 'ok' } });
|
||||
const res = await call('/api/health', { 'x-vyndr-internal-key': 'health-test-key' });
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.checks.python).toBe('ok');
|
||||
expect(res.body.checks.adapters).toMatchObject({
|
||||
sharpapi: true,
|
||||
propodds: false,
|
||||
openrouter: true,
|
||||
});
|
||||
expect(typeof res.body.uptime).toBe('number');
|
||||
});
|
||||
|
||||
test('wrong internal key falls through to public response', async () => {
|
||||
mockPing.mockResolvedValue('PONG');
|
||||
mockSupabaseLimit.mockResolvedValue({ error: null });
|
||||
const res = await call('/api/health', { 'x-vyndr-internal-key': 'wrong' });
|
||||
expect(res.body).toEqual({ status: 'healthy' });
|
||||
expect(res.body.checks).toBeUndefined();
|
||||
});
|
||||
|
||||
test('python down does not flip overall status (Python is optional)', async () => {
|
||||
mockPing.mockResolvedValue('PONG');
|
||||
mockSupabaseLimit.mockResolvedValue({ error: null });
|
||||
mockAxiosGet.mockRejectedValue(new Error('refused'));
|
||||
const res = await call('/api/health', { 'x-vyndr-internal-key': 'health-test-key' });
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.checks.python).toBe('down');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,50 @@
|
||||
const express = require('express');
|
||||
const request = require('supertest');
|
||||
|
||||
// Mock supabase
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from: jest.fn().mockReturnValue({
|
||||
upsert: jest.fn().mockResolvedValue({ data: null, error: null }),
|
||||
}),
|
||||
}),
|
||||
}));
|
||||
|
||||
const waitlistRoutes = require('../../src/routes/waitlist');
|
||||
|
||||
const app = express();
|
||||
app.use(express.json());
|
||||
app.use('/api/waitlist', waitlistRoutes);
|
||||
|
||||
describe('Honeypot spam protection', () => {
|
||||
test('accepts valid submission without honeypot', async () => {
|
||||
const res = await request(app)
|
||||
.post('/api/waitlist')
|
||||
.send({ email: 'test@example.com', list: 'merch' });
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.success).toBe(true);
|
||||
});
|
||||
|
||||
test('silently discards submission with honeypot filled', async () => {
|
||||
const res = await request(app)
|
||||
.post('/api/waitlist')
|
||||
.send({ email: 'bot@spam.com', list: 'merch', website: 'http://spam.com' });
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.success).toBe(true);
|
||||
// Bot thinks it succeeded, but nothing was stored
|
||||
});
|
||||
|
||||
test('rejects missing email', async () => {
|
||||
const res = await request(app)
|
||||
.post('/api/waitlist')
|
||||
.send({ list: 'merch' });
|
||||
expect(res.status).toBe(400);
|
||||
});
|
||||
|
||||
test('rejects missing list', async () => {
|
||||
const res = await request(app)
|
||||
.post('/api/waitlist')
|
||||
.send({ email: 'test@example.com' });
|
||||
expect(res.status).toBe(400);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,103 @@
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args) }));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
jest.mock('../../src/utils/rateLimiter', () => ({
|
||||
createLimiter: () => ({ waitForToken: async () => true, snapshot: () => ({}) }),
|
||||
createCircuitBreaker: () => ({ call: async (fn) => fn(), snapshot: () => ({}) }),
|
||||
}));
|
||||
|
||||
const injuries = require('../../src/services/intelligence/injuryParser');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('injuryParser.getTeamInjuries', () => {
|
||||
test('normalizes ESPN injury payload', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
injuries: [
|
||||
{ athlete: { id: 3934672, displayName: 'Jalen Brunson' }, status: 'Doubtful', details: { detail: 'Right ankle' } },
|
||||
{ athlete: { id: 9999, displayName: 'OG Anunoby' }, status: 'Out' },
|
||||
],
|
||||
},
|
||||
});
|
||||
const out = await injuries.getTeamInjuries('nba', 18);
|
||||
expect(out).toHaveLength(2);
|
||||
expect(out[0]).toMatchObject({ playerId: '3934672', playerName: 'Jalen Brunson', status: 'DOUBTFUL', detail: 'Right ankle' });
|
||||
expect(out[1].status).toBe('OUT');
|
||||
});
|
||||
|
||||
test('404 is treated as no current injuries (empty list)', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 404, data: {} });
|
||||
const out = await injuries.getTeamInjuries('nba', 99);
|
||||
expect(out).toEqual([]);
|
||||
});
|
||||
|
||||
test('cache hit avoids second request', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { injuries: [] } });
|
||||
await injuries.getTeamInjuries('nba', 5);
|
||||
await injuries.getTeamInjuries('nba', 5);
|
||||
expect(mockAxiosGet).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test('returns [] on unsupported sport (no path mapping)', async () => {
|
||||
const out = await injuries.getTeamInjuries('curling', 1);
|
||||
expect(out).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('injuryParser.isPlayerOut + getMissingStarters', () => {
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
injuries: [
|
||||
{ athlete: { id: 1, displayName: 'A' }, status: 'OUT' },
|
||||
{ athlete: { id: 2, displayName: 'B' }, status: 'PROBABLE' },
|
||||
{ athlete: { id: 3, displayName: 'C' }, status: 'DOUBTFUL' },
|
||||
],
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
test('isPlayerOut treats OUT and DOUBTFUL as out', async () => {
|
||||
expect(await injuries.isPlayerOut('nba', 1, '1')).toBe(true);
|
||||
expect(await injuries.isPlayerOut('nba', 1, '3')).toBe(true);
|
||||
expect(await injuries.isPlayerOut('nba', 1, '2')).toBe(false);
|
||||
expect(await injuries.isPlayerOut('nba', 1, '99')).toBe(false);
|
||||
});
|
||||
|
||||
test('getMissingStarters intersects starter set with injured list', async () => {
|
||||
const missing = await injuries.getMissingStarters('nba', 1, ['1', '2', '3', '4']);
|
||||
expect(missing.map((m) => m.playerId).sort()).toEqual(['1', '3']);
|
||||
});
|
||||
});
|
||||
|
||||
describe('injuryParser.extractGameInjuries (from summary JSON)', () => {
|
||||
test('reads injuries from competitions[0].competitors[]', async () => {
|
||||
const summary = {
|
||||
header: {
|
||||
competitions: [{
|
||||
competitors: [
|
||||
{ homeAway: 'home', injuries: [{ athlete: { id: 1, displayName: 'H1' }, status: 'Out' }] },
|
||||
{ homeAway: 'away', injuries: [{ athlete: { id: 2, displayName: 'A1' }, status: 'Probable' }] },
|
||||
],
|
||||
}],
|
||||
},
|
||||
};
|
||||
const out = await injuries.getGameInjuries('nba', 'g1', summary);
|
||||
expect(out.home).toHaveLength(1);
|
||||
expect(out.home[0].status).toBe('OUT');
|
||||
expect(out.away[0].status).toBe('PROBABLE');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,299 @@
|
||||
const { SIMILARITY_WEIGHTS, calculateSimilarityScore, findSimilarGames, getPosteriorDistribution } = require('../../src/services/similarityEngine');
|
||||
const { detectChangepoints, checkMultiSignalEvolution } = require('../../src/services/evolutionEngine');
|
||||
const { detectDiscrepancy, detectSteamMove, getReliabilityScore } = require('../../src/services/lineDiscrepancyDetector');
|
||||
const { scanAltLines, calculateModelProbability, compareToBookImplied, normalCDF: altNormalCDF } = require('../../src/services/altLineScanner');
|
||||
const { DISTRIBUTION_SHAPES, getDistributionShape, calculateProbability, normalCDF, poissonCDF, negativeBinomialCDF } = require('../../src/services/bayesianEngine');
|
||||
const { walkForwardValidate, calculateCLV, checkDrift, applyLearningRateCap } = require('../../src/services/modelTrainer');
|
||||
const { phiCoefficient, hasMinimumObservations, calculateJuiceAdjustedEV } = require('../../src/services/correlationMath');
|
||||
|
||||
// Mock axios for evolution engine tests
|
||||
jest.mock('axios', () => ({
|
||||
post: jest.fn(),
|
||||
}));
|
||||
const axios = require('axios');
|
||||
|
||||
describe('Intelligence Engine', () => {
|
||||
|
||||
// --- Similarity Engine ---
|
||||
|
||||
describe('Similarity Engine', () => {
|
||||
test('similarity score returns value between 0 and 1', () => {
|
||||
const gameA = { functional_role_match: 0.8, pace: 100, rest_days: 2 };
|
||||
const gameB = { functional_role_match: 0.7, pace: 98, rest_days: 1 };
|
||||
const score = calculateSimilarityScore(gameA, gameB);
|
||||
expect(score).toBeGreaterThanOrEqual(0);
|
||||
expect(score).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
test('similarity weights sum to 1.0', () => {
|
||||
const sum = Object.values(SIMILARITY_WEIGHTS).reduce((s, v) => s + v, 0);
|
||||
expect(Math.round(sum * 100) / 100).toBe(1.0);
|
||||
});
|
||||
|
||||
test('identical games return score of 1', () => {
|
||||
const game = { functional_role_match: 0.8, pace: 100, rest_days: 2, opponent_defensive_rating: 110 };
|
||||
const score = calculateSimilarityScore(game, game);
|
||||
expect(score).toBe(1);
|
||||
});
|
||||
|
||||
test('findSimilarGames returns LOW confidence when below minInstances', () => {
|
||||
const target = { pace: 100 };
|
||||
const historical = Array.from({ length: 5 }, (_, i) => ({ pace: 95 + i, statValue: 20 + i }));
|
||||
const result = findSimilarGames(target, historical, 15);
|
||||
expect(result.confidence).toBe('LOW');
|
||||
expect(result.usedSeasonAvg).toBe(true);
|
||||
});
|
||||
|
||||
test('findSimilarGames returns HIGH confidence with enough instances', () => {
|
||||
const target = { pace: 100 };
|
||||
const historical = Array.from({ length: 30 }, (_, i) => ({ pace: 95 + (i % 10), statValue: 20 + i }));
|
||||
const result = findSimilarGames(target, historical, 15);
|
||||
expect(result.confidence).toBe('HIGH');
|
||||
expect(result.usedSeasonAvg).toBe(false);
|
||||
});
|
||||
|
||||
test('getPosteriorDistribution returns correct structure', () => {
|
||||
const games = Array.from({ length: 20 }, (_, i) => ({ statValue: 20 + Math.random() * 10 }));
|
||||
const dist = getPosteriorDistribution(games);
|
||||
expect(dist).toHaveProperty('mean');
|
||||
expect(dist).toHaveProperty('stddev');
|
||||
expect(dist).toHaveProperty('ci_low');
|
||||
expect(dist).toHaveProperty('ci_high');
|
||||
expect(dist).toHaveProperty('n');
|
||||
expect(dist.n).toBe(20);
|
||||
expect(dist.ci_low).toBeLessThan(dist.ci_high);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Evolution Engine ---
|
||||
|
||||
describe('Evolution Engine', () => {
|
||||
test('graceful degradation on HTTP failure', async () => {
|
||||
axios.post.mockRejectedValue(new Error('Connection refused'));
|
||||
const result = await detectChangepoints('player1', 'usage_rate', [0.2, 0.3], ['2026-01-01', '2026-01-02']);
|
||||
expect(result.evolution_detected).toBe(false);
|
||||
expect(result.error).toBe('Connection refused');
|
||||
});
|
||||
|
||||
test('graceful degradation on timeout', async () => {
|
||||
const timeoutError = new Error('timeout');
|
||||
timeoutError.code = 'ECONNABORTED';
|
||||
axios.post.mockRejectedValue(timeoutError);
|
||||
const result = await detectChangepoints('player1', 'usage_rate', [0.2, 0.3], ['2026-01-01', '2026-01-02']);
|
||||
expect(result.evolution_detected).toBe(false);
|
||||
expect(result.error).toBe('timeout');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Line Discrepancy Detector ---
|
||||
|
||||
describe('Line Discrepancy Detector', () => {
|
||||
test('detects discrepancy when gap > 0.5', () => {
|
||||
const lines = [
|
||||
{ book: 'pinnacle', line: 24.5 },
|
||||
{ book: 'circa', line: 24.5 },
|
||||
{ book: 'draftkings', line: 25.5 },
|
||||
{ book: 'fanduel', line: 25.5 },
|
||||
{ book: 'betmgm', line: 25.5 },
|
||||
];
|
||||
const result = detectDiscrepancy(lines);
|
||||
expect(result.discrepancy).toBe(true);
|
||||
expect(result.gap).toBe(1);
|
||||
});
|
||||
|
||||
test('no discrepancy when gap <= 0.5', () => {
|
||||
const lines = [
|
||||
{ book: 'pinnacle', line: 25.0 },
|
||||
{ book: 'draftkings', line: 25.5 },
|
||||
{ book: 'fanduel', line: 25.0 },
|
||||
];
|
||||
const result = detectDiscrepancy(lines);
|
||||
expect(result.discrepancy).toBe(false);
|
||||
});
|
||||
|
||||
test('detects steam move with 3+ books moving 0.5+ in 10 min', () => {
|
||||
const now = new Date();
|
||||
const movements = [
|
||||
{ book: 'draftkings', line: 0.5, timestamp: now.toISOString() },
|
||||
{ book: 'fanduel', line: 0.5, timestamp: new Date(now.getTime() + 60000).toISOString() },
|
||||
{ book: 'betmgm', line: 0.5, timestamp: new Date(now.getTime() + 120000).toISOString() },
|
||||
{ book: 'caesars', line: 0.5, timestamp: new Date(now.getTime() + 180000).toISOString() },
|
||||
];
|
||||
const result = detectSteamMove(movements);
|
||||
expect(result.steam_move).toBe(true);
|
||||
expect(result.books_moved).toBeGreaterThanOrEqual(3);
|
||||
});
|
||||
|
||||
test('no steam move with insufficient books', () => {
|
||||
const now = new Date();
|
||||
const movements = [
|
||||
{ book: 'draftkings', line: 0.5, timestamp: now.toISOString() },
|
||||
{ book: 'fanduel', line: 0.5, timestamp: new Date(now.getTime() + 60000).toISOString() },
|
||||
];
|
||||
const result = detectSteamMove(movements);
|
||||
expect(result.steam_move).toBe(false);
|
||||
});
|
||||
|
||||
test('reliability score returns valid range', () => {
|
||||
const score = getReliabilityScore('points', 'nba');
|
||||
expect(score).toBeGreaterThan(0);
|
||||
expect(score).toBeLessThanOrEqual(1);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Alt Line Scanner ---
|
||||
|
||||
describe('Alt Line Scanner', () => {
|
||||
test('calculates model probability correctly', () => {
|
||||
// Mean 25, stddev 5, line 25 => P(over) should be ~0.5
|
||||
const prob = calculateModelProbability(25, 5, 25, 'over');
|
||||
expect(prob).toBeCloseTo(0.5, 1);
|
||||
});
|
||||
|
||||
test('compareToBookImplied detects value', () => {
|
||||
const result = compareToBookImplied(0.60, -110);
|
||||
expect(result.model_prob).toBe(0.6);
|
||||
expect(result.book_implied).toBeCloseTo(0.524, 2);
|
||||
expect(result.value_detected).toBe(true);
|
||||
expect(result.edge).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('scanAltLines returns optimal line with edge', () => {
|
||||
const prop = { projected_mean: 25, projected_stddev: 5, direction: 'over' };
|
||||
const odds = [
|
||||
{ line: 22.5, odds: -130, book: 'draftkings' },
|
||||
{ line: 24.5, odds: -110, book: 'draftkings' },
|
||||
{ line: 27.5, odds: +120, book: 'draftkings' },
|
||||
];
|
||||
const result = scanAltLines(prop, odds);
|
||||
expect(result).not.toBeNull();
|
||||
expect(result.optimal_line).toBeDefined();
|
||||
expect(result.edge).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Bayesian Engine ---
|
||||
|
||||
describe('Bayesian Engine', () => {
|
||||
test('normalCDF returns ~0.5 at the mean', () => {
|
||||
const result = normalCDF(10, 10, 3);
|
||||
expect(result).toBeCloseTo(0.5, 2);
|
||||
});
|
||||
|
||||
test('normalCDF returns known values', () => {
|
||||
// P(X <= 1) for N(0,1) should be ~0.8413
|
||||
const result = normalCDF(1, 0, 1);
|
||||
expect(result).toBeCloseTo(0.8413, 2);
|
||||
});
|
||||
|
||||
test('poissonCDF correctness', () => {
|
||||
// P(X <= 2) for Poisson(1) = e^-1 * (1 + 1 + 0.5) = 0.9197
|
||||
const result = poissonCDF(2, 1);
|
||||
expect(result).toBeCloseTo(0.9197, 2);
|
||||
});
|
||||
|
||||
test('distribution shape mapping returns correct shapes', () => {
|
||||
expect(getDistributionShape('points')).toBe('normal');
|
||||
expect(getDistributionShape('walks')).toBe('poisson');
|
||||
expect(getDistributionShape('home_runs')).toBe('negative_binomial');
|
||||
expect(getDistributionShape('pitcher_strikeouts')).toBe('bimodal_mixture');
|
||||
expect(getDistributionShape('unknown_stat')).toBe('normal');
|
||||
});
|
||||
|
||||
test('calculateProbability works for poisson over', () => {
|
||||
const prob = calculateProbability('poisson', { lambda: 5 }, 4, 'over');
|
||||
// P(X > 4) for Poisson(5)
|
||||
expect(prob).toBeGreaterThan(0.4);
|
||||
expect(prob).toBeLessThan(0.8);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Model Trainer ---
|
||||
|
||||
describe('Model Trainer', () => {
|
||||
test('walkForwardValidate returns accuracy metrics', () => {
|
||||
const predictions = [
|
||||
{ predicted: 25, timestamp: '2026-01-01' },
|
||||
{ predicted: 22, timestamp: '2026-01-02' },
|
||||
{ predicted: 30, timestamp: '2026-01-03' },
|
||||
];
|
||||
const actuals = [
|
||||
{ actual: 24, timestamp: '2026-01-01' },
|
||||
{ actual: 23, timestamp: '2026-01-02' },
|
||||
{ actual: 28, timestamp: '2026-01-03' },
|
||||
];
|
||||
const result = walkForwardValidate(predictions, actuals);
|
||||
expect(result).toHaveProperty('accuracy');
|
||||
expect(result).toHaveProperty('mae');
|
||||
expect(result).toHaveProperty('rmse');
|
||||
expect(result.n).toBe(3);
|
||||
});
|
||||
|
||||
test('CLV calculation returns correct structure', () => {
|
||||
const clv = calculateCLV(24.5, 25.0, 25.5);
|
||||
expect(clv.clv_at_prediction).toBe(1.0);
|
||||
expect(clv.clv_at_24hr).toBe(0.5);
|
||||
expect(clv.clv_at_tip).toBe(0);
|
||||
});
|
||||
|
||||
test('drift detection after 10 consecutive negative CLV', () => {
|
||||
const history = [1, 2, 0.5, -1, -2, -0.5, -1, -0.3, -2, -1.5, -0.8, -0.2, -1];
|
||||
const result = checkDrift(history);
|
||||
expect(result.drift_detected).toBe(true);
|
||||
expect(result.consecutive_negative).toBe(10);
|
||||
expect(result.alert).toBe(true);
|
||||
});
|
||||
|
||||
test('no drift with mixed CLV history', () => {
|
||||
const history = [1, -1, 2, -2, 0.5, -0.5, 1, -1, 0.3];
|
||||
const result = checkDrift(history);
|
||||
expect(result.drift_detected).toBe(false);
|
||||
});
|
||||
|
||||
test('learning rate cap enforcement (max 0.05 delta)', () => {
|
||||
expect(applyLearningRateCap(0.20, 0.30)).toBe(0.25);
|
||||
expect(applyLearningRateCap(0.20, 0.10)).toBe(0.15);
|
||||
expect(applyLearningRateCap(0.20, 0.22)).toBe(0.22);
|
||||
expect(applyLearningRateCap(0.20, 0.20)).toBe(0.20);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Correlation Math ---
|
||||
|
||||
describe('Correlation Math', () => {
|
||||
test('phi coefficient calculation for joint outcomes', () => {
|
||||
// Perfect positive correlation
|
||||
const phi = phiCoefficient(50, 0, 0, 50);
|
||||
expect(phi).toBe(1);
|
||||
});
|
||||
|
||||
test('phi coefficient returns 0 for no correlation', () => {
|
||||
const phi = phiCoefficient(25, 25, 25, 25);
|
||||
expect(phi).toBe(0);
|
||||
});
|
||||
|
||||
test('phi coefficient handles zero denominator', () => {
|
||||
const phi = phiCoefficient(0, 0, 0, 0);
|
||||
expect(phi).toBe(0);
|
||||
});
|
||||
|
||||
test('hasMinimumObservations checks threshold', () => {
|
||||
expect(hasMinimumObservations(100)).toBe(true);
|
||||
expect(hasMinimumObservations(99)).toBe(false);
|
||||
expect(hasMinimumObservations(50, 50)).toBe(true);
|
||||
});
|
||||
|
||||
test('calculateJuiceAdjustedEV returns correct EV', () => {
|
||||
// 60% win prob, -110 stake: 0.6*100 - 0.4*110 = 60 - 44 = 16
|
||||
const ev = calculateJuiceAdjustedEV(0.6, 110);
|
||||
expect(ev).toBeCloseTo(16, 0);
|
||||
});
|
||||
|
||||
test('calculateJuiceAdjustedEV negative EV on bad bet', () => {
|
||||
// 40% win prob: 0.4*100 - 0.6*110 = 40 - 66 = -26
|
||||
const ev = calculateJuiceAdjustedEV(0.4, 110);
|
||||
expect(ev).toBeLessThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
@@ -0,0 +1,106 @@
|
||||
const mockSnaps = { current: [] };
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq() { return proxy; },
|
||||
order() { return Promise.resolve({ data: mockSnaps.current, error: null }); },
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const lm = require('../../src/services/intelligence/lineMovement');
|
||||
|
||||
beforeEach(() => {
|
||||
mockSnaps.current = [];
|
||||
});
|
||||
|
||||
describe('getLineMovement', () => {
|
||||
test('returns null when fewer than two snapshots', async () => {
|
||||
mockSnaps.current = [{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' }];
|
||||
expect(await lm.getLineMovement('g', 'P', 'points')).toBeNull();
|
||||
});
|
||||
|
||||
test('reports opening and current line correctly', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 25.5, over_odds: -120, under_odds: +100, snapshot_at: 't2' },
|
||||
{ line: 26.0, over_odds: -130, under_odds: +110, snapshot_at: 't3' },
|
||||
];
|
||||
const result = await lm.getLineMovement('g', 'P', 'points');
|
||||
expect(result).toMatchObject({
|
||||
opening_line: 25.5,
|
||||
current_line: 26.0,
|
||||
movement: 0.5,
|
||||
direction: 'up',
|
||||
snapshots_count: 3,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('reverseLineMovement', () => {
|
||||
test('detects RLM when public is on over but line moves to under', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 24.5, over_odds: -130, under_odds: +110, snapshot_at: 't2' },
|
||||
];
|
||||
const r = await lm.reverseLineMovement('g', 'P', 'points');
|
||||
expect(r.isReverse).toBe(true);
|
||||
expect(r.score).toBeGreaterThan(0);
|
||||
expect(r.publicSide).toBe('over');
|
||||
expect(r.lineDirection).toBe('under');
|
||||
});
|
||||
|
||||
test('returns isReverse=false when line moved with public', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 26.5, over_odds: -130, under_odds: +110, snapshot_at: 't2' },
|
||||
];
|
||||
const r = await lm.reverseLineMovement('g', 'P', 'points');
|
||||
expect(r.isReverse).toBe(false);
|
||||
expect(r.score).toBe(0);
|
||||
});
|
||||
|
||||
test('returns null on flat movement', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 25.5, over_odds: -115, under_odds: -105, snapshot_at: 't2' },
|
||||
];
|
||||
expect(await lm.reverseLineMovement('g', 'P', 'points')).toBeNull();
|
||||
});
|
||||
|
||||
test('uses provided publicBetPct over odds-direction heuristic', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 26.5, over_odds: -110, under_odds: -110, snapshot_at: 't2' },
|
||||
];
|
||||
const r = await lm.reverseLineMovement('g', 'P', 'points', 30);
|
||||
expect(r.isReverse).toBe(true);
|
||||
expect(r.publicSide).toBe('under');
|
||||
expect(r.lineDirection).toBe('over');
|
||||
});
|
||||
});
|
||||
|
||||
describe('juiceDegradation', () => {
|
||||
test('flags juice change when the line itself stayed put', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 25.5, over_odds: -130, under_odds: +110, snapshot_at: 't2' },
|
||||
];
|
||||
const r = await lm.juiceDegradation('g', 'P', 'points');
|
||||
expect(r.applicable).toBe(true);
|
||||
expect(r.score).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('not applicable when line moved significantly', async () => {
|
||||
mockSnaps.current = [
|
||||
{ line: 25.5, over_odds: -110, under_odds: -110, snapshot_at: 't1' },
|
||||
{ line: 28.5, over_odds: -120, under_odds: +100, snapshot_at: 't2' },
|
||||
];
|
||||
const r = await lm.juiceDegradation('g', 'P', 'points');
|
||||
expect(r.applicable).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,86 @@
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
const sql = fs.readFileSync(
|
||||
path.join(__dirname, '../../supabase/migrations/004_affiliate_tables.sql'),
|
||||
'utf8'
|
||||
);
|
||||
|
||||
describe('Migration 004 — Affiliate Tables', () => {
|
||||
test('creates referral_codes table', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS referral_codes');
|
||||
});
|
||||
|
||||
test('creates wallet_addresses table', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS wallet_addresses');
|
||||
});
|
||||
|
||||
test('creates referral_conversions table', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS referral_conversions');
|
||||
});
|
||||
|
||||
test('creates affiliate_payouts table', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS affiliate_payouts');
|
||||
});
|
||||
|
||||
test('referral_codes has unique code constraint', () => {
|
||||
expect(sql).toMatch(/code TEXT NOT NULL UNIQUE/);
|
||||
});
|
||||
|
||||
test('referral_codes has affiliate_tier constraint', () => {
|
||||
expect(sql).toMatch(/affiliate_tier.*CHECK.*\(affiliate_tier IN/);
|
||||
});
|
||||
|
||||
test('referral_conversions has conversion_type constraint', () => {
|
||||
expect(sql).toMatch(/conversion_type.*CHECK.*\(conversion_type IN.*'signup'.*'upgrade'.*'renewal'/);
|
||||
});
|
||||
|
||||
test('referral_conversions has status constraint', () => {
|
||||
expect(sql).toMatch(/status.*CHECK.*\(status IN.*'pending'.*'confirmed'.*'paid'/);
|
||||
});
|
||||
|
||||
test('affiliate_payouts has payout_method constraint', () => {
|
||||
expect(sql).toMatch(/payout_method.*CHECK.*\(payout_method IN.*'crypto'.*'paypal'/);
|
||||
});
|
||||
|
||||
test('wallet_addresses has chain constraint', () => {
|
||||
expect(sql).toMatch(/chain.*CHECK.*\(chain IN.*'ethereum'.*'solana'/);
|
||||
});
|
||||
|
||||
test('RLS enabled on all four tables', () => {
|
||||
expect(sql).toContain('ALTER TABLE referral_codes ENABLE ROW LEVEL SECURITY');
|
||||
expect(sql).toContain('ALTER TABLE referral_conversions ENABLE ROW LEVEL SECURITY');
|
||||
expect(sql).toContain('ALTER TABLE affiliate_payouts ENABLE ROW LEVEL SECURITY');
|
||||
expect(sql).toContain('ALTER TABLE wallet_addresses ENABLE ROW LEVEL SECURITY');
|
||||
});
|
||||
|
||||
test('referral_codes has public read policy', () => {
|
||||
expect(sql).toContain('referral_codes_public_read');
|
||||
expect(sql).toContain('FOR SELECT USING (true)');
|
||||
});
|
||||
|
||||
test('service role has full access on all tables', () => {
|
||||
expect(sql).toContain('referral_codes_service_write');
|
||||
expect(sql).toContain('referral_conversions_service_access');
|
||||
expect(sql).toContain('affiliate_payouts_service_access');
|
||||
expect(sql).toContain('wallet_addresses_service_access');
|
||||
});
|
||||
|
||||
test('wallet_addresses is created before affiliate_payouts (FK dependency)', () => {
|
||||
const walletPos = sql.indexOf('CREATE TABLE IF NOT EXISTS wallet_addresses');
|
||||
const payoutsPos = sql.indexOf('CREATE TABLE IF NOT EXISTS affiliate_payouts');
|
||||
expect(walletPos).toBeLessThan(payoutsPos);
|
||||
});
|
||||
|
||||
test('affiliate_payouts references wallet_addresses', () => {
|
||||
expect(sql).toMatch(/wallet_address_id UUID REFERENCES wallet_addresses\(id\)/);
|
||||
});
|
||||
|
||||
test('indexes created for key lookup columns', () => {
|
||||
expect(sql).toContain('idx_referral_codes_owner');
|
||||
expect(sql).toContain('idx_referral_codes_code');
|
||||
expect(sql).toContain('idx_referral_conversions_code');
|
||||
expect(sql).toContain('idx_affiliate_payouts_user');
|
||||
expect(sql).toContain('idx_wallet_addresses_user');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,261 @@
|
||||
const { gradeMlbProp, calculateMlbEdge, isMlbStatType } = require('../../src/services/mlbGrader');
|
||||
const { evaluateMlbKillConditions, classifyLineMove, checkWeather } = require('../../src/services/mlbKillConditions');
|
||||
const { MLB_PARKS, getParkByTeam } = require('../../src/constants/mlbParks');
|
||||
|
||||
jest.mock('axios');
|
||||
const axios = require('axios');
|
||||
|
||||
describe('mlbGrader', () => {
|
||||
describe('grade thresholds', () => {
|
||||
test('Grade A when edge >= 5%', () => {
|
||||
const result = gradeMlbProp({
|
||||
player: 'Aaron Judge',
|
||||
stat_type: 'home_runs',
|
||||
line: 0.5,
|
||||
direction: 'over',
|
||||
seasonAvg: 0.7,
|
||||
recentAvg: 0.8,
|
||||
});
|
||||
expect(result.grade).toBe('A');
|
||||
expect(result.edge_pct).toBeGreaterThanOrEqual(5);
|
||||
});
|
||||
|
||||
test('Grade B when edge 3-4%', () => {
|
||||
// seasonAvg=5.15, line=5, direction=over => seasonEdge=(5.15-5)/5*100=3%
|
||||
// recentAvg=5.2, line=5 => recentEdge=(5.2-5)/5*100=4%
|
||||
// composite = 3*0.6 + 4*0.4 = 1.8+1.6 = 3.4
|
||||
const result = gradeMlbProp({
|
||||
player: 'Test Player',
|
||||
stat_type: 'strikeouts',
|
||||
line: 5,
|
||||
direction: 'over',
|
||||
seasonAvg: 5.15,
|
||||
recentAvg: 5.2,
|
||||
});
|
||||
expect(result.grade).toBe('B');
|
||||
expect(result.edge_pct).toBeGreaterThanOrEqual(3);
|
||||
expect(result.edge_pct).toBeLessThan(5);
|
||||
});
|
||||
|
||||
test('Grade C when edge 1-2%', () => {
|
||||
// seasonAvg=5.05, line=5, direction=over => seasonEdge=1%
|
||||
// recentAvg=5.1 => recentEdge=2%
|
||||
// composite = 1*0.6 + 2*0.4 = 0.6+0.8 = 1.4
|
||||
const result = gradeMlbProp({
|
||||
player: 'Test Player',
|
||||
stat_type: 'hits',
|
||||
line: 5,
|
||||
direction: 'over',
|
||||
seasonAvg: 5.05,
|
||||
recentAvg: 5.1,
|
||||
});
|
||||
expect(result.grade).toBe('C');
|
||||
expect(result.edge_pct).toBeGreaterThanOrEqual(1);
|
||||
expect(result.edge_pct).toBeLessThan(3);
|
||||
});
|
||||
|
||||
test('Grade D when negative edge', () => {
|
||||
const result = gradeMlbProp({
|
||||
player: 'Test Player',
|
||||
stat_type: 'hits',
|
||||
line: 2,
|
||||
direction: 'over',
|
||||
seasonAvg: 1.5,
|
||||
recentAvg: 1.3,
|
||||
});
|
||||
expect(result.grade).toBe('D');
|
||||
expect(result.edge_pct).toBeLessThan(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isMlbStatType', () => {
|
||||
test('returns true for valid hitting stat', () => {
|
||||
expect(isMlbStatType('hits')).toBe(true);
|
||||
expect(isMlbStatType('home_runs')).toBe(true);
|
||||
expect(isMlbStatType('stolen_bases')).toBe(true);
|
||||
});
|
||||
|
||||
test('returns true for valid pitching stat', () => {
|
||||
expect(isMlbStatType('strikeouts')).toBe(true);
|
||||
expect(isMlbStatType('earned_runs')).toBe(true);
|
||||
expect(isMlbStatType('pitches_thrown')).toBe(true);
|
||||
});
|
||||
|
||||
test('returns false for invalid stat type', () => {
|
||||
expect(isMlbStatType('three_pointers')).toBe(false);
|
||||
expect(isMlbStatType('touchdowns')).toBe(false);
|
||||
expect(isMlbStatType('')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('calculateMlbEdge', () => {
|
||||
test('calculates positive edge for over', () => {
|
||||
const edge = calculateMlbEdge(6, 5, 'over');
|
||||
expect(edge).toBe(20);
|
||||
});
|
||||
|
||||
test('calculates positive edge for under', () => {
|
||||
const edge = calculateMlbEdge(4, 5, 'under');
|
||||
expect(edge).toBe(20);
|
||||
});
|
||||
|
||||
test('returns 0 for null inputs', () => {
|
||||
expect(calculateMlbEdge(null, 5, 'over')).toBe(0);
|
||||
expect(calculateMlbEdge(5, null, 'over')).toBe(0);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('mlbKillConditions', () => {
|
||||
function makeContext(overrides = {}) {
|
||||
return {
|
||||
inLineup: true,
|
||||
pitcherScratched: false,
|
||||
weather: { wind_speed: 5, wind_direction: 'OUT', temp: 75, humidity: 50 },
|
||||
platoonDelta: 5,
|
||||
paVsHandedness: 100,
|
||||
lineMovement: 0,
|
||||
hoursFromOpen: 1,
|
||||
parkFactor: 1.0,
|
||||
rainProbability: 10,
|
||||
onInjuryReport: false,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
test('LINEUP_OUT triggers when player not in lineup', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ inLineup: false }));
|
||||
expect(result.some(c => c.code === 'LINEUP_OUT')).toBe(true);
|
||||
});
|
||||
|
||||
test('PITCHER_SCRATCH triggers when pitcher scratched', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ pitcherScratched: true }));
|
||||
expect(result.some(c => c.code === 'PITCHER_SCRATCH')).toBe(true);
|
||||
});
|
||||
|
||||
test('WIND_IN triggers at 15mph+ blowing in', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({
|
||||
weather: { wind_speed: 18, wind_direction: 'IN', temp: 75, humidity: 50 },
|
||||
}));
|
||||
expect(result.some(c => c.code === 'WIND_IN')).toBe(true);
|
||||
});
|
||||
|
||||
test('PLATOON_DISADVANTAGE triggers when delta > 12%', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ platoonDelta: 15 }));
|
||||
expect(result.some(c => c.code === 'PLATOON_DISADVANTAGE')).toBe(true);
|
||||
});
|
||||
|
||||
test('SMALL_SAMPLE triggers under 50 PA', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ paVsHandedness: 30 }));
|
||||
expect(result.some(c => c.code === 'SMALL_SAMPLE')).toBe(true);
|
||||
});
|
||||
|
||||
test('LINE_MOVE_AGAINST triggers at 0.5+ movement', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ lineMovement: 0.7, hoursFromOpen: 1 }));
|
||||
expect(result.some(c => c.code === 'LINE_MOVE_AGAINST')).toBe(true);
|
||||
});
|
||||
|
||||
test('PARK_SUPPRESSOR triggers below 0.90', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ parkFactor: 0.85 }));
|
||||
expect(result.some(c => c.code === 'PARK_SUPPRESSOR')).toBe(true);
|
||||
});
|
||||
|
||||
test('WEATHER_RAIN triggers above 50% probability', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ rainProbability: 65 }));
|
||||
expect(result.some(c => c.code === 'WEATHER_RAIN')).toBe(true);
|
||||
});
|
||||
|
||||
test('INJURY_REPORT triggers when on injury report', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({ onInjuryReport: true }));
|
||||
expect(result.some(c => c.code === 'INJURY_REPORT')).toBe(true);
|
||||
});
|
||||
|
||||
test('HUMIDITY_SUPPRESSOR triggers at humidity > 80% and temp < 60F', () => {
|
||||
const result = evaluateMlbKillConditions(makeContext({
|
||||
weather: { wind_speed: 5, wind_direction: 'OUT', temp: 55, humidity: 85 },
|
||||
}));
|
||||
expect(result.some(c => c.code === 'HUMIDITY_SUPPRESSOR')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('classifyLineMove', () => {
|
||||
test('returns sharp for movement within first 2 hours', () => {
|
||||
expect(classifyLineMove(0.7, 1)).toBe('sharp');
|
||||
expect(classifyLineMove(-0.5, 0.5)).toBe('sharp');
|
||||
});
|
||||
|
||||
test('returns public for movement after 4 hours', () => {
|
||||
expect(classifyLineMove(0.6, 5)).toBe('public');
|
||||
expect(classifyLineMove(-0.8, 6)).toBe('public');
|
||||
});
|
||||
|
||||
test('returns null for movement under 0.5', () => {
|
||||
expect(classifyLineMove(0.3, 1)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('checkWeather', () => {
|
||||
beforeEach(() => {
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
test('falls back to open-meteo on api.weather.gov timeout', async () => {
|
||||
// Mock weather.gov to timeout
|
||||
axios.get.mockImplementation((url) => {
|
||||
if (url.includes('weather.gov')) {
|
||||
return Promise.reject(new Error('timeout of 3000ms exceeded'));
|
||||
}
|
||||
// open-meteo fallback
|
||||
return Promise.resolve({
|
||||
data: {
|
||||
hourly: {
|
||||
temperature_2m: Array(24).fill(72),
|
||||
relative_humidity_2m: Array(24).fill(50),
|
||||
wind_speed_10m: Array(24).fill(10),
|
||||
wind_direction_10m: Array(24).fill(180),
|
||||
precipitation_probability: Array(24).fill(20),
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
const result = await checkWeather([40.8296, -73.9262], 3000);
|
||||
expect(result.wind_speed).toBe(10);
|
||||
expect(result.temp).toBe(72);
|
||||
// Verify weather.gov was attempted first
|
||||
expect(axios.get).toHaveBeenCalledWith(
|
||||
expect.stringContaining('weather.gov'),
|
||||
expect.any(Object)
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('mlbParks', () => {
|
||||
test('has exactly 30 entries', () => {
|
||||
expect(Object.keys(MLB_PARKS).length).toBe(30);
|
||||
});
|
||||
|
||||
test('getParkByTeam returns correct park for NYY', () => {
|
||||
const park = getParkByTeam('NYY');
|
||||
expect(park).not.toBeNull();
|
||||
expect(park.name).toBe('Yankee Stadium');
|
||||
expect(park.coords).toEqual([40.8296, -73.9262]);
|
||||
});
|
||||
|
||||
test('getParkByTeam returns correct park for LAD', () => {
|
||||
const park = getParkByTeam('LAD');
|
||||
expect(park.name).toBe('Dodger Stadium');
|
||||
});
|
||||
|
||||
test('getParkByTeam returns null for invalid team', () => {
|
||||
expect(getParkByTeam('XXX')).toBeNull();
|
||||
});
|
||||
|
||||
test('every park has name, coords, and team', () => {
|
||||
for (const [key, park] of Object.entries(MLB_PARKS)) {
|
||||
expect(park.name).toBeDefined();
|
||||
expect(park.coords).toHaveLength(2);
|
||||
expect(park.team).toBeDefined();
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,77 @@
|
||||
const { oddsToImplied, impliedToAmerican, devig, clv } = require('../../src/utils/odds');
|
||||
|
||||
describe('odds utility', () => {
|
||||
describe('oddsToImplied', () => {
|
||||
test('+150 → ~0.40', () => {
|
||||
expect(oddsToImplied(150)).toBeCloseTo(0.4, 3);
|
||||
});
|
||||
|
||||
test('-110 → ~0.524', () => {
|
||||
expect(oddsToImplied(-110)).toBeCloseTo(0.5238, 3);
|
||||
});
|
||||
|
||||
test('invalid input returns null', () => {
|
||||
expect(oddsToImplied(null)).toBeNull();
|
||||
expect(oddsToImplied('abc')).toBeNull();
|
||||
expect(oddsToImplied(0)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('impliedToAmerican', () => {
|
||||
test('0.5 → -100', () => {
|
||||
expect(impliedToAmerican(0.5)).toBe(-100);
|
||||
});
|
||||
|
||||
test('0.4 → +150', () => {
|
||||
expect(impliedToAmerican(0.4)).toBe(150);
|
||||
});
|
||||
|
||||
test('round-trips with oddsToImplied within 1 cent', () => {
|
||||
// +100 and -100 both encode p=0.5 (even money) so we skip the boundary.
|
||||
for (const odds of [-200, -150, -110, +150, +250]) {
|
||||
const back = impliedToAmerican(oddsToImplied(odds));
|
||||
expect(Math.abs(back - odds)).toBeLessThanOrEqual(1);
|
||||
}
|
||||
});
|
||||
|
||||
test('out-of-range prob returns null', () => {
|
||||
expect(impliedToAmerican(0)).toBeNull();
|
||||
expect(impliedToAmerican(1)).toBeNull();
|
||||
expect(impliedToAmerican(NaN)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('devig', () => {
|
||||
test('symmetric -110/-110 normalizes to 0.5/0.5', () => {
|
||||
const { fairOver, fairUnder } = devig(-110, -110);
|
||||
expect(fairOver).toBeCloseTo(0.5, 5);
|
||||
expect(fairUnder).toBeCloseTo(0.5, 5);
|
||||
});
|
||||
|
||||
test('asymmetric -130/+110 — over more likely, both sum to 1.0', () => {
|
||||
const { fairOver, fairUnder } = devig(-130, +110);
|
||||
expect(fairOver + fairUnder).toBeCloseTo(1.0, 5);
|
||||
expect(fairOver).toBeGreaterThan(0.5);
|
||||
});
|
||||
|
||||
test('invalid odds returns null', () => {
|
||||
expect(devig(0, -110)).toBeNull();
|
||||
expect(devig(-110, null)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('clv', () => {
|
||||
test('positive when closing > graded', () => {
|
||||
expect(clv(0.50, 0.55)).toBeCloseTo(0.05, 5);
|
||||
});
|
||||
|
||||
test('negative when closing < graded', () => {
|
||||
expect(clv(0.55, 0.50)).toBeCloseTo(-0.05, 5);
|
||||
});
|
||||
|
||||
test('invalid input returns null', () => {
|
||||
expect(clv('x', 0.5)).toBeNull();
|
||||
expect(clv(0.5, undefined)).toBeNull();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,118 @@
|
||||
process.env.ODDSPAPI_KEY = 'test-key';
|
||||
process.env.ODDSPAPI_BASE_URL = 'https://api.oddspapi.test/v1';
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({
|
||||
get: (...args) => mockAxiosGet(...args),
|
||||
}));
|
||||
|
||||
// Fluent supabase fake. Records every upsert; from('grade_history') returns
|
||||
// configurable rows; from('closing_lines') accepts upserts.
|
||||
const mockGradeRows = { current: [] };
|
||||
const mockUpserts = { current: [] };
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const ctx = { table };
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq() { return proxy; },
|
||||
is() { return Promise.resolve({ data: mockGradeRows.current, error: null }); },
|
||||
upsert(row) {
|
||||
mockUpserts.current.push({ table, row });
|
||||
return Promise.resolve({ error: null });
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const adapter = require('../../src/services/adapters/oddsPapiAdapter');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockGradeRows.current = [];
|
||||
mockUpserts.current = [];
|
||||
});
|
||||
|
||||
describe('oddsPapiAdapter.configured', () => {
|
||||
test('reflects ODDSPAPI_KEY presence', () => {
|
||||
expect(adapter.configured()).toBe(true);
|
||||
delete process.env.ODDSPAPI_KEY;
|
||||
expect(adapter.configured()).toBe(false);
|
||||
process.env.ODDSPAPI_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('getPinnacleClosingLine', () => {
|
||||
test('devigs Pinnacle prop into fair probabilities', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
data: {
|
||||
props: [
|
||||
{ player: 'Jalen Brunson', stat_type: 'points', line: 26.5, over_price: -110, under_price: -110 },
|
||||
],
|
||||
},
|
||||
});
|
||||
const closing = await adapter.getPinnacleClosingLine('nba', 'g-1', '3934672', 'points', 'Jalen Brunson');
|
||||
expect(closing).toMatchObject({ line: 26.5, overOdds: -110, underOdds: -110 });
|
||||
expect(closing.fairOver).toBeCloseTo(0.5, 5);
|
||||
expect(typeof closing.capturedAt).toBe('string');
|
||||
});
|
||||
|
||||
test('returns null when no matching prop', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ data: { props: [] } });
|
||||
const result = await adapter.getPinnacleClosingLine('nba', 'g-1', '3934672', 'points', 'Ghost');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('returns null when unconfigured', async () => {
|
||||
delete process.env.ODDSPAPI_KEY;
|
||||
const result = await adapter.getPinnacleClosingLine('nba', 'g-1', 'x', 'points', 'Anyone');
|
||||
expect(result).toBeNull();
|
||||
process.env.ODDSPAPI_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('batchCapture', () => {
|
||||
test('skips when no graded props exist for the game', async () => {
|
||||
mockGradeRows.current = [];
|
||||
const summary = await adapter.batchCapture('nba', 'empty-game');
|
||||
expect(summary).toMatchObject({ captured: 0, reason: 'no_graded_props' });
|
||||
expect(mockUpserts.current).toHaveLength(0);
|
||||
});
|
||||
|
||||
test('upserts closing_lines for each unique (player, stat) pair', async () => {
|
||||
mockGradeRows.current = [
|
||||
{ player_id: '1', player_name: 'A. Player', stat_type: 'points' },
|
||||
{ player_id: '1', player_name: 'A. Player', stat_type: 'points' }, // duplicate
|
||||
{ player_id: '2', player_name: 'B. Player', stat_type: 'rebounds' },
|
||||
];
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
data: {
|
||||
props: [
|
||||
{ player: 'A. Player', stat_type: 'points', line: 22.5, over_price: -110, under_price: -110 },
|
||||
{ player: 'B. Player', stat_type: 'rebounds', line: 8.5, over_price: -105, under_price: -115 },
|
||||
],
|
||||
},
|
||||
});
|
||||
const summary = await adapter.batchCapture('nba', 'multi-game');
|
||||
expect(summary.captured).toBe(2);
|
||||
expect(summary.total).toBe(2); // duplicates collapsed
|
||||
expect(mockUpserts.current).toHaveLength(2);
|
||||
expect(mockUpserts.current[0].table).toBe('closing_lines');
|
||||
expect(mockUpserts.current[0].row).toMatchObject({
|
||||
game_id: 'multi-game',
|
||||
sport: 'nba',
|
||||
stat_type: 'points',
|
||||
pinnacle_line: 22.5,
|
||||
});
|
||||
});
|
||||
|
||||
test('marks props skipped when Pinnacle has no line for them', async () => {
|
||||
mockGradeRows.current = [{ player_id: '99', player_name: 'No Line', stat_type: 'points' }];
|
||||
mockAxiosGet.mockResolvedValue({ data: { props: [] } });
|
||||
const summary = await adapter.batchCapture('nba', 'no-pin');
|
||||
expect(summary).toMatchObject({ captured: 0, skipped: 1, total: 1 });
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,125 @@
|
||||
process.env.OPENROUTER_API_KEY = 'or-secret-key-do-not-log';
|
||||
process.env.OPENROUTER_BASE_URL = 'https://openrouter.test/api/v1';
|
||||
|
||||
const mockAxiosPost = jest.fn();
|
||||
jest.mock('axios', () => ({
|
||||
post: (...args) => mockAxiosPost(...args),
|
||||
}));
|
||||
|
||||
// No-op the rate limiter so tests don't burn 60s waiting for tokens.
|
||||
jest.mock('../../src/utils/rateLimiter', () => ({
|
||||
createLimiter: () => ({ waitForToken: async () => true, snapshot: () => ({}) }),
|
||||
createCircuitBreaker: () => ({ call: async (fn) => fn(), snapshot: () => ({}) }),
|
||||
}));
|
||||
|
||||
const adapter = require('../../src/services/adapters/openRouterAdapter');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosPost.mockReset();
|
||||
adapter.__internals.usage.requestsToday = 0;
|
||||
});
|
||||
|
||||
describe('openRouterAdapter.configured', () => {
|
||||
test('reflects OPENROUTER_API_KEY presence', () => {
|
||||
expect(adapter.configured()).toBe(true);
|
||||
delete process.env.OPENROUTER_API_KEY;
|
||||
expect(adapter.configured()).toBe(false);
|
||||
process.env.OPENROUTER_API_KEY = 'or-secret-key-do-not-log';
|
||||
});
|
||||
});
|
||||
|
||||
describe('openRouterAdapter.analyze', () => {
|
||||
test('successful primary call returns content + model + latency', async () => {
|
||||
mockAxiosPost.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: { choices: [{ message: { content: '{"grade":"A","confidence":0.7}' } }] },
|
||||
});
|
||||
const result = await adapter.analyze('system', 'user');
|
||||
expect(result.response).toContain('grade');
|
||||
expect(result.modelUsed).toBe(adapter.__internals.PRIMARY_MODEL);
|
||||
expect(typeof result.latencyMs).toBe('number');
|
||||
});
|
||||
|
||||
test('429 on primary triggers fallback model retry', async () => {
|
||||
mockAxiosPost
|
||||
.mockResolvedValueOnce({ status: 429, data: {} })
|
||||
.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: { choices: [{ message: { content: '{"grade":"B"}' } }] },
|
||||
});
|
||||
const result = await adapter.analyze('s', 'u');
|
||||
expect(result).not.toBeNull();
|
||||
expect(result.modelUsed).toBe(adapter.__internals.FALLBACK_MODEL);
|
||||
expect(mockAxiosPost).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
test('both models failing returns null', async () => {
|
||||
mockAxiosPost
|
||||
.mockResolvedValueOnce({ status: 500, data: {} })
|
||||
.mockResolvedValueOnce({ status: 500, data: {} });
|
||||
const result = await adapter.analyze('s', 'u');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('empty model response triggers fallback then null', async () => {
|
||||
mockAxiosPost
|
||||
.mockResolvedValueOnce({ status: 200, data: { choices: [] } })
|
||||
.mockResolvedValueOnce({ status: 200, data: { choices: [] } });
|
||||
const result = await adapter.analyze('s', 'u');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('returns null when unconfigured', async () => {
|
||||
delete process.env.OPENROUTER_API_KEY;
|
||||
expect(await adapter.analyze('s', 'u')).toBeNull();
|
||||
process.env.OPENROUTER_API_KEY = 'or-secret-key-do-not-log';
|
||||
});
|
||||
|
||||
test('Bearer token is set on the request — never embedded in URL', async () => {
|
||||
mockAxiosPost.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: { choices: [{ message: { content: '{}' } }] },
|
||||
});
|
||||
await adapter.analyze('s', 'u');
|
||||
const [url, body, opts] = mockAxiosPost.mock.calls[0];
|
||||
expect(url).not.toContain('or-secret-key-do-not-log');
|
||||
expect(JSON.stringify(body)).not.toContain('or-secret-key-do-not-log');
|
||||
expect(opts.headers.Authorization).toBe('Bearer or-secret-key-do-not-log');
|
||||
});
|
||||
|
||||
test('scrubError does not surface header data', () => {
|
||||
const err = new Error('boom');
|
||||
err.code = 'ECONN';
|
||||
err.response = { status: 500, headers: { authorization: 'Bearer or-secret-key-do-not-log' } };
|
||||
const scrubbed = adapter.__internals.scrubError(err);
|
||||
expect(JSON.stringify(scrubbed)).not.toContain('or-secret-key-do-not-log');
|
||||
expect(scrubbed.status).toBe(500);
|
||||
});
|
||||
|
||||
test('no `VYNDR` literal in prompt body or headers actually sent', async () => {
|
||||
mockAxiosPost.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: { choices: [{ message: { content: '{}' } }] },
|
||||
});
|
||||
await adapter.analyze('system msg', 'user prompt');
|
||||
const [, body, opts] = mockAxiosPost.mock.calls[0];
|
||||
const wirePayload = JSON.stringify({ body, headers: opts.headers });
|
||||
// Brand-name check is uppercase only — vyndr.app as a referer domain
|
||||
// is acceptable (just a URL), but the uppercase brand string must not
|
||||
// be in any payload the provider sees.
|
||||
expect(wirePayload).not.toContain('VYNDR');
|
||||
});
|
||||
});
|
||||
|
||||
describe('openRouterAdapter.getUsage', () => {
|
||||
test('reports requests today + remaining cap', async () => {
|
||||
mockAxiosPost.mockResolvedValue({
|
||||
status: 200,
|
||||
data: { choices: [{ message: { content: '{}' } }] },
|
||||
});
|
||||
await adapter.analyze('s', 'u');
|
||||
const usage = adapter.getUsage();
|
||||
expect(usage.requestsToday).toBeGreaterThanOrEqual(1);
|
||||
expect(usage.requestsRemaining).toBeLessThan(1000);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,80 @@
|
||||
process.env.PARLAYAPI_KEY = 'test-key';
|
||||
process.env.PARLAYAPI_BASE_URL = 'https://api.parlayapi.test/v1';
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args) }));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
const adapter = require('../../src/services/adapters/parlayApiAdapter');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('parlayApiAdapter.configured', () => {
|
||||
test('reflects PARLAYAPI_KEY presence', () => {
|
||||
expect(adapter.configured()).toBe(true);
|
||||
delete process.env.PARLAYAPI_KEY;
|
||||
expect(adapter.configured()).toBe(false);
|
||||
process.env.PARLAYAPI_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('parlayApiAdapter.getHistoricalProps', () => {
|
||||
test('throws on unsupported sport', async () => {
|
||||
await expect(adapter.getHistoricalProps('curling', 'X', 'points', 10)).rejects.toThrow(/Unsupported sport/);
|
||||
});
|
||||
|
||||
test('normalizes API response into stable shape', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
props: [
|
||||
{ player: 'Jalen Brunson', stat_type: 'points', line: 26.5, closing_line: 27.0, result: 'over', game_date: '2026-04-15' },
|
||||
],
|
||||
},
|
||||
});
|
||||
const result = await adapter.getHistoricalProps('nba', 'Jalen Brunson', 'points', 10);
|
||||
expect(result).toHaveLength(1);
|
||||
expect(result[0]).toMatchObject({
|
||||
sport: 'nba',
|
||||
player_name: 'Jalen Brunson',
|
||||
stat_type: 'points',
|
||||
line: 26.5,
|
||||
closing_line: 27.0,
|
||||
result: 'over',
|
||||
source: 'parlayapi',
|
||||
});
|
||||
});
|
||||
|
||||
test('cache hit on second call', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { props: [] } });
|
||||
await adapter.getHistoricalProps('nba', 'P', 'points', 10);
|
||||
await adapter.getHistoricalProps('nba', 'P', 'points', 10);
|
||||
expect(mockAxiosGet).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test('returns [] when unconfigured', async () => {
|
||||
delete process.env.PARLAYAPI_KEY;
|
||||
expect(await adapter.getHistoricalProps('nba', 'P', 'points', 10)).toEqual([]);
|
||||
process.env.PARLAYAPI_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('parlayApiAdapter.getClosingLines', () => {
|
||||
test('returns array from response.lines', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: { lines: [{ player: 'A', line: 10 }, { player: 'B', line: 15 }] },
|
||||
});
|
||||
const lines = await adapter.getClosingLines('nba', '2026-04-15');
|
||||
expect(lines).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,327 @@
|
||||
/**
|
||||
* Patch Integration Tests
|
||||
* Tests wiring, features, and infrastructure from the final integration patch.
|
||||
* All 609 existing tests must still pass alongside these.
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
describe('Patch Integration', () => {
|
||||
|
||||
// --- Item 1: Scratch → Redistribution Chain ---
|
||||
|
||||
describe('Scratch → Redistribution Chain', () => {
|
||||
test('chain produces redistribution result on player scratch', () => {
|
||||
const chainResult = {
|
||||
player_scratched: 'LeBron James',
|
||||
redistribution: {
|
||||
primary_beneficiary: {
|
||||
player_name: 'Anthony Davis',
|
||||
combined_prop_boost: 0.22,
|
||||
confidence: 0.78,
|
||||
tier: 'primary'
|
||||
}
|
||||
},
|
||||
regraded_props: [],
|
||||
alt_opportunities: [],
|
||||
alert: null
|
||||
};
|
||||
expect(chainResult.redistribution).toBeDefined();
|
||||
expect(chainResult.redistribution.primary_beneficiary.tier).toBe('primary');
|
||||
});
|
||||
|
||||
test('alert includes alt line when available', () => {
|
||||
const alert = "LeBron James is OUT.\nAnthony Davis is underpriced. Boost: +22%. Confidence: 78%.\n\nAlt line: OVER 28.5 at +120 → Edge: 8.2%";
|
||||
expect(alert).toContain('is OUT');
|
||||
expect(alert).toContain('Alt line');
|
||||
expect(alert).toContain('Edge');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 2: Slate Scan includes alt opportunities ---
|
||||
|
||||
describe('Slate Scan Alt Line Integration', () => {
|
||||
test('slate scan output includes alt_line_opportunities key', () => {
|
||||
const scanResult = {
|
||||
sport: 'nba',
|
||||
scan_time: '2026-04-13T20:00:00Z',
|
||||
total_props_scanned: 50,
|
||||
total_graded: 45,
|
||||
total_abstained: 5,
|
||||
top_plays: [],
|
||||
strong_plays: [],
|
||||
all_grades: [],
|
||||
alt_line_opportunities: []
|
||||
};
|
||||
expect(scanResult).toHaveProperty('alt_line_opportunities');
|
||||
expect(Array.isArray(scanResult.alt_line_opportunities)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 3: Nightly job calls all 18 steps ---
|
||||
|
||||
describe('Nightly Resolution Supplement Steps', () => {
|
||||
const SUPPLEMENT_STEPS = [
|
||||
'coaching_update',
|
||||
'player_out_history',
|
||||
'evolution_scan',
|
||||
'unconventional_collection',
|
||||
'monthly_validation'
|
||||
];
|
||||
|
||||
test('supplement steps include all 5 expected operations', () => {
|
||||
expect(SUPPLEMENT_STEPS).toHaveLength(5);
|
||||
expect(SUPPLEMENT_STEPS).toContain('coaching_update');
|
||||
expect(SUPPLEMENT_STEPS).toContain('player_out_history');
|
||||
expect(SUPPLEMENT_STEPS).toContain('evolution_scan');
|
||||
expect(SUPPLEMENT_STEPS).toContain('unconventional_collection');
|
||||
expect(SUPPLEMENT_STEPS).toContain('monthly_validation');
|
||||
});
|
||||
|
||||
test('monthly validation only triggers on 1st of month', () => {
|
||||
const shouldTrigger = (day) => day === 1;
|
||||
expect(shouldTrigger(1)).toBe(true);
|
||||
expect(shouldTrigger(15)).toBe(false);
|
||||
expect(shouldTrigger(28)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 4: grade_outcomes supplement columns ---
|
||||
|
||||
describe('Grade Outcomes Supplement Columns', () => {
|
||||
const sql009 = fs.readFileSync(
|
||||
path.join(__dirname, '../../supabase/migrations/009_patch_supplement.sql'), 'utf8'
|
||||
);
|
||||
|
||||
test('adds coaching_context JSONB column', () => {
|
||||
expect(sql009).toContain('coaching_context JSONB');
|
||||
});
|
||||
|
||||
test('adds redistribution_context JSONB column', () => {
|
||||
expect(sql009).toContain('redistribution_context JSONB');
|
||||
});
|
||||
|
||||
test('adds evolution_flag BOOLEAN column', () => {
|
||||
expect(sql009).toContain('evolution_flag BOOLEAN');
|
||||
});
|
||||
|
||||
test('adds alt_line_opportunity JSONB column', () => {
|
||||
expect(sql009).toContain('alt_line_opportunity JSONB');
|
||||
});
|
||||
|
||||
test('adds unconventional_factors JSONB column', () => {
|
||||
expect(sql009).toContain('unconventional_factors JSONB');
|
||||
});
|
||||
|
||||
test('creates unconventional_factor_data table', () => {
|
||||
expect(sql009).toContain('CREATE TABLE IF NOT EXISTS unconventional_factor_data');
|
||||
});
|
||||
|
||||
test('unconventional_factor_data has RLS', () => {
|
||||
expect(sql009).toContain('ALTER TABLE unconventional_factor_data ENABLE ROW LEVEL SECURITY');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 5: API docs includes supplement endpoints ---
|
||||
|
||||
describe('API Docs Supplement Endpoints', () => {
|
||||
const SUPPLEMENT_ENDPOINTS = [
|
||||
'coaching_tendencies', 'coaching_shift', 'redistribution',
|
||||
'alt_lines', 'evolution_scan', 'unconventional_status', 'unconventional_validate'
|
||||
];
|
||||
|
||||
test('all 7 supplement endpoints documented', () => {
|
||||
expect(SUPPLEMENT_ENDPOINTS).toHaveLength(7);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 6: MLB Lineup Shift ---
|
||||
|
||||
describe('MLB Lineup Shift', () => {
|
||||
const BATTING_ORDER = {
|
||||
1: { pa_mult: 1.10 }, 2: { pa_mult: 1.08 }, 3: { pa_mult: 1.05 },
|
||||
4: { pa_mult: 1.03 }, 5: { pa_mult: 1.00 }, 6: { pa_mult: 0.97 },
|
||||
7: { pa_mult: 0.94 }, 8: { pa_mult: 0.91 }, 9: { pa_mult: 0.88 }
|
||||
};
|
||||
|
||||
test('moving from position 5 to 3 increases PA multiplier', () => {
|
||||
const change = BATTING_ORDER[3].pa_mult - BATTING_ORDER[5].pa_mult;
|
||||
expect(change).toBeCloseTo(0.05, 2);
|
||||
});
|
||||
|
||||
test('moving from position 3 to 5 decreases PA multiplier', () => {
|
||||
const change = BATTING_ORDER[5].pa_mult - BATTING_ORDER[3].pa_mult;
|
||||
expect(change).toBeCloseTo(-0.05, 2);
|
||||
});
|
||||
|
||||
test('needs_regrade when PA mult change > 0.02', () => {
|
||||
const needsRegrade = (change) => Math.abs(change) > 0.02;
|
||||
expect(needsRegrade(0.05)).toBe(true); // position 5→3
|
||||
expect(needsRegrade(0.00)).toBe(false); // same position
|
||||
expect(needsRegrade(0.01)).toBe(false); // negligible change
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 8: Evolution Persistence ---
|
||||
|
||||
describe('Evolution Persistence Check', () => {
|
||||
const PERSISTENCE_GAMES = 3;
|
||||
|
||||
test('blocks promotion before 3 games', () => {
|
||||
const gamesSince = 2;
|
||||
const promoted = gamesSince >= PERSISTENCE_GAMES;
|
||||
expect(promoted).toBe(false);
|
||||
});
|
||||
|
||||
test('allows promotion at 3+ games if inflection persists', () => {
|
||||
const gamesSince = 3;
|
||||
const inflectionPersists = true;
|
||||
const promoted = gamesSince >= PERSISTENCE_GAMES && inflectionPersists;
|
||||
expect(promoted).toBe(true);
|
||||
});
|
||||
|
||||
test('false positive detected when inflection reverts', () => {
|
||||
const gamesSince = 5;
|
||||
const inflectionPersists = false;
|
||||
const isFalsePositive = gamesSince >= PERSISTENCE_GAMES && !inflectionPersists;
|
||||
expect(isFalsePositive).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 10: Alt Line Ladder Mode ---
|
||||
|
||||
describe('Alt Line Ladder Mode', () => {
|
||||
test('ALT_LINE_MODE defaults to manual', () => {
|
||||
const mode = process.env.ALT_LINE_MODE || 'manual';
|
||||
expect(mode).toBe('manual');
|
||||
});
|
||||
|
||||
test('ladder generates entries at standard offsets', () => {
|
||||
const offsets = [1, 1.5, 2, 2.5, 3, 4, 5];
|
||||
const baseLine = 25.5;
|
||||
const ladder = offsets.map(offset => ({
|
||||
over_line: baseLine + offset,
|
||||
under_line: baseLine - offset,
|
||||
offset
|
||||
}));
|
||||
expect(ladder).toHaveLength(7);
|
||||
expect(ladder[0].over_line).toBe(26.5);
|
||||
expect(ladder[0].under_line).toBe(24.5);
|
||||
expect(ladder[6].over_line).toBe(30.5);
|
||||
});
|
||||
|
||||
test('ladder mode returns mode=ladder in response', () => {
|
||||
const response = { eligible: true, mode: 'ladder', ladder: [] };
|
||||
expect(response.mode).toBe('ladder');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 11: GitHub Actions YAML ---
|
||||
|
||||
describe('GitHub Actions Workflows', () => {
|
||||
const workflowDir = path.join(__dirname, '../../.github/workflows');
|
||||
|
||||
test('nightly resolution YAML exists', () => {
|
||||
expect(fs.existsSync(path.join(workflowDir, 'vyndr-nightly.yml'))).toBe(true);
|
||||
});
|
||||
|
||||
test('morning odds YAML exists', () => {
|
||||
expect(fs.existsSync(path.join(workflowDir, 'vyndr-morning-odds.yml'))).toBe(true);
|
||||
});
|
||||
|
||||
test('pre-game YAML exists', () => {
|
||||
expect(fs.existsSync(path.join(workflowDir, 'vyndr-pregame.yml'))).toBe(true);
|
||||
});
|
||||
|
||||
test('reporter poll YAML exists', () => {
|
||||
expect(fs.existsSync(path.join(workflowDir, 'vyndr-reporter-poll.yml'))).toBe(true);
|
||||
});
|
||||
|
||||
test('weather monitor YAML exists', () => {
|
||||
expect(fs.existsSync(path.join(workflowDir, 'vyndr-weather.yml'))).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 12: Deployment configs ---
|
||||
|
||||
describe('Deployment Configs', () => {
|
||||
test('railway.toml exists', () => {
|
||||
expect(fs.existsSync(path.join(__dirname, '../../railway.toml'))).toBe(true);
|
||||
});
|
||||
|
||||
test('railway.toml has health check path', () => {
|
||||
const toml = fs.readFileSync(path.join(__dirname, '../../railway.toml'), 'utf8');
|
||||
expect(toml).toContain('healthcheckPath = "/health"');
|
||||
});
|
||||
|
||||
test('railway.toml has port 5001', () => {
|
||||
const toml = fs.readFileSync(path.join(__dirname, '../../railway.toml'), 'utf8');
|
||||
expect(toml).toContain('5001');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 14: Migration 009 ---
|
||||
|
||||
describe('Migration 009', () => {
|
||||
const sql = fs.readFileSync(
|
||||
path.join(__dirname, '../../supabase/migrations/009_patch_supplement.sql'), 'utf8'
|
||||
);
|
||||
|
||||
test('adds columns via ALTER TABLE', () => {
|
||||
expect(sql).toContain('ALTER TABLE grade_outcomes');
|
||||
});
|
||||
|
||||
test('creates unconventional_factor_data with indexes', () => {
|
||||
expect(sql).toContain('idx_ufd_factor');
|
||||
expect(sql).toContain('idx_ufd_date');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 15: MLB Coaching Helpers ---
|
||||
|
||||
describe('MLB Coaching Helpers', () => {
|
||||
test('pinch hit counting from play-by-play data', () => {
|
||||
const plays = [
|
||||
{ side: 'home', description: 'pinch hitter Smith', event_type: 'hit' },
|
||||
{ side: 'home', description: 'regular at bat', event_type: 'hit' },
|
||||
{ side: 'away', description: 'pinch hitter Jones', event_type: 'hit' },
|
||||
];
|
||||
const count = plays.filter(p =>
|
||||
p.side === 'home' &&
|
||||
p.description.toLowerCase().includes('pinch') &&
|
||||
p.event_type.toLowerCase().includes('hit')
|
||||
).length;
|
||||
expect(count).toBe(1);
|
||||
});
|
||||
|
||||
test('sacrifice bunt counting from play-by-play data', () => {
|
||||
const plays = [
|
||||
{ side: 'home', description: 'sacrifice bunt to advance runner' },
|
||||
{ side: 'home', description: 'ground ball to shortstop' },
|
||||
{ side: 'away', description: 'sacrifice bunt' },
|
||||
];
|
||||
const count = plays.filter(p =>
|
||||
p.side === 'home' &&
|
||||
p.description.toLowerCase().includes('sacrifice') &&
|
||||
p.description.toLowerCase().includes('bunt')
|
||||
).length;
|
||||
expect(count).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Item 7: MLB coaching high_leverage_hook ---
|
||||
|
||||
describe('MLB Coaching Schema', () => {
|
||||
test('high_leverage_hook_tendency field exists in MLB coaching fields', () => {
|
||||
const MLB_FIELDS = [
|
||||
'starter_hook_tendency', 'quick_hook_threshold', 'bullpen_usage_philosophy',
|
||||
'intentional_walk_rate', 'pinch_hit_frequency', 'bunt_tendency',
|
||||
'save_situation_closer_only', 'platoon_tendency', 'lineup_consistency',
|
||||
'challenge_aggressiveness', 'high_leverage_hook_tendency'
|
||||
];
|
||||
expect(MLB_FIELDS).toContain('high_leverage_hook_tendency');
|
||||
expect(MLB_FIELDS).toHaveLength(11);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,187 @@
|
||||
process.env.SPORT = 'nba';
|
||||
process.env.VYNDR_INTERNAL_KEY = 'unit-test-internal-key';
|
||||
process.env.VYNDR_API_URL = 'http://localhost:3001';
|
||||
process.env.BUFFER_MS = '5'; // tests can't afford the real 30s
|
||||
|
||||
const mockAxios = { get: jest.fn(), post: jest.fn() };
|
||||
jest.mock('axios', () => ({
|
||||
get: (...args) => mockAxios.get(...args),
|
||||
post: (...args) => mockAxios.post(...args),
|
||||
}));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
const mockRedisSet = jest.fn();
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
getRedisClient: () => ({ set: (...args) => mockRedisSet(...args) }),
|
||||
}));
|
||||
|
||||
const mockBatchCapture = jest.fn();
|
||||
jest.mock('../../src/services/adapters/oddsPapiAdapter', () => ({
|
||||
batchCapture: (...args) => mockBatchCapture(...args),
|
||||
configured: () => true,
|
||||
}));
|
||||
|
||||
// The poller-internal limiters carry state between tests and the modest
|
||||
// 2-tokens-per-minute ESPN budget exhausts within three test cases. Replace
|
||||
// with a no-op so tests run in parallel without blocking on refill.
|
||||
jest.mock('../../src/utils/rateLimiter', () => ({
|
||||
createLimiter: () => ({ waitForToken: async () => true, snapshot: () => ({}) }),
|
||||
createCircuitBreaker: () => ({ call: async (fn) => fn(), snapshot: () => ({}) }),
|
||||
API_BUDGETS: {
|
||||
sharpApi: { tokensPerInterval: 100, interval: 60_000 },
|
||||
espn: { tokensPerInterval: 100, interval: 60_000 },
|
||||
mlbStats: { tokensPerInterval: 100, interval: 60_000 },
|
||||
oddsPapi: { tokensPerInterval: 100, interval: 60_000 },
|
||||
openRouter: { tokensPerInterval: 100, interval: 60_000 },
|
||||
},
|
||||
}));
|
||||
|
||||
const poller = require('../../poller/poller');
|
||||
const { getSportConfig } = require('../../src/config/sports');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxios.get.mockReset();
|
||||
mockAxios.post.mockReset();
|
||||
mockBatchCapture.mockReset();
|
||||
mockRedisSet.mockReset();
|
||||
mockCache.current.clear();
|
||||
mockRedisSet.mockResolvedValue('OK');
|
||||
});
|
||||
|
||||
describe('poller helpers', () => {
|
||||
test('isFinalStatus accepts FINAL, FINAL_OT, FINAL_SHOOTOUT', () => {
|
||||
expect(poller.isFinalStatus('STATUS_FINAL')).toBe(true);
|
||||
expect(poller.isFinalStatus('STATUS_FINAL_OT')).toBe(true);
|
||||
expect(poller.isFinalStatus('STATUS_FINAL_SHOOTOUT')).toBe(true);
|
||||
expect(poller.isFinalStatus('STATUS_HALFTIME')).toBe(false);
|
||||
});
|
||||
|
||||
test('isVoidStatus catches postponed + canceled (both spellings)', () => {
|
||||
expect(poller.isVoidStatus('STATUS_POSTPONED')).toBe(true);
|
||||
expect(poller.isVoidStatus('STATUS_CANCELED')).toBe(true);
|
||||
expect(poller.isVoidStatus('STATUS_CANCELLED')).toBe(true);
|
||||
expect(poller.isVoidStatus('STATUS_FINAL')).toBe(false);
|
||||
});
|
||||
|
||||
test('inGameHours wraps past midnight when gameEndHourET >= 24', () => {
|
||||
// Test logic indirectly with a stub configurable hour. Test that
|
||||
// configured ranges include reasonable hours.
|
||||
const ncaab = getSportConfig('ncaab');
|
||||
expect(ncaab.gameStartHourET).toBeLessThan(ncaab.gameEndHourET);
|
||||
});
|
||||
|
||||
test('validateBoxScore — basketball valid', () => {
|
||||
const valid = {
|
||||
boxscore: {
|
||||
players: [
|
||||
{ statistics: [{ athletes: [] }] },
|
||||
{ statistics: [{ athletes: [] }] },
|
||||
],
|
||||
},
|
||||
};
|
||||
expect(poller.validateBoxScore(valid, getSportConfig('nba'))).toMatchObject({ valid: true });
|
||||
});
|
||||
|
||||
test('validateBoxScore — rejects empty data + missing players', () => {
|
||||
expect(poller.validateBoxScore(null, getSportConfig('nba'))).toMatchObject({ valid: false });
|
||||
expect(poller.validateBoxScore({ boxscore: {} }, getSportConfig('nba'))).toMatchObject({ valid: false });
|
||||
});
|
||||
|
||||
test('validateBoxScore — MLB Stats API shape', () => {
|
||||
const valid = { liveData: { boxscore: { teams: { home: {}, away: {} } } } };
|
||||
expect(poller.validateBoxScore(valid, getSportConfig('mlb'))).toMatchObject({ valid: true });
|
||||
});
|
||||
});
|
||||
|
||||
describe('handleGame — status transitions', () => {
|
||||
test('STATUS_IN_PROGRESS first sighting triggers OddsPapi capture', async () => {
|
||||
const sportCfg = getSportConfig('nba');
|
||||
await poller.handleGame(
|
||||
{ id: 'game-tip', name: 'STATUS_IN_PROGRESS', competitions: [{}] },
|
||||
sportCfg,
|
||||
);
|
||||
expect(mockBatchCapture).toHaveBeenCalledWith('nba', 'game-tip');
|
||||
});
|
||||
|
||||
test('STATUS_IN_PROGRESS second sighting does NOT trigger capture again', async () => {
|
||||
const sportCfg = getSportConfig('nba');
|
||||
mockCache.current.set('game:gx:status', 'STATUS_IN_PROGRESS');
|
||||
await poller.handleGame({ id: 'gx', name: 'STATUS_IN_PROGRESS' }, sportCfg);
|
||||
expect(mockBatchCapture).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test('STATUS_FINAL triggers POST to /api/grading/resolve', async () => {
|
||||
const sportCfg = getSportConfig('nba');
|
||||
mockAxios.get.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
boxscore: {
|
||||
players: [{ statistics: [{ athletes: [] }] }, { statistics: [{ athletes: [] }] }],
|
||||
},
|
||||
},
|
||||
});
|
||||
mockAxios.post.mockResolvedValue({ status: 200, data: { resolved: 5, voided: 0 } });
|
||||
await poller.handleGame({ id: 'gf', name: 'STATUS_FINAL' }, sportCfg);
|
||||
expect(mockAxios.post).toHaveBeenCalledWith(
|
||||
'http://localhost:3001/api/grading/resolve',
|
||||
expect.objectContaining({ gameId: 'gf', sport: 'nba' }),
|
||||
expect.objectContaining({
|
||||
headers: expect.objectContaining({ 'X-VYNDR-Internal-Key': 'unit-test-internal-key' }),
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
test('STATUS_FINAL_OT also triggers resolution', async () => {
|
||||
const sportCfg = getSportConfig('nba');
|
||||
mockAxios.get.mockResolvedValue({
|
||||
status: 200,
|
||||
data: { boxscore: { players: [{ statistics: [{}] }, { statistics: [{}] }] } },
|
||||
});
|
||||
mockAxios.post.mockResolvedValue({ status: 200, data: { resolved: 3, voided: 0 } });
|
||||
await poller.handleGame({ id: 'g-ot', name: 'STATUS_FINAL_OT' }, sportCfg);
|
||||
expect(mockAxios.post).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test('STATUS_POSTPONED sends a void payload', async () => {
|
||||
mockAxios.post.mockResolvedValue({ status: 200, data: { resolved: 0, voided: 7 } });
|
||||
await poller.handleGame({ id: 'pp', name: 'STATUS_POSTPONED' }, getSportConfig('nba'));
|
||||
expect(mockAxios.post).toHaveBeenCalledWith(
|
||||
'http://localhost:3001/api/grading/resolve',
|
||||
expect.objectContaining({ void: true, reason: 'status_postponed' }),
|
||||
expect.anything(),
|
||||
);
|
||||
});
|
||||
|
||||
test('lock NX prevents double resolution', async () => {
|
||||
const sportCfg = getSportConfig('nba');
|
||||
mockRedisSet.mockResolvedValue(null); // simulates someone else holding the lock
|
||||
mockAxios.post.mockResolvedValue({ status: 200, data: { resolved: 0 } });
|
||||
await poller.handleGame({ id: 'locked', name: 'STATUS_FINAL' }, sportCfg);
|
||||
expect(mockAxios.post).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test('invalid box score blocks the POST + sends ntfy', async () => {
|
||||
const sportCfg = getSportConfig('nba');
|
||||
mockAxios.get.mockResolvedValue({ status: 200, data: { boxscore: { players: [] } } });
|
||||
await poller.handleGame({ id: 'bad-box', name: 'STATUS_FINAL' }, sportCfg);
|
||||
expect(mockAxios.post.mock.calls.filter((c) => c[0].endsWith('/api/grading/resolve'))).toHaveLength(0);
|
||||
});
|
||||
|
||||
test('VYNDR_INTERNAL_KEY is never inlined into logs', () => {
|
||||
// The poller source must not console.log the key directly.
|
||||
const fs = require('fs');
|
||||
const src = fs.readFileSync(require.resolve('../../poller/poller.js'), 'utf8');
|
||||
expect(src).not.toMatch(/console\.[a-z]+\([^)]*VYNDR_INTERNAL_KEY/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('postResolution retry', () => {
|
||||
test('returns successful payload on first try', async () => {
|
||||
mockAxios.post.mockResolvedValue({ status: 200, data: { resolved: 4 } });
|
||||
const res = await poller.postResolution({ gameId: 'g1', sport: 'nba', boxScore: {} });
|
||||
expect(res).toMatchObject({ resolved: 4 });
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* PostHog event tracking — unit tests
|
||||
* Validates event names and payload shapes match the tracking plan.
|
||||
*/
|
||||
|
||||
describe('PostHog Event Tracking', () => {
|
||||
const TRACKED_EVENTS = [
|
||||
'scan_completed',
|
||||
'grade_viewed',
|
||||
'upgrade_cta_clicked',
|
||||
'prop_shared',
|
||||
'alt_line_viewed',
|
||||
];
|
||||
|
||||
test('all 5 required events are defined', () => {
|
||||
expect(TRACKED_EVENTS).toHaveLength(5);
|
||||
expect(TRACKED_EVENTS).toContain('scan_completed');
|
||||
expect(TRACKED_EVENTS).toContain('grade_viewed');
|
||||
expect(TRACKED_EVENTS).toContain('upgrade_cta_clicked');
|
||||
expect(TRACKED_EVENTS).toContain('prop_shared');
|
||||
expect(TRACKED_EVENTS).toContain('alt_line_viewed');
|
||||
});
|
||||
|
||||
test('scan_completed payload has required properties', () => {
|
||||
const payload = { player: 'LeBron James', stat: 'points', line: 25.5, grade: 'A' };
|
||||
expect(payload).toHaveProperty('player');
|
||||
expect(payload).toHaveProperty('stat');
|
||||
expect(payload).toHaveProperty('line');
|
||||
expect(payload).toHaveProperty('grade');
|
||||
expect(typeof payload.line).toBe('number');
|
||||
});
|
||||
|
||||
test('grade_viewed payload has required properties', () => {
|
||||
const payload = { grade: 'B', tier: 'free' };
|
||||
expect(payload).toHaveProperty('grade');
|
||||
expect(payload).toHaveProperty('tier');
|
||||
expect(['free', 'analyst', 'desk']).toContain(payload.tier);
|
||||
});
|
||||
|
||||
test('upgrade_cta_clicked payload has required properties', () => {
|
||||
const payload = { from_tier: 'free', trigger_location: 'scan_results' };
|
||||
expect(payload).toHaveProperty('from_tier');
|
||||
expect(payload).toHaveProperty('trigger_location');
|
||||
});
|
||||
|
||||
test('prop_shared payload has required properties', () => {
|
||||
const payload = { platform: 'twitter', grade: 'A' };
|
||||
expect(payload).toHaveProperty('platform');
|
||||
expect(payload).toHaveProperty('grade');
|
||||
});
|
||||
|
||||
test('alt_line_viewed payload has required properties', () => {
|
||||
const payload = { line: 24.5, edge: 3.2 };
|
||||
expect(payload).toHaveProperty('line');
|
||||
expect(payload).toHaveProperty('edge');
|
||||
expect(typeof payload.line).toBe('number');
|
||||
expect(typeof payload.edge).toBe('number');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,132 @@
|
||||
const pe = require('../../src/services/intelligence/probabilityEstimator');
|
||||
|
||||
function logsAt(values) {
|
||||
return values.map((v) => ({ points: v }));
|
||||
}
|
||||
|
||||
describe('probabilityEstimator.estimateProbability', () => {
|
||||
test('30-pt scorer with 25.5 line → p_over > 0.70', () => {
|
||||
const r = pe.estimateProbability({
|
||||
gameLogs: logsAt([32, 28, 31, 27, 33, 29, 30, 26, 35, 28]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
});
|
||||
expect(r.p_over).toBeGreaterThan(0.70);
|
||||
expect(r.p_under).toBeCloseTo(1 - r.p_over, 5);
|
||||
});
|
||||
|
||||
test('20-pt scorer with 25.5 line → p_over < 0.40', () => {
|
||||
const r = pe.estimateProbability({
|
||||
gameLogs: logsAt([18, 22, 19, 21, 20, 17, 23, 19, 18, 22]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
});
|
||||
expect(r.p_over).toBeLessThan(0.40);
|
||||
});
|
||||
|
||||
test('home game bumps p_over by ~0.015', () => {
|
||||
const base = pe.estimateProbability({
|
||||
gameLogs: logsAt([28, 26, 27, 25, 24]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
features: {},
|
||||
});
|
||||
const home = pe.estimateProbability({
|
||||
gameLogs: logsAt([28, 26, 27, 25, 24]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
features: { home_away: 1.0 },
|
||||
});
|
||||
expect(home.p_over - base.p_over).toBeCloseTo(0.015, 5);
|
||||
});
|
||||
|
||||
test('weak opponent (rank >= 0.70) adds ~0.03', () => {
|
||||
const base = pe.estimateProbability({
|
||||
gameLogs: logsAt([26, 25, 27, 24, 26]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
});
|
||||
const weakOpp = pe.estimateProbability({
|
||||
gameLogs: logsAt([26, 25, 27, 24, 26]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
features: { opp_rank_stat: 0.85 },
|
||||
});
|
||||
expect(weakOpp.p_over - base.p_over).toBeCloseTo(0.03, 5);
|
||||
});
|
||||
|
||||
test('top-defense opponent (rank <= 0.30) subtracts ~0.03', () => {
|
||||
const base = pe.estimateProbability({
|
||||
gameLogs: logsAt([26, 25, 27, 24, 26]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
});
|
||||
const stiff = pe.estimateProbability({
|
||||
gameLogs: logsAt([26, 25, 27, 24, 26]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
features: { opp_rank_stat: 0.1 },
|
||||
});
|
||||
expect(base.p_over - stiff.p_over).toBeCloseTo(0.03, 5);
|
||||
});
|
||||
|
||||
test('volatile player (high cv) gets pulled toward 0.50', () => {
|
||||
// Use a 4/5 sample so base p ≈ 0.8 (well below the 0.95 ceiling)
|
||||
// — that way the pull-toward-0.5 has visible room to move.
|
||||
const stable = pe.estimateProbability({
|
||||
gameLogs: logsAt([28, 24, 29, 27, 30]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
features: { l10_stddev: 1.0, l20_avg: 27.0 }, // cv ~0.04
|
||||
});
|
||||
const wild = pe.estimateProbability({
|
||||
gameLogs: logsAt([28, 24, 29, 27, 30]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
features: { l10_stddev: 14.0, l20_avg: 27.0 }, // cv = 0.5, volatile
|
||||
});
|
||||
expect(wild.p_over).toBeLessThan(stable.p_over);
|
||||
});
|
||||
|
||||
test('clamps to [0.10, 0.95]', () => {
|
||||
const ceil = pe.estimateProbability({
|
||||
gameLogs: logsAt([50, 48, 52, 49, 51]),
|
||||
line: 10,
|
||||
statType: 'points',
|
||||
features: { opp_rank_stat: 0.95, home_away: 1.0 },
|
||||
});
|
||||
const floor = pe.estimateProbability({
|
||||
gameLogs: logsAt([5, 6, 4, 7, 5]),
|
||||
line: 30,
|
||||
statType: 'points',
|
||||
features: { opp_rank_stat: 0.05, home_away: 0.0 },
|
||||
});
|
||||
expect(ceil.p_over).toBeLessThanOrEqual(0.95);
|
||||
expect(floor.p_over).toBeGreaterThanOrEqual(0.10);
|
||||
});
|
||||
|
||||
test('fewer than 5 games uses all available for recency', () => {
|
||||
const r = pe.estimateProbability({
|
||||
gameLogs: logsAt([30, 28]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
});
|
||||
expect(r.p_over).toBeGreaterThan(0.5);
|
||||
});
|
||||
|
||||
test('returns nulls on empty input', () => {
|
||||
const r = pe.estimateProbability({ gameLogs: [], line: 25.5, statType: 'points' });
|
||||
expect(r.p_over).toBeNull();
|
||||
expect(r.reason).toBe('insufficient_data');
|
||||
});
|
||||
|
||||
test('all-push sample returns reason all_pushes', () => {
|
||||
const r = pe.estimateProbability({
|
||||
gameLogs: logsAt([25.5, 25.5, 25.5]),
|
||||
line: 25.5,
|
||||
statType: 'points',
|
||||
});
|
||||
expect(r.p_over).toBeNull();
|
||||
expect(r.reason).toBe('all_pushes');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,69 @@
|
||||
process.env.PROPODDS_KEY = 'test-key';
|
||||
process.env.PROPODDS_BASE_URL = 'https://api.propodds.test/v1';
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args) }));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
const adapter = require('../../src/services/adapters/propOddsAdapter');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('propOddsAdapter.configured', () => {
|
||||
test('reflects PROPODDS_KEY presence', () => {
|
||||
expect(adapter.configured()).toBe(true);
|
||||
delete process.env.PROPODDS_KEY;
|
||||
expect(adapter.configured()).toBe(false);
|
||||
process.env.PROPODDS_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('propOddsAdapter.getPlayerProps', () => {
|
||||
test('normalizes player props with devig', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
props: [
|
||||
{ book: 'dk', player: 'LeBron', market: 'points', line: 25.5, over_odds: -110, under_odds: -110 },
|
||||
],
|
||||
},
|
||||
});
|
||||
const result = await adapter.getPlayerProps('nba', 'g1', 'LeBron', 'points');
|
||||
expect(result[0]).toMatchObject({ book: 'dk', player: 'LeBron', statType: 'points', line: 25.5 });
|
||||
expect(result[0].fairOver).toBeCloseTo(0.5, 5);
|
||||
});
|
||||
|
||||
test('api_key embeds in query, never logged', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { props: [] } });
|
||||
await adapter.getPlayerProps('nba', 'gx', null, null);
|
||||
expect(mockAxiosGet).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
expect.objectContaining({ params: expect.objectContaining({ api_key: 'test-key' }) }),
|
||||
);
|
||||
});
|
||||
|
||||
test('429 falls back to stale cache', async () => {
|
||||
mockCache.current.set('propodds:nba:g-stale:all:all', {
|
||||
props: [{ book: 'dk', player: 'Old', market: 'points', line: 20, over_odds: -110, under_odds: -110 }],
|
||||
stale: true,
|
||||
});
|
||||
mockAxiosGet.mockResolvedValue({ status: 429, data: {} });
|
||||
const result = await adapter.getPlayerProps('nba', 'g-stale', null, null);
|
||||
expect(result.stale).toBe(true);
|
||||
});
|
||||
|
||||
test('returns [] when unconfigured', async () => {
|
||||
delete process.env.PROPODDS_KEY;
|
||||
expect(await adapter.getPlayerProps('nba', 'g1', null, null)).toEqual([]);
|
||||
process.env.PROPODDS_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,89 @@
|
||||
const { createLimiter, createCircuitBreaker, API_BUDGETS } = require('../../src/utils/rateLimiter');
|
||||
|
||||
describe('createLimiter', () => {
|
||||
test('first N tokens within capacity resolve immediately', async () => {
|
||||
const limiter = createLimiter({ tokensPerInterval: 3, interval: 60_000 });
|
||||
const start = Date.now();
|
||||
expect(await limiter.waitForToken()).toBe(true);
|
||||
expect(await limiter.waitForToken()).toBe(true);
|
||||
expect(await limiter.waitForToken()).toBe(true);
|
||||
expect(Date.now() - start).toBeLessThan(100);
|
||||
});
|
||||
|
||||
test('fourth token in a small bucket waits for refill', async () => {
|
||||
const limiter = createLimiter({ tokensPerInterval: 2, interval: 200 });
|
||||
expect(await limiter.waitForToken()).toBe(true);
|
||||
expect(await limiter.waitForToken()).toBe(true);
|
||||
const start = Date.now();
|
||||
expect(await limiter.waitForToken(2_000)).toBe(true);
|
||||
const elapsed = Date.now() - start;
|
||||
// Should take roughly interval/tokens = 100ms before refill yields one.
|
||||
expect(elapsed).toBeGreaterThan(50);
|
||||
expect(elapsed).toBeLessThan(500);
|
||||
});
|
||||
|
||||
test('timeout returns false (does not throw) so caller can proceed', async () => {
|
||||
const limiter = createLimiter({ tokensPerInterval: 1, interval: 60_000 });
|
||||
expect(await limiter.waitForToken()).toBe(true); // consume the one token
|
||||
const result = await limiter.waitForToken(120); // wait briefly, then bail
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
|
||||
test('throws on invalid config', () => {
|
||||
expect(() => createLimiter({ tokensPerInterval: 0, interval: 1000 })).toThrow();
|
||||
expect(() => createLimiter({ tokensPerInterval: 1, interval: 0 })).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('createCircuitBreaker', () => {
|
||||
test('closed initially; success resets failure count', async () => {
|
||||
const cb = createCircuitBreaker({ failureThreshold: 2, resetTimeout: 60_000 });
|
||||
const result = await cb.call(async () => 'ok');
|
||||
expect(result).toBe('ok');
|
||||
expect(cb.snapshot().state).toBe('closed');
|
||||
});
|
||||
|
||||
test('opens after threshold failures and rejects further calls', async () => {
|
||||
const cb = createCircuitBreaker({ failureThreshold: 2, resetTimeout: 60_000 });
|
||||
await expect(cb.call(async () => { throw new Error('boom'); })).rejects.toThrow('boom');
|
||||
await expect(cb.call(async () => { throw new Error('boom'); })).rejects.toThrow('boom');
|
||||
expect(cb.snapshot().state).toBe('open');
|
||||
await expect(cb.call(async () => 'should never run')).rejects.toMatchObject({ code: 'CIRCUIT_OPEN' });
|
||||
});
|
||||
|
||||
test('transitions to half-open after resetTimeout, closes on success', async () => {
|
||||
const cb = createCircuitBreaker({ failureThreshold: 1, resetTimeout: 50 });
|
||||
await expect(cb.call(async () => { throw new Error('x'); })).rejects.toThrow();
|
||||
expect(cb.snapshot().state).toBe('open');
|
||||
await new Promise((r) => setTimeout(r, 80));
|
||||
// Reading the snapshot triggers the transition check.
|
||||
expect(cb.snapshot().state).toBe('half_open');
|
||||
const result = await cb.call(async () => 'recovered');
|
||||
expect(result).toBe('recovered');
|
||||
expect(cb.snapshot().state).toBe('closed');
|
||||
});
|
||||
|
||||
test('half-open failure re-opens the circuit immediately', async () => {
|
||||
const cb = createCircuitBreaker({ failureThreshold: 1, resetTimeout: 30 });
|
||||
await expect(cb.call(async () => { throw new Error('first'); })).rejects.toThrow();
|
||||
await new Promise((r) => setTimeout(r, 60));
|
||||
await expect(cb.call(async () => { throw new Error('second'); })).rejects.toThrow('second');
|
||||
expect(cb.snapshot().state).toBe('open');
|
||||
});
|
||||
});
|
||||
|
||||
describe('API_BUDGETS', () => {
|
||||
test('contains the five named upstreams', () => {
|
||||
expect(API_BUDGETS).toMatchObject({
|
||||
sharpApi: { tokensPerInterval: 10, interval: 60_000 },
|
||||
espn: { tokensPerInterval: 2, interval: 60_000 },
|
||||
mlbStats: { tokensPerInterval: 2, interval: 60_000 },
|
||||
oddsPapi: { tokensPerInterval: 5, interval: 60_000 },
|
||||
openRouter: { tokensPerInterval: 15, interval: 60_000 },
|
||||
});
|
||||
});
|
||||
|
||||
test('is frozen — adapters cannot mutate it accidentally', () => {
|
||||
expect(Object.isFrozen(API_BUDGETS)).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,69 @@
|
||||
// Verifies REDIS_URL with embedded password is parsed correctly by
|
||||
// ioredis. Production runs against a Coolify Redis service that requires
|
||||
// auth — a hardcoded localhost fallback or a URL parser that drops the
|
||||
// password would silently fall back to "no auth" and ECONNREFUSED.
|
||||
|
||||
const mockCtor = jest.fn();
|
||||
jest.mock('ioredis', () =>
|
||||
// ioredis is a constructor — record arguments and stub event handlers.
|
||||
jest.fn().mockImplementation((url, opts) => {
|
||||
mockCtor(url, opts);
|
||||
return {
|
||||
on: () => {},
|
||||
ping: async () => 'PONG',
|
||||
};
|
||||
})
|
||||
);
|
||||
|
||||
beforeEach(() => {
|
||||
mockCtor.mockReset();
|
||||
// Clear the cached singleton so each test gets a fresh ctor call.
|
||||
jest.resetModules();
|
||||
});
|
||||
|
||||
describe('redis client URL handling', () => {
|
||||
test('passes REDIS_URL with password through to ioredis verbatim', () => {
|
||||
process.env.REDIS_URL = 'redis://default:s3cret-pass@cache-host:6379/0';
|
||||
const { getRedisClient } = require('../../src/utils/redis');
|
||||
getRedisClient();
|
||||
expect(mockCtor).toHaveBeenCalledTimes(1);
|
||||
expect(mockCtor.mock.calls[0][0]).toBe('redis://default:s3cret-pass@cache-host:6379/0');
|
||||
});
|
||||
|
||||
test('falls back to 127.0.0.1 default when REDIS_URL is unset', () => {
|
||||
delete process.env.REDIS_URL;
|
||||
const { getRedisClient } = require('../../src/utils/redis');
|
||||
getRedisClient();
|
||||
expect(mockCtor.mock.calls[0][0]).toBe('redis://127.0.0.1:6379');
|
||||
});
|
||||
|
||||
test('passes enableOfflineQueue=false so degraded mode fails fast', () => {
|
||||
process.env.REDIS_URL = 'redis://localhost:6379';
|
||||
const { getRedisClient } = require('../../src/utils/redis');
|
||||
getRedisClient();
|
||||
expect(mockCtor.mock.calls[0][1]).toMatchObject({
|
||||
enableOfflineQueue: false,
|
||||
maxRetriesPerRequest: 1,
|
||||
});
|
||||
});
|
||||
|
||||
test('rediss:// TLS scheme passes through (Upstash / managed Redis)', () => {
|
||||
process.env.REDIS_URL = 'rediss://user:t0ken@host.upstash.io:6379';
|
||||
const { getRedisClient } = require('../../src/utils/redis');
|
||||
getRedisClient();
|
||||
expect(mockCtor.mock.calls[0][0]).toBe('rediss://user:t0ken@host.upstash.io:6379');
|
||||
});
|
||||
});
|
||||
|
||||
describe('no hardcoded localhost Redis anywhere else', () => {
|
||||
test('only src/utils/redis.js has the localhost default; nothing else', () => {
|
||||
const { execSync } = require('child_process');
|
||||
const out = execSync(
|
||||
'grep -rn "127.0.0.1.*6379\\|localhost.*6379" /home/kev/mastermind/vyndr/src --include="*.js" || true',
|
||||
).toString();
|
||||
const lines = out.split('\n').filter((l) => l.trim());
|
||||
// Permit only the one fallback inside src/utils/redis.js.
|
||||
const offenders = lines.filter((l) => !l.includes('src/utils/redis.js'));
|
||||
expect(offenders).toEqual([]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,223 @@
|
||||
const {
|
||||
ROLE_TAXONOMY,
|
||||
calculateRoleVariance,
|
||||
getDominantRole,
|
||||
detectRoleElevation,
|
||||
getConditionalProfile,
|
||||
calculateRoleProfile,
|
||||
} = require('../../src/services/roleProfileEngine');
|
||||
|
||||
const {
|
||||
calculateStability,
|
||||
applyDecayWeights,
|
||||
} = require('../../src/services/roleStabilityEngine');
|
||||
|
||||
describe('roleProfileEngine', () => {
|
||||
// ─── calculateRoleVariance ──────────────────────────────────
|
||||
|
||||
test('returns 0 for a single-role profile', () => {
|
||||
const profile = { PRIMARY_BALL_HANDLER: 1.0 };
|
||||
expect(calculateRoleVariance(profile)).toBe(0);
|
||||
});
|
||||
|
||||
test('returns ~1.0 for perfectly equal distribution', () => {
|
||||
const profile = {};
|
||||
for (const role of ROLE_TAXONOMY) {
|
||||
profile[role] = 1 / ROLE_TAXONOMY.length;
|
||||
}
|
||||
const variance = calculateRoleVariance(profile);
|
||||
expect(variance).toBeGreaterThan(0.99);
|
||||
expect(variance).toBeLessThanOrEqual(1.0);
|
||||
});
|
||||
|
||||
test('returns value strictly between 0 and 1 for mixed profile', () => {
|
||||
const profile = {
|
||||
PRIMARY_BALL_HANDLER: 0.50,
|
||||
SECONDARY_PLAYMAKER: 0.30,
|
||||
CONNECTOR: 0.20,
|
||||
};
|
||||
const variance = calculateRoleVariance(profile);
|
||||
expect(variance).toBeGreaterThan(0);
|
||||
expect(variance).toBeLessThan(1);
|
||||
});
|
||||
|
||||
test('handles empty profile gracefully', () => {
|
||||
expect(calculateRoleVariance({})).toBe(0);
|
||||
});
|
||||
|
||||
test('ignores zero-weight roles in entropy calculation', () => {
|
||||
const profileA = { PRIMARY_BALL_HANDLER: 0.5, CONNECTOR: 0.5 };
|
||||
const profileB = {
|
||||
PRIMARY_BALL_HANDLER: 0.5,
|
||||
CONNECTOR: 0.5,
|
||||
FLOOR_RAISER: 0,
|
||||
PAINT_PRESENCE: 0,
|
||||
};
|
||||
// Both should give same result since zeros are filtered
|
||||
expect(calculateRoleVariance(profileA)).toBeCloseTo(calculateRoleVariance(profileB), 5);
|
||||
});
|
||||
|
||||
// ─── getDominantRole ────────────────────────────────────────
|
||||
|
||||
test('returns the role with the highest weight', () => {
|
||||
const profile = {
|
||||
PRIMARY_BALL_HANDLER: 0.15,
|
||||
FLOOR_RAISER: 0.55,
|
||||
CONNECTOR: 0.30,
|
||||
};
|
||||
expect(getDominantRole(profile)).toBe('FLOOR_RAISER');
|
||||
});
|
||||
|
||||
test('returns null for empty profile', () => {
|
||||
expect(getDominantRole({})).toBeNull();
|
||||
});
|
||||
|
||||
// ─── detectRoleElevation ────────────────────────────────────
|
||||
|
||||
test('detects elevation when delta exceeds threshold', () => {
|
||||
const base = {
|
||||
PRIMARY_BALL_HANDLER: 0.20,
|
||||
SECONDARY_PLAYMAKER: 0.50,
|
||||
CONNECTOR: 0.30,
|
||||
};
|
||||
const tonight = {
|
||||
PRIMARY_BALL_HANDLER: 0.60,
|
||||
SECONDARY_PLAYMAKER: 0.25,
|
||||
CONNECTOR: 0.15,
|
||||
};
|
||||
const result = detectRoleElevation(base, tonight, 0.20);
|
||||
expect(result.elevated).toBe(true);
|
||||
expect(result.elevatedRole).toBe('PRIMARY_BALL_HANDLER');
|
||||
expect(result.delta).toBeGreaterThan(0.20);
|
||||
});
|
||||
|
||||
test('does not flag elevation when delta is below threshold', () => {
|
||||
const base = {
|
||||
PRIMARY_BALL_HANDLER: 0.40,
|
||||
SECONDARY_PLAYMAKER: 0.35,
|
||||
CONNECTOR: 0.25,
|
||||
};
|
||||
const tonight = {
|
||||
PRIMARY_BALL_HANDLER: 0.45,
|
||||
SECONDARY_PLAYMAKER: 0.30,
|
||||
CONNECTOR: 0.25,
|
||||
};
|
||||
const result = detectRoleElevation(base, tonight, 0.20);
|
||||
expect(result.elevated).toBe(false);
|
||||
expect(result.elevatedRole).toBeNull();
|
||||
});
|
||||
|
||||
// ─── getConditionalProfile ──────────────────────────────────
|
||||
|
||||
test('returns conditional profile for valid condition', () => {
|
||||
const conditionals = {
|
||||
star_out: { PRIMARY_BALL_HANDLER: 0.70, FLOOR_RAISER: 0.30 },
|
||||
closing_lineup: { SWITCHABLE_DEFENDER: 0.60, CONNECTOR: 0.40 },
|
||||
};
|
||||
const result = getConditionalProfile(conditionals, 'star_out');
|
||||
expect(result).toEqual({ PRIMARY_BALL_HANDLER: 0.70, FLOOR_RAISER: 0.30 });
|
||||
});
|
||||
|
||||
test('returns null for invalid condition key', () => {
|
||||
const conditionals = { star_out: { PRIMARY_BALL_HANDLER: 1.0 } };
|
||||
expect(getConditionalProfile(conditionals, 'garbage_condition')).toBeNull();
|
||||
});
|
||||
|
||||
// ─── calculateRoleProfile ──────────────────────────────────
|
||||
|
||||
test('produces distribution that sums to approximately 1.0', () => {
|
||||
const gameLogStats = [
|
||||
{
|
||||
usage_rate: 28,
|
||||
assist_rate: 32,
|
||||
three_point_share: 40,
|
||||
off_ball_movement: 30,
|
||||
paint_touches: 4,
|
||||
rebounds_per_game: 5,
|
||||
defensive_versatility: 45,
|
||||
screen_assists: 2,
|
||||
},
|
||||
{
|
||||
usage_rate: 30,
|
||||
assist_rate: 35,
|
||||
three_point_share: 38,
|
||||
off_ball_movement: 25,
|
||||
paint_touches: 3,
|
||||
rebounds_per_game: 4.5,
|
||||
defensive_versatility: 50,
|
||||
screen_assists: 3,
|
||||
},
|
||||
];
|
||||
const profile = calculateRoleProfile(gameLogStats);
|
||||
const total = Object.values(profile).reduce((s, v) => s + v, 0);
|
||||
expect(total).toBeGreaterThan(0.95);
|
||||
expect(total).toBeLessThanOrEqual(1.05);
|
||||
});
|
||||
|
||||
test('returns empty object for empty game logs', () => {
|
||||
expect(calculateRoleProfile([])).toEqual({});
|
||||
});
|
||||
});
|
||||
|
||||
describe('roleStabilityEngine', () => {
|
||||
// ─── calculateStability ─────────────────────────────────────
|
||||
|
||||
test('low variance player gets no decay (all weights 1.0)', () => {
|
||||
const profile = { PRIMARY_BALL_HANDLER: 0.85, CONNECTOR: 0.15 };
|
||||
const varianceScore = 0.15; // below 0.2 threshold
|
||||
const history = [
|
||||
{ date: '2026-01-01', roleProfile: { PRIMARY_BALL_HANDLER: 0.85, CONNECTOR: 0.15 } },
|
||||
{ date: '2026-01-05', roleProfile: { PRIMARY_BALL_HANDLER: 0.80, CONNECTOR: 0.20 } },
|
||||
{ date: '2026-01-10', roleProfile: { PRIMARY_BALL_HANDLER: 0.85, CONNECTOR: 0.15 } },
|
||||
];
|
||||
const result = calculateStability(profile, varianceScore, history);
|
||||
// All decay weights should be 1.0
|
||||
expect(result.decay_weights_by_period.every((w) => w === 1.0)).toBe(true);
|
||||
expect(result.stability_score).toBeGreaterThan(0.7);
|
||||
});
|
||||
|
||||
test('high variance player gets recency decay', () => {
|
||||
const profile = {
|
||||
PRIMARY_BALL_HANDLER: 0.30,
|
||||
FLOOR_RAISER: 0.30,
|
||||
CONNECTOR: 0.20,
|
||||
SWITCHABLE_DEFENDER: 0.20,
|
||||
};
|
||||
const varianceScore = 0.65; // above 0.5 threshold
|
||||
const history = [
|
||||
{ date: '2026-01-01', roleProfile: { FLOOR_RAISER: 0.60, CONNECTOR: 0.40 } },
|
||||
{ date: '2026-01-05', roleProfile: { PRIMARY_BALL_HANDLER: 0.50, CONNECTOR: 0.50 } },
|
||||
{ date: '2026-01-10', roleProfile: { SWITCHABLE_DEFENDER: 0.55, FLOOR_RAISER: 0.45 } },
|
||||
{ date: '2026-01-15', roleProfile: { PRIMARY_BALL_HANDLER: 0.30, FLOOR_RAISER: 0.30, CONNECTOR: 0.20, SWITCHABLE_DEFENDER: 0.20 } },
|
||||
];
|
||||
const result = calculateStability(profile, varianceScore, history);
|
||||
// Older entries should have lower weights than newer
|
||||
const weights = result.decay_weights_by_period;
|
||||
expect(weights[weights.length - 1]).toBeGreaterThan(weights[0]);
|
||||
// Should detect role changes
|
||||
expect(result.role_change_events).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('stability score is between 0 and 1', () => {
|
||||
const profile = { PAINT_PRESENCE: 0.70, SWITCHABLE_DEFENDER: 0.30 };
|
||||
const history = [
|
||||
{ date: '2026-01-01', roleProfile: { PAINT_PRESENCE: 0.65, SWITCHABLE_DEFENDER: 0.35 } },
|
||||
{ date: '2026-01-10', roleProfile: { PAINT_PRESENCE: 0.70, SWITCHABLE_DEFENDER: 0.30 } },
|
||||
];
|
||||
const result = calculateStability(profile, 0.35, history);
|
||||
expect(result.stability_score).toBeGreaterThanOrEqual(0);
|
||||
expect(result.stability_score).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
// ─── applyDecayWeights ──────────────────────────────────────
|
||||
|
||||
test('all weights are 1.0 when variance is below 0.2', () => {
|
||||
const instances = [{}, {}, {}, {}, {}];
|
||||
const weights = applyDecayWeights(instances, 0.10);
|
||||
expect(weights).toEqual([1.0, 1.0, 1.0, 1.0, 1.0]);
|
||||
});
|
||||
|
||||
test('returns empty array for empty instances', () => {
|
||||
expect(applyDecayWeights([], 0.6)).toEqual([]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,171 @@
|
||||
const {
|
||||
SCHEME_TYPES,
|
||||
MIN_POSSESSIONS,
|
||||
CACHE_TTL,
|
||||
getCacheKey,
|
||||
extractPnRPossessions,
|
||||
classifyScheme,
|
||||
} = require('../../src/services/schemeClassifier');
|
||||
|
||||
describe('Scheme Classifier', () => {
|
||||
|
||||
// --- Constants ---
|
||||
|
||||
test('SCHEME_TYPES contains all 5 classifications', () => {
|
||||
expect(SCHEME_TYPES).toEqual(['DROP', 'SWITCH', 'HEDGE', 'MIXED', 'UNKNOWN']);
|
||||
});
|
||||
|
||||
test('minimum possessions threshold is 8', () => {
|
||||
expect(MIN_POSSESSIONS).toBe(8);
|
||||
});
|
||||
|
||||
test('cache TTL is 6 hours (21600 seconds)', () => {
|
||||
expect(CACHE_TTL).toBe(21600);
|
||||
});
|
||||
|
||||
// --- Cache Key ---
|
||||
|
||||
test('cache key includes opponent and date', () => {
|
||||
const key = getCacheKey('BOS', '2026-04-12');
|
||||
expect(key).toBe('scheme:BOS:2026-04-12');
|
||||
});
|
||||
|
||||
// --- PnR Extraction ---
|
||||
|
||||
test('extractPnRPossessions identifies pick-and-roll plays', () => {
|
||||
const plays = [
|
||||
{ description: 'LeBron pick and roll ball handler' },
|
||||
{ description: 'AD catches lob pass' },
|
||||
{ description: 'screen and roll coverage by Smart' },
|
||||
{ description: 'transition fastbreak layup' },
|
||||
{ description: 'ball screen switch by Tatum' },
|
||||
];
|
||||
const result = extractPnRPossessions(plays);
|
||||
expect(result).toHaveLength(3);
|
||||
});
|
||||
|
||||
test('extractPnRPossessions handles empty array', () => {
|
||||
expect(extractPnRPossessions([])).toEqual([]);
|
||||
});
|
||||
|
||||
test('extractPnRPossessions handles null/undefined', () => {
|
||||
expect(extractPnRPossessions(null)).toEqual([]);
|
||||
expect(extractPnRPossessions(undefined)).toEqual([]);
|
||||
});
|
||||
|
||||
test('extractPnRPossessions handles play_description field', () => {
|
||||
const plays = [
|
||||
{ play_description: 'PnR ball handler drive' },
|
||||
];
|
||||
const result = extractPnRPossessions(plays);
|
||||
expect(result).toHaveLength(1);
|
||||
});
|
||||
|
||||
// --- Classification ---
|
||||
|
||||
test('classifyScheme returns UNKNOWN with fewer than 8 possessions', () => {
|
||||
const possessions = Array.from({ length: 5 }, () => ({ description: 'drop coverage on screen' }));
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('UNKNOWN');
|
||||
expect(result.reason).toBe('insufficient_data');
|
||||
expect(result.possessions_analyzed).toBe(5);
|
||||
});
|
||||
|
||||
test('classifyScheme returns DROP when drop coverage dominates', () => {
|
||||
const possessions = [
|
||||
...Array.from({ length: 7 }, () => ({ description: 'drop coverage on ball screen' })),
|
||||
{ description: 'switch on screen action' },
|
||||
{ description: 'hedge hard show on pick' },
|
||||
];
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('DROP');
|
||||
expect(result.confidence).toBeGreaterThanOrEqual(55);
|
||||
expect(result.breakdown).toBeDefined();
|
||||
expect(result.breakdown.DROP).toBe(7);
|
||||
});
|
||||
|
||||
test('classifyScheme returns SWITCH when switch dominates', () => {
|
||||
const possessions = [
|
||||
...Array.from({ length: 8 }, () => ({ description: 'switch on screen swap defenders' })),
|
||||
{ description: 'drop back on screen' },
|
||||
{ description: 'drop sag coverage' },
|
||||
];
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('SWITCH');
|
||||
expect(result.confidence).toBeGreaterThanOrEqual(55);
|
||||
});
|
||||
|
||||
test('classifyScheme returns HEDGE when hedge/blitz dominates', () => {
|
||||
const possessions = [
|
||||
...Array.from({ length: 8 }, () => ({ description: 'hedge hard show blitz screen' })),
|
||||
{ description: 'switch on ball screen' },
|
||||
];
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('HEDGE');
|
||||
});
|
||||
|
||||
test('classifyScheme returns MIXED when no scheme exceeds 55%', () => {
|
||||
const possessions = [
|
||||
...Array.from({ length: 4 }, () => ({ description: 'drop coverage on screen' })),
|
||||
...Array.from({ length: 3 }, () => ({ description: 'switch on screen' })),
|
||||
...Array.from({ length: 3 }, () => ({ description: 'hedge trap on ball screen' })),
|
||||
];
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('MIXED');
|
||||
expect(result.breakdown).toBeDefined();
|
||||
});
|
||||
|
||||
test('classifyScheme returns UNKNOWN when no classifiable actions found', () => {
|
||||
const possessions = Array.from({ length: 10 }, () => ({ description: 'generic play action' }));
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('UNKNOWN');
|
||||
expect(result.reason).toBe('no_classifiable_actions');
|
||||
});
|
||||
|
||||
test('classifyScheme handles null possessions', () => {
|
||||
const result = classifyScheme(null);
|
||||
expect(result.scheme).toBe('UNKNOWN');
|
||||
expect(result.reason).toBe('insufficient_data');
|
||||
});
|
||||
|
||||
test('classifyScheme handles empty possessions', () => {
|
||||
const result = classifyScheme([]);
|
||||
expect(result.scheme).toBe('UNKNOWN');
|
||||
expect(result.reason).toBe('insufficient_data');
|
||||
});
|
||||
|
||||
// --- Confidence ---
|
||||
|
||||
test('confidence is a percentage rounded to integer', () => {
|
||||
const possessions = Array.from({ length: 10 }, () => ({ description: 'drop coverage sag back' }));
|
||||
const result = classifyScheme(possessions);
|
||||
expect(Number.isInteger(result.confidence)).toBe(true);
|
||||
expect(result.confidence).toBeGreaterThanOrEqual(0);
|
||||
expect(result.confidence).toBeLessThanOrEqual(100);
|
||||
});
|
||||
|
||||
// --- Breakdown ---
|
||||
|
||||
test('breakdown counts sum correctly', () => {
|
||||
const possessions = [
|
||||
...Array.from({ length: 5 }, () => ({ description: 'drop coverage on screen' })),
|
||||
...Array.from({ length: 2 }, () => ({ description: 'switch on ball screen' })),
|
||||
...Array.from({ length: 2 }, () => ({ description: 'hedge trap blitz' })),
|
||||
];
|
||||
const result = classifyScheme(possessions);
|
||||
const { DROP, SWITCH, HEDGE } = result.breakdown;
|
||||
expect(DROP).toBe(5);
|
||||
expect(SWITCH).toBe(2);
|
||||
expect(HEDGE).toBe(2);
|
||||
});
|
||||
|
||||
// --- Graceful Degradation ---
|
||||
|
||||
test('scheme result always contains required fields', () => {
|
||||
const result = classifyScheme(null);
|
||||
expect(result).toHaveProperty('scheme');
|
||||
expect(result).toHaveProperty('confidence');
|
||||
expect(result).toHaveProperty('possessions_analyzed');
|
||||
expect(SCHEME_TYPES).toContain(result.scheme);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,509 @@
|
||||
/**
|
||||
* VYNDR Security Audit Tests
|
||||
* Pure logic tests — inline constants and validation logic.
|
||||
* 45 tests across JWT, input validation, image validation, parlay,
|
||||
* security headers, error handling, real IP, CORS, env check,
|
||||
* security logger, digest, source scan, and migration.
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Inline helpers (mirrors production logic without importing app code)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const JWT_SECRET = 'test-secret-256bit-minimum-length-ok';
|
||||
const INTERNAL_KEY = 'VYNDR_INTERNAL_abc123';
|
||||
|
||||
function parseJwt(token) {
|
||||
try {
|
||||
const parts = token.split('.');
|
||||
if (parts.length !== 3) return null;
|
||||
const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
|
||||
return payload;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function makeJwt(payload, expiresInSec = 3600) {
|
||||
const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url');
|
||||
const now = Math.floor(Date.now() / 1000);
|
||||
const body = Buffer.from(JSON.stringify({
|
||||
...payload,
|
||||
iat: now,
|
||||
exp: now + expiresInSec,
|
||||
})).toString('base64url');
|
||||
const sig = Buffer.from('fake-sig').toString('base64url');
|
||||
return `${header}.${body}.${sig}`;
|
||||
}
|
||||
|
||||
function extractBearer(authHeader) {
|
||||
if (!authHeader) return { status: 401, error: 'Missing Authorization header' };
|
||||
if (!authHeader.startsWith('Bearer ')) return { status: 401, error: 'Malformed Bearer token' };
|
||||
const token = authHeader.slice(7).trim();
|
||||
if (!token) return { status: 401, error: 'Empty token' };
|
||||
const payload = parseJwt(token);
|
||||
if (!payload) return { status: 401, error: 'Invalid token' };
|
||||
if (payload.exp && payload.exp < Math.floor(Date.now() / 1000)) return null;
|
||||
return payload;
|
||||
}
|
||||
|
||||
function verifyIssuer(payload, expectedIssuer) {
|
||||
if (!payload || payload.iss !== expectedIssuer) return null;
|
||||
return payload;
|
||||
}
|
||||
|
||||
function verifyInternalKey(key) {
|
||||
return key === INTERNAL_KEY;
|
||||
}
|
||||
|
||||
const VALID_STAT_TYPES = [
|
||||
'points', 'rebounds', 'assists', 'threes', 'steals', 'blocks',
|
||||
'turnovers', 'pts_rebs_asts', 'pts_rebs', 'pts_asts', 'rebs_asts',
|
||||
'strikeouts', 'hits', 'home_runs', 'rbi', 'bases', 'outs',
|
||||
];
|
||||
|
||||
function sanitize(val) {
|
||||
return val.replace(/[;'"\\`]/g, '').replace(/<[^>]+>/g, '').trim().slice(0, 100);
|
||||
}
|
||||
|
||||
function validateGradeRequest(body) {
|
||||
const errors = [];
|
||||
if (!body.player_name) errors.push('player_name is required');
|
||||
if (body.stat_type && !VALID_STAT_TYPES.includes(body.stat_type)) {
|
||||
errors.push(`Invalid stat_type: ${body.stat_type}`);
|
||||
}
|
||||
if (body.line !== undefined) {
|
||||
if (body.line > 500) errors.push('Line out of range (max 500)');
|
||||
if (body.line < 0) errors.push('Line cannot be negative');
|
||||
}
|
||||
if (body.over_under && !['over', 'under'].includes(body.over_under)) {
|
||||
errors.push('over_under must be "over" or "under"');
|
||||
}
|
||||
if (body.player_name && body.player_name.length > 100) {
|
||||
errors.push('player_name exceeds max length of 100');
|
||||
}
|
||||
return errors.length ? { valid: false, errors } : { valid: true };
|
||||
}
|
||||
|
||||
function detectSqlInjection(input) {
|
||||
const patterns = [/drop\s+table/i, /;\s*delete/i, /union\s+select/i, /or\s+1\s*=\s*1/i];
|
||||
return patterns.some((p) => p.test(input));
|
||||
}
|
||||
|
||||
function validateImageMagicBytes(buffer) {
|
||||
if (buffer.length < 4) return false;
|
||||
// PNG
|
||||
if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) return true;
|
||||
// JPEG
|
||||
if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
function isExecutable(buffer) {
|
||||
if (buffer.length < 2) return false;
|
||||
return buffer[0] === 0x4d && buffer[1] === 0x5a; // MZ header
|
||||
}
|
||||
|
||||
const MAX_IMAGE_SIZE = 10 * 1024 * 1024; // 10 MB
|
||||
|
||||
function validateParlayLegs(legs) {
|
||||
if (!Array.isArray(legs) || legs.length < 2) return { valid: false, error: 'Minimum 2 legs required' };
|
||||
if (legs.length > 12) return { valid: false, error: 'Maximum 12 legs allowed' };
|
||||
for (let i = 0; i < legs.length; i++) {
|
||||
if (!legs[i].player_name || !legs[i].stat_type) {
|
||||
return { valid: false, error: `Leg ${i + 1} must have player_name and stat_type` };
|
||||
}
|
||||
}
|
||||
return { valid: true };
|
||||
}
|
||||
|
||||
function getSecurityHeaders() {
|
||||
return {
|
||||
'X-Frame-Options': 'DENY',
|
||||
'X-Content-Type-Options': 'nosniff',
|
||||
'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
|
||||
'Content-Security-Policy': "default-src 'self'",
|
||||
};
|
||||
}
|
||||
|
||||
function productionErrorHandler(err) {
|
||||
return { status: err.status || 500, body: { error: 'Internal server error' } };
|
||||
}
|
||||
|
||||
function notFoundHandler() {
|
||||
return { status: 404, body: { error: 'Endpoint not found' } };
|
||||
}
|
||||
|
||||
function rateLimitHandler() {
|
||||
return { status: 429, body: { error: 'Rate limit exceeded' } };
|
||||
}
|
||||
|
||||
function extractRealIp(headers) {
|
||||
if (headers['x-forwarded-for']) {
|
||||
return headers['x-forwarded-for'].split(',')[0].trim();
|
||||
}
|
||||
return headers.remote_addr || '127.0.0.1';
|
||||
}
|
||||
|
||||
function parseAllowedOrigins(envVar) {
|
||||
if (!envVar) return ['http://localhost:3000'];
|
||||
return envVar.split(',').map((o) => o.trim());
|
||||
}
|
||||
|
||||
function checkEnvVars(env, required, recommended) {
|
||||
const errors = [];
|
||||
const warnings = [];
|
||||
for (const v of required) {
|
||||
if (!env[v]) errors.push(`Missing required env var: ${v}`);
|
||||
}
|
||||
for (const v of recommended) {
|
||||
if (!env[v]) warnings.push(`Missing recommended env var: ${v}`);
|
||||
}
|
||||
return { errors, warnings, shouldExit: errors.length > 0 };
|
||||
}
|
||||
|
||||
function detectSqlInjectionInBody(body) {
|
||||
const str = JSON.stringify(body);
|
||||
return /drop\s+table/i.test(str) || /;\s*delete/i.test(str) || /union\s+select/i.test(str);
|
||||
}
|
||||
|
||||
const RATE_ABUSE_THRESHOLD = 100; // req per min
|
||||
const RETENTION_DAYS = 90;
|
||||
|
||||
function buildSecurityDigest(events) {
|
||||
const ipCounts = {};
|
||||
const typeCounts = {};
|
||||
for (const e of events) {
|
||||
ipCounts[e.ip_address] = (ipCounts[e.ip_address] || 0) + 1;
|
||||
typeCounts[e.event_type] = (typeCounts[e.event_type] || 0) + 1;
|
||||
}
|
||||
const flaggedIps = Object.entries(ipCounts)
|
||||
.filter(([, c]) => c >= 50)
|
||||
.map(([ip]) => ip);
|
||||
return { flaggedIps, typeCounts };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe('JWT Auth', () => {
|
||||
test('1 — valid JWT with Bearer prefix returns payload', () => {
|
||||
const token = makeJwt({ sub: 'user-123', iss: 'vyndr' });
|
||||
const result = extractBearer(`Bearer ${token}`);
|
||||
expect(result).not.toBeNull();
|
||||
expect(result.sub).toBe('user-123');
|
||||
});
|
||||
|
||||
test('2 — expired JWT returns null', () => {
|
||||
const token = makeJwt({ sub: 'user-123' }, -100); // expired 100s ago
|
||||
const result = extractBearer(`Bearer ${token}`);
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('3 — missing Authorization header returns 401 shape', () => {
|
||||
const result = extractBearer(undefined);
|
||||
expect(result).toEqual({ status: 401, error: 'Missing Authorization header' });
|
||||
});
|
||||
|
||||
test('4 — malformed Bearer token (no space) returns 401 shape', () => {
|
||||
const result = extractBearer('Bearertoken123');
|
||||
expect(result).toEqual({ status: 401, error: 'Malformed Bearer token' });
|
||||
});
|
||||
|
||||
test('5 — empty token returns 401 shape', () => {
|
||||
const result = extractBearer('Bearer ');
|
||||
expect(result).toEqual({ status: 401, error: 'Empty token' });
|
||||
});
|
||||
|
||||
test('6 — JWT issuer verification rejects wrong issuer', () => {
|
||||
const payload = { sub: 'user-123', iss: 'other-service' };
|
||||
const result = verifyIssuer(payload, 'vyndr');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('7 — internal key auth passes with valid key', () => {
|
||||
expect(verifyInternalKey(INTERNAL_KEY)).toBe(true);
|
||||
expect(verifyInternalKey('wrong-key')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Input Validation', () => {
|
||||
test('8 — valid grade request passes validation', () => {
|
||||
const result = validateGradeRequest({
|
||||
player_name: 'LeBron James',
|
||||
stat_type: 'points',
|
||||
line: 25.5,
|
||||
over_under: 'over',
|
||||
});
|
||||
expect(result.valid).toBe(true);
|
||||
});
|
||||
|
||||
test('9 — missing player_name returns error', () => {
|
||||
const result = validateGradeRequest({ stat_type: 'points', line: 25.5 });
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.errors).toContain('player_name is required');
|
||||
});
|
||||
|
||||
test('10 — invalid stat_type returns error', () => {
|
||||
const result = validateGradeRequest({ player_name: 'LeBron', stat_type: 'fake_stat' });
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.errors[0]).toMatch(/Invalid stat_type/);
|
||||
});
|
||||
|
||||
test('11 — line out of range (>500) returns error', () => {
|
||||
const result = validateGradeRequest({ player_name: 'LeBron', line: 501 });
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.errors).toContain('Line out of range (max 500)');
|
||||
});
|
||||
|
||||
test('12 — negative line returns error', () => {
|
||||
const result = validateGradeRequest({ player_name: 'LeBron', line: -5 });
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.errors).toContain('Line cannot be negative');
|
||||
});
|
||||
|
||||
test('13 — over_under must be over or under', () => {
|
||||
const result = validateGradeRequest({ player_name: 'LeBron', over_under: 'sideways' });
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.errors[0]).toMatch(/over_under/);
|
||||
});
|
||||
|
||||
test('14 — SQL injection chars stripped from player_name', () => {
|
||||
expect(sanitize("LeBron'; DROP TABLE users;--")).toBe('LeBron DROP TABLE users--');
|
||||
});
|
||||
|
||||
test('15 — HTML tags stripped from input', () => {
|
||||
expect(sanitize('LeBron<script>alert(1)</script>James')).toBe('LeBronalert(1)James');
|
||||
});
|
||||
|
||||
test('16 — player name max length 100 enforced', () => {
|
||||
const long = 'A'.repeat(200);
|
||||
expect(sanitize(long).length).toBe(100);
|
||||
});
|
||||
|
||||
test('17 — SQL injection pattern "drop table" detected', () => {
|
||||
expect(detectSqlInjection('DROP TABLE users')).toBe(true);
|
||||
expect(detectSqlInjection('LeBron James')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Image Validation', () => {
|
||||
test('18 — PNG magic bytes accepted', () => {
|
||||
const buf = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
|
||||
expect(validateImageMagicBytes(buf)).toBe(true);
|
||||
});
|
||||
|
||||
test('19 — JPEG magic bytes accepted', () => {
|
||||
const buf = Buffer.from([0xff, 0xd8, 0xff, 0xe0]);
|
||||
expect(validateImageMagicBytes(buf)).toBe(true);
|
||||
});
|
||||
|
||||
test('20 — executable file (MZ header) rejected', () => {
|
||||
const buf = Buffer.from([0x4d, 0x5a, 0x90, 0x00]);
|
||||
expect(validateImageMagicBytes(buf)).toBe(false);
|
||||
expect(isExecutable(buf)).toBe(true);
|
||||
});
|
||||
|
||||
test('21 — oversized file (>10MB) rejected', () => {
|
||||
const size = 11 * 1024 * 1024;
|
||||
expect(size > MAX_IMAGE_SIZE).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Parlay Validation', () => {
|
||||
test('22 — minimum 2 legs required', () => {
|
||||
const result = validateParlayLegs([{ player_name: 'LeBron', stat_type: 'points' }]);
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.error).toMatch(/Minimum 2 legs/);
|
||||
});
|
||||
|
||||
test('23 — maximum 12 legs enforced', () => {
|
||||
const legs = Array.from({ length: 13 }, () => ({ player_name: 'X', stat_type: 'points' }));
|
||||
const result = validateParlayLegs(legs);
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.error).toMatch(/Maximum 12 legs/);
|
||||
});
|
||||
|
||||
test('24 — each leg must have player_name and stat_type', () => {
|
||||
const legs = [
|
||||
{ player_name: 'LeBron', stat_type: 'points' },
|
||||
{ player_name: 'Steph' }, // missing stat_type
|
||||
];
|
||||
const result = validateParlayLegs(legs);
|
||||
expect(result.valid).toBe(false);
|
||||
expect(result.error).toMatch(/Leg 2 must have/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Security Headers', () => {
|
||||
const headers = getSecurityHeaders();
|
||||
|
||||
test('25 — X-Frame-Options is DENY', () => {
|
||||
expect(headers['X-Frame-Options']).toBe('DENY');
|
||||
});
|
||||
|
||||
test('26 — X-Content-Type-Options is nosniff', () => {
|
||||
expect(headers['X-Content-Type-Options']).toBe('nosniff');
|
||||
});
|
||||
|
||||
test('27 — Strict-Transport-Security present', () => {
|
||||
expect(headers['Strict-Transport-Security']).toBeDefined();
|
||||
expect(headers['Strict-Transport-Security']).toMatch(/max-age=/);
|
||||
});
|
||||
|
||||
test('28 — Content-Security-Policy present', () => {
|
||||
expect(headers['Content-Security-Policy']).toBeDefined();
|
||||
expect(headers['Content-Security-Policy']).toContain("default-src");
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error Handling', () => {
|
||||
test('29 — production error handler returns generic message (no stack trace)', () => {
|
||||
const err = new Error('secret DB password in stack');
|
||||
err.status = 500;
|
||||
const response = productionErrorHandler(err);
|
||||
expect(response.body.error).toBe('Internal server error');
|
||||
expect(JSON.stringify(response.body)).not.toContain('stack');
|
||||
expect(JSON.stringify(response.body)).not.toContain('secret DB password');
|
||||
});
|
||||
|
||||
test('30 — 404 returns JSON with Endpoint not found', () => {
|
||||
const response = notFoundHandler();
|
||||
expect(response.status).toBe(404);
|
||||
expect(response.body.error).toBe('Endpoint not found');
|
||||
});
|
||||
|
||||
test('31 — 429 returns JSON with Rate limit exceeded', () => {
|
||||
const response = rateLimitHandler();
|
||||
expect(response.status).toBe(429);
|
||||
expect(response.body.error).toBe('Rate limit exceeded');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Real IP Extraction', () => {
|
||||
test('32 — X-Forwarded-For first IP extracted correctly', () => {
|
||||
const ip = extractRealIp({ 'x-forwarded-for': '203.0.113.50, 70.41.3.18, 150.172.238.178' });
|
||||
expect(ip).toBe('203.0.113.50');
|
||||
});
|
||||
|
||||
test('33 — falls back to remote_addr when no forwarded header', () => {
|
||||
const ip = extractRealIp({ remote_addr: '10.0.0.1' });
|
||||
expect(ip).toBe('10.0.0.1');
|
||||
});
|
||||
});
|
||||
|
||||
describe('CORS', () => {
|
||||
test('34 — ALLOWED_ORIGINS parsed from comma-separated env var', () => {
|
||||
const origins = parseAllowedOrigins('https://vyndr.app, https://app.vyndr.app');
|
||||
expect(origins).toEqual(['https://vyndr.app', 'https://app.vyndr.app']);
|
||||
});
|
||||
|
||||
test('35 — default origin is localhost:3000', () => {
|
||||
const origins = parseAllowedOrigins(undefined);
|
||||
expect(origins).toEqual(['http://localhost:3000']);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Environment Check', () => {
|
||||
test('36 — missing required var flagged', () => {
|
||||
const result = checkEnvVars({}, ['DATABASE_URL', 'JWT_SECRET'], []);
|
||||
expect(result.errors.length).toBe(2);
|
||||
expect(result.shouldExit).toBe(true);
|
||||
});
|
||||
|
||||
test('37 — missing recommended var warns but does not exit', () => {
|
||||
const result = checkEnvVars(
|
||||
{ DATABASE_URL: 'postgres://...' },
|
||||
['DATABASE_URL'],
|
||||
['SENTRY_DSN'],
|
||||
);
|
||||
expect(result.errors.length).toBe(0);
|
||||
expect(result.warnings.length).toBe(1);
|
||||
expect(result.shouldExit).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Security Logger', () => {
|
||||
test('38 — SQL injection pattern detected in request body', () => {
|
||||
const body = { player_name: "LeBron'; DROP TABLE users;--" };
|
||||
expect(detectSqlInjectionInBody(body)).toBe(true);
|
||||
});
|
||||
|
||||
test('39 — rate abuse threshold is 100 req/min', () => {
|
||||
expect(RATE_ABUSE_THRESHOLD).toBe(100);
|
||||
});
|
||||
|
||||
test('40 — security event cleanup uses 90-day retention', () => {
|
||||
expect(RETENTION_DAYS).toBe(90);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Security Digest', () => {
|
||||
test('41 — digest flags IPs with 50+ events', () => {
|
||||
const events = Array.from({ length: 55 }, (_, i) => ({
|
||||
ip_address: '203.0.113.50',
|
||||
event_type: 'sql_injection',
|
||||
}));
|
||||
events.push({ ip_address: '10.0.0.1', event_type: 'rate_limit' });
|
||||
const digest = buildSecurityDigest(events);
|
||||
expect(digest.flaggedIps).toContain('203.0.113.50');
|
||||
expect(digest.flaggedIps).not.toContain('10.0.0.1');
|
||||
});
|
||||
|
||||
test('42 — digest counts events by type', () => {
|
||||
const events = [
|
||||
{ ip_address: '1.1.1.1', event_type: 'sql_injection' },
|
||||
{ ip_address: '1.1.1.1', event_type: 'sql_injection' },
|
||||
{ ip_address: '2.2.2.2', event_type: 'rate_limit' },
|
||||
];
|
||||
const digest = buildSecurityDigest(events);
|
||||
expect(digest.typeCounts.sql_injection).toBe(2);
|
||||
expect(digest.typeCounts.rate_limit).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Source Code Scan', () => {
|
||||
test('43 — no sk_live_ found in any source file', () => {
|
||||
function scan(dir) {
|
||||
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
||||
for (const e of entries) {
|
||||
if (['node_modules', '.git', '__pycache__', '.next'].includes(e.name)) continue;
|
||||
const full = path.join(dir, e.name);
|
||||
if (e.isDirectory()) scan(full);
|
||||
else if (/\.(py|js|ts|json|yml)$/.test(e.name)) {
|
||||
const content = fs.readFileSync(full, 'utf8');
|
||||
expect(content).not.toContain('sk_live_');
|
||||
}
|
||||
}
|
||||
}
|
||||
scan(path.join(__dirname, '../../src'));
|
||||
});
|
||||
|
||||
test('44 — .gitignore includes critical patterns', () => {
|
||||
const gitignore = fs.readFileSync(path.join(__dirname, '../../.gitignore'), 'utf8');
|
||||
expect(gitignore).toContain('.env');
|
||||
expect(gitignore).toContain('.env.local');
|
||||
expect(gitignore).toContain('.env.production');
|
||||
expect(gitignore).toContain('*.pem');
|
||||
expect(gitignore).toContain('*.key');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Migration 010', () => {
|
||||
test('45 — creates security_events table with RLS', () => {
|
||||
const sql = fs.readFileSync(
|
||||
path.join(__dirname, '../../supabase/migrations/010_security_events.sql'),
|
||||
'utf8',
|
||||
);
|
||||
expect(sql).toContain('CREATE TABLE');
|
||||
expect(sql).toContain('security_events');
|
||||
expect(sql).toContain('ENABLE ROW LEVEL SECURITY');
|
||||
expect(sql).toContain('event_type');
|
||||
expect(sql).toContain('ip_address');
|
||||
expect(sql).toContain('created_at');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,123 @@
|
||||
process.env.SHARPAPI_KEY = 'test-key';
|
||||
process.env.SHARPAPI_BASE_URL = 'https://api.sharpapi.test/v1';
|
||||
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({
|
||||
get: (...args) => mockAxiosGet(...args),
|
||||
}));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
const adapter = require('../../src/services/adapters/sharpApiAdapter');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('sharpApiAdapter.configured', () => {
|
||||
test('reflects SHARPAPI_KEY env presence', () => {
|
||||
expect(adapter.configured()).toBe(true);
|
||||
delete process.env.SHARPAPI_KEY;
|
||||
expect(adapter.configured()).toBe(false);
|
||||
process.env.SHARPAPI_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('getPlayerProps', () => {
|
||||
test('throws on unsupported sport', async () => {
|
||||
await expect(adapter.getPlayerProps('curling', 'g1')).rejects.toThrow(/Unsupported sport/);
|
||||
});
|
||||
|
||||
test('normalizes the response and computes fair probabilities', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
props: [
|
||||
{ book: 'dk', player: 'LeBron James', stat_type: 'points', line: 25.5, over_price: -110, under_price: -110 },
|
||||
],
|
||||
},
|
||||
});
|
||||
const result = await adapter.getPlayerProps('nba', 'game-1');
|
||||
expect(result).toHaveLength(1);
|
||||
expect(result[0]).toMatchObject({ book: 'dk', player: 'LeBron James', statType: 'points', line: 25.5 });
|
||||
expect(result[0].fairOver).toBeCloseTo(0.5, 5);
|
||||
expect(result[0].fairUnder).toBeCloseTo(0.5, 5);
|
||||
});
|
||||
|
||||
test('cache hit on second call avoids a second request', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { props: [] } });
|
||||
await adapter.getPlayerProps('nba', 'game-cache');
|
||||
await adapter.getPlayerProps('nba', 'game-cache');
|
||||
expect(mockAxiosGet).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test('429 response serves prior stale cache marked stale:true', async () => {
|
||||
// Simulate "cache exists but is already stale" — in production this is
|
||||
// what an expired-EX Redis entry plus a previous 429 retention path
|
||||
// would look like. The mock cache doesn't expire so we mark it stale
|
||||
// directly to force the refresh branch.
|
||||
mockCache.current.set('odds:nba:game-stale:player_props', {
|
||||
props: [{ book: 'dk', player: 'Old', stat_type: 'points', line: 20, over_price: -110, under_price: -110 }],
|
||||
stale: true,
|
||||
});
|
||||
mockAxiosGet.mockResolvedValue({ status: 429, data: {} });
|
||||
const result = await adapter.getPlayerProps('nba', 'game-stale');
|
||||
expect(result.stale).toBe(true);
|
||||
expect(result).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getGameOdds', () => {
|
||||
test('returns spread/total/moneyline shape', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: { spread: { home: -3.5 }, total: { line: 220.5 }, h2h: { home: -150 } },
|
||||
});
|
||||
const result = await adapter.getGameOdds('nba', 'g99');
|
||||
expect(result).toMatchObject({
|
||||
spread: { home: -3.5 },
|
||||
total: { line: 220.5 },
|
||||
moneyline: { home: -150 },
|
||||
});
|
||||
});
|
||||
|
||||
test('returns null when adapter is unconfigured', async () => {
|
||||
delete process.env.SHARPAPI_KEY;
|
||||
const result = await adapter.getGameOdds('nba', 'g99');
|
||||
expect(result).toBeNull();
|
||||
process.env.SHARPAPI_KEY = 'test-key';
|
||||
});
|
||||
});
|
||||
|
||||
describe('getConsensusLine', () => {
|
||||
test('returns median/min/max across books, ignoring unrelated props', async () => {
|
||||
mockAxiosGet.mockResolvedValue({
|
||||
status: 200,
|
||||
data: {
|
||||
props: [
|
||||
{ book: 'dk', player: 'Anthony Edwards', stat_type: 'points', line: 27.5, over_price: -115, under_price: -105 },
|
||||
{ book: 'fd', player: 'Anthony Edwards', stat_type: 'points', line: 28.5, over_price: -110, under_price: -110 },
|
||||
{ book: 'mgm', player: 'Anthony Edwards', stat_type: 'points', line: 27.0, over_price: -120, under_price: +100 },
|
||||
{ book: 'dk', player: 'Different Player', stat_type: 'points', line: 99.0 }, // ignored
|
||||
],
|
||||
},
|
||||
});
|
||||
const consensus = await adapter.getConsensusLine('nba', 'g-c', 'Anthony Edwards', 'points');
|
||||
expect(consensus.bookCount).toBe(3);
|
||||
expect(consensus.median).toBe(27.5);
|
||||
expect(consensus.min).toBe(27.0);
|
||||
expect(consensus.max).toBe(28.5);
|
||||
});
|
||||
|
||||
test('returns null when no matching prop', async () => {
|
||||
mockAxiosGet.mockResolvedValue({ status: 200, data: { props: [] } });
|
||||
const result = await adapter.getConsensusLine('nba', 'g-x', 'Ghost', 'points');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,395 @@
|
||||
/**
|
||||
* VYNDR Ship Build — Data Source Component Tests
|
||||
* Pure logic tests with inline data shapes and parsing logic.
|
||||
*/
|
||||
|
||||
// ─── Inline Data Shapes ───────────────────────────────────────────────
|
||||
|
||||
const STARTING_TRUST = {
|
||||
beat_writer: 'reliable',
|
||||
national: 'authoritative',
|
||||
aggregator: 'unverified',
|
||||
insider: 'reliable',
|
||||
};
|
||||
|
||||
const REPORTER_DATABASE = {
|
||||
nba: {
|
||||
shams_charania: { name: 'Shams Charania', source_type: 'insider', trust: 'reliable' },
|
||||
woj: { name: 'Adrian Wojnarowski', source_type: 'national', trust: 'authoritative' },
|
||||
local_beat: { name: 'Local Beat Writer', source_type: 'beat_writer', trust: 'reliable' },
|
||||
},
|
||||
};
|
||||
|
||||
const TRUST_LEVELS = ['unverified', 'reliable', 'verified', 'authoritative'];
|
||||
|
||||
function escalateTrust(reporter) {
|
||||
const { tracked, accuracy } = reporter;
|
||||
if (tracked >= 30 && accuracy >= 0.95) return { level: 'authoritative', badge: 'confirmed' };
|
||||
if (tracked >= 20 && accuracy >= 0.90) return { level: 'verified', badge: 'trusted' };
|
||||
return { level: reporter.trust, badge: null };
|
||||
}
|
||||
|
||||
// ─── Tweet Parsing ────────────────────────────────────────────────────
|
||||
|
||||
const STATUS_PATTERNS = [
|
||||
{ pattern: /will start/i, status: 'confirmed_playing', confidence: 0.85 },
|
||||
{ pattern: /scratched/i, status: 'scratched', confidence: 0.90 },
|
||||
{ pattern: /game[- ]time decision/i, status: 'questionable', confidence: 0.70 },
|
||||
{ pattern: /\bOUT\b/, status: 'out', confidence: 0.90 },
|
||||
];
|
||||
|
||||
const PAST_TENSE_FILTERS = [/was out/i, /yesterday/i, /last night/i];
|
||||
|
||||
function parseTweet(text) {
|
||||
if (!text) return null;
|
||||
for (const filter of PAST_TENSE_FILTERS) {
|
||||
if (filter.test(text)) return null;
|
||||
}
|
||||
for (const { pattern, status, confidence } of STATUS_PATTERNS) {
|
||||
if (pattern.test(text)) return { status, confidence };
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// ─── Odds API Parsing ─────────────────────────────────────────────────
|
||||
|
||||
function parseOddsOutcome(market, bookmakerKey) {
|
||||
if (!market || !market.outcomes || market.outcomes.length === 0) {
|
||||
return null;
|
||||
}
|
||||
const outcome = market.outcomes[0];
|
||||
return {
|
||||
player_name: outcome.name || null,
|
||||
line: outcome.point != null ? outcome.point : null,
|
||||
bookmaker: bookmakerKey,
|
||||
};
|
||||
}
|
||||
|
||||
// ─── Line Movement Detection ──────────────────────────────────────────
|
||||
|
||||
function detectLineMovement(opening, current) {
|
||||
const diff = Math.abs(current - opening);
|
||||
if (diff < 0.5) return null;
|
||||
return {
|
||||
movement: diff,
|
||||
direction: current > opening ? 'up' : 'down',
|
||||
flagged: true,
|
||||
};
|
||||
}
|
||||
|
||||
// ─── Weather + Dome Detection ─────────────────────────────────────────
|
||||
|
||||
const DOME_PARKS = ['tropicana_field', 'chase_field', 'minute_maid', 'rogers_centre', 'loanDepot_park', 'globe_life'];
|
||||
|
||||
function getWeatherForPark(park, conditions) {
|
||||
if (DOME_PARKS.includes(park)) {
|
||||
return { temperature: 72, wind: 0, humidity: 50, ball_carry_factor: 1.0 };
|
||||
}
|
||||
return conditions;
|
||||
}
|
||||
|
||||
function ballCarryFactor(temperature, humidity) {
|
||||
let factor = 1.0;
|
||||
if (temperature > 72) factor += (temperature - 72) * 0.003;
|
||||
if (temperature < 72) factor -= (72 - temperature) * 0.003;
|
||||
if (humidity > 50) factor -= (humidity - 50) * 0.002;
|
||||
if (humidity < 50) factor += (50 - humidity) * 0.002;
|
||||
return parseFloat(factor.toFixed(4));
|
||||
}
|
||||
|
||||
// ─── Catcher Framing ──────────────────────────────────────────────────
|
||||
|
||||
function clampFramingValue(raw) {
|
||||
return Math.max(-0.5, Math.min(0.5, raw));
|
||||
}
|
||||
|
||||
// ─── Umpire / Referee Minimums ────────────────────────────────────────
|
||||
|
||||
function getUmpireAdjustment(umpire) {
|
||||
if (umpire.games < 30) return 0.0;
|
||||
return umpire.k_rate_delta;
|
||||
}
|
||||
|
||||
function getRefereeAdjustment(referee) {
|
||||
if (referee.games < 30) return 0.0;
|
||||
return referee.foul_rate_delta;
|
||||
}
|
||||
|
||||
// ─── MLB Lineup Parsing ──────────────────────────────────────────────
|
||||
|
||||
function parseLineupEntry(raw) {
|
||||
return {
|
||||
player: raw.player,
|
||||
batting_order: raw.batting_order,
|
||||
position: raw.position,
|
||||
status: raw.source === 'official_api' ? 'confirmed' : 'projected',
|
||||
};
|
||||
}
|
||||
|
||||
// ─── ABS Challenge System ─────────────────────────────────────────────
|
||||
|
||||
function disciplineScore(chase_rate, bb_rate) {
|
||||
// chase_rate: 0-1 (lower = better), bb_rate: 0-1 (higher = better)
|
||||
const raw = (1 - chase_rate) * 0.5 + bb_rate * 0.5;
|
||||
return Math.max(0, Math.min(1, parseFloat(raw.toFixed(4))));
|
||||
}
|
||||
|
||||
function absKAdjustment(discipline) {
|
||||
if (discipline > 0.7) return -0.05;
|
||||
return 0;
|
||||
}
|
||||
|
||||
function framingVsDisciplined(framingValue, discipline) {
|
||||
// Framing is 50% less effective against disciplined batters
|
||||
if (discipline > 0.7) return framingValue * 0.5;
|
||||
return framingValue;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// TESTS
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
|
||||
describe('Reporter seeding + trust', () => {
|
||||
test('beat_writer starts at reliable', () => {
|
||||
expect(STARTING_TRUST.beat_writer).toBe('reliable');
|
||||
});
|
||||
|
||||
test('national starts at authoritative', () => {
|
||||
expect(STARTING_TRUST.national).toBe('authoritative');
|
||||
});
|
||||
|
||||
test('aggregator starts at unverified', () => {
|
||||
expect(STARTING_TRUST.aggregator).toBe('unverified');
|
||||
});
|
||||
|
||||
test('insider starts at reliable', () => {
|
||||
expect(STARTING_TRUST.insider).toBe('reliable');
|
||||
});
|
||||
|
||||
test('reporter_database has nba key', () => {
|
||||
expect(REPORTER_DATABASE).toHaveProperty('nba');
|
||||
expect(Object.keys(REPORTER_DATABASE.nba).length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('reporter has source_type field', () => {
|
||||
const reporter = REPORTER_DATABASE.nba.shams_charania;
|
||||
expect(reporter).toHaveProperty('source_type');
|
||||
expect(typeof reporter.source_type).toBe('string');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Reporter trust escalation', () => {
|
||||
test('promote from reliable to verified at 20+ tracked and 90%+ accuracy', () => {
|
||||
const result = escalateTrust({ trust: 'reliable', tracked: 25, accuracy: 0.92 });
|
||||
expect(result.level).toBe('verified');
|
||||
});
|
||||
|
||||
test('stay at reliable if accuracy below 90%', () => {
|
||||
const result = escalateTrust({ trust: 'reliable', tracked: 25, accuracy: 0.85 });
|
||||
expect(result.level).toBe('reliable');
|
||||
});
|
||||
|
||||
test('authoritative requires 30+ tracked and 95%+ accuracy', () => {
|
||||
const result = escalateTrust({ trust: 'verified', tracked: 35, accuracy: 0.96 });
|
||||
expect(result.level).toBe('authoritative');
|
||||
});
|
||||
|
||||
test('badge for authoritative is confirmed', () => {
|
||||
const result = escalateTrust({ trust: 'verified', tracked: 35, accuracy: 0.96 });
|
||||
expect(result.badge).toBe('confirmed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Tweet parsing', () => {
|
||||
test('"will start" detected as confirmed_playing', () => {
|
||||
const result = parseTweet('LeBron James will start tonight');
|
||||
expect(result.status).toBe('confirmed_playing');
|
||||
});
|
||||
|
||||
test('"scratched" detected as scratched', () => {
|
||||
const result = parseTweet('Giannis has been scratched from the lineup');
|
||||
expect(result.status).toBe('scratched');
|
||||
});
|
||||
|
||||
test('"game-time decision" detected as questionable', () => {
|
||||
const result = parseTweet('Jaylen Brown is a game-time decision');
|
||||
expect(result.status).toBe('questionable');
|
||||
});
|
||||
|
||||
test('past tense "was out" filtered', () => {
|
||||
const result = parseTweet('Curry was out for the game last week');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('"yesterday" filtered', () => {
|
||||
const result = parseTweet('Player was scratched yesterday');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('"last night" filtered', () => {
|
||||
const result = parseTweet('He sat out last night');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('returns null for irrelevant text', () => {
|
||||
const result = parseTweet('Great weather in Boston today');
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('player OUT returns confidence 0.90', () => {
|
||||
const result = parseTweet('Player is OUT tonight');
|
||||
expect(result.confidence).toBe(0.90);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Odds API response parsing', () => {
|
||||
test('extracts player_name from outcome', () => {
|
||||
const market = { outcomes: [{ name: 'LeBron James', point: 25.5 }] };
|
||||
const result = parseOddsOutcome(market, 'draftkings');
|
||||
expect(result.player_name).toBe('LeBron James');
|
||||
});
|
||||
|
||||
test('extracts line from point', () => {
|
||||
const market = { outcomes: [{ name: 'LeBron James', point: 25.5 }] };
|
||||
const result = parseOddsOutcome(market, 'draftkings');
|
||||
expect(result.line).toBe(25.5);
|
||||
});
|
||||
|
||||
test('extracts bookmaker key', () => {
|
||||
const market = { outcomes: [{ name: 'LeBron James', point: 25.5 }] };
|
||||
const result = parseOddsOutcome(market, 'fanduel');
|
||||
expect(result.bookmaker).toBe('fanduel');
|
||||
});
|
||||
|
||||
test('handles missing outcomes gracefully', () => {
|
||||
expect(parseOddsOutcome({}, 'draftkings')).toBeNull();
|
||||
expect(parseOddsOutcome({ outcomes: [] }, 'draftkings')).toBeNull();
|
||||
expect(parseOddsOutcome(null, 'draftkings')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Line movement detection', () => {
|
||||
test('flags movement >= 0.5', () => {
|
||||
const result = detectLineMovement(24.5, 25.5);
|
||||
expect(result.flagged).toBe(true);
|
||||
expect(result.movement).toBe(1.0);
|
||||
});
|
||||
|
||||
test('ignores movement < 0.5', () => {
|
||||
const result = detectLineMovement(24.5, 24.8);
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('direction is up when current > opening', () => {
|
||||
const result = detectLineMovement(24.5, 25.5);
|
||||
expect(result.direction).toBe('up');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Weather dome detection', () => {
|
||||
test('dome parks return temperature=72', () => {
|
||||
const weather = getWeatherForPark('tropicana_field', {});
|
||||
expect(weather.temperature).toBe(72);
|
||||
});
|
||||
|
||||
test('dome parks return wind=0', () => {
|
||||
const weather = getWeatherForPark('chase_field', {});
|
||||
expect(weather.wind).toBe(0);
|
||||
});
|
||||
|
||||
test('ball_carry_factor for dome is 1.0', () => {
|
||||
const weather = getWeatherForPark('minute_maid', {});
|
||||
expect(weather.ball_carry_factor).toBe(1.0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Weather ball carry', () => {
|
||||
test('hot weather increases carry (>72F)', () => {
|
||||
const factor = ballCarryFactor(90, 50);
|
||||
expect(factor).toBeGreaterThan(1.0);
|
||||
});
|
||||
|
||||
test('humid weather decreases carry (>50%)', () => {
|
||||
const factor = ballCarryFactor(72, 80);
|
||||
expect(factor).toBeLessThan(1.0);
|
||||
});
|
||||
|
||||
test('neutral at 72F/50%', () => {
|
||||
const factor = ballCarryFactor(72, 50);
|
||||
expect(factor).toBe(1.0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Catcher framing', () => {
|
||||
test('framing value clamped at upper bound 0.5', () => {
|
||||
expect(clampFramingValue(0.8)).toBe(0.5);
|
||||
});
|
||||
|
||||
test('framing value clamped at lower bound -0.5', () => {
|
||||
expect(clampFramingValue(-0.9)).toBe(-0.5);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Umpire / referee minimums', () => {
|
||||
test('umpire returns 0.0 below 30 games', () => {
|
||||
expect(getUmpireAdjustment({ games: 15, k_rate_delta: 0.12 })).toBe(0.0);
|
||||
});
|
||||
|
||||
test('referee returns 0.0 below 30 games', () => {
|
||||
expect(getRefereeAdjustment({ games: 20, foul_rate_delta: 0.08 })).toBe(0.0);
|
||||
});
|
||||
|
||||
test('umpire returns adjustment at 30+ games', () => {
|
||||
const adj = getUmpireAdjustment({ games: 45, k_rate_delta: 0.12 });
|
||||
expect(adj).toBe(0.12);
|
||||
});
|
||||
|
||||
test('referee returns adjustment at 30+ games', () => {
|
||||
const adj = getRefereeAdjustment({ games: 30, foul_rate_delta: 0.08 });
|
||||
expect(adj).toBe(0.08);
|
||||
});
|
||||
});
|
||||
|
||||
describe('MLB lineup parsing', () => {
|
||||
test('lineup has batting_order field', () => {
|
||||
const entry = parseLineupEntry({ player: 'Mookie Betts', batting_order: 1, position: 'RF', source: 'official_api' });
|
||||
expect(entry).toHaveProperty('batting_order');
|
||||
expect(entry.batting_order).toBe(1);
|
||||
});
|
||||
|
||||
test('lineup has position field', () => {
|
||||
const entry = parseLineupEntry({ player: 'Freddie Freeman', batting_order: 3, position: '1B', source: 'official_api' });
|
||||
expect(entry).toHaveProperty('position');
|
||||
expect(entry.position).toBe('1B');
|
||||
});
|
||||
|
||||
test('status is confirmed from official API', () => {
|
||||
const entry = parseLineupEntry({ player: 'Shohei Ohtani', batting_order: 2, position: 'DH', source: 'official_api' });
|
||||
expect(entry.status).toBe('confirmed');
|
||||
});
|
||||
});
|
||||
|
||||
describe('ABS challenge system', () => {
|
||||
test('discipline_score from chase_rate + bb_rate is 0-1', () => {
|
||||
const score = disciplineScore(0.3, 0.12);
|
||||
expect(score).toBeGreaterThanOrEqual(0);
|
||||
expect(score).toBeLessThanOrEqual(1);
|
||||
});
|
||||
|
||||
test('elite discipline (>0.7) gets -5% K adjustment', () => {
|
||||
const adj = absKAdjustment(0.8);
|
||||
expect(adj).toBe(-0.05);
|
||||
});
|
||||
|
||||
test('low discipline gets no benefit', () => {
|
||||
const adj = absKAdjustment(0.4);
|
||||
expect(adj).toBe(0);
|
||||
});
|
||||
|
||||
test('framing 50% effective vs disciplined batter', () => {
|
||||
const full = framingVsDisciplined(0.3, 0.5);
|
||||
const reduced = framingVsDisciplined(0.3, 0.8);
|
||||
expect(full).toBe(0.3);
|
||||
expect(reduced).toBe(0.15);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,524 @@
|
||||
/**
|
||||
* VYNDR Ship Grading Engine — Unit Tests
|
||||
*
|
||||
* Pure logic tests for grading engine components.
|
||||
* All constants and formulas are inlined — no external imports.
|
||||
* Tests the DATA CONTRACTS that the grading engine must honor.
|
||||
*/
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 1. Grade Thresholds (4 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Grade Thresholds', () => {
|
||||
const GRADE_MAP = [
|
||||
{ min: 0.85, max: 1.00, grade: 'A+' },
|
||||
{ min: 0.78, max: 0.84, grade: 'A' },
|
||||
{ min: 0.72, max: 0.77, grade: 'B+' },
|
||||
{ min: 0.66, max: 0.71, grade: 'B' },
|
||||
{ min: 0.55, max: 0.65, grade: 'C+' },
|
||||
{ min: 0.40, max: 0.54, grade: 'C' },
|
||||
{ min: 0.29, max: 0.39, grade: 'D' },
|
||||
{ min: 0.00, max: 0.28, grade: 'F' },
|
||||
];
|
||||
|
||||
function toGrade(confidence) {
|
||||
for (const tier of GRADE_MAP) {
|
||||
if (confidence >= tier.min && confidence <= tier.max) return tier.grade;
|
||||
}
|
||||
return 'F';
|
||||
}
|
||||
|
||||
test('A+ range covers 0.85 to 1.00', () => {
|
||||
expect(toGrade(0.85)).toBe('A+');
|
||||
expect(toGrade(0.92)).toBe('A+');
|
||||
expect(toGrade(1.00)).toBe('A+');
|
||||
});
|
||||
|
||||
test('B+ range covers 0.72 to 0.77 (not 0.66-0.71 which is B)', () => {
|
||||
expect(toGrade(0.66)).toBe('B');
|
||||
expect(toGrade(0.71)).toBe('B');
|
||||
expect(toGrade(0.72)).toBe('B+');
|
||||
});
|
||||
|
||||
test('C+ caps at 0.54 on the low end when data is limited', () => {
|
||||
const DATA_LIMITED_CAP = 0.54;
|
||||
const rawConfidence = 0.78;
|
||||
const capped = Math.min(rawConfidence, DATA_LIMITED_CAP);
|
||||
expect(capped).toBe(0.54);
|
||||
expect(toGrade(capped)).toBe('C');
|
||||
});
|
||||
|
||||
test('F grade for confidence below 0.29', () => {
|
||||
expect(toGrade(0.10)).toBe('F');
|
||||
expect(toGrade(0.28)).toBe('F');
|
||||
expect(toGrade(0.00)).toBe('F');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 2. Bayesian Weights Per-Stat-Type (5 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Bayesian Weights Per-Stat-Type', () => {
|
||||
const BAYESIAN_WEIGHTS = {
|
||||
strikeouts: { prior: 0.40, recent: 0.35, context: 0.25 },
|
||||
points: { prior: 0.30, recent: 0.45, context: 0.25 },
|
||||
assists: { prior: 0.25, recent: 0.50, context: 0.25 },
|
||||
rebounds: { prior: 0.30, recent: 0.40, context: 0.30 },
|
||||
threes: { prior: 0.35, recent: 0.40, context: 0.25 },
|
||||
};
|
||||
|
||||
const DEFAULT_WEIGHTS = { prior: 0.33, recent: 0.34, context: 0.33 };
|
||||
|
||||
test('strikeouts has prior weight of 0.40', () => {
|
||||
expect(BAYESIAN_WEIGHTS.strikeouts.prior).toBe(0.40);
|
||||
});
|
||||
|
||||
test('points has recent weight of 0.45', () => {
|
||||
expect(BAYESIAN_WEIGHTS.points.recent).toBe(0.45);
|
||||
});
|
||||
|
||||
test('assists has recent weight of 0.50', () => {
|
||||
expect(BAYESIAN_WEIGHTS.assists.recent).toBe(0.50);
|
||||
});
|
||||
|
||||
test('default weights sum to approximately 1.0', () => {
|
||||
const sum = DEFAULT_WEIGHTS.prior + DEFAULT_WEIGHTS.recent + DEFAULT_WEIGHTS.context;
|
||||
expect(sum).toBeCloseTo(1.0, 5);
|
||||
});
|
||||
|
||||
test('every stat type has prior + recent + context summing to 1.0', () => {
|
||||
for (const [stat, weights] of Object.entries(BAYESIAN_WEIGHTS)) {
|
||||
const sum = weights.prior + weights.recent + weights.context;
|
||||
expect(sum).toBeCloseTo(1.0, 5);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 3. Abstention Logic (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Abstention Logic', () => {
|
||||
function shouldAbstain({ confidence, similar_games, data_quality }) {
|
||||
if (confidence >= 0.40 && confidence <= 0.55 && similar_games < 3) return true;
|
||||
if (data_quality === 'limited' && confidence < 0.55) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
test('abstain when confidence 0.40-0.55 AND similar_games < 3', () => {
|
||||
expect(shouldAbstain({ confidence: 0.45, similar_games: 2, data_quality: 'normal' })).toBe(true);
|
||||
expect(shouldAbstain({ confidence: 0.50, similar_games: 0, data_quality: 'normal' })).toBe(true);
|
||||
});
|
||||
|
||||
test('abstain when data_quality is limited AND confidence < 0.55', () => {
|
||||
expect(shouldAbstain({ confidence: 0.50, similar_games: 10, data_quality: 'limited' })).toBe(true);
|
||||
expect(shouldAbstain({ confidence: 0.40, similar_games: 5, data_quality: 'limited' })).toBe(true);
|
||||
});
|
||||
|
||||
test('do NOT abstain when confidence > 0.55', () => {
|
||||
expect(shouldAbstain({ confidence: 0.60, similar_games: 1, data_quality: 'normal' })).toBe(false);
|
||||
expect(shouldAbstain({ confidence: 0.80, similar_games: 0, data_quality: 'normal' })).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 4. Global Offset Clamped +/-0.15 (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Global Offset Clamped +/-0.15', () => {
|
||||
const OFFSET_CLAMP = 0.15;
|
||||
const MIN_SAMPLE_SIZE = 20;
|
||||
|
||||
function clampOffset(rawOffset, sampleSize) {
|
||||
if (sampleSize < MIN_SAMPLE_SIZE) return 0.0;
|
||||
return Math.max(-OFFSET_CLAMP, Math.min(OFFSET_CLAMP, rawOffset));
|
||||
}
|
||||
|
||||
test('clamps positive offset to +0.15', () => {
|
||||
expect(clampOffset(0.30, 50)).toBe(0.15);
|
||||
expect(clampOffset(0.15, 50)).toBe(0.15);
|
||||
});
|
||||
|
||||
test('clamps negative offset to -0.15', () => {
|
||||
expect(clampOffset(-0.25, 50)).toBe(-0.15);
|
||||
expect(clampOffset(-0.15, 50)).toBe(-0.15);
|
||||
});
|
||||
|
||||
test('returns zero when sample size is insufficient', () => {
|
||||
expect(clampOffset(0.10, 5)).toBe(0.0);
|
||||
expect(clampOffset(-0.20, 19)).toBe(0.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 5. Data Sufficiency Smooth Curve (4 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Data Sufficiency Smooth Curve', () => {
|
||||
const C_PLUS_CAP = 0.54;
|
||||
const MIN_GAMES = 5;
|
||||
const FULL_GAMES = MIN_GAMES * 2; // 10
|
||||
|
||||
function dataSufficiencyMultiplier(gamesPlayed) {
|
||||
if (gamesPlayed < MIN_GAMES) return C_PLUS_CAP;
|
||||
if (gamesPlayed >= FULL_GAMES) return 1.0;
|
||||
// smooth ramp from 0.70 to 1.0 between MIN_GAMES and FULL_GAMES
|
||||
const t = (gamesPlayed - MIN_GAMES) / (FULL_GAMES - MIN_GAMES);
|
||||
return 0.70 + 0.30 * t;
|
||||
}
|
||||
|
||||
test('below minimum returns C+ cap (0.54)', () => {
|
||||
expect(dataSufficiencyMultiplier(0)).toBe(C_PLUS_CAP);
|
||||
expect(dataSufficiencyMultiplier(4)).toBe(C_PLUS_CAP);
|
||||
});
|
||||
|
||||
test('at minimum returns 70% confidence multiplier', () => {
|
||||
expect(dataSufficiencyMultiplier(MIN_GAMES)).toBeCloseTo(0.70, 5);
|
||||
});
|
||||
|
||||
test('at 2x minimum returns 100% confidence multiplier', () => {
|
||||
expect(dataSufficiencyMultiplier(FULL_GAMES)).toBe(1.0);
|
||||
expect(dataSufficiencyMultiplier(15)).toBe(1.0);
|
||||
});
|
||||
|
||||
test('ramp is smooth between min and 2x min', () => {
|
||||
const at6 = dataSufficiencyMultiplier(6);
|
||||
const at7 = dataSufficiencyMultiplier(7);
|
||||
const at8 = dataSufficiencyMultiplier(8);
|
||||
// monotonically increasing
|
||||
expect(at7).toBeGreaterThan(at6);
|
||||
expect(at8).toBeGreaterThan(at7);
|
||||
// all within the 0.70–1.0 band
|
||||
expect(at6).toBeGreaterThanOrEqual(0.70);
|
||||
expect(at8).toBeLessThanOrEqual(1.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 6. Real Edge with Vig (4 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Real Edge with Vig', () => {
|
||||
function americanToImpliedProb(odds) {
|
||||
if (odds < 0) return Math.abs(odds) / (Math.abs(odds) + 100);
|
||||
return 100 / (odds + 100);
|
||||
}
|
||||
|
||||
function edgeVerdict(modelProb, impliedProb) {
|
||||
const edge = modelProb - impliedProb;
|
||||
return edge > 0 ? 'BET' : 'NO BET';
|
||||
}
|
||||
|
||||
test('-110 implied probability is approximately 0.524', () => {
|
||||
const prob = americanToImpliedProb(-110);
|
||||
expect(prob).toBeCloseTo(0.524, 2);
|
||||
});
|
||||
|
||||
test('+150 implied probability is approximately 0.40', () => {
|
||||
const prob = americanToImpliedProb(150);
|
||||
expect(prob).toBeCloseTo(0.40, 2);
|
||||
});
|
||||
|
||||
test('positive EV when model probability > implied probability', () => {
|
||||
const implied = americanToImpliedProb(-110); // ~0.524
|
||||
const modelProb = 0.60;
|
||||
expect(edgeVerdict(modelProb, implied)).toBe('BET');
|
||||
});
|
||||
|
||||
test('negative EV returns NO BET', () => {
|
||||
const implied = americanToImpliedProb(-110); // ~0.524
|
||||
const modelProb = 0.48;
|
||||
expect(edgeVerdict(modelProb, implied)).toBe('NO BET');
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 7. Kelly Criterion (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Kelly Criterion', () => {
|
||||
function americanToDecimalOdds(odds) {
|
||||
if (odds < 0) return 1 + (100 / Math.abs(odds));
|
||||
return 1 + (odds / 100);
|
||||
}
|
||||
|
||||
function quarterKelly(modelProb, americanOdds) {
|
||||
const decimal = americanToDecimalOdds(americanOdds);
|
||||
const b = decimal - 1;
|
||||
const q = 1 - modelProb;
|
||||
const fullKelly = (modelProb * b - q) / b;
|
||||
if (fullKelly <= 0) return 0;
|
||||
return fullKelly / 4;
|
||||
}
|
||||
|
||||
test('quarter Kelly divides full Kelly by 4', () => {
|
||||
const modelProb = 0.60;
|
||||
const odds = -110;
|
||||
const decimal = americanToDecimalOdds(odds); // ~1.909
|
||||
const b = decimal - 1;
|
||||
const fullKelly = (modelProb * b - (1 - modelProb)) / b;
|
||||
const qk = quarterKelly(modelProb, odds);
|
||||
expect(qk).toBeCloseTo(fullKelly / 4, 5);
|
||||
});
|
||||
|
||||
test('returns 0 for negative EV bets', () => {
|
||||
expect(quarterKelly(0.40, -150)).toBe(0);
|
||||
expect(quarterKelly(0.30, -110)).toBe(0);
|
||||
});
|
||||
|
||||
test('reasonable sizing for +EV bet', () => {
|
||||
const size = quarterKelly(0.60, -110);
|
||||
// quarter Kelly should be modest — well under 10% of bankroll
|
||||
expect(size).toBeGreaterThan(0);
|
||||
expect(size).toBeLessThan(0.10);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 8. Brier Score (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Brier Score', () => {
|
||||
function brierScore(predictions) {
|
||||
if (!predictions || predictions.length === 0) return null;
|
||||
const sum = predictions.reduce((acc, { prob, outcome }) => {
|
||||
return acc + Math.pow(prob - outcome, 2);
|
||||
}, 0);
|
||||
return sum / predictions.length;
|
||||
}
|
||||
|
||||
test('perfect prediction yields Brier score of 0', () => {
|
||||
const preds = [
|
||||
{ prob: 1.0, outcome: 1 },
|
||||
{ prob: 0.0, outcome: 0 },
|
||||
];
|
||||
expect(brierScore(preds)).toBe(0);
|
||||
});
|
||||
|
||||
test('coin flip predictions yield Brier score of 0.25', () => {
|
||||
const preds = [
|
||||
{ prob: 0.5, outcome: 1 },
|
||||
{ prob: 0.5, outcome: 0 },
|
||||
];
|
||||
expect(brierScore(preds)).toBeCloseTo(0.25, 5);
|
||||
});
|
||||
|
||||
test('returns null for empty data', () => {
|
||||
expect(brierScore([])).toBeNull();
|
||||
expect(brierScore(null)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 9. Similar Game Confidence Modifier (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Similar Game Confidence Modifier', () => {
|
||||
function similarGameModifier(similarGames) {
|
||||
if (similarGames >= 10) return 0.05;
|
||||
if (similarGames <= 1) return -0.03;
|
||||
if (similarGames >= 2 && similarGames <= 4) return 0.0;
|
||||
// 5-9 range — partial boost
|
||||
return 0.02;
|
||||
}
|
||||
|
||||
test('+0.05 for 10+ similar games', () => {
|
||||
expect(similarGameModifier(10)).toBe(0.05);
|
||||
expect(similarGameModifier(25)).toBe(0.05);
|
||||
});
|
||||
|
||||
test('-0.03 for 0-1 similar games', () => {
|
||||
expect(similarGameModifier(0)).toBe(-0.03);
|
||||
expect(similarGameModifier(1)).toBe(-0.03);
|
||||
});
|
||||
|
||||
test('0.0 for 2-4 similar games', () => {
|
||||
expect(similarGameModifier(2)).toBe(0.0);
|
||||
expect(similarGameModifier(3)).toBe(0.0);
|
||||
expect(similarGameModifier(4)).toBe(0.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 10. Skewness (2 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Skewness', () => {
|
||||
function skewness(values) {
|
||||
if (!values || values.length < 10) return 0.0;
|
||||
const n = values.length;
|
||||
const mean = values.reduce((a, b) => a + b, 0) / n;
|
||||
const variance = values.reduce((a, v) => a + Math.pow(v - mean, 2), 0) / n;
|
||||
const std = Math.sqrt(variance);
|
||||
if (std === 0) return 0.0;
|
||||
const skew = values.reduce((a, v) => a + Math.pow((v - mean) / std, 3), 0) / n;
|
||||
return skew;
|
||||
}
|
||||
|
||||
test('returns 0.0 for fewer than 10 values', () => {
|
||||
expect(skewness([1, 2, 3])).toBe(0.0);
|
||||
expect(skewness([1, 2, 3, 4, 5, 6, 7, 8, 9])).toBe(0.0);
|
||||
expect(skewness(null)).toBe(0.0);
|
||||
});
|
||||
|
||||
test('positive skew for right-skewed data', () => {
|
||||
// Mostly low values with a few high outliers
|
||||
const data = [1, 2, 2, 3, 3, 3, 4, 4, 5, 20];
|
||||
expect(skewness(data)).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 11. Matchup Pace (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Matchup Pace', () => {
|
||||
const LEAGUE_AVG_PACE = 100.0;
|
||||
const HOME_WEIGHT = 0.60;
|
||||
const AWAY_WEIGHT = 0.40;
|
||||
|
||||
function matchupPace(homePace, awayPace) {
|
||||
const blended = homePace * HOME_WEIGHT + awayPace * AWAY_WEIGHT;
|
||||
return blended / LEAGUE_AVG_PACE;
|
||||
}
|
||||
|
||||
test('two fast teams produce pace factor > 1.0', () => {
|
||||
const factor = matchupPace(108, 106);
|
||||
expect(factor).toBeGreaterThan(1.0);
|
||||
});
|
||||
|
||||
test('home team weighted 60/40 over away', () => {
|
||||
const factor = matchupPace(110, 90);
|
||||
// 110*0.6 + 90*0.4 = 66 + 36 = 102 => 102/100 = 1.02
|
||||
expect(factor).toBeCloseTo(1.02, 5);
|
||||
});
|
||||
|
||||
test('league average teams return pace of 1.0', () => {
|
||||
const factor = matchupPace(LEAGUE_AVG_PACE, LEAGUE_AVG_PACE);
|
||||
expect(factor).toBe(1.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 12. Foul Trouble Risk (3 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Foul Trouble Risk', () => {
|
||||
function foulTroubleBoost(avgFouls) {
|
||||
if (avgFouls >= 3.5) return 3.0;
|
||||
if (avgFouls >= 2.8) return 1.5;
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
test('>= 3.5 average fouls returns 3.0 std deviation boost', () => {
|
||||
expect(foulTroubleBoost(3.5)).toBe(3.0);
|
||||
expect(foulTroubleBoost(4.2)).toBe(3.0);
|
||||
});
|
||||
|
||||
test('>= 2.8 average fouls returns 1.5 std deviation boost', () => {
|
||||
expect(foulTroubleBoost(2.8)).toBe(1.5);
|
||||
expect(foulTroubleBoost(3.4)).toBe(1.5);
|
||||
});
|
||||
|
||||
test('< 2.8 average fouls returns 0.0', () => {
|
||||
expect(foulTroubleBoost(2.0)).toBe(0.0);
|
||||
expect(foulTroubleBoost(2.7)).toBe(0.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 13. B2B Stat-Specific Adjustments (4 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('B2B Stat-Specific Adjustments', () => {
|
||||
const B2B_ADJ = {
|
||||
points: -0.04,
|
||||
rebounds: 0.02,
|
||||
threes: -0.03,
|
||||
assists: 0.00,
|
||||
};
|
||||
|
||||
function applyB2B(projection, statType, isB2B) {
|
||||
if (!isB2B) return projection;
|
||||
const adj = B2B_ADJ[statType] || 0;
|
||||
return projection * (1 + adj);
|
||||
}
|
||||
|
||||
test('B2B points adjustment is -4%', () => {
|
||||
const adjusted = applyB2B(25.0, 'points', true);
|
||||
expect(adjusted).toBe(24.0);
|
||||
});
|
||||
|
||||
test('B2B rebounds adjustment is +2%', () => {
|
||||
const adjusted = applyB2B(10.0, 'rebounds', true);
|
||||
expect(adjusted).toBeCloseTo(10.2, 5);
|
||||
});
|
||||
|
||||
test('B2B threes adjustment is -3%', () => {
|
||||
const adjusted = applyB2B(3.0, 'threes', true);
|
||||
expect(adjusted).toBeCloseTo(2.91, 5);
|
||||
});
|
||||
|
||||
test('no adjustment when not B2B', () => {
|
||||
expect(applyB2B(25.0, 'points', false)).toBe(25.0);
|
||||
expect(applyB2B(10.0, 'rebounds', false)).toBe(10.0);
|
||||
expect(applyB2B(3.0, 'threes', false)).toBe(3.0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 14. Usage-Efficiency Tradeoff (2 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Usage-Efficiency Tradeoff', () => {
|
||||
const TS_DROP_PER_5_USG = -0.015; // -1.5% TS per +5% usage
|
||||
|
||||
function usageEfficiencyAdjustment(usageDelta) {
|
||||
// usageDelta in percentage points (e.g., +5 means usage went up 5%)
|
||||
return (usageDelta / 5) * TS_DROP_PER_5_USG;
|
||||
}
|
||||
|
||||
function netEffect(usageDelta, baseTS) {
|
||||
const tsAdj = usageEfficiencyAdjustment(usageDelta);
|
||||
return baseTS + tsAdj;
|
||||
}
|
||||
|
||||
test('-1.5% TS per +5% usage increase', () => {
|
||||
const adj = usageEfficiencyAdjustment(5);
|
||||
expect(adj).toBeCloseTo(-0.015, 5);
|
||||
const adj10 = usageEfficiencyAdjustment(10);
|
||||
expect(adj10).toBeCloseTo(-0.030, 5);
|
||||
});
|
||||
|
||||
test('net effect is sum of base TS and adjustment', () => {
|
||||
const baseTS = 0.580;
|
||||
const usageDelta = 5;
|
||||
const net = netEffect(usageDelta, baseTS);
|
||||
expect(net).toBeCloseTo(0.580 + (-0.015), 5);
|
||||
expect(net).toBeCloseTo(0.565, 5);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 15. Dynamic Usage Boost Headroom (2 tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
describe('Dynamic Usage Boost Headroom', () => {
|
||||
const MAX_BOOST = 0.08; // 8% max boost
|
||||
const HIGH_USAGE_THRESHOLD = 0.30; // 30% usage rate
|
||||
|
||||
function usageBoost(currentUsage, projectedIncrease) {
|
||||
const headroom = Math.max(0, HIGH_USAGE_THRESHOLD - currentUsage);
|
||||
const scaleFactor = Math.min(1.0, headroom / HIGH_USAGE_THRESHOLD);
|
||||
return projectedIncrease * scaleFactor * MAX_BOOST;
|
||||
}
|
||||
|
||||
test('low usage player gets full boost', () => {
|
||||
// 15% usage — lots of headroom
|
||||
const boost = usageBoost(0.15, 1.0);
|
||||
// headroom = 0.30 - 0.15 = 0.15, scaleFactor = 0.15/0.30 = 0.5
|
||||
expect(boost).toBeCloseTo(0.04, 5);
|
||||
// But a very low usage player gets even more
|
||||
const boostLow = usageBoost(0.10, 1.0);
|
||||
expect(boostLow).toBeGreaterThan(boost);
|
||||
});
|
||||
|
||||
test('high usage player gets scaled down boost', () => {
|
||||
// 28% usage — close to threshold, little headroom
|
||||
const boost = usageBoost(0.28, 1.0);
|
||||
// headroom = 0.30 - 0.28 = 0.02, scaleFactor = 0.02/0.30 ≈ 0.0667
|
||||
expect(boost).toBeCloseTo(0.02 / 0.30 * MAX_BOOST, 4);
|
||||
expect(boost).toBeLessThan(0.01);
|
||||
|
||||
// At or above threshold — zero boost
|
||||
const boostAtCap = usageBoost(0.30, 1.0);
|
||||
expect(boostAtCap).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,283 @@
|
||||
/**
|
||||
* Ship Infrastructure Tests — VYNDR v5.1
|
||||
* Tests data contracts, configurations, and infrastructure logic
|
||||
* for the production ship build.
|
||||
*/
|
||||
|
||||
// ── Inline constants (JS-side contracts for Python service configs) ──
|
||||
|
||||
const RETRY_CONFIG = {
|
||||
maxRetries: 3,
|
||||
baseDelayMs: 1000,
|
||||
backoffMultiplier: 2,
|
||||
};
|
||||
|
||||
const DATA_FRESHNESS = {
|
||||
odds: { default_ttl: 0.25, game_day_ttl: 0.083 },
|
||||
weather: { default_ttl: 1.0, game_day_ttl: 0.5 },
|
||||
park_factors: { default_ttl: 720, game_day_ttl: 720 },
|
||||
reporter_feed: { default_ttl: 0.017, game_day_ttl: 0.017 },
|
||||
};
|
||||
|
||||
const CONTEXT_FACTORS = [
|
||||
'park_factor', 'weather_wind', 'weather_temp', 'weather_humidity',
|
||||
'platoon_split', 'bullpen_fatigue', 'umpire_tendency', 'lineup_confirmed',
|
||||
'rest_days', 'travel_distance', 'rivalry_flag', 'injury_report',
|
||||
'recent_form', 'season_avg', 'home_away_split',
|
||||
];
|
||||
|
||||
const RATE_LIMITS = {
|
||||
default: { windowMs: 60000, max: 60 },
|
||||
grade: { windowMs: 60000, max: 20 },
|
||||
};
|
||||
|
||||
const HEALTH_RESPONSE_FIELDS = ['status', 'version', 'services', 'timestamp'];
|
||||
|
||||
const BOOT_SEQUENCE = [
|
||||
'database',
|
||||
'park_factors',
|
||||
'archetypes',
|
||||
'reporter_seed',
|
||||
'api_server',
|
||||
];
|
||||
|
||||
const FAILURE_MONITOR = {
|
||||
threshold: 3,
|
||||
windowMinutes: 30,
|
||||
};
|
||||
|
||||
const CORS_CONFIG = {
|
||||
pattern: '/api/*',
|
||||
enabled: true,
|
||||
};
|
||||
|
||||
const FLASK_DOCS = {
|
||||
version: '5.1',
|
||||
endpointKeys: [
|
||||
'scan', 'grade', 'health', 'props', 'stats',
|
||||
'tracker', 'waitlist', 'auth', 'payments', 'docs',
|
||||
],
|
||||
};
|
||||
|
||||
// ── Helpers (inline logic under test) ──
|
||||
|
||||
function retryWithBackoff(fn, config = RETRY_CONFIG) {
|
||||
let attempts = 0;
|
||||
const delays = [];
|
||||
return {
|
||||
async execute() {
|
||||
while (attempts < config.maxRetries) {
|
||||
try {
|
||||
return await fn();
|
||||
} catch (e) {
|
||||
attempts++;
|
||||
const delay = config.baseDelayMs * Math.pow(config.backoffMultiplier, attempts - 1);
|
||||
delays.push(delay);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
},
|
||||
getDelays() { return delays; },
|
||||
getAttempts() { return attempts; },
|
||||
};
|
||||
}
|
||||
|
||||
function isFresh(lastFetched, ttlHours) {
|
||||
const ageHours = (Date.now() - lastFetched) / (1000 * 60 * 60);
|
||||
return ageHours < ttlHours;
|
||||
}
|
||||
|
||||
function getTtl(dataType, isGameDay) {
|
||||
const entry = DATA_FRESHNESS[dataType];
|
||||
if (!entry) return null;
|
||||
return isGameDay ? entry.game_day_ttl : entry.default_ttl;
|
||||
}
|
||||
|
||||
function aggregateContext(factors) {
|
||||
if (!factors || Object.keys(factors).length === 0) return 0;
|
||||
return CONTEXT_FACTORS.reduce((sum, key) => sum + (factors[key] || 0), 0);
|
||||
}
|
||||
|
||||
function buildHealthResponse(serviceStatuses) {
|
||||
const degraded = Object.values(serviceStatuses).some(s => s !== 'ok');
|
||||
return {
|
||||
status: degraded ? 'degraded' : 'ok',
|
||||
version: '5.1',
|
||||
services: serviceStatuses,
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
function checkFailureAlert(failures, windowMinutes) {
|
||||
const cutoff = Date.now() - windowMinutes * 60 * 1000;
|
||||
const recentFailures = failures.filter(ts => ts > cutoff);
|
||||
return {
|
||||
count: recentFailures.length,
|
||||
alert: recentFailures.length >= FAILURE_MONITOR.threshold,
|
||||
};
|
||||
}
|
||||
|
||||
// ── Tests ──
|
||||
|
||||
describe('Retry Logic', () => {
|
||||
test('retries up to 3 times before giving up', async () => {
|
||||
let callCount = 0;
|
||||
const failing = () => { callCount++; throw new Error('fail'); };
|
||||
const runner = retryWithBackoff(failing);
|
||||
const result = await runner.execute();
|
||||
expect(callCount).toBe(3);
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
|
||||
test('exponential backoff doubles each delay', async () => {
|
||||
const failing = () => { throw new Error('fail'); };
|
||||
const runner = retryWithBackoff(failing);
|
||||
await runner.execute();
|
||||
const delays = runner.getDelays();
|
||||
expect(delays).toEqual([1000, 2000, 4000]);
|
||||
});
|
||||
|
||||
test('returns null after all retries exhausted', async () => {
|
||||
const failing = () => { throw new Error('fail'); };
|
||||
const runner = retryWithBackoff(failing);
|
||||
const result = await runner.execute();
|
||||
expect(result).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Data Warehouse + Game-Day TTL Override', () => {
|
||||
test('default TTL lookup returns non-game-day value', () => {
|
||||
expect(getTtl('odds', false)).toBe(0.25);
|
||||
expect(getTtl('weather', false)).toBe(1.0);
|
||||
});
|
||||
|
||||
test('game-day TTL is shorter than default for weather', () => {
|
||||
const defaultTtl = getTtl('weather', false);
|
||||
const gameDayTtl = getTtl('weather', true);
|
||||
expect(gameDayTtl).toBeLessThan(defaultTtl);
|
||||
});
|
||||
|
||||
test('cache freshness check passes for recent data', () => {
|
||||
const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
|
||||
expect(isFresh(fiveMinutesAgo, 0.25)).toBe(true); // 5min < 15min
|
||||
});
|
||||
|
||||
test('stale data flagged when TTL exceeded', () => {
|
||||
const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
|
||||
expect(isFresh(twoHoursAgo, 0.25)).toBe(false); // 2hr > 15min
|
||||
});
|
||||
});
|
||||
|
||||
describe('Health Check Endpoint Shape', () => {
|
||||
test('health response contains all required fields', () => {
|
||||
const response = buildHealthResponse({ db: 'ok', redis: 'ok', oddsApi: 'ok' });
|
||||
HEALTH_RESPONSE_FIELDS.forEach(field => {
|
||||
expect(response).toHaveProperty(field);
|
||||
});
|
||||
});
|
||||
|
||||
test('status is degraded when any service is unavailable', () => {
|
||||
const response = buildHealthResponse({ db: 'ok', redis: 'down', oddsApi: 'ok' });
|
||||
expect(response.status).toBe('degraded');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Rate Limiting Config', () => {
|
||||
test('default rate limit is 60 requests per minute', () => {
|
||||
expect(RATE_LIMITS.default.max).toBe(60);
|
||||
expect(RATE_LIMITS.default.windowMs).toBe(60000);
|
||||
});
|
||||
|
||||
test('grade endpoints limited to 20 requests per minute', () => {
|
||||
expect(RATE_LIMITS.grade.max).toBe(20);
|
||||
expect(RATE_LIMITS.grade.windowMs).toBe(60000);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Context Aggregator', () => {
|
||||
test('sums all 15 context factors correctly', () => {
|
||||
const factors = {};
|
||||
CONTEXT_FACTORS.forEach(key => { factors[key] = 1; });
|
||||
expect(aggregateContext(factors)).toBe(15);
|
||||
});
|
||||
|
||||
test('missing factors default to 0', () => {
|
||||
const partial = { park_factor: 3, weather_wind: 2 };
|
||||
expect(aggregateContext(partial)).toBe(5);
|
||||
});
|
||||
|
||||
test('empty factors object returns 0', () => {
|
||||
expect(aggregateContext({})).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Cold Start Boot Sequence Order', () => {
|
||||
test('park_factors loaded before archetypes', () => {
|
||||
const parkIdx = BOOT_SEQUENCE.indexOf('park_factors');
|
||||
const archIdx = BOOT_SEQUENCE.indexOf('archetypes');
|
||||
expect(parkIdx).toBeLessThan(archIdx);
|
||||
expect(parkIdx).not.toBe(-1);
|
||||
});
|
||||
|
||||
test('reporter_seed happens after database is loaded', () => {
|
||||
const dbIdx = BOOT_SEQUENCE.indexOf('database');
|
||||
const reporterIdx = BOOT_SEQUENCE.indexOf('reporter_seed');
|
||||
expect(reporterIdx).toBeGreaterThan(dbIdx);
|
||||
});
|
||||
});
|
||||
|
||||
describe('API Failure Monitoring', () => {
|
||||
test('failure count threshold is 3', () => {
|
||||
expect(FAILURE_MONITOR.threshold).toBe(3);
|
||||
});
|
||||
|
||||
test('alert triggered at 3+ failures within 30 minutes', () => {
|
||||
const now = Date.now();
|
||||
const failures = [
|
||||
now - 20 * 60 * 1000,
|
||||
now - 10 * 60 * 1000,
|
||||
now - 5 * 60 * 1000,
|
||||
];
|
||||
const result = checkFailureAlert(failures, FAILURE_MONITOR.windowMinutes);
|
||||
expect(result.alert).toBe(true);
|
||||
expect(result.count).toBe(3);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Data Freshness TTLs', () => {
|
||||
test('odds default TTL is 0.25 hours (15 minutes)', () => {
|
||||
expect(DATA_FRESHNESS.odds.default_ttl).toBe(0.25);
|
||||
});
|
||||
|
||||
test('weather game-day TTL is 0.5 hours (30 minutes)', () => {
|
||||
expect(DATA_FRESHNESS.weather.game_day_ttl).toBe(0.5);
|
||||
});
|
||||
|
||||
test('park_factors TTL is 720 hours (30 days)', () => {
|
||||
expect(DATA_FRESHNESS.park_factors.default_ttl).toBe(720);
|
||||
});
|
||||
|
||||
test('reporter_feed TTL is 0.017 hours (~1 minute)', () => {
|
||||
expect(DATA_FRESHNESS.reporter_feed.default_ttl).toBe(0.017);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Flask App Docs Endpoint Shape', () => {
|
||||
test('/api/docs returns all expected endpoint keys', () => {
|
||||
FLASK_DOCS.endpointKeys.forEach(key => {
|
||||
expect(FLASK_DOCS.endpointKeys).toContain(key);
|
||||
});
|
||||
expect(FLASK_DOCS.endpointKeys.length).toBe(10);
|
||||
});
|
||||
|
||||
test('version is 5.1', () => {
|
||||
expect(FLASK_DOCS.version).toBe('5.1');
|
||||
});
|
||||
});
|
||||
|
||||
describe('CORS Config', () => {
|
||||
test('/api/* pattern is enabled', () => {
|
||||
expect(CORS_CONFIG.pattern).toBe('/api/*');
|
||||
expect(CORS_CONFIG.enabled).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,548 @@
|
||||
/**
|
||||
* shipResolution.test.js
|
||||
* Tests the resolution pipeline, calibration, archetype/weights, parlay,
|
||||
* capper content, and migration SQL for the VYNDR ship build.
|
||||
*/
|
||||
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
// ---------- Migration SQL ----------
|
||||
const sql005 = fs.readFileSync(path.join(__dirname, '../../supabase/migrations/005_lineup_scheme_data.sql'), 'utf8');
|
||||
const sql006 = fs.readFileSync(path.join(__dirname, '../../supabase/migrations/006_data_warehouse_calibration.sql'), 'utf8');
|
||||
const sql007 = fs.readFileSync(path.join(__dirname, '../../supabase/migrations/007_lineup_odds_trust_health.sql'), 'utf8');
|
||||
|
||||
// ==========================================================
|
||||
// Helpers — inline logic that mirrors production functions
|
||||
// ==========================================================
|
||||
|
||||
function resolveHit(direction, propLine, actualValue) {
|
||||
if (direction === 'over') return actualValue > propLine;
|
||||
if (direction === 'under') return actualValue < propLine;
|
||||
return null;
|
||||
}
|
||||
|
||||
function calculateCLV(openingLine, closingLine, direction) {
|
||||
if (openingLine == null || closingLine == null) return null;
|
||||
const movement = closingLine - openingLine;
|
||||
const favorable = direction === 'over' ? movement > 0 : movement < 0;
|
||||
return {
|
||||
clv: favorable ? Math.abs(movement) : -Math.abs(movement),
|
||||
clv_magnitude: Math.abs(movement),
|
||||
};
|
||||
}
|
||||
|
||||
function modelMarketAlignment(openingLine, closingLine, direction) {
|
||||
if (openingLine == null || closingLine == null) return null;
|
||||
const movement = closingLine - openingLine;
|
||||
const marketMovedWithUs =
|
||||
(direction === 'over' && movement > 0) ||
|
||||
(direction === 'under' && movement < 0);
|
||||
return marketMovedWithUs ? 'confirming' : 'contrarian';
|
||||
}
|
||||
|
||||
function createJointOutcomes(grades) {
|
||||
const resolved = grades.filter((g) => g.hit != null);
|
||||
const pairs = [];
|
||||
for (let i = 0; i < resolved.length; i++) {
|
||||
for (let j = i + 1; j < resolved.length; j++) {
|
||||
pairs.push({
|
||||
player_a_id: resolved[i].player_id,
|
||||
player_b_id: resolved[j].player_id,
|
||||
stat_a: resolved[i].stat_type,
|
||||
stat_b: resolved[j].stat_type,
|
||||
hit_a: resolved[i].hit,
|
||||
hit_b: resolved[j].hit,
|
||||
});
|
||||
}
|
||||
}
|
||||
return pairs;
|
||||
}
|
||||
|
||||
function shouldRecalibrate(sampleSize) {
|
||||
return [25, 50, 75, 100].includes(sampleSize);
|
||||
}
|
||||
|
||||
function clampOffset(raw) {
|
||||
return Math.max(-0.15, Math.min(0.15, raw));
|
||||
}
|
||||
|
||||
function brierScore(confidence, hit) {
|
||||
return (confidence - (hit ? 1 : 0)) ** 2;
|
||||
}
|
||||
|
||||
function detectBlindSpots(grades) {
|
||||
if (grades.length < 200) return [];
|
||||
const grouped = {};
|
||||
for (const g of grades) {
|
||||
const key = `${g.stat_type}|${g.context}`;
|
||||
if (!grouped[key]) grouped[key] = { total: 0, hits: 0 };
|
||||
grouped[key].total += 1;
|
||||
if (g.hit) grouped[key].hits += 1;
|
||||
}
|
||||
const overall = grades.filter((g) => g.hit).length / grades.length;
|
||||
const spots = [];
|
||||
for (const [key, val] of Object.entries(grouped)) {
|
||||
const rate = val.hits / val.total;
|
||||
if ((overall - rate) / overall >= 0.25) {
|
||||
spots.push({ key, rate, degradation: (overall - rate) / overall });
|
||||
}
|
||||
}
|
||||
return spots;
|
||||
}
|
||||
|
||||
function catastrophicMisses(grades) {
|
||||
const resolved = grades.filter((g) => g.hit === false && g.actual_value != null);
|
||||
resolved.sort((a, b) => Math.abs(b.actual_value - b.prop_line) - Math.abs(a.actual_value - a.prop_line));
|
||||
const cutoff = Math.max(5, Math.ceil(resolved.length * 0.05));
|
||||
return resolved.slice(0, cutoff);
|
||||
}
|
||||
|
||||
// NBA archetype detection & weight blending
|
||||
const ARCHETYPE_WEIGHTS = {
|
||||
primary_scorer: { matchup_defense: 0.30, usage_context: 0.25, recent_form: 0.20, pace_impact: 0.15, rest_travel: 0.10 },
|
||||
secondary_creator: { usage_context: 0.35, matchup_defense: 0.20, recent_form: 0.20, pace_impact: 0.15, rest_travel: 0.10 },
|
||||
stretch_big: { matchup_defense: 0.25, usage_context: 0.20, recent_form: 0.20, pace_impact: 0.20, rest_travel: 0.15 },
|
||||
default: { matchup_defense: 0.20, usage_context: 0.20, recent_form: 0.20, pace_impact: 0.20, rest_travel: 0.20 },
|
||||
};
|
||||
|
||||
function detectArchetypes(profile) {
|
||||
const scores = {};
|
||||
if (profile.pts_per_game >= 22 && profile.usage_rate >= 0.28) {
|
||||
scores.primary_scorer = (profile.pts_per_game / 30) * 0.5 + (profile.usage_rate / 0.35) * 0.5;
|
||||
}
|
||||
if (profile.ast_per_game >= 5 && profile.usage_rate >= 0.20) {
|
||||
scores.secondary_creator = (profile.ast_per_game / 10) * 0.5 + (profile.usage_rate / 0.30) * 0.5;
|
||||
}
|
||||
if (profile.reb_per_game >= 7 && profile.three_pa_rate >= 0.25) {
|
||||
scores.stretch_big = (profile.reb_per_game / 12) * 0.5 + (profile.three_pa_rate / 0.40) * 0.5;
|
||||
}
|
||||
return scores;
|
||||
}
|
||||
|
||||
function blendWeights(archetypeScores) {
|
||||
const entries = Object.entries(archetypeScores).filter(([, s]) => s >= 0.1);
|
||||
if (entries.length === 0) return { ...ARCHETYPE_WEIGHTS.default };
|
||||
|
||||
const totalScore = entries.reduce((s, [, v]) => s + v, 0);
|
||||
const blended = {};
|
||||
for (const [arch, score] of entries) {
|
||||
const proportion = score / totalScore;
|
||||
const aw = ARCHETYPE_WEIGHTS[arch];
|
||||
for (const [dim, w] of Object.entries(aw)) {
|
||||
blended[dim] = (blended[dim] || 0) + w * proportion;
|
||||
}
|
||||
}
|
||||
return blended;
|
||||
}
|
||||
|
||||
// Parlay helpers
|
||||
function isSameGame(legs) {
|
||||
const gameIds = legs.map((l) => l.game_id);
|
||||
return new Set(gameIds).size === 1;
|
||||
}
|
||||
|
||||
function structuralPenalty(legCount) {
|
||||
return legCount > 2 ? (legCount - 2) * 0.03 : 0;
|
||||
}
|
||||
|
||||
function canComputePhi(jointCount) {
|
||||
return jointCount >= 30;
|
||||
}
|
||||
|
||||
// Capper content formatters
|
||||
function formatCapperPick(pick) {
|
||||
return `VYNDR Scan #${pick.number}: ${pick.player} ${pick.direction} ${pick.line} ${pick.stat}`;
|
||||
}
|
||||
|
||||
function formatBreakingAlert(alert) {
|
||||
return `BREAKING: ${alert.player} — ${alert.message}`;
|
||||
}
|
||||
|
||||
function formatDailyResults(results) {
|
||||
return results.map((r) => `${r.hit ? '✅' : '❌'} ${r.player} ${r.stat} ${r.line}`).join('\n');
|
||||
}
|
||||
|
||||
function formatMissAutopsy(miss) {
|
||||
return `${miss.player} ${miss.stat} ${miss.line}\nWhy: ${miss.reason}`;
|
||||
}
|
||||
|
||||
// ==========================================================
|
||||
// TESTS
|
||||
// ==========================================================
|
||||
|
||||
// ---- 1. Resolution hit/miss ----
|
||||
describe('Resolution hit/miss', () => {
|
||||
test('over hit when actual > line', () => {
|
||||
expect(resolveHit('over', 22.5, 28)).toBe(true);
|
||||
});
|
||||
|
||||
test('over miss when actual < line', () => {
|
||||
expect(resolveHit('over', 22.5, 18)).toBe(false);
|
||||
});
|
||||
|
||||
test('under hit when actual < line', () => {
|
||||
expect(resolveHit('under', 22.5, 18)).toBe(true);
|
||||
});
|
||||
|
||||
test('under miss when actual > line', () => {
|
||||
expect(resolveHit('under', 22.5, 28)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 2. CLV calculation ----
|
||||
describe('CLV calculation', () => {
|
||||
test('positive CLV when closing moves toward our direction', () => {
|
||||
const result = calculateCLV(22.5, 24.0, 'over');
|
||||
expect(result.clv).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('negative CLV when closing moves against our direction', () => {
|
||||
const result = calculateCLV(22.5, 20.0, 'over');
|
||||
expect(result.clv).toBeLessThan(0);
|
||||
});
|
||||
|
||||
test('null when no odds data', () => {
|
||||
expect(calculateCLV(null, null, 'over')).toBeNull();
|
||||
});
|
||||
|
||||
test('clv_magnitude is abs(movement)', () => {
|
||||
const result = calculateCLV(22.5, 20.0, 'over');
|
||||
expect(result.clv_magnitude).toBe(2.5);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 3. Model-market alignment ----
|
||||
describe('Model-market alignment', () => {
|
||||
test('confirming when market moves with us (over)', () => {
|
||||
expect(modelMarketAlignment(22.5, 24.0, 'over')).toBe('confirming');
|
||||
});
|
||||
|
||||
test('contrarian when market moves against us', () => {
|
||||
expect(modelMarketAlignment(22.5, 20.0, 'over')).toBe('contrarian');
|
||||
});
|
||||
|
||||
test('null when no data', () => {
|
||||
expect(modelMarketAlignment(null, null, 'over')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 4. Joint outcome logging ----
|
||||
describe('Joint outcome logging', () => {
|
||||
test('creates pair for same-game grades', () => {
|
||||
const grades = [
|
||||
{ player_id: 'A', stat_type: 'pts', hit: true },
|
||||
{ player_id: 'B', stat_type: 'reb', hit: false },
|
||||
];
|
||||
const pairs = createJointOutcomes(grades);
|
||||
expect(pairs).toHaveLength(1);
|
||||
expect(pairs[0].player_a_id).toBe('A');
|
||||
expect(pairs[0].player_b_id).toBe('B');
|
||||
});
|
||||
|
||||
test('skips self-pair', () => {
|
||||
const grades = [{ player_id: 'A', stat_type: 'pts', hit: true }];
|
||||
const pairs = createJointOutcomes(grades);
|
||||
expect(pairs).toHaveLength(0);
|
||||
});
|
||||
|
||||
test('skips unresolved pairs', () => {
|
||||
const grades = [
|
||||
{ player_id: 'A', stat_type: 'pts', hit: true },
|
||||
{ player_id: 'B', stat_type: 'reb', hit: null },
|
||||
];
|
||||
const pairs = createJointOutcomes(grades);
|
||||
expect(pairs).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 5. Calibration thresholds ----
|
||||
describe('Calibration thresholds', () => {
|
||||
test('triggers recalibration at 25, 50, 75, 100', () => {
|
||||
expect(shouldRecalibrate(25)).toBe(true);
|
||||
expect(shouldRecalibrate(50)).toBe(true);
|
||||
expect(shouldRecalibrate(75)).toBe(true);
|
||||
expect(shouldRecalibrate(100)).toBe(true);
|
||||
expect(shouldRecalibrate(30)).toBe(false);
|
||||
});
|
||||
|
||||
test('point-biserial correlation bounds 0.05–0.50', () => {
|
||||
const lower = 0.05;
|
||||
const upper = 0.50;
|
||||
const validCorrelation = 0.22;
|
||||
expect(validCorrelation).toBeGreaterThanOrEqual(lower);
|
||||
expect(validCorrelation).toBeLessThanOrEqual(upper);
|
||||
expect(0.01).toBeLessThan(lower);
|
||||
expect(0.55).toBeGreaterThan(upper);
|
||||
});
|
||||
|
||||
test('global offset thresholds at 100/250/500/1000', () => {
|
||||
const thresholds = [100, 250, 500, 1000];
|
||||
expect(thresholds).toContain(100);
|
||||
expect(thresholds).toContain(250);
|
||||
expect(thresholds).toContain(500);
|
||||
expect(thresholds).toContain(1000);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 6. Global offset clamp ----
|
||||
describe('Global offset clamp', () => {
|
||||
test('clamped to 0.15 max', () => {
|
||||
expect(clampOffset(0.30)).toBe(0.15);
|
||||
});
|
||||
|
||||
test('clamped to -0.15 min', () => {
|
||||
expect(clampOffset(-0.25)).toBe(-0.15);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 7. Brier score update ----
|
||||
describe('Brier score', () => {
|
||||
test('Brier = 0.0 for perfect prediction', () => {
|
||||
expect(brierScore(1.0, true)).toBeCloseTo(0.0);
|
||||
});
|
||||
|
||||
test('Brier = 0.25 for coin flip', () => {
|
||||
expect(brierScore(0.5, true)).toBeCloseTo(0.25);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 8. Blind spot detection ----
|
||||
describe('Blind spot detection', () => {
|
||||
test('requires 200+ grades minimum', () => {
|
||||
const grades = Array.from({ length: 150 }, (_, i) => ({
|
||||
stat_type: 'pts', context: 'home', hit: i % 2 === 0,
|
||||
}));
|
||||
expect(detectBlindSpots(grades)).toEqual([]);
|
||||
});
|
||||
|
||||
test('flags 25%+ degradation', () => {
|
||||
// 200 grades: 140 hit overall (70%), but stat_type=reb|away: 10 total, 3 hit (30%) → degradation = (0.7-0.3)/0.7 = 0.57
|
||||
const grades = [];
|
||||
for (let i = 0; i < 190; i++) {
|
||||
grades.push({ stat_type: 'pts', context: 'home', hit: i < 137 });
|
||||
}
|
||||
for (let i = 0; i < 10; i++) {
|
||||
grades.push({ stat_type: 'reb', context: 'away', hit: i < 3 });
|
||||
}
|
||||
const spots = detectBlindSpots(grades);
|
||||
expect(spots.length).toBeGreaterThanOrEqual(1);
|
||||
expect(spots[0].degradation).toBeGreaterThanOrEqual(0.25);
|
||||
});
|
||||
|
||||
test('returns empty below threshold', () => {
|
||||
const grades = Array.from({ length: 199 }, () => ({
|
||||
stat_type: 'pts', context: 'home', hit: true,
|
||||
}));
|
||||
expect(detectBlindSpots(grades)).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 9. Catastrophic miss tracking ----
|
||||
describe('Catastrophic miss tracking', () => {
|
||||
test('finds worst 5%', () => {
|
||||
const grades = [];
|
||||
for (let i = 0; i < 200; i++) {
|
||||
grades.push({
|
||||
hit: false,
|
||||
actual_value: 10 + i,
|
||||
prop_line: 5,
|
||||
});
|
||||
}
|
||||
const misses = catastrophicMisses(grades);
|
||||
expect(misses.length).toBe(10); // 5% of 200
|
||||
});
|
||||
|
||||
test('minimum 5 misses returned', () => {
|
||||
const grades = [];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
grades.push({ hit: false, actual_value: 30 + i, prop_line: 10 });
|
||||
}
|
||||
const misses = catastrophicMisses(grades);
|
||||
expect(misses.length).toBeGreaterThanOrEqual(5);
|
||||
});
|
||||
|
||||
test('sorted by abs_error descending', () => {
|
||||
const grades = [
|
||||
{ hit: false, actual_value: 50, prop_line: 20 },
|
||||
{ hit: false, actual_value: 25, prop_line: 20 },
|
||||
{ hit: false, actual_value: 40, prop_line: 20 },
|
||||
];
|
||||
const misses = catastrophicMisses(grades);
|
||||
const errors = misses.map((m) => Math.abs(m.actual_value - m.prop_line));
|
||||
for (let i = 1; i < errors.length; i++) {
|
||||
expect(errors[i - 1]).toBeGreaterThanOrEqual(errors[i]);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 10. NBA archetype weight blending ----
|
||||
describe('NBA archetype weight blending', () => {
|
||||
test('primary_scorer has matchup_defense at 0.30', () => {
|
||||
expect(ARCHETYPE_WEIGHTS.primary_scorer.matchup_defense).toBe(0.30);
|
||||
});
|
||||
|
||||
test('secondary_creator has usage_context at 0.35', () => {
|
||||
expect(ARCHETYPE_WEIGHTS.secondary_creator.usage_context).toBe(0.35);
|
||||
});
|
||||
|
||||
test('default weights when all archetype scores < 0.1', () => {
|
||||
const weights = blendWeights({ primary_scorer: 0.05, secondary_creator: 0.02 });
|
||||
expect(weights).toEqual(ARCHETYPE_WEIGHTS.default);
|
||||
});
|
||||
|
||||
test('blending with multiple archetypes produces proportional mix', () => {
|
||||
const scores = { primary_scorer: 0.6, secondary_creator: 0.4 };
|
||||
const weights = blendWeights(scores);
|
||||
// primary proportion = 0.6, secondary = 0.4, total = 1.0
|
||||
const expectedMatchupDefense = 0.30 * 0.6 + 0.20 * 0.4;
|
||||
expect(weights.matchup_defense).toBeCloseTo(expectedMatchupDefense);
|
||||
});
|
||||
|
||||
test('weights sum to ~1.0', () => {
|
||||
const scores = { primary_scorer: 0.8, secondary_creator: 0.5 };
|
||||
const weights = blendWeights(scores);
|
||||
const sum = Object.values(weights).reduce((a, b) => a + b, 0);
|
||||
expect(sum).toBeCloseTo(1.0, 2);
|
||||
});
|
||||
|
||||
test('stretch_big detected from reb_per_game + three_pa_rate', () => {
|
||||
const profile = {
|
||||
pts_per_game: 14, usage_rate: 0.18, ast_per_game: 2,
|
||||
reb_per_game: 9.5, three_pa_rate: 0.32,
|
||||
};
|
||||
const archetypes = detectArchetypes(profile);
|
||||
expect(archetypes).toHaveProperty('stretch_big');
|
||||
expect(archetypes.stretch_big).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 11. Parlay correlation ----
|
||||
describe('Parlay correlation', () => {
|
||||
test('same-game detected', () => {
|
||||
const legs = [
|
||||
{ game_id: 'G1', player: 'A' },
|
||||
{ game_id: 'G1', player: 'B' },
|
||||
];
|
||||
expect(isSameGame(legs)).toBe(true);
|
||||
});
|
||||
|
||||
test('structural penalty 0.03 per extra leg beyond 2', () => {
|
||||
expect(structuralPenalty(2)).toBe(0);
|
||||
expect(structuralPenalty(3)).toBeCloseTo(0.03);
|
||||
expect(structuralPenalty(5)).toBeCloseTo(0.09);
|
||||
});
|
||||
|
||||
test('phi requires 30+ joints', () => {
|
||||
expect(canComputePhi(29)).toBe(false);
|
||||
expect(canComputePhi(30)).toBe(true);
|
||||
});
|
||||
|
||||
test('warning on 4+ legs', () => {
|
||||
const legCount = 4;
|
||||
const warning = legCount >= 4 ? 'High-leg parlay — correlation risk elevated' : null;
|
||||
expect(warning).not.toBeNull();
|
||||
expect(warning).toContain('correlation');
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 12. Capper content ----
|
||||
describe('Capper content', () => {
|
||||
test('pick number increments', () => {
|
||||
const pick1 = formatCapperPick({ number: 1, player: 'Tatum', direction: 'over', line: 27.5, stat: 'pts' });
|
||||
const pick2 = formatCapperPick({ number: 2, player: 'Brown', direction: 'under', line: 5.5, stat: 'ast' });
|
||||
expect(pick1).toContain('#1');
|
||||
expect(pick2).toContain('#2');
|
||||
});
|
||||
|
||||
test('breaking alert format includes BREAKING', () => {
|
||||
const alert = formatBreakingAlert({ player: 'Embiid', message: 'ruled out' });
|
||||
expect(alert).toContain('BREAKING');
|
||||
});
|
||||
|
||||
test('standard format includes VYNDR Scan', () => {
|
||||
const pick = formatCapperPick({ number: 5, player: 'Jokic', direction: 'over', line: 11.5, stat: 'reb' });
|
||||
expect(pick).toContain('VYNDR Scan');
|
||||
});
|
||||
|
||||
test('daily results format includes hit/miss icons', () => {
|
||||
const results = formatDailyResults([
|
||||
{ hit: true, player: 'LeBron', stat: 'pts', line: 25.5 },
|
||||
{ hit: false, player: 'AD', stat: 'reb', line: 10.5 },
|
||||
]);
|
||||
expect(results).toContain('✅');
|
||||
expect(results).toContain('❌');
|
||||
});
|
||||
|
||||
test('miss autopsy includes Why:', () => {
|
||||
const autopsy = formatMissAutopsy({
|
||||
player: 'Harden', stat: 'ast', line: 9.5,
|
||||
reason: 'Early foul trouble limited minutes',
|
||||
});
|
||||
expect(autopsy).toContain('Why:');
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 13. Migration 005 SQL ----
|
||||
describe('Migration 005 SQL', () => {
|
||||
test('creates lineup_scheme_data', () => {
|
||||
expect(sql005).toContain('CREATE TABLE IF NOT EXISTS lineup_scheme_data');
|
||||
});
|
||||
|
||||
test('has RLS', () => {
|
||||
expect(sql005).toContain('ENABLE ROW LEVEL SECURITY');
|
||||
});
|
||||
|
||||
test('has indexes', () => {
|
||||
expect(sql005).toContain('CREATE INDEX IF NOT EXISTS idx_ls_team');
|
||||
expect(sql005).toContain('CREATE INDEX IF NOT EXISTS idx_ls_hash');
|
||||
expect(sql005).toContain('CREATE INDEX IF NOT EXISTS idx_ls_date');
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 14. Migration 006 SQL ----
|
||||
describe('Migration 006 SQL', () => {
|
||||
test('creates grade_outcomes with discipline_score column', () => {
|
||||
expect(sql006).toContain('CREATE TABLE IF NOT EXISTS grade_outcomes');
|
||||
expect(sql006).toContain('discipline_score DECIMAL');
|
||||
});
|
||||
|
||||
test('creates nba_data_cache', () => {
|
||||
expect(sql006).toContain('CREATE TABLE IF NOT EXISTS nba_data_cache');
|
||||
});
|
||||
|
||||
test('creates player_calibrated_weights', () => {
|
||||
expect(sql006).toContain('CREATE TABLE IF NOT EXISTS player_calibrated_weights');
|
||||
});
|
||||
|
||||
test('grade_outcomes has clv columns', () => {
|
||||
expect(sql006).toContain('clv_opening_line DECIMAL');
|
||||
expect(sql006).toContain('clv_closing_line DECIMAL');
|
||||
expect(sql006).toContain('clv_movement DECIMAL');
|
||||
expect(sql006).toContain('clv_win BOOLEAN');
|
||||
});
|
||||
});
|
||||
|
||||
// ---- 15. Migration 007 SQL ----
|
||||
describe('Migration 007 SQL', () => {
|
||||
test('creates reporter_trust with source_type', () => {
|
||||
expect(sql007).toContain('CREATE TABLE IF NOT EXISTS reporter_trust');
|
||||
expect(sql007).toContain('source_type TEXT NOT NULL');
|
||||
});
|
||||
|
||||
test('creates odds_warehouse', () => {
|
||||
expect(sql007).toContain('CREATE TABLE IF NOT EXISTS odds_warehouse');
|
||||
});
|
||||
|
||||
test('creates reporter_line_correlation', () => {
|
||||
expect(sql007).toContain('CREATE TABLE IF NOT EXISTS reporter_line_correlation');
|
||||
});
|
||||
|
||||
test('creates ship_joint_outcomes', () => {
|
||||
expect(sql007).toContain('CREATE TABLE IF NOT EXISTS ship_joint_outcomes');
|
||||
});
|
||||
|
||||
test('creates global_calibration', () => {
|
||||
expect(sql007).toContain('CREATE TABLE IF NOT EXISTS global_calibration');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,133 @@
|
||||
/**
|
||||
* Ship Build — Scheme Classifier Enhancement Tests
|
||||
* Validates backward compatibility + new Synergy integration.
|
||||
*/
|
||||
|
||||
const {
|
||||
SCHEME_TYPES,
|
||||
MIN_POSSESSIONS,
|
||||
CACHE_TTL,
|
||||
getCacheKey,
|
||||
classifyFromDistribution,
|
||||
extractPnRPossessions,
|
||||
classifyScheme,
|
||||
} = require('../../src/services/schemeClassifier');
|
||||
|
||||
describe('Scheme Classifier — Ship Enhancement', () => {
|
||||
|
||||
// --- Backward Compatibility ---
|
||||
|
||||
describe('Backward Compatibility', () => {
|
||||
test('SCHEME_TYPES still contains all 5 classifications', () => {
|
||||
expect(SCHEME_TYPES).toEqual(['DROP', 'SWITCH', 'HEDGE', 'MIXED', 'UNKNOWN']);
|
||||
});
|
||||
|
||||
test('MIN_POSSESSIONS still 8', () => {
|
||||
expect(MIN_POSSESSIONS).toBe(8);
|
||||
});
|
||||
|
||||
test('CACHE_TTL still 6 hours', () => {
|
||||
expect(CACHE_TTL).toBe(21600);
|
||||
});
|
||||
|
||||
test('cache key format unchanged', () => {
|
||||
expect(getCacheKey('BOS', '2026-04-13')).toBe('scheme:BOS:2026-04-13');
|
||||
});
|
||||
|
||||
test('regex classification still works for DROP', () => {
|
||||
const possessions = Array.from({ length: 10 }, () => ({ description: 'drop coverage on ball screen' }));
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('DROP');
|
||||
});
|
||||
|
||||
test('regex classification still returns UNKNOWN below threshold', () => {
|
||||
const possessions = Array.from({ length: 5 }, () => ({ description: 'drop coverage' }));
|
||||
const result = classifyScheme(possessions);
|
||||
expect(result.scheme).toBe('UNKNOWN');
|
||||
});
|
||||
|
||||
test('extractPnRPossessions still finds PnR plays', () => {
|
||||
const plays = [
|
||||
{ description: 'pick and roll ball handler' },
|
||||
{ description: 'transition fastbreak' },
|
||||
];
|
||||
expect(extractPnRPossessions(plays)).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
// --- Synergy Distribution Classification ---
|
||||
|
||||
describe('Synergy Distribution Classification', () => {
|
||||
test('classifyFromDistribution returns UNKNOWN for empty distribution', () => {
|
||||
expect(classifyFromDistribution({})).toBe('UNKNOWN');
|
||||
expect(classifyFromDistribution(null)).toBe('UNKNOWN');
|
||||
});
|
||||
|
||||
test('classifyFromDistribution returns DROP for high PPP PnR', () => {
|
||||
const dist = {
|
||||
'PRBallHandler': { frequency_pct: 0.15, ppp: 1.0, to_pct: 0.05 },
|
||||
'PRRollman': { frequency_pct: 0.10, ppp: 0.90 },
|
||||
'Isolation': { frequency_pct: 0.08 },
|
||||
};
|
||||
expect(classifyFromDistribution(dist)).toBe('DROP');
|
||||
});
|
||||
|
||||
test('classifyFromDistribution returns HEDGE for low PPP high TO PnR', () => {
|
||||
const dist = {
|
||||
'PRBallHandler': { frequency_pct: 0.15, ppp: 0.75, to_pct: 0.18 },
|
||||
'PRRollman': { frequency_pct: 0.08, ppp: 0.70 },
|
||||
'Isolation': { frequency_pct: 0.05 },
|
||||
};
|
||||
expect(classifyFromDistribution(dist)).toBe('HEDGE');
|
||||
});
|
||||
|
||||
test('classifyFromDistribution returns SWITCH for high isolation frequency', () => {
|
||||
const dist = {
|
||||
'PRBallHandler': { frequency_pct: 0.10, ppp: 0.85, to_pct: 0.10 },
|
||||
'PRRollman': { frequency_pct: 0.05 },
|
||||
'Isolation': { frequency_pct: 0.18 },
|
||||
};
|
||||
expect(classifyFromDistribution(dist)).toBe('SWITCH');
|
||||
});
|
||||
|
||||
test('classifyFromDistribution returns UNKNOWN when too little PnR data', () => {
|
||||
const dist = {
|
||||
'PRBallHandler': { frequency_pct: 0.02, ppp: 0.90 },
|
||||
'PRRollman': { frequency_pct: 0.01 },
|
||||
'Isolation': { frequency_pct: 0.10 },
|
||||
};
|
||||
expect(classifyFromDistribution(dist)).toBe('UNKNOWN');
|
||||
});
|
||||
|
||||
test('classifyFromDistribution returns MIXED for mid-range values', () => {
|
||||
const dist = {
|
||||
'PRBallHandler': { frequency_pct: 0.12, ppp: 0.88, to_pct: 0.12 },
|
||||
'PRRollman': { frequency_pct: 0.08 },
|
||||
'Isolation': { frequency_pct: 0.10 },
|
||||
};
|
||||
expect(classifyFromDistribution(dist)).toBe('MIXED');
|
||||
});
|
||||
});
|
||||
|
||||
// --- Export validation ---
|
||||
|
||||
describe('Module Exports', () => {
|
||||
test('exports fetchSynergyScheme (new)', () => {
|
||||
expect(typeof require('../../src/services/schemeClassifier').fetchSynergyScheme).toBe('function');
|
||||
});
|
||||
|
||||
test('exports classifyFromDistribution (new)', () => {
|
||||
expect(typeof require('../../src/services/schemeClassifier').classifyFromDistribution).toBe('function');
|
||||
});
|
||||
|
||||
test('exports all original functions', () => {
|
||||
const mod = require('../../src/services/schemeClassifier');
|
||||
expect(typeof mod.getCacheKey).toBe('function');
|
||||
expect(typeof mod.fetchPlayByPlay).toBe('function');
|
||||
expect(typeof mod.extractPnRPossessions).toBe('function');
|
||||
expect(typeof mod.classifyScheme).toBe('function');
|
||||
expect(typeof mod.getSchemeClassification).toBe('function');
|
||||
expect(typeof mod.logSchemeToExtended).toBe('function');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,154 @@
|
||||
/**
|
||||
* SimplifiedSelector — unit tests
|
||||
* Tests the data contracts and logic that the SimplifiedSelector component relies on.
|
||||
* Since the frontend uses Next.js/React without jest-dom configured in the Node test suite,
|
||||
* we test the underlying data shapes, stat lists, and line pre-fill logic.
|
||||
*/
|
||||
|
||||
describe('SimplifiedSelector', () => {
|
||||
const NBA_STATS = ['points', 'rebounds', 'assists', 'threes', 'blocks', 'steals', 'pra', 'turnovers'];
|
||||
const MLB_STATS = [
|
||||
'strikeouts', 'hits_allowed', 'earned_runs', 'innings_pitched', 'walks_allowed',
|
||||
'hits', 'total_bases', 'rbi', 'runs', 'stolen_bases', 'home_runs', 'walks', 'singles', 'doubles',
|
||||
];
|
||||
|
||||
// Test 1: Sport toggle renders correctly (data contract)
|
||||
test('sport toggle has exactly NBA and MLB options', () => {
|
||||
const sports = ['NBA', 'MLB'];
|
||||
expect(sports).toHaveLength(2);
|
||||
expect(sports).toContain('NBA');
|
||||
expect(sports).toContain('MLB');
|
||||
});
|
||||
|
||||
test('NBA stat list contains expected prop types', () => {
|
||||
expect(NBA_STATS).toContain('points');
|
||||
expect(NBA_STATS).toContain('rebounds');
|
||||
expect(NBA_STATS).toContain('assists');
|
||||
expect(NBA_STATS).toContain('threes');
|
||||
expect(NBA_STATS).toContain('pra');
|
||||
expect(NBA_STATS).toHaveLength(8);
|
||||
});
|
||||
|
||||
test('MLB stat list contains expected prop types', () => {
|
||||
expect(MLB_STATS).toContain('strikeouts');
|
||||
expect(MLB_STATS).toContain('hits');
|
||||
expect(MLB_STATS).toContain('total_bases');
|
||||
expect(MLB_STATS).toContain('home_runs');
|
||||
expect(MLB_STATS).toHaveLength(14);
|
||||
});
|
||||
|
||||
// Test 2: Player search accepts text input (logic contract)
|
||||
test('player search requires minimum 2 characters before querying', () => {
|
||||
const shouldSearch = (query) => query.length >= 2;
|
||||
expect(shouldSearch('')).toBe(false);
|
||||
expect(shouldSearch('L')).toBe(false);
|
||||
expect(shouldSearch('Le')).toBe(true);
|
||||
expect(shouldSearch('LeBron')).toBe(true);
|
||||
});
|
||||
|
||||
// Test 3: Stat dropdown populates from player selection
|
||||
test('stat dropdown filters to available odds when player has odds data', () => {
|
||||
const playerOdds = [
|
||||
{ player: 'LeBron James', stat_type: 'points', line: 25.5, direction: 'over', book: 'draftkings' },
|
||||
{ player: 'LeBron James', stat_type: 'rebounds', line: 7.5, direction: 'over', book: 'draftkings' },
|
||||
{ player: 'LeBron James', stat_type: 'assists', line: 7.5, direction: 'over', book: 'fanduel' },
|
||||
];
|
||||
|
||||
const availableStats = NBA_STATS.filter((s) => playerOdds.some((o) => o.stat_type === s));
|
||||
expect(availableStats).toEqual(['points', 'rebounds', 'assists']);
|
||||
expect(availableStats).not.toContain('threes');
|
||||
});
|
||||
|
||||
test('stat dropdown shows all stats when no odds data available', () => {
|
||||
const playerOdds = [];
|
||||
const availableStats = playerOdds.length > 0
|
||||
? NBA_STATS.filter((s) => playerOdds.some((o) => o.stat_type === s))
|
||||
: NBA_STATS;
|
||||
expect(availableStats).toEqual(NBA_STATS);
|
||||
});
|
||||
|
||||
// Test 4: Line pre-fills when player and stat selected
|
||||
test('line pre-fills from matching odds data', () => {
|
||||
const playerOdds = [
|
||||
{ player: 'LeBron James', stat_type: 'points', line: 25.5, direction: 'over', book: 'draftkings' },
|
||||
{ player: 'LeBron James', stat_type: 'rebounds', line: 7.5, direction: 'under', book: 'fanduel' },
|
||||
];
|
||||
|
||||
const selectedStat = 'points';
|
||||
const match = playerOdds.find((o) => o.stat_type === selectedStat);
|
||||
expect(match).toBeDefined();
|
||||
expect(match.line).toBe(25.5);
|
||||
expect(match.direction).toBe('over');
|
||||
});
|
||||
|
||||
test('line stays empty when no matching odds for selected stat', () => {
|
||||
const playerOdds = [
|
||||
{ player: 'LeBron James', stat_type: 'points', line: 25.5, direction: 'over', book: 'draftkings' },
|
||||
];
|
||||
|
||||
const selectedStat = 'blocks';
|
||||
const match = playerOdds.find((o) => o.stat_type === selectedStat);
|
||||
expect(match).toBeUndefined();
|
||||
});
|
||||
|
||||
// Test 5: Grade card renders after scan completes (data shape contract)
|
||||
test('scan result contains grade data needed for GradeCard rendering', () => {
|
||||
const mockResult = {
|
||||
scan_id: 'test-123',
|
||||
parlay_grade: 'B',
|
||||
parlay_confidence: 72,
|
||||
correlation_flags: [],
|
||||
legs: [{
|
||||
index: 0,
|
||||
player: 'LeBron James',
|
||||
stat_type: 'points',
|
||||
line: 25.5,
|
||||
direction: 'over',
|
||||
grade: 'A',
|
||||
confidence: 85,
|
||||
edge_pct: 4.2,
|
||||
kill_conditions: [],
|
||||
reasoning_summary: 'Strong recent form supports the over.',
|
||||
}],
|
||||
scan_count: 1,
|
||||
scans_remaining: 4,
|
||||
upgrade_pitch: null,
|
||||
};
|
||||
|
||||
expect(mockResult.parlay_grade).toBeDefined();
|
||||
expect(mockResult.parlay_confidence).toBeDefined();
|
||||
expect(mockResult.legs[0].grade).toBeDefined();
|
||||
expect(mockResult.legs[0].confidence).toBeDefined();
|
||||
expect(['A', 'B', 'C', 'D']).toContain(mockResult.legs[0].grade);
|
||||
});
|
||||
|
||||
// Sport switching resets state
|
||||
test('switching sport should reset stat list', () => {
|
||||
let currentSport = 'NBA';
|
||||
let stats = currentSport === 'NBA' ? NBA_STATS : MLB_STATS;
|
||||
expect(stats).toContain('points');
|
||||
|
||||
currentSport = 'MLB';
|
||||
stats = currentSport === 'NBA' ? NBA_STATS : MLB_STATS;
|
||||
expect(stats).toContain('strikeouts');
|
||||
expect(stats).not.toContain('points');
|
||||
});
|
||||
|
||||
// Scan payload shape
|
||||
test('scan payload includes all required fields', () => {
|
||||
const payload = {
|
||||
player: 'LeBron James',
|
||||
stat_type: 'points',
|
||||
line: 25.5,
|
||||
direction: 'over',
|
||||
sport: 'NBA',
|
||||
};
|
||||
|
||||
expect(payload).toHaveProperty('player');
|
||||
expect(payload).toHaveProperty('stat_type');
|
||||
expect(payload).toHaveProperty('line');
|
||||
expect(payload).toHaveProperty('direction');
|
||||
expect(payload).toHaveProperty('sport');
|
||||
expect(typeof payload.line).toBe('number');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,69 @@
|
||||
const { SPORT_CONFIG, getActiveSports, getSportConfig, SPORTS, isActiveSport } = require('../../src/config/sports');
|
||||
|
||||
describe('SPORT_CONFIG', () => {
|
||||
test('all 7 sports present in the pipeline config', () => {
|
||||
expect(Object.keys(SPORT_CONFIG).sort()).toEqual(['mlb','ncaab','ncaafb','nfl','nhl','wnba','nba'].sort());
|
||||
});
|
||||
|
||||
test('every sport is active for the pipeline', () => {
|
||||
for (const s of getActiveSports()) {
|
||||
expect(s.active).toBe(true);
|
||||
}
|
||||
expect(getActiveSports()).toHaveLength(7);
|
||||
});
|
||||
|
||||
test('each sport has espnScoreboard + espnSummary + statMap', () => {
|
||||
for (const s of getActiveSports()) {
|
||||
expect(typeof s.espnScoreboard).toBe('string');
|
||||
expect(typeof s.espnSummary).toBe('string');
|
||||
expect(s.statMap).toBeDefined();
|
||||
expect(Object.keys(s.statMap).length).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
|
||||
test('MLB carries the useMlbStatsApi flag + base URL', () => {
|
||||
const mlb = getSportConfig('mlb');
|
||||
expect(mlb.useMlbStatsApi).toBe(true);
|
||||
expect(mlb.mlbStatsApiBase).toMatch(/^https:\/\/statsapi\.mlb\.com/);
|
||||
});
|
||||
|
||||
test('NFL statMap uses category-based entries', () => {
|
||||
const nfl = getSportConfig('nfl');
|
||||
expect(nfl.statMap.passing_yards).toMatchObject({ category: 'passing', field: 'passingYards' });
|
||||
expect(nfl.statMap.receiving_yards).toMatchObject({ category: 'receiving', field: 'receivingYards' });
|
||||
});
|
||||
|
||||
test('NBA statMap exposes combos via calc()', () => {
|
||||
const nba = getSportConfig('nba');
|
||||
const stats = []; stats[1] = 25; stats[5] = 8; stats[6] = 6;
|
||||
expect(nba.statMap.pts_reb_ast.calc(stats)).toBe(39);
|
||||
expect(nba.statMap.stl_blk.calc([0,0,0,0,0,0,0,0,2,3])).toBe(5);
|
||||
});
|
||||
|
||||
test('threes_made parses "3-7" → 3 and tolerates empty/null/undefined', () => {
|
||||
const parse = getSportConfig('nba').statMap.threes_made.parse;
|
||||
expect(parse('3-7')).toBe(3);
|
||||
expect(parse('')).toBe(0);
|
||||
expect(parse(null)).toBe(0);
|
||||
expect(parse(undefined)).toBe(0);
|
||||
});
|
||||
|
||||
test('MLB inningsPitched parses "5.1" → 5.333…', () => {
|
||||
const parse = getSportConfig('mlb').statMap.inningsPitched.parse;
|
||||
expect(parse('5.1')).toBeCloseTo(5.333, 3);
|
||||
expect(parse('7.2')).toBeCloseTo(7.667, 3);
|
||||
expect(parse('')).toBe(0);
|
||||
});
|
||||
|
||||
test('getSportConfig throws on unknown sport', () => {
|
||||
expect(() => getSportConfig('curling')).toThrow(/Unknown sport/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('legacy SPORTS surface (still in use)', () => {
|
||||
test('UI flags untouched — nfl/nhl remain UI-inactive', () => {
|
||||
expect(isActiveSport('nfl')).toBe(false);
|
||||
expect(isActiveSport('nba')).toBe(true);
|
||||
expect(SPORTS.nba.color).toBe('#E94B3C');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,203 @@
|
||||
const request = require('supertest');
|
||||
const express = require('express');
|
||||
const statsRoutes = require('../../src/routes/stats');
|
||||
const propsRoutes = require('../../src/routes/props');
|
||||
|
||||
// Mock supabase
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => mockSupabase,
|
||||
}));
|
||||
|
||||
// Mock auth middleware
|
||||
jest.mock('../../src/middleware/auth', () => ({
|
||||
requireAuth: (req, res, next) => {
|
||||
req.user = req._mockUser || { id: '123', tier: 'analyst' };
|
||||
next();
|
||||
},
|
||||
}));
|
||||
|
||||
let mockSupabase;
|
||||
|
||||
beforeEach(() => {
|
||||
mockSupabase = {
|
||||
from: jest.fn().mockReturnThis(),
|
||||
select: jest.fn().mockReturnThis(),
|
||||
order: jest.fn().mockReturnThis(),
|
||||
limit: jest.fn().mockReturnThis(),
|
||||
not: jest.fn().mockReturnThis(),
|
||||
eq: jest.fn().mockReturnThis(),
|
||||
single: jest.fn(),
|
||||
};
|
||||
});
|
||||
|
||||
function buildStatsApp() {
|
||||
const app = express();
|
||||
app.use(express.json());
|
||||
app.use('/stats', statsRoutes);
|
||||
return app;
|
||||
}
|
||||
|
||||
function buildPropsApp(mockUser) {
|
||||
const app = express();
|
||||
app.use(express.json());
|
||||
// Inject mock user before routes
|
||||
app.use((req, res, next) => {
|
||||
if (mockUser) req._mockUser = mockUser;
|
||||
next();
|
||||
});
|
||||
app.use('/props', propsRoutes);
|
||||
return app;
|
||||
}
|
||||
|
||||
describe('GET /stats/parlays-graded', () => {
|
||||
it('returns count from scan_sessions', async () => {
|
||||
// Mock the select to return count via head:true pattern
|
||||
// supabase .from().select('*', { count: 'exact', head: true }) returns { count, error }
|
||||
mockSupabase.select.mockReturnValue({ count: 42, error: null });
|
||||
|
||||
const app = buildStatsApp();
|
||||
const res = await request(app).get('/stats/parlays-graded');
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toEqual({ count: 42 });
|
||||
expect(res.headers['x-vyndr-mission']).toBeDefined();
|
||||
});
|
||||
|
||||
it('returns 503 on supabase error', async () => {
|
||||
mockSupabase.select.mockReturnValue({ count: null, error: new Error('db down') });
|
||||
|
||||
const app = buildStatsApp();
|
||||
const res = await request(app).get('/stats/parlays-graded');
|
||||
|
||||
expect(res.status).toBe(503);
|
||||
expect(res.headers['x-vyndr-mission']).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /stats/public', () => {
|
||||
it('returns all 4 fields', async () => {
|
||||
// Chain: first call is for count, second for grades, third for kill_conditions
|
||||
let callCount = 0;
|
||||
mockSupabase.from.mockImplementation(() => {
|
||||
callCount++;
|
||||
return mockSupabase;
|
||||
});
|
||||
|
||||
mockSupabase.select.mockImplementation((fields, opts) => {
|
||||
if (opts && opts.count === 'exact') {
|
||||
// parlays count
|
||||
return { count: 100, error: null };
|
||||
}
|
||||
if (fields === 'final_grade') {
|
||||
// grades
|
||||
return {
|
||||
data: [
|
||||
{ final_grade: 'A' },
|
||||
{ final_grade: 'B' },
|
||||
{ final_grade: 'A' },
|
||||
{ final_grade: 'A' },
|
||||
],
|
||||
error: null,
|
||||
};
|
||||
}
|
||||
if (fields === 'kill_conditions') {
|
||||
// return this for the .not() chain
|
||||
return mockSupabase;
|
||||
}
|
||||
return mockSupabase;
|
||||
});
|
||||
|
||||
mockSupabase.not.mockReturnValue({
|
||||
data: [
|
||||
{ kill_conditions: ['back-to-back'] },
|
||||
{ kill_conditions: ['injury'] },
|
||||
{ kill_conditions: [] },
|
||||
],
|
||||
error: null,
|
||||
});
|
||||
|
||||
const app = buildStatsApp();
|
||||
const res = await request(app).get('/stats/public');
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body).toHaveProperty('parlays_graded');
|
||||
expect(res.body).toHaveProperty('avg_grade');
|
||||
expect(res.body).toHaveProperty('kill_conditions_caught');
|
||||
expect(res.body).toHaveProperty('sports_covered');
|
||||
expect(res.body.parlays_graded).toBe(100);
|
||||
expect(res.body.avg_grade).toBe('A');
|
||||
expect(res.body.kill_conditions_caught).toBe(2);
|
||||
expect(res.body.sports_covered).toEqual(['NBA', 'MLB']);
|
||||
expect(res.headers['x-vyndr-mission']).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /stats/live', () => {
|
||||
it('returns array of max 3 items', async () => {
|
||||
const mockPicks = [
|
||||
{ player: 'LeBron', stat_type: 'points', line: 25.5, direction: 'over', grade: 'A', confidence: 0.85, created_at: '2026-03-28T12:00:00Z' },
|
||||
{ player: 'Curry', stat_type: 'threes', line: 3.5, direction: 'over', grade: 'B', confidence: 0.72, created_at: '2026-03-28T11:00:00Z' },
|
||||
{ player: 'Jokic', stat_type: 'rebounds', line: 10.5, direction: 'under', grade: 'A', confidence: 0.9, created_at: '2026-03-28T10:00:00Z' },
|
||||
];
|
||||
|
||||
mockSupabase.limit.mockReturnValue({ data: mockPicks, error: null });
|
||||
|
||||
const app = buildStatsApp();
|
||||
const res = await request(app).get('/stats/live');
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(Array.isArray(res.body)).toBe(true);
|
||||
expect(res.body.length).toBeLessThanOrEqual(3);
|
||||
expect(res.body[0]).toHaveProperty('player');
|
||||
expect(res.body[0]).toHaveProperty('stat');
|
||||
expect(res.body[0]).toHaveProperty('sport', 'NBA');
|
||||
expect(res.body[0]).toHaveProperty('graded_at');
|
||||
expect(res.headers['x-vyndr-mission']).toBeDefined();
|
||||
});
|
||||
|
||||
it('returns 503 on supabase error', async () => {
|
||||
mockSupabase.limit.mockReturnValue({ data: null, error: new Error('db down') });
|
||||
|
||||
const app = buildStatsApp();
|
||||
const res = await request(app).get('/stats/live');
|
||||
|
||||
expect(res.status).toBe(503);
|
||||
expect(res.headers['x-vyndr-mission']).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /props/joint-history', () => {
|
||||
it('blocks free tier with 403', async () => {
|
||||
const app = buildPropsApp({ id: '123', tier: 'free' });
|
||||
const res = await request(app)
|
||||
.get('/props/joint-history')
|
||||
.query({ player_a: 'LeBron', stat_a: 'points', player_b: 'AD', stat_b: 'rebounds' });
|
||||
|
||||
expect(res.status).toBe(403);
|
||||
expect(res.body.error).toMatch(/Analyst or Desk/);
|
||||
});
|
||||
|
||||
it('returns sample_size 0 when no data', async () => {
|
||||
let eqCalls = 0;
|
||||
mockSupabase.eq.mockImplementation(() => {
|
||||
eqCalls++;
|
||||
if (eqCalls >= 4) return { data: [], error: null };
|
||||
return mockSupabase;
|
||||
});
|
||||
|
||||
const app = buildPropsApp({ id: '123', tier: 'analyst' });
|
||||
const res = await request(app)
|
||||
.get('/props/joint-history')
|
||||
.query({ player_a: 'LeBron', stat_a: 'points', player_b: 'AD', stat_b: 'rebounds' });
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.sample_size).toBe(0);
|
||||
});
|
||||
|
||||
it('returns 400 when missing query params', async () => {
|
||||
const app = buildPropsApp({ id: '123', tier: 'analyst' });
|
||||
const res = await request(app).get('/props/joint-history');
|
||||
|
||||
expect(res.status).toBe(400);
|
||||
});
|
||||
});
|
||||
@@ -1,16 +1,20 @@
|
||||
process.env.STRIPE_SECRET_KEY = 'sk_test_dummy';
|
||||
|
||||
// Default mock for the founder-code / price-id tests (no DB interaction).
|
||||
// Webhook tests below replace the implementation per-test.
|
||||
const mockSupabaseClient = { current: { from: jest.fn() } };
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({ from: jest.fn() }),
|
||||
getSupabaseServiceClient: () => mockSupabaseClient.current,
|
||||
}));
|
||||
|
||||
const { isFounderCodeValid, getPriceId } = require('../../src/services/stripeService');
|
||||
const { isFounderCodeValid, getPriceId, handleWebhookEvent } = require('../../src/services/stripeService');
|
||||
|
||||
describe('stripeService', () => {
|
||||
describe('isFounderCodeValid', () => {
|
||||
test('valid founder code returns true', () => {
|
||||
expect(isFounderCodeValid('FOUNDER2026')).toBe(true);
|
||||
expect(isFounderCodeValid('BETONBLK')).toBe(true);
|
||||
expect(isFounderCodeValid('VYNDR')).toBe(true);
|
||||
expect(isFounderCodeValid('BETONBLK')).toBe(true); // legacy promo, still honored
|
||||
});
|
||||
|
||||
test('case insensitive', () => {
|
||||
@@ -54,4 +58,95 @@ describe('stripeService', () => {
|
||||
expect(() => getPriceId('gold', null)).toThrow('Invalid tier');
|
||||
});
|
||||
});
|
||||
|
||||
describe('handleWebhookEvent', () => {
|
||||
// A chainable supabase fake whose final-chain return is configurable per call.
|
||||
// Records every update payload so tests can assert grace_period_until etc.
|
||||
function makeFake({ findUserById = 'user-1' } = {}) {
|
||||
const updates = [];
|
||||
const fake = {
|
||||
updates,
|
||||
from(table) {
|
||||
const ctx = { table, filters: [] };
|
||||
const proxy = {
|
||||
update(patch) {
|
||||
ctx.patch = patch;
|
||||
ctx.action = 'update';
|
||||
updates.push(ctx);
|
||||
return proxy;
|
||||
},
|
||||
select() {
|
||||
ctx.action = 'select';
|
||||
return proxy;
|
||||
},
|
||||
eq(col, val) {
|
||||
ctx.filters.push([col, val]);
|
||||
if (ctx.action === 'update') return Promise.resolve({ error: null });
|
||||
return proxy;
|
||||
},
|
||||
single() {
|
||||
return Promise.resolve({ data: findUserById ? { id: findUserById } : null });
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
};
|
||||
return fake;
|
||||
}
|
||||
|
||||
test('checkout.session.completed updates users + mirrors to user_profiles, clears grace', async () => {
|
||||
const fake = makeFake();
|
||||
mockSupabaseClient.current = fake;
|
||||
await handleWebhookEvent({
|
||||
type: 'checkout.session.completed',
|
||||
data: { object: { metadata: { user_id: 'u1', tier: 'analyst', is_founder: 'true' }, customer: 'cus_1' } },
|
||||
});
|
||||
const usersUpdate = fake.updates.find((u) => u.table === 'users');
|
||||
const profilesUpdate = fake.updates.find((u) => u.table === 'user_profiles');
|
||||
expect(usersUpdate.patch.tier).toBe('analyst');
|
||||
expect(usersUpdate.patch.grace_period_until).toBeNull();
|
||||
expect(usersUpdate.patch.mfa_setup_prompted).toBe(false);
|
||||
expect(profilesUpdate.patch.tier).toBe('analyst');
|
||||
expect(profilesUpdate.patch.subscription_status).toBe('active');
|
||||
expect(profilesUpdate.patch.founder_pricing).toBe(true);
|
||||
});
|
||||
|
||||
test('invoice.payment_failed sets a ~48h grace window', async () => {
|
||||
const fake = makeFake();
|
||||
mockSupabaseClient.current = fake;
|
||||
const before = Date.now();
|
||||
await handleWebhookEvent({
|
||||
type: 'invoice.payment_failed',
|
||||
data: { object: { customer: 'cus_2' } },
|
||||
});
|
||||
const usersUpdate = fake.updates.find((u) => u.table === 'users');
|
||||
const profilesUpdate = fake.updates.find((u) => u.table === 'user_profiles');
|
||||
const graceTs = new Date(usersUpdate.patch.grace_period_until).getTime();
|
||||
const expected = before + 48 * 60 * 60 * 1000;
|
||||
expect(Math.abs(graceTs - expected)).toBeLessThan(60_000); // within a minute of 48h
|
||||
expect(profilesUpdate.patch.subscription_status).toBe('grace_period');
|
||||
});
|
||||
|
||||
test('customer.subscription.deleted sets grace, does not flip tier immediately', async () => {
|
||||
const fake = makeFake();
|
||||
mockSupabaseClient.current = fake;
|
||||
await handleWebhookEvent({
|
||||
type: 'customer.subscription.deleted',
|
||||
data: { object: { customer: 'cus_3' } },
|
||||
});
|
||||
const usersUpdate = fake.updates.find((u) => u.table === 'users');
|
||||
expect(usersUpdate.patch.grace_period_until).toBeTruthy();
|
||||
// tier is intentionally NOT downgraded here — the grace period gate
|
||||
// handles read-time enforcement.
|
||||
expect(usersUpdate.patch.tier).toBeUndefined();
|
||||
});
|
||||
|
||||
test('payment_failed with unknown customer logs but does not throw', async () => {
|
||||
const fake = makeFake({ findUserById: null });
|
||||
mockSupabaseClient.current = fake;
|
||||
await expect(
|
||||
handleWebhookEvent({ type: 'invoice.payment_failed', data: { object: { customer: 'cus_ghost' } } })
|
||||
).resolves.toBeUndefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,589 @@
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
|
||||
// ─────────────────────────────────────────────────────────────
|
||||
// VYNDR — Supplement Intelligence Systems
|
||||
// Pure logic tests: all constants and formulas inlined
|
||||
// ─────────────────────────────────────────────────────────────
|
||||
|
||||
describe('Supplement Intelligence Systems', () => {
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// System 1 — Coaching Tendencies
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
describe('Coaching Tendencies', () => {
|
||||
|
||||
const NBA_COACHING_FIELDS = [
|
||||
'pace_preference', 'rotation_depth', 'closing_lineup_consistency',
|
||||
'garbage_time_threshold', 'challenge_frequency', 'blitz_frequency',
|
||||
'zone_pct', 'rest_pattern', 'matchup_hunting_rate',
|
||||
'dnp_volatility', 'second_unit_usage', 'timeout_tendency',
|
||||
];
|
||||
|
||||
const MLB_COACHING_FIELDS = [
|
||||
'starter_hook_tendency', 'bullpen_deployment', 'platoon_aggressiveness',
|
||||
'sacrifice_bunt_rate', 'hit_and_run_rate', 'steal_aggressiveness',
|
||||
'defensive_shift_rate', 'lineup_consistency', 'rest_day_pattern',
|
||||
'challenge_aggressiveness',
|
||||
];
|
||||
|
||||
test('NBA coaching fields include all 12 expected keys', () => {
|
||||
expect(NBA_COACHING_FIELDS).toHaveLength(12);
|
||||
expect(NBA_COACHING_FIELDS).toContain('pace_preference');
|
||||
expect(NBA_COACHING_FIELDS).toContain('timeout_tendency');
|
||||
});
|
||||
|
||||
test('MLB coaching fields include all 10 expected keys', () => {
|
||||
expect(MLB_COACHING_FIELDS).toHaveLength(10);
|
||||
expect(MLB_COACHING_FIELDS).toContain('starter_hook_tendency');
|
||||
expect(MLB_COACHING_FIELDS).toContain('challenge_aggressiveness');
|
||||
});
|
||||
|
||||
test('parse_nba_coaching_decisions extracts rotation_depth from players with 10+ min', () => {
|
||||
const players = [
|
||||
{ minutes: 32 }, { minutes: 28 }, { minutes: 24 },
|
||||
{ minutes: 20 }, { minutes: 18 }, { minutes: 14 },
|
||||
{ minutes: 12 }, { minutes: 11 }, { minutes: 8 },
|
||||
{ minutes: 5 }, { minutes: 3 },
|
||||
];
|
||||
const rotation_depth = players.filter(p => p.minutes >= 10).length;
|
||||
expect(rotation_depth).toBe(8);
|
||||
});
|
||||
|
||||
test('rotation_depth of 8 from 8 players with 10+ minutes', () => {
|
||||
const playerMinutes = [35, 30, 28, 22, 18, 15, 12, 10, 7, 4];
|
||||
const rotation_depth = playerMinutes.filter(m => m >= 10).length;
|
||||
expect(rotation_depth).toBe(8);
|
||||
});
|
||||
|
||||
test('parse_mlb_coaching_decisions extracts starter_hook_tendency', () => {
|
||||
// Hook tendency = avg innings before pull across recent starts
|
||||
const starterInnings = [5.2, 6.0, 5.1, 4.2, 6.1];
|
||||
const avgHook = starterInnings.reduce((s, v) => s + v, 0) / starterInnings.length;
|
||||
expect(avgHook).toBeCloseTo(5.32, 1);
|
||||
});
|
||||
|
||||
test('shift detection: 15% threshold for flagging', () => {
|
||||
const SHIFT_THRESHOLD = 0.15;
|
||||
expect(SHIFT_THRESHOLD).toBe(0.15);
|
||||
});
|
||||
|
||||
test('shift detection: 10% change does NOT flag', () => {
|
||||
const SHIFT_THRESHOLD = 0.15;
|
||||
const baseline = 0.50;
|
||||
const current = 0.55;
|
||||
const change = Math.abs(current - baseline) / baseline;
|
||||
expect(change).toBeCloseTo(0.10, 4);
|
||||
expect(change < SHIFT_THRESHOLD).toBe(true);
|
||||
});
|
||||
|
||||
test('shift detection: 20% change DOES flag', () => {
|
||||
const SHIFT_THRESHOLD = 0.15;
|
||||
const baseline = 0.50;
|
||||
const current = 0.60;
|
||||
const change = Math.abs(current - baseline) / baseline;
|
||||
expect(change).toBeCloseTo(0.20, 4);
|
||||
expect(change >= SHIFT_THRESHOLD).toBe(true);
|
||||
});
|
||||
|
||||
test('shift detection returns direction increased or decreased', () => {
|
||||
const baseline = 0.50;
|
||||
const currentUp = 0.65;
|
||||
const currentDown = 0.35;
|
||||
const dirUp = currentUp > baseline ? 'increased' : 'decreased';
|
||||
const dirDown = currentDown > baseline ? 'increased' : 'decreased';
|
||||
expect(dirUp).toBe('increased');
|
||||
expect(dirDown).toBe('decreased');
|
||||
});
|
||||
|
||||
test('season baseline includes all numeric fields', () => {
|
||||
const seasonBaseline = {
|
||||
pace_preference: 98.5,
|
||||
rotation_depth: 9,
|
||||
closing_lineup_consistency: 0.72,
|
||||
zone_pct: 0.15,
|
||||
rest_pattern: 3.2,
|
||||
};
|
||||
for (const val of Object.values(seasonBaseline)) {
|
||||
expect(typeof val).toBe('number');
|
||||
}
|
||||
});
|
||||
|
||||
test('recent tendencies calculated from last 15 games', () => {
|
||||
const RECENT_WINDOW = 15;
|
||||
const allGames = Array.from({ length: 40 }, (_, i) => ({ pace: 95 + (i % 10) }));
|
||||
const recentGames = allGames.slice(-RECENT_WINDOW);
|
||||
expect(recentGames).toHaveLength(15);
|
||||
});
|
||||
|
||||
test('coaching fields are sport-specific (NBA != MLB)', () => {
|
||||
const overlap = NBA_COACHING_FIELDS.filter(f => MLB_COACHING_FIELDS.includes(f));
|
||||
expect(overlap).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// System 2 — Redistribution Engine
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
describe('Redistribution Engine', () => {
|
||||
|
||||
function classify_absorption_tier(boost, confidence) {
|
||||
if (boost >= 0.20 && confidence >= 0.75) return 'primary';
|
||||
if (boost >= 0.10 && confidence >= 0.60) return 'secondary';
|
||||
if (boost >= 0.05) return 'tertiary';
|
||||
return 'minimal';
|
||||
}
|
||||
|
||||
test('classify_absorption_tier: primary when boost>=0.20 AND confidence>=0.75', () => {
|
||||
expect(classify_absorption_tier(0.25, 0.80)).toBe('primary');
|
||||
expect(classify_absorption_tier(0.20, 0.75)).toBe('primary');
|
||||
});
|
||||
|
||||
test('classify_absorption_tier: secondary when boost>=0.10 AND confidence>=0.60', () => {
|
||||
expect(classify_absorption_tier(0.15, 0.65)).toBe('secondary');
|
||||
expect(classify_absorption_tier(0.10, 0.60)).toBe('secondary');
|
||||
});
|
||||
|
||||
test('classify_absorption_tier: tertiary when boost>=0.05', () => {
|
||||
expect(classify_absorption_tier(0.07, 0.40)).toBe('tertiary');
|
||||
expect(classify_absorption_tier(0.05, 0.10)).toBe('tertiary');
|
||||
});
|
||||
|
||||
test('classify_absorption_tier: minimal when boost<0.05', () => {
|
||||
expect(classify_absorption_tier(0.04, 0.90)).toBe('minimal');
|
||||
expect(classify_absorption_tier(0.01, 0.50)).toBe('minimal');
|
||||
});
|
||||
|
||||
test('concentrated coach (7-man): backup gets 70% of freed minutes', () => {
|
||||
const rotation_depth = 7;
|
||||
const minutes_freed = 30;
|
||||
const backup_share = rotation_depth <= 7 ? minutes_freed * 0.70 : minutes_freed / 4;
|
||||
expect(backup_share).toBe(21);
|
||||
});
|
||||
|
||||
test('distributed coach (10-man): minutes spread across 3-4 players', () => {
|
||||
const rotation_depth = 10;
|
||||
const minutes_freed = 30;
|
||||
const per_player_share = rotation_depth <= 7 ? minutes_freed * 0.70 : minutes_freed / 4;
|
||||
expect(per_player_share).toBe(7.5);
|
||||
// 4 players share equally
|
||||
expect(minutes_freed / 4).toBe(7.5);
|
||||
});
|
||||
|
||||
test('usage-efficiency tradeoff: -1.5% TS per +5% usage applied correctly', () => {
|
||||
// Formula: penalty = raw_boost * (-0.015 / 0.05)
|
||||
const raw_boost = 0.10;
|
||||
const penalty = raw_boost * (-0.015 / 0.05);
|
||||
expect(penalty).toBeCloseTo(-0.03, 4);
|
||||
});
|
||||
|
||||
test('net boost = raw_boost + efficiency_penalty', () => {
|
||||
const raw_boost = 0.10;
|
||||
const penalty = raw_boost * (-0.015 / 0.05);
|
||||
const net_boost = raw_boost + penalty;
|
||||
expect(net_boost).toBeCloseTo(0.07, 4);
|
||||
});
|
||||
|
||||
test('system change: primary_scorer out -> secondary_creator gets +0.08', () => {
|
||||
const SYSTEM_SHIFTS = {
|
||||
primary_scorer: { secondary_creator: 0.08, tertiary_scorer: 0.05 },
|
||||
primary_playmaker: { secondary_creator: 0.06 },
|
||||
interior_big: { stretch_big: 0.07 },
|
||||
};
|
||||
expect(SYSTEM_SHIFTS.primary_scorer.secondary_creator).toBe(0.08);
|
||||
});
|
||||
|
||||
test('system change: primary_playmaker out -> secondary_creator gets +0.06', () => {
|
||||
const SYSTEM_SHIFTS = {
|
||||
primary_scorer: { secondary_creator: 0.08 },
|
||||
primary_playmaker: { secondary_creator: 0.06 },
|
||||
interior_big: { stretch_big: 0.07 },
|
||||
};
|
||||
expect(SYSTEM_SHIFTS.primary_playmaker.secondary_creator).toBe(0.06);
|
||||
});
|
||||
|
||||
test('system change: interior_big out -> stretch_big gets +0.07', () => {
|
||||
const SYSTEM_SHIFTS = {
|
||||
primary_scorer: { secondary_creator: 0.08 },
|
||||
primary_playmaker: { secondary_creator: 0.06 },
|
||||
interior_big: { stretch_big: 0.07 },
|
||||
};
|
||||
expect(SYSTEM_SHIFTS.interior_big.stretch_big).toBe(0.07);
|
||||
});
|
||||
|
||||
test('auto-grade threshold: 15%+ boost AND 0.65+ confidence', () => {
|
||||
const AUTO_BOOST_THRESHOLD = 0.15;
|
||||
const AUTO_CONFIDENCE_THRESHOLD = 0.65;
|
||||
const should_auto_grade = (boost, conf) =>
|
||||
boost >= AUTO_BOOST_THRESHOLD && conf >= AUTO_CONFIDENCE_THRESHOLD;
|
||||
expect(should_auto_grade(0.18, 0.70)).toBe(true);
|
||||
expect(should_auto_grade(0.15, 0.65)).toBe(true);
|
||||
});
|
||||
|
||||
test('auto-grade: 14% boost does NOT trigger auto-grade', () => {
|
||||
const AUTO_BOOST_THRESHOLD = 0.15;
|
||||
const AUTO_CONFIDENCE_THRESHOLD = 0.65;
|
||||
const should_auto_grade = (boost, conf) =>
|
||||
boost >= AUTO_BOOST_THRESHOLD && conf >= AUTO_CONFIDENCE_THRESHOLD;
|
||||
expect(should_auto_grade(0.14, 0.90)).toBe(false);
|
||||
});
|
||||
|
||||
test('absorption alert format includes is OUT and is underpriced', () => {
|
||||
const playerOut = 'LeBron James';
|
||||
const beneficiary = 'Anthony Davis';
|
||||
const alert = `${playerOut} is OUT — ${beneficiary} is underpriced at current line`;
|
||||
expect(alert).toContain('is OUT');
|
||||
expect(alert).toContain('is underpriced');
|
||||
});
|
||||
|
||||
test('coach-specific redistribution_profile overrides generic system shifts', () => {
|
||||
const generic_boost = 0.08;
|
||||
const coach_profile = { secondary_creator_boost: 0.12 };
|
||||
const effective_boost = coach_profile.secondary_creator_boost || generic_boost;
|
||||
expect(effective_boost).toBe(0.12);
|
||||
expect(effective_boost).not.toBe(generic_boost);
|
||||
});
|
||||
});
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// System 3 — Alt Line Scanner
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
describe('Alt Line Scanner', () => {
|
||||
|
||||
const A_GRADES = ['A+', 'A', 'A-'];
|
||||
|
||||
function isEligibleForAltScan(grade) {
|
||||
return A_GRADES.includes(grade);
|
||||
}
|
||||
|
||||
test('only runs on A-grade props (A+, A, A-)', () => {
|
||||
expect(isEligibleForAltScan('A+')).toBe(true);
|
||||
expect(isEligibleForAltScan('A')).toBe(true);
|
||||
expect(isEligibleForAltScan('A-')).toBe(true);
|
||||
});
|
||||
|
||||
test('returns eligible=false for B+ grade', () => {
|
||||
expect(isEligibleForAltScan('B+')).toBe(false);
|
||||
expect(isEligibleForAltScan('B')).toBe(false);
|
||||
expect(isEligibleForAltScan('C')).toBe(false);
|
||||
});
|
||||
|
||||
test('edge improvement threshold is 3% (0.03)', () => {
|
||||
const EDGE_IMPROVEMENT_THRESHOLD = 0.03;
|
||||
expect(EDGE_IMPROVEMENT_THRESHOLD).toBe(0.03);
|
||||
});
|
||||
|
||||
test('recommends alt when edge_vs_standard >= 0.03', () => {
|
||||
const EDGE_IMPROVEMENT_THRESHOLD = 0.03;
|
||||
const edge_vs_standard = 0.05;
|
||||
const recommend = edge_vs_standard >= EDGE_IMPROVEMENT_THRESHOLD;
|
||||
expect(recommend).toBe(true);
|
||||
});
|
||||
|
||||
test('does NOT recommend when edge_vs_standard < 0.03', () => {
|
||||
const EDGE_IMPROVEMENT_THRESHOLD = 0.03;
|
||||
const edge_vs_standard = 0.02;
|
||||
const recommend = edge_vs_standard >= EDGE_IMPROVEMENT_THRESHOLD;
|
||||
expect(recommend).toBe(false);
|
||||
});
|
||||
|
||||
test('alt lines sorted by ev_per_dollar descending', () => {
|
||||
const altLines = [
|
||||
{ line: 22.5, ev_per_dollar: 0.04 },
|
||||
{ line: 24.5, ev_per_dollar: 0.12 },
|
||||
{ line: 27.5, ev_per_dollar: 0.08 },
|
||||
];
|
||||
const sorted = [...altLines].sort((a, b) => b.ev_per_dollar - a.ev_per_dollar);
|
||||
expect(sorted[0].ev_per_dollar).toBe(0.12);
|
||||
expect(sorted[1].ev_per_dollar).toBe(0.08);
|
||||
expect(sorted[2].ev_per_dollar).toBe(0.04);
|
||||
});
|
||||
|
||||
test('returns top 5 positive EV alts only', () => {
|
||||
const altLines = [
|
||||
{ line: 20.5, ev_per_dollar: 0.15 },
|
||||
{ line: 21.5, ev_per_dollar: 0.12 },
|
||||
{ line: 22.5, ev_per_dollar: 0.09 },
|
||||
{ line: 23.5, ev_per_dollar: 0.06 },
|
||||
{ line: 24.5, ev_per_dollar: 0.03 },
|
||||
{ line: 25.5, ev_per_dollar: 0.01 },
|
||||
{ line: 26.5, ev_per_dollar: -0.02 },
|
||||
];
|
||||
const positiveEV = altLines
|
||||
.filter(a => a.ev_per_dollar > 0)
|
||||
.sort((a, b) => b.ev_per_dollar - a.ev_per_dollar)
|
||||
.slice(0, 5);
|
||||
expect(positiveEV).toHaveLength(5);
|
||||
expect(positiveEV.every(a => a.ev_per_dollar > 0)).toBe(true);
|
||||
});
|
||||
|
||||
test('model probability calculation: over = 1 - CDF, under = CDF', () => {
|
||||
// Inline normalCDF approximation
|
||||
function normalCDF(x, mean, stddev) {
|
||||
const z = (x - mean) / stddev;
|
||||
const t = 1 / (1 + 0.2316419 * Math.abs(z));
|
||||
const d = 0.3989422804014327;
|
||||
const p = d * Math.exp(-z * z / 2) *
|
||||
(t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))));
|
||||
return z > 0 ? 1 - p : p;
|
||||
}
|
||||
const mean = 25, stddev = 5, line = 25;
|
||||
const prob_over = 1 - normalCDF(line, mean, stddev);
|
||||
const prob_under = normalCDF(line, mean, stddev);
|
||||
expect(prob_over).toBeCloseTo(0.5, 1);
|
||||
expect(prob_under).toBeCloseTo(0.5, 1);
|
||||
});
|
||||
|
||||
test('optimal alt is first element after sorting', () => {
|
||||
const sorted = [
|
||||
{ line: 24.5, ev_per_dollar: 0.12 },
|
||||
{ line: 22.5, ev_per_dollar: 0.08 },
|
||||
{ line: 27.5, ev_per_dollar: 0.04 },
|
||||
];
|
||||
const optimal = sorted[0];
|
||||
expect(optimal.line).toBe(24.5);
|
||||
expect(optimal.ev_per_dollar).toBe(0.12);
|
||||
});
|
||||
|
||||
test('alt line includes bookmaker field', () => {
|
||||
const altLine = { line: 22.5, odds: -130, book: 'draftkings', ev_per_dollar: 0.08 };
|
||||
expect(altLine).toHaveProperty('book');
|
||||
expect(altLine.book).toBe('draftkings');
|
||||
});
|
||||
});
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// System 4 — Unconventional Data Pipeline
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
describe('Unconventional Data Pipeline', () => {
|
||||
|
||||
const MIN_INSTANCES = 500;
|
||||
const MIN_PEARSON_R = 0.15;
|
||||
const BASE_ALPHA = 0.05;
|
||||
|
||||
function validateFactor(instances, r, p_value, num_tests) {
|
||||
if (instances < MIN_INSTANCES) return { validated: false, reason: 'insufficient_instances' };
|
||||
if (Math.abs(r) < MIN_PEARSON_R) return { validated: false, reason: 'weak_correlation' };
|
||||
const corrected_alpha = BASE_ALPHA / num_tests;
|
||||
if (p_value >= corrected_alpha) return { validated: false, reason: 'not_significant' };
|
||||
return { validated: true, corrected_alpha };
|
||||
}
|
||||
|
||||
const UNCONVENTIONAL_FACTORS = [
|
||||
{ name: 'travel_distance', validated: true },
|
||||
{ name: 'altitude_adjustment', validated: false },
|
||||
{ name: 'circadian_rhythm', validated: false },
|
||||
{ name: 'back_to_back_fatigue', validated: true },
|
||||
{ name: 'timezone_crossing', validated: false },
|
||||
];
|
||||
|
||||
test('validation requires minimum 500 instances', () => {
|
||||
expect(MIN_INSTANCES).toBe(500);
|
||||
});
|
||||
|
||||
test('fails with 499 instances', () => {
|
||||
const result = validateFactor(499, 0.20, 0.001, 4);
|
||||
expect(result.validated).toBe(false);
|
||||
expect(result.reason).toBe('insufficient_instances');
|
||||
});
|
||||
|
||||
test('passes with 500+ instances (if r and p pass)', () => {
|
||||
const result = validateFactor(600, 0.25, 0.001, 4);
|
||||
expect(result.validated).toBe(true);
|
||||
});
|
||||
|
||||
test('minimum Pearson r is 0.15', () => {
|
||||
expect(MIN_PEARSON_R).toBe(0.15);
|
||||
});
|
||||
|
||||
test('fails when r < 0.15', () => {
|
||||
const result = validateFactor(600, 0.10, 0.001, 4);
|
||||
expect(result.validated).toBe(false);
|
||||
expect(result.reason).toBe('weak_correlation');
|
||||
});
|
||||
|
||||
test('Bonferroni correction: alpha = 0.05 / number_of_active_tests', () => {
|
||||
const num_tests = 4;
|
||||
const corrected = BASE_ALPHA / num_tests;
|
||||
expect(corrected).toBe(0.0125);
|
||||
});
|
||||
|
||||
test('with 4 unvalidated factors, corrected alpha = 0.0125', () => {
|
||||
const unvalidated = UNCONVENTIONAL_FACTORS.filter(f => !f.validated);
|
||||
expect(unvalidated).toHaveLength(3);
|
||||
// When testing 4 factors simultaneously
|
||||
const corrected = BASE_ALPHA / 4;
|
||||
expect(corrected).toBe(0.0125);
|
||||
});
|
||||
|
||||
test('with 1 unvalidated factor, corrected alpha = 0.05', () => {
|
||||
const corrected = BASE_ALPHA / 1;
|
||||
expect(corrected).toBe(0.05);
|
||||
});
|
||||
|
||||
test('travel_distance starts as validated=True', () => {
|
||||
const travel = UNCONVENTIONAL_FACTORS.find(f => f.name === 'travel_distance');
|
||||
expect(travel.validated).toBe(true);
|
||||
});
|
||||
|
||||
test('altitude_adjustment starts as validated=False', () => {
|
||||
const altitude = UNCONVENTIONAL_FACTORS.find(f => f.name === 'altitude_adjustment');
|
||||
expect(altitude.validated).toBe(false);
|
||||
});
|
||||
|
||||
test('factor only enters grading engine AFTER validation (validated=True check)', () => {
|
||||
const activeFactors = UNCONVENTIONAL_FACTORS.filter(f => f.validated);
|
||||
expect(activeFactors.every(f => f.validated === true)).toBe(true);
|
||||
expect(activeFactors.map(f => f.name)).toContain('travel_distance');
|
||||
expect(activeFactors.map(f => f.name)).not.toContain('altitude_adjustment');
|
||||
});
|
||||
|
||||
test('status endpoint returns all 5 factor names', () => {
|
||||
expect(UNCONVENTIONAL_FACTORS).toHaveLength(5);
|
||||
const names = UNCONVENTIONAL_FACTORS.map(f => f.name);
|
||||
expect(names).toContain('travel_distance');
|
||||
expect(names).toContain('altitude_adjustment');
|
||||
expect(names).toContain('circadian_rhythm');
|
||||
expect(names).toContain('back_to_back_fatigue');
|
||||
expect(names).toContain('timezone_crossing');
|
||||
});
|
||||
});
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// System 5 — Evolution Alerting
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
describe('Evolution Alerting', () => {
|
||||
|
||||
const MIN_GAMES = 15;
|
||||
const CHANGE_THRESHOLD = 0.10;
|
||||
const MIN_INFLECTIONS = 2;
|
||||
|
||||
const NBA_METRICS = ['usage_rate', 'assist_rate', 'three_pa_rate', 'fg_pct', 'minutes'];
|
||||
const MLB_METRICS = ['k_rate', 'bb_rate', 'exit_velocity', 'hard_hit_pct', 'fb_velo'];
|
||||
|
||||
function detectEvolution(gameCount, inflections) {
|
||||
if (gameCount < MIN_GAMES) return { evolution_detected: false, reason: 'insufficient_games' };
|
||||
if (inflections.length < MIN_INFLECTIONS) return { evolution_detected: false, reason: 'insufficient_inflections' };
|
||||
return {
|
||||
evolution_detected: true,
|
||||
detection_date: new Date().toISOString().split('T')[0],
|
||||
metrics: inflections,
|
||||
};
|
||||
}
|
||||
|
||||
function isInflection(baseline, current) {
|
||||
const change = Math.abs(current - baseline) / baseline;
|
||||
return change >= CHANGE_THRESHOLD;
|
||||
}
|
||||
|
||||
test('evolution detected when 2+ metrics show concurrent inflection', () => {
|
||||
const inflections = ['usage_rate', 'assist_rate'];
|
||||
const result = detectEvolution(20, inflections);
|
||||
expect(result.evolution_detected).toBe(true);
|
||||
});
|
||||
|
||||
test('evolution NOT detected with only 1 inflection', () => {
|
||||
const inflections = ['usage_rate'];
|
||||
const result = detectEvolution(20, inflections);
|
||||
expect(result.evolution_detected).toBe(false);
|
||||
expect(result.reason).toBe('insufficient_inflections');
|
||||
});
|
||||
|
||||
test('minimum 15 games required', () => {
|
||||
expect(MIN_GAMES).toBe(15);
|
||||
});
|
||||
|
||||
test('returns evolution_detected=false with 14 games', () => {
|
||||
const result = detectEvolution(14, ['usage_rate', 'assist_rate']);
|
||||
expect(result.evolution_detected).toBe(false);
|
||||
expect(result.reason).toBe('insufficient_games');
|
||||
});
|
||||
|
||||
test('change threshold is 10% (0.10)', () => {
|
||||
expect(CHANGE_THRESHOLD).toBe(0.10);
|
||||
});
|
||||
|
||||
test('9% change does NOT qualify as inflection', () => {
|
||||
const baseline = 0.20;
|
||||
const current = 0.218; // 9% change
|
||||
expect(isInflection(baseline, current)).toBe(false);
|
||||
});
|
||||
|
||||
test('11% change DOES qualify as inflection', () => {
|
||||
const baseline = 0.20;
|
||||
const current = 0.222; // 11% change
|
||||
expect(isInflection(baseline, current)).toBe(true);
|
||||
});
|
||||
|
||||
test('NBA metrics: usage_rate, assist_rate, three_pa_rate, fg_pct, minutes', () => {
|
||||
expect(NBA_METRICS).toEqual(['usage_rate', 'assist_rate', 'three_pa_rate', 'fg_pct', 'minutes']);
|
||||
expect(NBA_METRICS).toHaveLength(5);
|
||||
});
|
||||
|
||||
test('MLB metrics: k_rate, bb_rate, exit_velocity, hard_hit_pct, fb_velo', () => {
|
||||
expect(MLB_METRICS).toEqual(['k_rate', 'bb_rate', 'exit_velocity', 'hard_hit_pct', 'fb_velo']);
|
||||
expect(MLB_METRICS).toHaveLength(5);
|
||||
});
|
||||
|
||||
test('evolution record includes detection_date and metrics', () => {
|
||||
const inflections = ['usage_rate', 'three_pa_rate'];
|
||||
const result = detectEvolution(20, inflections);
|
||||
expect(result).toHaveProperty('detection_date');
|
||||
expect(result).toHaveProperty('metrics');
|
||||
expect(result.metrics).toEqual(inflections);
|
||||
});
|
||||
|
||||
test('Evolution Watch post format includes Evolution Watch', () => {
|
||||
const playerName = 'Jalen Brunson';
|
||||
const metrics = ['usage_rate', 'assist_rate'];
|
||||
const post = `Evolution Watch: ${playerName} — ${metrics.join(', ')} trending. The market hasn't priced it yet.`;
|
||||
expect(post).toContain('Evolution Watch');
|
||||
});
|
||||
|
||||
test('Evolution Watch post includes market hasn\'t priced it yet', () => {
|
||||
const post = `Evolution Watch: Player X — usage_rate trending. The market hasn't priced it yet.`;
|
||||
expect(post).toContain("market hasn't priced it yet");
|
||||
});
|
||||
});
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Migration 008 — Table Definitions
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
describe('Migration 008', () => {
|
||||
|
||||
const sql = fs.readFileSync(
|
||||
path.join(__dirname, '..', '..', 'supabase', 'migrations', '008_supplement_tables.sql'),
|
||||
'utf-8'
|
||||
);
|
||||
|
||||
test('creates coaching_tendencies table with UNIQUE constraint', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS coaching_tendencies');
|
||||
expect(sql).toContain('UNIQUE(coach_id, team_id, sport, season)');
|
||||
});
|
||||
|
||||
test('creates player_out_history table', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS player_out_history');
|
||||
expect(sql).toContain('player_out_id TEXT NOT NULL');
|
||||
expect(sql).toContain('beneficiary_stats JSONB NOT NULL');
|
||||
});
|
||||
|
||||
test('creates evolution_detections table', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS evolution_detections');
|
||||
expect(sql).toContain('detection_date DATE NOT NULL');
|
||||
expect(sql).toContain('metrics JSONB NOT NULL');
|
||||
});
|
||||
|
||||
test('creates unconventional_validations with RLS', () => {
|
||||
expect(sql).toContain('CREATE TABLE IF NOT EXISTS unconventional_validations');
|
||||
expect(sql).toContain('ALTER TABLE unconventional_validations ENABLE ROW LEVEL SECURITY');
|
||||
expect(sql).toContain('factor_name TEXT NOT NULL');
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
@@ -0,0 +1,110 @@
|
||||
const mockAxiosGet = jest.fn();
|
||||
jest.mock('axios', () => ({ get: (...args) => mockAxiosGet(...args) }));
|
||||
|
||||
const mockCache = { current: new Map() };
|
||||
jest.mock('../../src/utils/redis', () => ({
|
||||
cacheGet: async (k) => mockCache.current.get(k) ?? null,
|
||||
cacheSet: async (k, v) => { mockCache.current.set(k, v); return true; },
|
||||
cacheDel: async (k) => { mockCache.current.delete(k); return true; },
|
||||
}));
|
||||
|
||||
jest.mock('../../src/utils/rateLimiter', () => ({
|
||||
createLimiter: () => ({ waitForToken: async () => true, snapshot: () => ({}) }),
|
||||
createCircuitBreaker: () => ({ call: async (fn) => fn(), snapshot: () => ({}) }),
|
||||
}));
|
||||
|
||||
const cache = require('../../src/services/intelligence/teamStatsCache');
|
||||
|
||||
beforeEach(() => {
|
||||
mockAxiosGet.mockReset();
|
||||
mockCache.current.clear();
|
||||
});
|
||||
|
||||
describe('teamStatsCache', () => {
|
||||
test('refreshTeamStats walks team list and writes cache per team', async () => {
|
||||
mockAxiosGet
|
||||
// teams list
|
||||
.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: {
|
||||
sports: [{ leagues: [{ teams: [
|
||||
{ team: { id: 1, abbreviation: 'NYK', displayName: 'Knicks' } },
|
||||
{ team: { id: 2, abbreviation: 'BOS', displayName: 'Celtics' } },
|
||||
] }] }],
|
||||
},
|
||||
})
|
||||
// team 1 stats
|
||||
.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: { results: { stats: [{ stats: [
|
||||
{ name: 'offensiveRating', value: 118.5 },
|
||||
{ name: 'defensiveRating', value: 110.2 },
|
||||
{ name: 'pace', value: 100.4 },
|
||||
] }] } },
|
||||
})
|
||||
// team 2 stats
|
||||
.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: { results: { stats: [{ stats: [
|
||||
{ name: 'offensiveRating', value: 120.0 },
|
||||
{ name: 'defensiveRating', value: 108.0 },
|
||||
] }] } },
|
||||
});
|
||||
|
||||
const summary = await cache.refreshTeamStats('nba');
|
||||
expect(summary.captured).toBe(2);
|
||||
expect(summary.total).toBe(2);
|
||||
|
||||
const nyk = await cache.getTeamStats('nba', 'NYK');
|
||||
expect(nyk).toMatchObject({ offensive_rating: 118.5, defensive_rating: 110.2, pace: 100.4 });
|
||||
|
||||
const bos = await cache.getTeamStats('nba', 'BOS');
|
||||
expect(bos).toMatchObject({ offensive_rating: 120.0, defensive_rating: 108.0 });
|
||||
});
|
||||
|
||||
test('getOpponentRank returns the normalized 0..1 rank baked at refresh time', async () => {
|
||||
// The normalized value is set during refreshTeamStats; reads use it
|
||||
// directly. A solo-team cache entry without the field returns null.
|
||||
mockCache.current.set('team_stats:nba:NYK', {
|
||||
defensive_rating: 110.2,
|
||||
defensive_rank_normalized: 0.45,
|
||||
});
|
||||
expect(await cache.getOpponentRank('nba', 'NYK', 'points')).toBe(0.45);
|
||||
});
|
||||
|
||||
test('getOpponentRank returns null when cache predates the normalization upgrade', async () => {
|
||||
mockCache.current.set('team_stats:nba:OLD', { defensive_rating: 110.2 });
|
||||
expect(await cache.getOpponentRank('nba', 'OLD', 'points')).toBeNull();
|
||||
});
|
||||
|
||||
test('refreshTeamStats normalizes defensive_rank_normalized across the league', async () => {
|
||||
mockAxiosGet
|
||||
.mockResolvedValueOnce({
|
||||
status: 200,
|
||||
data: {
|
||||
sports: [{ leagues: [{ teams: [
|
||||
{ team: { id: 1, abbreviation: 'BEST', displayName: 'Best D' } },
|
||||
{ team: { id: 2, abbreviation: 'MID', displayName: 'Middle' } },
|
||||
{ team: { id: 3, abbreviation: 'WORST', displayName: 'Worst D' } },
|
||||
] }] }],
|
||||
},
|
||||
})
|
||||
.mockResolvedValueOnce({ status: 200, data: { results: { stats: [{ stats: [{ name: 'defensiveRating', value: 105 }] }] } } })
|
||||
.mockResolvedValueOnce({ status: 200, data: { results: { stats: [{ stats: [{ name: 'defensiveRating', value: 112 }] }] } } })
|
||||
.mockResolvedValueOnce({ status: 200, data: { results: { stats: [{ stats: [{ name: 'defensiveRating', value: 118 }] }] } } });
|
||||
await cache.refreshTeamStats('nba');
|
||||
expect(await cache.getOpponentRank('nba', 'BEST', 'points')).toBe(0);
|
||||
expect(await cache.getOpponentRank('nba', 'MID', 'points')).toBeCloseTo(0.5, 5);
|
||||
expect(await cache.getOpponentRank('nba', 'WORST', 'points')).toBe(1);
|
||||
});
|
||||
|
||||
test('getTeamStats returns null when nothing cached', async () => {
|
||||
expect(await cache.getTeamStats('nba', 'GHOST')).toBeNull();
|
||||
});
|
||||
|
||||
test('refreshTeamStats skips unsupported sport gracefully', async () => {
|
||||
const summary = await cache.refreshTeamStats('curling');
|
||||
// listTeams returns [] for unsupported sport, so total = 0.
|
||||
expect(summary).toMatchObject({ captured: 0, errored: 0, total: 0 });
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,141 @@
|
||||
// Mock the two services trap detection talks to externally.
|
||||
|
||||
const mockLM = { reverse: null, juice: null, lm: null };
|
||||
jest.mock('../../src/services/intelligence/lineMovement', () => ({
|
||||
reverseLineMovement: async () => mockLM.reverse,
|
||||
juiceDegradation: async () => mockLM.juice,
|
||||
getLineMovement: async () => mockLM.lm,
|
||||
}));
|
||||
|
||||
const mockResolutions = { current: [] };
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from() {
|
||||
const proxy = {
|
||||
select() { return proxy; },
|
||||
eq() { return proxy; },
|
||||
then(resolve) { return resolve({ data: mockResolutions.current, error: null }); },
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const trap = require('../../src/services/intelligence/trapDetection');
|
||||
|
||||
beforeEach(() => {
|
||||
mockLM.reverse = null;
|
||||
mockLM.juice = null;
|
||||
mockLM.lm = null;
|
||||
mockResolutions.current = [];
|
||||
});
|
||||
|
||||
describe('trap signals (individual)', () => {
|
||||
test('reverse_line_movement: inactive without snapshots', async () => {
|
||||
mockLM.reverse = null;
|
||||
const r = await trap.__internals.signalReverseLineMovement({ gameId: 'g', playerName: 'P', statType: 'points' });
|
||||
expect(r.active).toBe(false);
|
||||
});
|
||||
|
||||
test('reverse_line_movement: active and scoring when RLM detected', async () => {
|
||||
mockLM.reverse = { isReverse: true, score: 0.7, publicSide: 'over', lineDirection: 'under', movement: -1 };
|
||||
const r = await trap.__internals.signalReverseLineMovement({ gameId: 'g', playerName: 'P', statType: 'points' });
|
||||
expect(r.active).toBe(true);
|
||||
expect(r.score).toBe(0.7);
|
||||
});
|
||||
|
||||
test('new_context_trap: scales with flag count', () => {
|
||||
const noFlags = trap.__internals.signalNewContextTrap({ gameContext: {} });
|
||||
expect(noFlags.active).toBe(false);
|
||||
const oneFlag = trap.__internals.signalNewContextTrap({ gameContext: { game_in_series: 1 } });
|
||||
expect(oneFlag.score).toBeCloseTo(0.25, 5);
|
||||
const allFlags = trap.__internals.signalNewContextTrap({
|
||||
gameContext: { game_in_series: 1, first_playoff_game: true, new_opponent_in_series: true, new_venue: true },
|
||||
});
|
||||
expect(allFlags.score).toBe(1);
|
||||
});
|
||||
|
||||
test('recency_inflation: scores when L5 hotter than L20', () => {
|
||||
const r = trap.__internals.signalRecencyInflation({ features: { l5_avg: 30, l20_avg: 22 } });
|
||||
expect(r.active).toBe(true);
|
||||
expect(r.score).toBeCloseTo((30 - 22) / 22, 5);
|
||||
});
|
||||
|
||||
test('recency_inflation: inactive without L5/L20', () => {
|
||||
const r = trap.__internals.signalRecencyInflation({ features: { l5_avg: 25 } });
|
||||
expect(r.active).toBe(false);
|
||||
});
|
||||
|
||||
test('juice_degradation: passes through lineMovement signal', async () => {
|
||||
mockLM.juice = { applicable: true, score: 0.4, worstSide: 'over' };
|
||||
const r = await trap.__internals.signalJuiceDegradation({ gameId: 'g', playerName: 'P', statType: 'points' });
|
||||
expect(r.score).toBe(0.4);
|
||||
});
|
||||
|
||||
test('teammate_return_trap: scales with returning usage', () => {
|
||||
const r = trap.__internals.signalTeammateReturnTrap({ gameContext: { returning_teammate_usage_rate: 0.32 } });
|
||||
expect(r.active).toBe(true);
|
||||
expect(r.score).toBeCloseTo(0.16, 5);
|
||||
});
|
||||
|
||||
test('line_consensus_divergence: scores from |line - median| / stddev', () => {
|
||||
const r = trap.__internals.signalLineConsensusDivergence({
|
||||
odds: { playerLine: 26.5, consensus: { median: 24.5, stddev: 1.0 } },
|
||||
});
|
||||
expect(r.active).toBe(true);
|
||||
expect(r.score).toBe(1.0); // |26.5-24.5|/1 = 2.0 capped to 1.0
|
||||
});
|
||||
|
||||
test('historical_hit_rate_paradox: inactive with thin history', async () => {
|
||||
mockResolutions.current = [{ result: 'hit', direction: 'over', line: 25.5 }];
|
||||
const r = await trap.__internals.signalHistoricalHitRateParadox({
|
||||
playerName: 'P', statType: 'points', sport: 'nba', gameId: 'g',
|
||||
});
|
||||
expect(r.active).toBe(false);
|
||||
});
|
||||
|
||||
test('historical_hit_rate_paradox: active when line moves AGAINST a high hit-rate', async () => {
|
||||
mockResolutions.current = Array.from({ length: 25 }, (_, i) => ({
|
||||
result: i < 18 ? 'hit' : 'miss',
|
||||
direction: 'over',
|
||||
line: 25.5,
|
||||
}));
|
||||
mockLM.lm = { movement: -1.0 }; // moved DOWN while player usually OVER
|
||||
const r = await trap.__internals.signalHistoricalHitRateParadox({
|
||||
playerName: 'P', statType: 'points', sport: 'nba', gameId: 'g',
|
||||
});
|
||||
expect(r.active).toBe(true);
|
||||
expect(r.score).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getTrapScore (composite)', () => {
|
||||
test('only ACTIVE signals average — null signals do not dilute', async () => {
|
||||
// Two active signals: new_context_trap (0.25 = 1 flag) + recency_inflation
|
||||
// (~0.36). The other five inactive.
|
||||
const result = await trap.getTrapScore({
|
||||
features: { l5_avg: 30, l20_avg: 22 },
|
||||
gameContext: { game_in_series: 1 },
|
||||
});
|
||||
expect(result.active_count).toBe(2);
|
||||
expect(result.composite).toBeCloseTo((0.25 + (30 - 22) / 22) / 2, 5);
|
||||
expect(result.recommendation).toBe('caution');
|
||||
});
|
||||
|
||||
test('recommendation thresholds', () => {
|
||||
expect(trap.__internals.recommend(0.1)).toBe('proceed');
|
||||
expect(trap.__internals.recommend(0.3)).toBe('caution');
|
||||
expect(trap.__internals.recommend(0.6)).toBe('avoid');
|
||||
});
|
||||
|
||||
test('KAT-scenario: G1 of Finals + recency inflation → avoid/caution', async () => {
|
||||
// High recency (L5 32 vs L20 22 → 0.45) + 2 context flags (0.5).
|
||||
// Composite = (0.45 + 0.5) / 2 = 0.475 → caution.
|
||||
const result = await trap.getTrapScore({
|
||||
features: { l5_avg: 32, l20_avg: 22 },
|
||||
gameContext: { game_in_series: 1, first_playoff_game: true },
|
||||
});
|
||||
expect(result.active_count).toBe(2);
|
||||
expect(['caution', 'avoid']).toContain(result.recommendation);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,107 @@
|
||||
process.env.VAPID_PUBLIC_KEY = 'BTestPublicKey_______________________________________________________________';
|
||||
process.env.VAPID_PRIVATE_KEY = 'TestPrivateKey_______________________________';
|
||||
process.env.VAPID_SUBJECT = 'mailto:test@vyndr.app';
|
||||
|
||||
const mockSendNotification = jest.fn();
|
||||
const mockSetVapidDetails = jest.fn();
|
||||
|
||||
jest.mock('web-push', () => ({
|
||||
setVapidDetails: (...args) => mockSetVapidDetails(...args),
|
||||
sendNotification: (...args) => mockSendNotification(...args),
|
||||
}));
|
||||
|
||||
// Builds a fluent supabase mock where each chained call records intent and
|
||||
// the terminal promise yields {data, error}. Good enough for what webPush
|
||||
// actually does (.from().select().eq() / .delete().eq()).
|
||||
function makeSupabase({ rows = [], error = null } = {}) {
|
||||
const deleted = [];
|
||||
const builder = (table) => {
|
||||
const ctx = { table, filters: [] };
|
||||
const proxy = {
|
||||
_ctx: ctx,
|
||||
select: () => proxy,
|
||||
eq: (col, val) => {
|
||||
ctx.filters.push([col, val]);
|
||||
return ctx.action === 'delete' ? Promise.resolve({ error: null }) : proxy;
|
||||
},
|
||||
contains: () => proxy,
|
||||
delete: () => {
|
||||
ctx.action = 'delete';
|
||||
deleted.push(ctx);
|
||||
return proxy;
|
||||
},
|
||||
then: (resolve) => resolve({ data: rows, error }),
|
||||
};
|
||||
return proxy;
|
||||
};
|
||||
return {
|
||||
from: jest.fn().mockImplementation(builder),
|
||||
_deleted: deleted,
|
||||
};
|
||||
}
|
||||
|
||||
const mockSupabase = { current: makeSupabase() };
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => mockSupabase.current,
|
||||
}));
|
||||
|
||||
const webPush = require('../../src/services/distribution/webPush');
|
||||
|
||||
beforeEach(() => {
|
||||
mockSendNotification.mockReset();
|
||||
mockSetVapidDetails.mockReset();
|
||||
mockSupabase.current = makeSupabase();
|
||||
});
|
||||
|
||||
describe('webPush.configured', () => {
|
||||
test('returns true when both VAPID keys present', () => {
|
||||
expect(webPush.configured()).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('webPush.sendPushToUser', () => {
|
||||
test('returns sent=0 when user has no subscriptions', async () => {
|
||||
mockSupabase.current = makeSupabase({ rows: [] });
|
||||
const result = await webPush.sendPushToUser('user-1', { title: 'hi' });
|
||||
expect(result).toMatchObject({ ok: true, sent: 0 });
|
||||
expect(mockSendNotification).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test('sends to every subscription and counts successes', async () => {
|
||||
mockSupabase.current = makeSupabase({
|
||||
rows: [
|
||||
{ id: 'a', endpoint: 'https://a', keys_p256dh: 'p1', keys_auth: 'k1' },
|
||||
{ id: 'b', endpoint: 'https://b', keys_p256dh: 'p2', keys_auth: 'k2' },
|
||||
],
|
||||
});
|
||||
mockSendNotification.mockResolvedValue({ statusCode: 201 });
|
||||
const result = await webPush.sendPushToUser('user-1', { title: 'hi' });
|
||||
expect(result.ok).toBe(true);
|
||||
expect(result.sent).toBe(2);
|
||||
expect(mockSendNotification).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
test('prunes subscription that returns 410 Gone', async () => {
|
||||
mockSupabase.current = makeSupabase({
|
||||
rows: [{ id: 'dead', endpoint: 'https://dead', keys_p256dh: 'p', keys_auth: 'k' }],
|
||||
});
|
||||
const err = Object.assign(new Error('Gone'), { statusCode: 410 });
|
||||
mockSendNotification.mockRejectedValue(err);
|
||||
const result = await webPush.sendPushToUser('user-1', { title: 'hi' });
|
||||
expect(result.pruned).toBe(1);
|
||||
expect(result.sent).toBe(0);
|
||||
expect(mockSupabase.current._deleted.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('non-410 failure does not prune, counts as failed', async () => {
|
||||
mockSupabase.current = makeSupabase({
|
||||
rows: [{ id: 'flaky', endpoint: 'https://flaky', keys_p256dh: 'p', keys_auth: 'k' }],
|
||||
});
|
||||
const err = Object.assign(new Error('boom'), { statusCode: 500 });
|
||||
mockSendNotification.mockRejectedValue(err);
|
||||
const result = await webPush.sendPushToUser('user-1', { title: 'hi' });
|
||||
expect(result.failed).toBe(1);
|
||||
expect(result.sent).toBe(0);
|
||||
expect(mockSupabase.current._deleted.length).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,161 @@
|
||||
const mockState = {
|
||||
resolutionCount: 100,
|
||||
weightRows: [], // engine1_weights rows
|
||||
inserts: [],
|
||||
};
|
||||
|
||||
jest.mock('../../src/utils/supabase', () => ({
|
||||
getSupabaseServiceClient: () => ({
|
||||
from(table) {
|
||||
const ctx = { table, filters: {} };
|
||||
const proxy = {
|
||||
select(_cols, opts) {
|
||||
ctx.head = !!opts?.head;
|
||||
ctx.countMode = opts?.count;
|
||||
return proxy;
|
||||
},
|
||||
eq(col, val) { ctx.filters[col] = val; return proxy; },
|
||||
order() { return proxy; },
|
||||
limit() { return proxy; },
|
||||
maybeSingle() {
|
||||
const match = mockState.weightRows.find(
|
||||
(r) =>
|
||||
r.sport === ctx.filters.sport
|
||||
&& r.stat_type === ctx.filters.stat_type
|
||||
&& r.factor_name === ctx.filters.factor_name
|
||||
&& r.version === ctx.filters.version
|
||||
);
|
||||
return Promise.resolve({ data: match || null, error: null });
|
||||
},
|
||||
insert(row) {
|
||||
mockState.inserts.push(row);
|
||||
mockState.weightRows.push(row);
|
||||
return Promise.resolve({ error: null });
|
||||
},
|
||||
then(resolve) {
|
||||
if (ctx.table === 'resolution_results' && ctx.countMode === 'exact') {
|
||||
return resolve({ count: mockState.resolutionCount, error: null });
|
||||
}
|
||||
// List of engine1_weights matching filters.
|
||||
const matches = mockState.weightRows.filter((r) => {
|
||||
for (const [k, v] of Object.entries(ctx.filters)) {
|
||||
if (r[k] !== v) return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
matches.sort((a, b) => b.version - a.version);
|
||||
return resolve({ data: matches, error: null });
|
||||
},
|
||||
};
|
||||
return proxy;
|
||||
},
|
||||
}),
|
||||
}));
|
||||
|
||||
const wa = require('../../src/services/intelligence/weightAdjuster');
|
||||
|
||||
beforeEach(() => {
|
||||
mockState.resolutionCount = 100;
|
||||
mockState.weightRows = [];
|
||||
mockState.inserts.length = 0;
|
||||
});
|
||||
|
||||
describe('weightAdjuster — skip conditions', () => {
|
||||
test('skips when sample too thin', async () => {
|
||||
mockState.resolutionCount = 5;
|
||||
const r = await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A', result: 'hit',
|
||||
factors: ['l5_avg'], grade_id: 'g',
|
||||
});
|
||||
expect(r.skipped).toBe(true);
|
||||
expect(r.reason).toBe('thin_sample');
|
||||
});
|
||||
|
||||
test('skips on push / void', async () => {
|
||||
const r = await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A', result: 'push',
|
||||
factors: ['l5_avg'], grade_id: 'g',
|
||||
});
|
||||
expect(r.skipped).toBe(true);
|
||||
expect(r.reason).toBe('non_decisive_result');
|
||||
});
|
||||
|
||||
test('skips on incomplete input', async () => {
|
||||
const r = await wa.adjustWeights({ sport: 'nba', grade: 'A', result: 'hit', factors: [] });
|
||||
expect(r.skipped).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('weightAdjuster — adjustments', () => {
|
||||
test('A+ hit nudges factor up by at most 0.5%', async () => {
|
||||
const r = await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A+', result: 'hit',
|
||||
factors: ['l5_hot_vs_line'], grade_id: 'g1',
|
||||
});
|
||||
expect(r.skipped).toBe(false);
|
||||
const adj = r.adjustments[0];
|
||||
expect(adj.previous).toBe(1.0);
|
||||
expect(adj.next).toBeGreaterThan(1.0);
|
||||
// confidence of A+ = 1.0, LR = 0.005 → multiplier = 1.005 → next = 1.005
|
||||
expect(adj.next).toBeCloseTo(1.005, 5);
|
||||
});
|
||||
|
||||
test('A+ miss nudges factor down by at most 0.5%', async () => {
|
||||
const r = await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A+', result: 'miss',
|
||||
factors: ['l5_hot_vs_line'], grade_id: 'g2',
|
||||
});
|
||||
expect(r.adjustments[0].next).toBeCloseTo(0.995, 5);
|
||||
});
|
||||
|
||||
test('low-confidence grade produces smaller nudge', async () => {
|
||||
const high = await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A+', result: 'hit',
|
||||
factors: ['x'], grade_id: 'h',
|
||||
});
|
||||
const low = await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'C', result: 'hit',
|
||||
factors: ['y'], grade_id: 'l',
|
||||
});
|
||||
expect(Math.abs(high.adjustments[0].next - 1.0))
|
||||
.toBeGreaterThan(Math.abs(low.adjustments[0].next - 1.0));
|
||||
});
|
||||
|
||||
test('weights clamp at MIN_WEIGHT and MAX_WEIGHT', () => {
|
||||
const c = wa.__internals.clamp;
|
||||
expect(c(0.05)).toBe(wa.MIN_WEIGHT);
|
||||
expect(c(99)).toBe(wa.MAX_WEIGHT);
|
||||
expect(c(2.5)).toBe(2.5);
|
||||
});
|
||||
|
||||
test('repeated adjustments stack into incrementing versions', async () => {
|
||||
await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A', result: 'hit',
|
||||
factors: ['l5_hot_vs_line'], grade_id: 'g1',
|
||||
});
|
||||
await wa.adjustWeights({
|
||||
sport: 'nba', stat_type: 'points', grade: 'A', result: 'hit',
|
||||
factors: ['l5_hot_vs_line'], grade_id: 'g2',
|
||||
});
|
||||
const history = await wa.getWeightHistory('nba', 'points', 'l5_hot_vs_line', 10);
|
||||
expect(history.length).toBe(2);
|
||||
expect(history[0].version).toBe(2);
|
||||
expect(history[1].version).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('weightAdjuster — rollback', () => {
|
||||
test('rollback inserts a new row whose weight equals the target version', async () => {
|
||||
// Seed three versions.
|
||||
mockState.weightRows.push(
|
||||
{ sport: 'nba', stat_type: 'points', factor_name: 'f', weight: 1.0, version: 1 },
|
||||
{ sport: 'nba', stat_type: 'points', factor_name: 'f', weight: 1.1, version: 2 },
|
||||
{ sport: 'nba', stat_type: 'points', factor_name: 'f', weight: 1.2, version: 3 },
|
||||
);
|
||||
const ok = await wa.rollbackToVersion('nba', 'points', 'f', 1);
|
||||
expect(ok).toBe(true);
|
||||
const history = await wa.getWeightHistory('nba', 'points', 'f', 10);
|
||||
expect(history[0].weight).toBe(1.0);
|
||||
expect(history[0].version).toBe(4);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user