rotatingMachine/test/basic/pressureRouter.basic.test.js

'use strict';

const test = require('node:test');
const assert = require('node:assert/strict');

const PressureRouter = require('../../src/pressure/pressureRouter');

const SILENT = { warn() {}, debug() {} };

function makeFakeMeasurements() {
  const writes = [];
  return {
    writes,
    type() { return this; },
    variant() { return this; },
    position(p) { this._pos = p; return this; },
    child(c) { this._child = c; return this; },
    value(v, t, u) { writes.push({ pos: this._pos, child: this._child, value: v, t, u }); },
  };
}

test('route("upstream", 1, ctx) writes to the upstream pressure slot', () => {
  const meas = makeFakeMeasurements();
  const router = new PressureRouter({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    resolveMeasurementUnit: () => 'mbar',
    logger: SILENT,
  });
  router.route('upstream', 1, { childId: 'real-1', unit: 'mbar', timestamp: 1234 });
  assert.equal(meas.writes.length, 1);
  assert.equal(meas.writes[0].pos, 'upstream');
  assert.equal(meas.writes[0].child, 'real-1');
  assert.equal(meas.writes[0].value, 1);
  assert.equal(meas.writes[0].u, 'mbar');
});

test('virtual source: full cascade still runs (dashboard-sim must update predictions)', () => {
  const meas = makeFakeMeasurements();
  let pressCalled = 0, posCalled = 0, driftCalled = 0, healthCalled = 0;
  const router = new PressureRouter({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    resolveMeasurementUnit: () => 'mbar',
    getPressure: () => { pressCalled++; return 100; },
    updatePosition: () => { posCalled++; },
    refreshDrift: () => { driftCalled++; },
    refreshHealth: () => { healthCalled++; },
    logger: SILENT,
  });
  router.route('upstream', 7, { childId: 'sim-u', unit: 'mbar' });
  assert.equal(pressCalled, 1);
  assert.equal(posCalled, 1);
  assert.equal(driftCalled, 1);
  assert.equal(healthCalled, 1);
});

test('real source: all refresh hooks called', () => {
  const meas = makeFakeMeasurements();
  let pressCalled = 0, posCalled = 0, driftCalled = 0, healthCalled = 0;
  const router = new PressureRouter({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    resolveMeasurementUnit: () => 'mbar',
    getPressure: () => { pressCalled++; return 100; },
    updatePosition: () => { posCalled++; },
    refreshDrift: () => { driftCalled++; },
    refreshHealth: () => { healthCalled++; },
    logger: SILENT,
  });
  router.route('upstream', 7, { childId: 'real-pt-1', unit: 'mbar' });
  assert.equal(pressCalled, 1);
  assert.equal(posCalled, 1);
  assert.equal(driftCalled, 1);
  assert.equal(healthCalled, 1);
});

test('cascade order: getPressure runs before updatePosition (fDimension must be fresh when calcFlowPower runs)', () => {
  const meas = makeFakeMeasurements();
  const calls = [];
  const router = new PressureRouter({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    resolveMeasurementUnit: () => 'mbar',
    getPressure: () => { calls.push('getPressure'); return 100; },
    updatePosition: () => { calls.push('updatePosition'); },
    refreshDrift: () => { calls.push('refreshDrift'); },
    refreshHealth: () => { calls.push('refreshHealth'); },
    logger: SILENT,
  });
  router.route('upstream', 7, { childId: 'real-pt-1', unit: 'mbar' });
  assert.deepEqual(calls, ['getPressure', 'updatePosition', 'refreshDrift', 'refreshHealth']);
});

test('rejected unit returns false and skips the write', () => {
  const meas = makeFakeMeasurements();
  const warns = [];
  const router = new PressureRouter({
    measurements: meas,
    virtualPressureChildIds: {},
    resolveMeasurementUnit: () => { throw new Error('bad unit'); },
    logger: { warn(m) { warns.push(m); }, debug() {} },
  });
  const ok = router.route('upstream', 1, { childId: 'x', unit: 'wat' });
  assert.equal(ok, false);
  assert.equal(meas.writes.length, 0);
  assert.match(warns[0], /Rejected pressure update/);
});

test('childId null is treated as not-virtual', () => {
  const meas = makeFakeMeasurements();
  let posCalled = 0;
  const router = new PressureRouter({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u' },
    resolveMeasurementUnit: () => 'mbar',
    updatePosition: () => { posCalled++; },
    logger: SILENT,
  });
  router.route('upstream', 2, { unit: 'mbar' });
  assert.equal(posCalled, 1);
});