zach/dotter

// Golden tests: dotter must send exactly the commands the official NextDraw

// Python API sends for the same scenario (status polls excluded, since their

// count depends on timing). Fixtures are recorded by

// scripts/golden/gen_golden.py; scenarios without a fixture are skipped.

import { describe, expect, test } from 'bun:test';

import { existsSync, readFileSync } from 'node:fs';

import { join } from 'node:path';

import { commands, makeMachine } from './helpers.js';

const dir = join(import.meta.dir, 'golden');

const scenarios = JSON.parse(readFileSync(join(dir, 'scenarios.json'), 'utf8'));

const OPTION_NAMES = {

  handling: 'handling', speed_pendown: 'speedPendown', speed_penup: 'speedPenup', accel: 'accel',

  pen_pos_up: 'penPosUp', pen_pos_down: 'penPosDown', pen_rate_lower: 'penRateLower',

  pen_rate_raise: 'penRateRaise', units: 'units', model: 'model',

};

const OP_NAMES = { draw_path: 'drawPath' };

export async function runScenario(spec) {

  const { nd, sim } = makeMachine({}, (n) => {

    n.options.homing = false;

    for (const [k, v] of Object.entries(spec.options)) n.options[OPTION_NAMES[k]] = v;

  });

  if (!(await nd.connect())) throw new Error('connect failed');

  for (const [op, ...args] of spec.ops) {

    if (op === 'draw_path_circle') {

      const [cx, cy, r, n] = args;

      const pts = [];

      for (let i = 0; i <= n; i++) pts.push([cx + r * Math.cos(2 * Math.PI * i / n), cy + r * Math.sin(2 * Math.PI * i / n)]);

      await nd.drawPath(pts);

    } else {

      await nd[OP_NAMES[op] ?? op](...args);

    }

  }

  await nd.disconnect();

  return { cmds: commands(sim), sim };

}

describe('golden command streams vs. the Python API', () => {

  for (const [name, spec] of Object.entries(scenarios)) {

    const fixture = join(dir, 'expected', `${name}.json`);

    const run = existsSync(fixture) ? test : test.skip;

    run(name, async () => {

      const expected = JSON.parse(readFileSync(fixture, 'utf8'));

      const { cmds } = await runScenario(spec);

      expect(cmds).toEqual(expected);

    });

  }

  // These run regardless: every scenario must be safe on the simulator.

  for (const [name, spec] of Object.entries(scenarios)) {

    test(`${name} is safe on the simulator`, async () => {

      const { sim } = await runScenario(spec);

      expect(sim.violations).toEqual([]);

    });

  }

});