vyndr/tests/integration/snapshotRoutes.test.js

// Session 45 — internal snapshot endpoints (auth-gated) + the public ticker.

const express = require('express');
const request = require('supertest');

jest.mock('../../scripts/tank01-prefetch', () => ({ main: jest.fn() }));
jest.mock('../../src/services/quotaTracker', () => ({ getAllQuotaStatuses: jest.fn() }));
jest.mock('../../src/services/snapshotService', () => ({
  runSnapshot: jest.fn(async (sport) => ({ sport, status: 'ok', gradeCount: 3 })),
  runAllSnapshots: jest.fn(async () => [{ sport: 'mlb', status: 'ok' }, { sport: 'nba', status: 'skipped' }]),
}));
const snapshot = require('../../src/services/snapshotService');

beforeEach(() => {
  jest.clearAllMocks();
  process.env.VYNDR_INTERNAL_KEY = 'test-key-123';
});

function mountInternal() {
  delete require.cache[require.resolve('../../src/routes/internal')];
  const internalRoutes = require('../../src/routes/internal');
  const app = express();
  app.use(express.json());
  app.use('/api/internal', internalRoutes);
  return app;
}

describe('POST /api/internal/snapshot/:sport', () => {
  it('rejects without the internal key (401)', async () => {
    const res = await request(mountInternal()).post('/api/internal/snapshot/mlb').send({});
    expect(res.status).toBe(401);
    expect(snapshot.runSnapshot).not.toHaveBeenCalled();
  });

  it('runs a single-sport snapshot with the key', async () => {
    const res = await request(mountInternal())
      .post('/api/internal/snapshot/mlb')
      .set('x-internal-key', 'test-key-123')
      .send({});
    expect(res.status).toBe(200);
    // Opts object added 2026-08-01 for the ?limit= bisect hook. With no ?limit
    // there must be NO limit key — a stray one would silently cap production
    // runs, which is the exact bug the hook exists to diagnose. The opts now
    // also carry truthful provenance (an operator run is CONTROLLED_FORCED, not
    // SCHEDULED); those two diagnostic keys are the only permitted additions.
    expect(snapshot.runSnapshot).toHaveBeenCalledWith('mlb', expect.objectContaining({
      trigger: 'CONTROLLED_FORCED',
    }));
    const passedOpts = snapshot.runSnapshot.mock.calls[0][1];
    expect(Object.keys(passedOpts).sort()).toEqual(['processStartedAt', 'trigger']);
    expect(passedOpts).not.toHaveProperty('limit');
    expect(res.body.summary.gradeCount).toBe(3);
  });

  it('routes /snapshot/all to runAllSnapshots (not captured as a sport)', async () => {
    const res = await request(mountInternal())
      .post('/api/internal/snapshot/all')
      .set('x-internal-key', 'test-key-123')
      .send({});
    expect(res.status).toBe(200);
    expect(snapshot.runAllSnapshots).toHaveBeenCalled();
    expect(snapshot.runSnapshot).not.toHaveBeenCalled();
    expect(res.body.results).toHaveLength(2);
  });
});

describe('GET /api/ticker', () => {
  const mockCache = { value: null };
  jest.mock('../../src/utils/redis', () => ({
    cacheGet: async () => mockCache.value,
    cacheSet: async () => true,
    getRedisClient: () => ({}),
    isDegraded: () => false,
  }));

  function mountTicker() {
    delete require.cache[require.resolve('../../src/routes/ticker')];
    const tickerRoutes = require('../../src/routes/ticker');
    const app = express();
    app.use('/api/ticker', tickerRoutes);
    return app;
  }

  it('returns snapshot items newest-first', async () => {
    mockCache.value = [{ tag: 'READ', text: 'MLB slate read · 248 props graded' }, { tag: 'A+', text: 'BOMBER Judge graded A+' }];
    delete process.env.TICKER_MANUAL;
    const res = await request(mountTicker()).get('/api/ticker');
    expect(res.status).toBe(200);
    expect(res.body.items[0].tag).toBe('READ');
  });

  it('merges editorial pins from TICKER_MANUAL', async () => {
    mockCache.value = [{ tag: 'READ', text: 'read' }];
    process.env.TICKER_MANUAL = JSON.stringify([{ tag: 'ALERT', text: 'VYNDR 2.0 is live.' }]);
    const res = await request(mountTicker()).get('/api/ticker');
    expect(res.body.items.find((i) => i.tag === 'ALERT')).toBeTruthy();
    delete process.env.TICKER_MANUAL;
  });

  it('returns [] gracefully on a cold cache', async () => {
    mockCache.value = null;
    delete process.env.TICKER_MANUAL;
    const res = await request(mountTicker()).get('/api/ticker');
    expect(res.body.items).toEqual([]);
  });
});