rotatingMachine/test/edge/error-paths.edge.test.js

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

const Machine = require('../../src/specificClass');
const NodeClass = require('../../src/nodeClass');
const { makeMachineConfig, makeStateConfig, makeNodeStub } = require('../helpers/factories');

test('setpoint rejects negative inputs without throwing', async () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));
  await assert.doesNotReject(async () => {
    await machine.setpoint(-1);
  });
});

test('setpoint is constrained to safe movement/curve bounds', async () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));
  const requested = [];
  machine.state.moveTo = async (target) => {
    requested.push(target);
  };

  const stateMin = machine.state.movementManager.minPosition;
  const stateMax = machine.state.movementManager.maxPosition;
  const curveMin = machine.predictFlow.currentFxyXMin;
  const curveMax = machine.predictFlow.currentFxyXMax;
  const min = Math.max(stateMin, curveMin);
  const max = Math.min(stateMax, curveMax);

  await machine.setpoint(min - 100);
  await machine.setpoint(max + 100);

  assert.equal(requested.length, 2);
  assert.equal(requested[0], min);
  assert.equal(requested[1], max);
});

test('source.getStatusBadge returns error status on internal failure', () => {
  // Status badge lives on the domain post-refactor. Build a tiny stub
  // that throws to verify the error-path returns an error badge.
  const errors = [];
  const source = {
    currentMode: 'auto',
    state: { getCurrentState() { throw new Error('boom'); } },
    logger: { error: (m) => errors.push(m) },
  };
  const { buildStatusBadge } = require('../../src/io/output');
  const status = buildStatusBadge(source);
  assert.match(status.text, /Status Error/);
  assert.equal(status.fill, 'red');
  assert.equal(errors.length, 1);
});

test('measurement handlers reject incompatible units', () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));

  assert.equal(machine.isUnitValidForType('flow', 'm3/h'), true);
  assert.equal(machine.isUnitValidForType('flow', 'mbar'), false);

  machine.updateMeasuredFlow(100, 'downstream', {
    timestamp: Date.now(),
    unit: 'mbar',
    childName: 'bad-ft',
  });

  const measuredFlow = machine.measurements
    .type('flow')
    .variant('measured')
    .position('downstream')
    .getCurrentValue();

  assert.equal(measuredFlow, null);
});