rotatingMachine/test/basic/pressureInitialization.basic.test.js

'use strict';

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

const PressureInitialization = require('../../src/pressure/pressureInitialization');

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

/* A tiny in-memory stand-in for MeasurementContainer's chained API. */
function makeFakeMeasurements() {
  const store = new Map();
  const key = (pos, childId) => `${pos}::${childId == null ? '*' : childId}`;
  return {
    _write(pos, childId, value) { store.set(key(pos, childId), value); },
    type() { return this; },
    variant() { return this; },
    position(p) { this._pos = p; return this; },
    child(c) { this._child = c; return this; },
    getCurrentValue() {
      const k = key(this._pos, this._child);
      this._child = null;
      const v = store.get(k);
      if (v != null) return v;
      // fallback to bare position when no child specified
      return store.get(key(this._pos, null));
    },
  };
}

test('getStatus reports initialized:false when neither real nor virtual data present', () => {
  const init = new PressureInitialization({
    measurements: makeFakeMeasurements(),
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    logger: SILENT,
  });
  const s = init.getStatus();
  assert.equal(s.initialized, false);
  assert.equal(s.hasDifferential, false);
  assert.equal(s.source, null);
});

test('registerReal then getStatus reports initialized:true for that position', () => {
  const meas = makeFakeMeasurements();
  const init = new PressureInitialization({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    logger: SILENT,
  });

  init.registerReal('upstream', 'pt-101');
  meas._write('upstream', 'pt-101', 5000);

  const s = init.getStatus();
  assert.equal(s.initialized, true);
  assert.equal(s.hasUpstream, true);
  assert.equal(s.hasDownstream, false);
  assert.equal(s.hasDifferential, false);
  assert.equal(s.source, 'upstream');
});

test('hasDifferential true only when both upstream + downstream have data', () => {
  const meas = makeFakeMeasurements();
  const init = new PressureInitialization({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    logger: SILENT,
  });
  init.registerReal('upstream', 'pt-1');
  meas._write('upstream', 'pt-1', 5000);
  assert.equal(init.getStatus().hasDifferential, false);

  init.registerReal('downstream', 'pt-2');
  meas._write('downstream', 'pt-2', 7000);
  const s = init.getStatus();
  assert.equal(s.hasDifferential, true);
  assert.equal(s.source, 'differential');
});

test('virtual fallback when no real children registered', () => {
  const meas = makeFakeMeasurements();
  const init = new PressureInitialization({
    measurements: meas,
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    logger: SILENT,
  });
  meas._write('upstream', 'sim-u', 5000);
  const s = init.getStatus();
  assert.equal(s.hasUpstream, true);
  assert.equal(s.source, 'upstream');
});

test('unregisterReal removes a tracked child id', () => {
  const init = new PressureInitialization({
    measurements: makeFakeMeasurements(),
    virtualPressureChildIds: { upstream: 'sim-u', downstream: 'sim-d' },
    logger: SILENT,
  });
  init.registerReal('upstream', 'pt-1');
  assert.ok(init.realPressureChildIds.upstream.has('pt-1'));
  init.unregisterReal('upstream', 'pt-1');
  assert.ok(!init.realPressureChildIds.upstream.has('pt-1'));
});