Session 23: All-day intelligence layer — schedule, game lines, streaks, hot lists, stat filtering, ParlayAPI dead (1567 tests)

2026-06-12 11:16:58 -04:00
parent 6ab49d4c37
commit 0538205fab
32 changed files with 2276 additions and 2 deletions
@@ -0,0 +1,98 @@
+// Integration: /api/gamelines/:sport (Session 23).
+//
+// The Tank01 adapters are mocked — we assert the route normalizes the
+// book-by-book body, parses teams from the gameID, handles the missing
+// API-key path gracefully, and never 500s on adapter failure.
+
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('../../src/services/adapters/tank01NbaAdapter', () => ({
+  getNBABettingOdds: jest.fn(),
+  hasApiKey: jest.fn(() => true),
+}));
+jest.mock('../../src/services/adapters/tank01MlbAdapter', () => ({
+  getMLBBettingOdds: jest.fn(),
+  hasApiKey: jest.fn(() => true),
+}));
+jest.mock('../../src/services/scheduleService', () => ({
+  todayET: () => '2026-06-12',
+}));
+
+const nbaAdapter = require('../../src/services/adapters/tank01NbaAdapter');
+const mlbAdapter = require('../../src/services/adapters/tank01MlbAdapter');
+
+function mountApp() {
+  delete require.cache[require.resolve('../../src/routes/gameLines')];
+  const routes = require('../../src/routes/gameLines');
+  const app = express();
+  app.use('/api/gamelines', routes);
+  return app;
+}
+
+const MLB_BODY = {
+  '20260612_ARI@CIN': {
+    gameID: '20260612_ARI@CIN',
+    sportsBooks: [
+      { sportsBook: 'bet365', odds: { homeTeamMLOdds: '-110', awayTeamMLOdds: '+100', totalOver: '9.5', totalOverOdds: '-105', totalUnderOdds: '-115' } },
+      { sportsBook: 'betmgm', odds: { homeTeamMLOdds: '-115', awayTeamMLOdds: '-105', totalOver: '9' } },
+    ],
+  },
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  // clearAllMocks wipes call history but not custom implementations set via
+  // mockReturnValue in a prior test — restore the configured-key default.
+  nbaAdapter.hasApiKey.mockReturnValue(true);
+  mlbAdapter.hasApiKey.mockReturnValue(true);
+});
+
+describe('GET /api/gamelines/:sport', () => {
+  test('mlb returns book-by-book odds with teams parsed from gameID', async () => {
+    mlbAdapter.getMLBBettingOdds.mockResolvedValue(MLB_BODY);
+    const res = await request(mountApp()).get('/api/gamelines/mlb');
+    expect(res.status).toBe(200);
+    expect(res.body.source).toBe('tank01');
+    const game = res.body.games['20260612_ARI@CIN'];
+    expect(game.homeTeam).toBe('CIN');
+    expect(game.awayTeam).toBe('ARI');
+    expect(game.books.bet365.homeML).toBe('-110');
+    expect(game.books.bet365.total).toBe('9.5');
+    expect(game.books.betmgm.homeML).toBe('-115');
+  });
+
+  test('nba returns empty games object off-season (not an error)', async () => {
+    nbaAdapter.getNBABettingOdds.mockResolvedValue({});
+    const res = await request(mountApp()).get('/api/gamelines/nba');
+    expect(res.status).toBe(200);
+    expect(res.body.games).toEqual({});
+  });
+
+  test('missing RAPID_API_KEY → graceful, configured:false, not a crash', async () => {
+    mlbAdapter.hasApiKey.mockReturnValue(false);
+    const res = await request(mountApp()).get('/api/gamelines/mlb');
+    expect(res.status).toBe(200);
+    expect(res.body.configured).toBe(false);
+    expect(mlbAdapter.getMLBBettingOdds).not.toHaveBeenCalled();
+  });
+
+  test('adapter throwing → empty games, 200 not 500', async () => {
+    mlbAdapter.getMLBBettingOdds.mockRejectedValue(new Error('rapidapi 429'));
+    const res = await request(mountApp()).get('/api/gamelines/mlb');
+    expect(res.status).toBe(200);
+    expect(res.body.games).toEqual({});
+  });
+
+  test('unsupported sport → 404', async () => {
+    const res = await request(mountApp()).get('/api/gamelines/soccer');
+    expect(res.status).toBe(404);
+  });
+
+  test('cache works — adapter called once per request (adapter owns TTL)', async () => {
+    mlbAdapter.getMLBBettingOdds.mockResolvedValue(MLB_BODY);
+    const app = mountApp();
+    await request(app).get('/api/gamelines/mlb');
+    expect(mlbAdapter.getMLBBettingOdds).toHaveBeenCalledTimes(1);
+  });
+});
@@ -0,0 +1,127 @@
+// Integration: /api/schedule/:sport (Session 23).
+//
+// The schedule service is mocked at the redis layer so we exercise the
+// route + service normalization + flag enrichment without hitting ESPN
+// or a live Redis. ESPN itself is stubbed via axios.
+
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('axios');
+const axios = require('axios');
+
+// In-memory redis stand-in. cacheGet returns whatever we seed; cacheSet
+// records writes so we can assert the cache-aside warm path.
+const store = {};
+jest.mock('../../src/utils/redis', () => ({
+  cacheGet: jest.fn(async (k) => (k in store ? store[k] : null)),
+  cacheSet: jest.fn(async (k, v) => { store[k] = v; return true; }),
+}));
+
+function mountApp() {
+  delete require.cache[require.resolve('../../src/routes/schedule')];
+  delete require.cache[require.resolve('../../src/services/scheduleService')];
+  const scheduleRoutes = require('../../src/routes/schedule');
+  const app = express();
+  app.use(express.json());
+  app.use('/api/schedule', scheduleRoutes);
+  return app;
+}
+
+const ESPN_NBA = {
+  data: {
+    events: [
+      {
+        id: '401234567',
+        date: '2026-06-14T00:40:00Z',
+        status: { type: { state: 'pre' } },
+        competitions: [{
+          venue: { fullName: 'Frost Bank Center' },
+          broadcasts: [{ names: ['ABC'] }],
+          competitors: [
+            { homeAway: 'home', score: '0', team: { displayName: 'San Antonio Spurs', abbreviation: 'SA' } },
+            { homeAway: 'away', score: '0', team: { displayName: 'New York Knicks', abbreviation: 'NYK' } },
+          ],
+        }],
+      },
+    ],
+  },
+};
+
+beforeEach(() => {
+  for (const k of Object.keys(store)) delete store[k];
+  jest.clearAllMocks();
+});
+
+describe('GET /api/schedule/:sport', () => {
+  test('returns normalized games from a fresh ESPN fetch (cache miss)', async () => {
+    axios.get.mockResolvedValue(ESPN_NBA);
+    const res = await request(mountApp()).get('/api/schedule/nba?date=2026-06-12');
+    expect(res.status).toBe(200);
+    expect(res.body.sport).toBe('nba');
+    expect(res.body.source).toBe('espn');
+    expect(res.body.games).toHaveLength(1);
+    const g = res.body.games[0];
+    expect(g.homeTeam.abbreviation).toBe('SA');
+    expect(g.awayTeam.name).toBe('New York Knicks');
+    expect(g.status).toBe('pre');
+    expect(g.venue).toBe('Frost Bank Center');
+    expect(g.broadcast).toBe('ABC');
+    expect(g.score).toBeNull();          // pre-game → no score
+    expect(g.hasOdds).toBe(false);
+    expect(g.hasGameLines).toBe(false);
+  });
+
+  test('warms the cache, second call does not re-fetch ESPN', async () => {
+    axios.get.mockResolvedValue(ESPN_NBA);
+    const app = mountApp();
+    await request(app).get('/api/schedule/nba?date=2026-06-12');
+    const callsAfterFirst = axios.get.mock.calls.length;
+    await request(app).get('/api/schedule/nba?date=2026-06-12');
+    expect(axios.get.mock.calls.length).toBe(callsAfterFirst); // served from cache
+  });
+
+  test('returns empty array (not error) when no games today', async () => {
+    axios.get.mockResolvedValue({ data: { events: [] } });
+    const res = await request(mountApp()).get('/api/schedule/mlb?date=2026-06-12');
+    expect(res.status).toBe(200);
+    expect(res.body.games).toEqual([]);
+  });
+
+  test('hasOdds true when odds-api cache has props for the slate', async () => {
+    store['odds:nba:2026-06-12'] = { updated_at: 'x', props: [{ player: 'Wemby' }] };
+    axios.get.mockResolvedValue(ESPN_NBA);
+    const res = await request(mountApp()).get('/api/schedule/nba?date=2026-06-12');
+    expect(res.body.games[0].hasOdds).toBe(true);
+    expect(res.body.games[0].hasGameLines).toBe(false);
+  });
+
+  test('hasGameLines true when Tank01 odds cache has data', async () => {
+    store['tank01:nba:odds:20260612'] = { body: { '20260612_NYK@SA': { homeML: '-110' } } };
+    axios.get.mockResolvedValue(ESPN_NBA);
+    const res = await request(mountApp()).get('/api/schedule/nba?date=2026-06-12');
+    expect(res.body.games[0].hasGameLines).toBe(true);
+  });
+
+  test('scores appear once a game is in/post', async () => {
+    axios.get.mockResolvedValue({
+      data: { events: [{
+        id: '9', date: '2026-06-12T20:00:00Z',
+        status: { type: { state: 'in' } },
+        competitions: [{
+          competitors: [
+            { homeAway: 'home', score: '54', team: { displayName: 'A', abbreviation: 'A' } },
+            { homeAway: 'away', score: '49', team: { displayName: 'B', abbreviation: 'B' } },
+          ],
+        }],
+      }] },
+    });
+    const res = await request(mountApp()).get('/api/schedule/nba?date=2026-06-12');
+    expect(res.body.games[0].score).toEqual({ home: 54, away: 49 });
+  });
+
+  test('unknown sport returns 404', async () => {
+    const res = await request(mountApp()).get('/api/schedule/cricket');
+    expect(res.status).toBe(404);
+  });
+});
@@ -0,0 +1,90 @@
+// Integration: /api/streaks/:sport and /api/hotlist/:sport (Session 23).
+// rosterLogs is mocked so we exercise route → engine without Redis.
+
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('../../src/services/rosterLogs', () => ({
+  loadRosterLogs: jest.fn(),
+}));
+const { loadRosterLogs } = require('../../src/services/rosterLogs');
+
+function mountStreaks() {
+  delete require.cache[require.resolve('../../src/routes/streaks')];
+  const app = express();
+  app.use('/api/streaks', require('../../src/routes/streaks'));
+  return app;
+}
+function mountHotlist() {
+  delete require.cache[require.resolve('../../src/routes/hotlist')];
+  const app = express();
+  app.use('/api/hotlist', require('../../src/routes/hotlist'));
+  return app;
+}
+
+beforeEach(() => jest.clearAllMocks());
+
+describe('GET /api/streaks/:sport', () => {
+  test('returns computed streaks from cached logs', async () => {
+    loadRosterLogs.mockResolvedValue([
+      { name: 'Wemby', team: 'SA', games: [{ points: 30 }, { points: 28 }, { points: 26 }] },
+    ]);
+    const res = await request(mountStreaks()).get('/api/streaks/nba');
+    expect(res.status).toBe(200);
+    expect(res.body.source).toBe('computed');
+    expect(res.body.streaks[0].player).toBe('Wemby');
+    expect(res.body.streaks[0].currentStreak).toBe(3);
+  });
+
+  test('stat filter narrows the response', async () => {
+    loadRosterLogs.mockResolvedValue([
+      { name: 'A', games: [{ points: 30 }, { points: 30 }] },
+      { name: 'B', games: [{ assists: 9 }, { assists: 8 }] },
+    ]);
+    const res = await request(mountStreaks()).get('/api/streaks/nba?stat=points');
+    expect(res.body.stat).toBe('points');
+    expect(res.body.streaks.every((s) => s.category === 'points')).toBe(true);
+  });
+
+  test('empty roster → empty streaks, not an error', async () => {
+    loadRosterLogs.mockResolvedValue([]);
+    const res = await request(mountStreaks()).get('/api/streaks/mlb');
+    expect(res.status).toBe(200);
+    expect(res.body.streaks).toEqual([]);
+  });
+
+  test('loader throwing → 200 with empty streaks (platform never down)', async () => {
+    loadRosterLogs.mockRejectedValue(new Error('redis exploded'));
+    const res = await request(mountStreaks()).get('/api/streaks/nba');
+    expect(res.status).toBe(200);
+    expect(res.body.streaks).toEqual([]);
+  });
+
+  test('unsupported sport → 404', async () => {
+    const res = await request(mountStreaks()).get('/api/streaks/cricket');
+    expect(res.status).toBe(404);
+  });
+});
+
+describe('GET /api/hotlist/:sport', () => {
+  test('returns ranked hot players', async () => {
+    loadRosterLogs.mockResolvedValue([
+      { name: 'Riser', seasonAvg: { points: 18 }, games: [{ points: 28 }, { points: 30 }] },
+    ]);
+    const res = await request(mountHotlist()).get('/api/hotlist/nba?stat=points');
+    expect(res.status).toBe(200);
+    expect(res.body.players[0].name).toBe('Riser');
+    expect(res.body.players[0].rank).toBe(1);
+  });
+
+  test('empty roster → empty players', async () => {
+    loadRosterLogs.mockResolvedValue([]);
+    const res = await request(mountHotlist()).get('/api/hotlist/mlb');
+    expect(res.body.players).toEqual([]);
+  });
+
+  test('unsupported sport → 404', async () => {
+    const res = await request(mountHotlist()).get('/api/hotlist/nfl');
+    expect(res.status).toBe(404);
+  });
+});