vyndr/tests/unit/gradeBoardSort.test.js

/**
 * Grade-board sort (specs/grade-board-sort.md) — display ORDERING only.
 *
 * Locks the two defects that were wrong at ANY scale:
 *   1. abs() on an already-direction-signed edge ranked DISAGREEMENTS level with
 *      agreements.
 *   2. Math.abs(-Infinity) === Infinity made a MISSING signal sort FIRST.
 * Plus: the takeable gate matches the hero, and p_win/edge scales never mix.
 */

const adapter = require('../../web/src/lib/slateAdapter');
const { isTakeable } = require('../../web/src/lib/valueState');
const { isTakeable: backendIsTakeable } = require('../../src/config/valueEngine');

const names = (rows) => rows.map((r) => r.player);

// SUPERSEDED 2026-08-01 by the p_win flip. These three asserted that EDGE
// ordered the board (signed, nulls last). Edge no longer ranks anything:
// measured on n=200 settled MLB rows, corr(edge, outcome) = -0.010 under the
// incumbent ruler and -0.022 under the consensus ruler, against
// corr(p_win, outcome) = +0.26.
//
// The replacements are strictly STRONGER — they fail if edge is ever
// re-introduced as a ranking key, which the originals could not detect.
describe('selectTopGrades — EDGE CANNOT RANK (retired 2026-08-01)', () => {
  test('flipping edge from -80 to +80 does NOT change the order', () => {
    const a = [
      { player: 'first', grade: 'B', confidence: 50, edge: -80 },
      { player: 'second', grade: 'B', confidence: 50, edge: 10 },
    ];
    const b = [
      { player: 'first', grade: 'B', confidence: 50, edge: 80 },
      { player: 'second', grade: 'B', confidence: 50, edge: -10 },
    ];
    // Equal grade + confidence + no p_win -> stable input order, edge irrelevant.
    expect(names(adapter.selectTopGrades(a, 10))).toEqual(['first', 'second']);
    expect(names(adapter.selectTopGrades(b, 10))).toEqual(['first', 'second']);
  });

  test('a MISSING edge is no longer penalised — rows are still all PRESENT', () => {
    const grades = [
      { player: 'no-signal', grade: 'B', confidence: 50 },
      { player: 'weak-but-real', grade: 'B', confidence: 50, edge: 0.1 },
      { player: 'negative-but-real', grade: 'B', confidence: 50, edge: -5 },
    ];
    const out = names(adapter.selectTopGrades(grades, 10));
    expect(out).toHaveLength(3);                  // never dropped
    expect(out).toEqual(['no-signal', 'weak-but-real', 'negative-but-real']); // input order
  });

  test('forecast_rank LEADS the chain when the server supplied it', () => {
    const grades = [
      { player: 'topGrade', grade: 'A', confidence: 90, forecast_rank: 3 },
      { player: 'topForecast', grade: 'C', confidence: 40, forecast_rank: 1 },
    ];
    // p_win-first order wins over the letter: the letter measured r ~ 0.005 and
    // is inverted, p_win measured +0.26.
    expect(names(adapter.selectTopGrades(grades, 10))).toEqual(['topForecast', 'topGrade']);
  });

  test('a MISSING forecast_rank sorts LAST and falls back to the grade chain', () => {
    const grades = [
      { player: 'noRank', grade: 'A', confidence: 90 },
      { player: 'ranked', grade: 'C', confidence: 40, forecast_rank: 2 },
    ];
    expect(names(adapter.selectTopGrades(grades, 10))).toEqual(['ranked', 'noRank']);
  });

  test('forecast_rank null/empty is ABSENT, not 0 (Number(null) === 0 guard)', () => {
    const grades = [
      { player: 'nullish', grade: 'B', confidence: 50, forecast_rank: null },
      { player: 'empty', grade: 'B', confidence: 50, forecast_rank: '' },
      { player: 'real', grade: 'C', confidence: 10, forecast_rank: 9 },
    ];
    // rank 9 is a REAL rank and must beat two absents — a 0-coercion would
    // have put the nulls first.
    expect(names(adapter.selectTopGrades(grades, 10))[0]).toBe('real');
  });
});

describe('selectTopGrades — takeable-gated p_win outranks edge, scales never mix', () => {
  test('takeable p_win row outranks an UNTAKEABLE higher-p_win chalk row', () => {
    const grades = [
      { player: 'chalk', grade: 'B', confidence: 50, p_win: 0.92, book_odds: -300 }, // untakeable
      { player: 'takeable', grade: 'B', confidence: 50, p_win: 0.61, book_odds: -120 },
    ];
    expect(names(adapter.selectTopGrades(grades, 10))[0]).toBe('takeable');
  });

  test('p_win is preferred over edge, and a p_win row outranks an edge-only row', () => {
    const grades = [
      { player: 'edge-only', grade: 'B', confidence: 50, edge: 300 },
      { player: 'has-pwin', grade: 'B', confidence: 50, p_win: 0.55, book_odds: 100 },
    ];
    // 0.55 must NOT be compared against 300 — the p_win-bearing row wins on the
    // earlier key instead (scales never mixed in one comparator).
    expect(names(adapter.selectTopGrades(grades, 10))[0]).toBe('has-pwin');
  });

  test('among takeable p_win rows the HIGHER p_win wins', () => {
    const grades = [
      { player: 'lower', grade: 'B', confidence: 50, p_win: 0.55, book_odds: -110 },
      { player: 'higher', grade: 'B', confidence: 50, p_win: 0.71, book_odds: -110 },
    ];
    expect(names(adapter.selectTopGrades(grades, 10))[0]).toBe('higher');
  });

  test('gradedAt.odds is accepted as the price when book_odds is absent', () => {
    const grades = [
      { player: 'via-gradedAt', grade: 'B', confidence: 50, p_win: 0.66, gradedAt: { odds: -115 } },
      { player: 'edge-only', grade: 'B', confidence: 50, edge: 5 },
    ];
    expect(names(adapter.selectTopGrades(grades, 10))[0]).toBe('via-gradedAt');
  });

  test('the frontend takeable band MATCHES the backend hero gate exactly', () => {
    for (const price of [-400, -160, -159, -110, 0, 100, 200, 201, 500]) {
      expect(isTakeable(price)).toBe(backendIsTakeable(price));
    }
    // and the strict-null contract both sides
    expect(isTakeable(null)).toBe(false);
    expect(backendIsTakeable(null)).toBe(false);
  });

  test('grade tier still dominates every signal', () => {
    const grades = [
      { player: 'B-strong', grade: 'B', confidence: 99, p_win: 0.99, book_odds: -110 },
      { player: 'A-weak', grade: 'A', confidence: 1, edge: -50 },
    ];
    expect(names(adapter.selectTopGrades(grades, 10))[0]).toBe('A-weak');
  });
});

describe('alt-line ladder — ordered highest-p_win-first via the monotonic line rule', () => {
  // P(stat >= k) is monotone non-increasing in k, so p_win-desc is line-ASC for an
  // over and line-DESC for an under. Assert the ordering the engine emits.
  const ladderOrder = (direction, lines) => {
    const rungs = lines.map((line) => ({ line }));
    return rungs
      .slice()
      .sort((a, b) => (String(direction).toLowerCase() === 'under'
        ? Number(b.line) - Number(a.line)
        : Number(a.line) - Number(b.line)))
      .map((r) => r.line);
  };

  test('OVER: lowest line (highest p_win) first', () => {
    expect(ladderOrder('over', [1.5, 0.5, 2.5, 1, 2])).toEqual([0.5, 1, 1.5, 2, 2.5]);
  });

  test('UNDER: highest line (highest p_win) first', () => {
    expect(ladderOrder('under', [1.5, 0.5, 2.5, 1, 2])).toEqual([2.5, 2, 1.5, 1, 0.5]);
  });

  test('the engine sorts its ladder by that rule, NOT by edge_pct', () => {
    const src = require('fs').readFileSync(
      require('path').join(__dirname, '../../src/services/intelligence/analyzeViaEngine1.js'),
      'utf8',
    );
    // the old key must be gone from the ladder sort
    expect(src).not.toMatch(/sort\(\(a, b\) => \(Number\(b\.edge_pct\)/);
    expect(src).toMatch(/Number\(b\.line\) - Number\(a\.line\)/);
  });
});