@machinemetrics/io-adapter-lib 2.32.0

package/test/transform/rateOfChange.test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const RateOfChange = require('../../lib/transform').rateOfChange;
+const testUtils = require('../util/testUtils');
+
+describe('rate of change transform tests', function () {
+  it('rate of change regular 1', function () {
+    const filter = new RateOfChange();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 5, 0, -5, 0], 1);
+    filter.valdAnalog([0, 2, 2, 0, -5, -5, 5], 1);
+  });
+
+  it('rate of change regular 2', function () {
+    const filter = new RateOfChange();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 5, 0, -5, 0], 0.1);
+    filter.valdAnalog([0, 20, 20, 0, -50, -50, 50], 0.1, 0);
+  });
+
+  it('rate of change irregular', function () {
+    const filter = new RateOfChange();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1, 2], [3, 4], [5, 6], [0, 10], [20, 14], [2, 15], [2, 16], [8, 21],
+    ]);
+    filter.validate([
+      [0, 2], [1, 4], [1, 6], [-1.25, 10], [5, 14], [-18, 15], [0, 16], [1.2, 21],
+    ]);
+  });
+});

package/test/transform/reject.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Reject = require('../../lib/transform').reject;
+const EngineV2 = require('../../lib/engine/engineV2');
+const testUtils = require('../util/testUtils');
+
+describe('reject config file tests', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/reject.yml');
+  });
+
+  const setupFilter = (transform) => {
+    const engine = new EngineV2(config);
+    return new Reject({
+      engine,
+      path: transform.path,
+      args: transform.args,
+    });
+  };
+
+  it('rejects simple string', async function () {
+    const filter = setupFilter(config.engine.variables.test1.transform[1]);
+
+    await testUtils.testValue(filter, ['prog1', 'warmup', 'prog2'], ['prog1', 'prog2']);
+    await testUtils.testValue(filter, ['warmup'], []);
+  });
+
+  it('rejects empty string', async function () {
+    const filter = setupFilter(config.engine.variables.test2.transform[1]);
+
+    await testUtils.testValue(filter, ['prog1', '', 'prog2'], ['prog1', 'prog2']);
+    await testUtils.testValue(filter, ['', '', ''], []);
+  });
+
+  it('rejects null', async function () {
+    const filter = setupFilter(config.engine.variables.test3.transform[1]);
+
+    await testUtils.testValue(filter, ['prog1', null, 'prog2'], ['prog1', 'prog2']);
+    await testUtils.testValue(filter, ['prog1', '', null], ['prog1', '']);
+  });
+
+  it('rejects pattern', async function () {
+    const filter = setupFilter(config.engine.variables.test4.transform[1]);
+
+    await testUtils.testValue(filter, ['prog1', 'warmup', 'prog2', 'warmup20'], ['prog1', 'prog2']);
+    await testUtils.testValue(filter, ['warm', 'warmup3'], ['warm']);
+  });
+
+  it('rejects expression', async function () {
+    const filter = setupFilter(config.engine.variables.test5.transform[1]);
+
+    await testUtils.testValue(filter, ['prog1', 'warmup', 'prog2', 'warmup20'], ['prog1', 'prog2', 'warmup20']);
+    await testUtils.testValue(filter, ['warm', 'warmup3'], ['warm', 'warmup3']);
+  });
+});

package/test/transform/resample.test.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const expect = require('chai').expect;
+const Source = require('../../lib/transform').source;
+const Resample = require('../../lib/transform').resample;
+const EngineV2 = require('../../lib/engine/engineV2');
+const ExpressionService = require('../../lib/expressionService');
+const testUtils = require('../util/testUtils');
+
+describe('resample transform tests', function () {
+  it('resample identity', function () {
+    const filter = new Resample({ interval: 1 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+  });
+
+  it('resample down 2', function () {
+    const filter = new Resample({ interval: 2 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 5, 9, 4, 8], 2, 0);
+  });
+
+  it('resample down 2 offset 1', function () {
+    const filter = new Resample({ interval: 2 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1, 1);
+    filter.valdAnalog([1, 5, 9, 4, 8], 2, 1);
+  });
+
+  it('resample down 2.25', function () {
+    // Without an engine to honor pending change times, this is equivalent to interval: 3
+    // when fed uniform samples at a rate of 1
+    const filter = new Resample({ interval: 2.25 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 7, 4, 0], 3, 0);
+  });
+
+  it('resample down 3', function () {
+    const filter = new Resample({ interval: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1);
+    filter.valdAnalog([1, 7, 4, 0], 3, 0);
+  });
+
+  it('resample down 3 offset 1', function () {
+    const filter = new Resample({ interval: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 1, 1);
+    filter.valdAnalog([1, 7, 4, 0], 3, 1);
+  });
+
+  it('resample up 2', function () {
+    // Without an engine to honor pending change times, it's generally not possible to upsample
+    const filter = new Resample({ interval: 0.5 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2], 1);
+    filter.valdAnalog([1, 3, 5, 7, 9, 2], 1, 0);
+  });
+
+  it('resample down 2 irregular', function () {
+    const filter = new Resample({ interval: 2 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1, 0], [3, 1], [5, 2], [7, 31], [9, 32],
+    ]);
+    filter.validate([
+      [1, 0], [5, 2], [7, 31],
+    ]);
+  });
+
+  it('supports pending change', function () {
+    const filter = new Resample({ interval: 2.25 });
+    expect(filter.supportsPendingChanges()).to.eq(true);
+    expect(filter.nextPendingChange()).to.eq(null);
+
+    const context = { sourceType: 'test', trigger: 'test' };
+
+    filter.update(context, 10, 1);
+    expect(filter.nextPendingChange()).to.eq(3.25);
+    filter.update(context, 15, 2);
+    expect(filter.nextPendingChange()).to.eq(3.25);
+    filter.update(context, 20, 3.25);
+    expect(filter.nextPendingChange()).to.eq(5.5);
+    filter.update(context, 25, 7);
+    expect(filter.nextPendingChange()).to.eq(9.25);
+
+    filter.setUnavailable(context);
+    expect(filter.nextPendingChange()).to.eq(null);
+  });
+});
+
+describe('resample transform engine tests', function () {
+  it('resample down 2.25', function () {
+    const exprsvc = new ExpressionService();
+    const engine = new EngineV2({ expressionService: exprsvc });
+
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addExpression({ expression: 'pin-1', path: 'test1' });
+
+    const filter = new Source({
+      engine,
+      path: 'test1',
+      baseTransform: true,
+      args: {
+        expression: 'pin-1',
+      },
+    }).chain(new Resample({ interval: 2.25 }));
+    engine.addVariable('res', filter);
+
+    testUtils.attachEngineTransformValidator(engine, filter);
+
+    engine.test([
+      [1, 1], [3, 2], [5, 3], [7, 4], [9, 5], [2, 6], [4, 7], [6, 8], [8, 9], [0, 10],
+    ]);
+    engine.validateFilter([
+      [1, 1], [5, 3.25], [9, 5.5], [4, 7.75], [0, 10],
+    ]);
+    engine.validateEngine('res', [
+      [1, 1], [5, 3.25], [9, 5.5], [4, 7.75], [0, 10],
+    ]);
+  });
+
+  it('resample up 2', function () {
+    const exprsvc = new ExpressionService();
+    const engine = new EngineV2({ expressionService: exprsvc });
+
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addExpression({ expression: 'pin-1', path: 'test1' });
+
+    const filter = new Source({
+      engine,
+      path: 'test1',
+      baseTransform: true,
+      args: {
+        expression: 'pin-1',
+      },
+    }).chain(new Resample({ interval: 0.5 }));
+    engine.addVariable('res', filter);
+
+    testUtils.attachEngineTransformValidator(engine, filter);
+
+    engine.test([
+      [1, 1], [3, 2], [5, 3], [7, 4], [9, 5],
+    ]);
+    engine.validateFilter([
+      [1, 1], [1, 1.5], [3, 2], [3, 2.5], [5, 3], [5, 3.5], [7, 4], [7, 4.5], [9, 5],
+    ]);
+    engine.validateEngine('res', [
+      [1, 1], [3, 2], [5, 3], [7, 4], [9, 5],
+    ]);
+  });
+
+  it('resample up 2 safety limit', function () {
+    const exprsvc = new ExpressionService();
+    const engine = new EngineV2({ expressionService: exprsvc });
+
+    exprsvc.addName({ name: 'pin-1', defaultValue: 0, channel: 'device' });
+    exprsvc.addExpression({ expression: 'pin-1', path: 'test1' });
+
+    const filter = new Source({
+      engine,
+      path: 'test1',
+      baseTransform: true,
+      args: {
+        expression: 'pin-1',
+      },
+    }).chain(new Resample({ interval: 0.5 }));
+    engine.addVariable('res', filter);
+
+    testUtils.attachEngineTransformValidator(engine, filter);
+
+    engine.test([
+      [1, 1], [3, 2], [5, 4], [7, 400],
+    ]);
+    engine.validateFilter([
+      [1, 1], [1, 1.5], [3, 2], [3, 2.5], [3, 3], [3, 3.5], [5, 4], [5, 399.5], [7, 400],
+    ]);
+    engine.validateEngine('res', [
+      [1, 1], [3, 2], [5, 4], [7, 400],
+    ]);
+  });
+});

package/test/transform/risingEdge.test.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const RisingEdge = require('../../lib/transform').risingEdge;
+const testUtils = require('../util/testUtils');
+
+describe('rising-edge transform tests', function () {
+  it('rising-edge regular', function () {
+    const filter = new RisingEdge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('__|___|_______|_|_____', 1);
+  });
+
+  it('rising-edge regular high start', function () {
+    const filter = new RisingEdge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('^^^^__^^^^____^_^^^^^_', 1);
+    filter.valdDigital('______|_______|_|_____', 1);
+  });
+
+  it('rising-edge irregular', function () {
+    const filter = new RisingEdge();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 2], [false, 4], [true, 6], [false, 10], [true, 14], [false, 15], [true, 16], [false, 21],
+    ]);
+    filter.validate([
+      [false, 2], [false, 4], [true, 6], [false, 6], [false, 10], [true, 14], [false, 14], [false, 15],
+      [true, 16], [false, 16], [false, 21],
+    ]);
+  });
+
+  // NB: At start of stream, signal has been in low state for "infinite" time.
+  it('rising-edge regular min-dwell 3', function () {
+    const filter = new RisingEdge({ minDwell: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^___^^^_', 1);
+    filter.valdDigital('__|___________|_________|___', 1);
+  });
+
+  it('rising-edge regular max-dwell 3', function () {
+    const filter = new RisingEdge({ maxDwell: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^___^^^_', 1);
+    filter.valdDigital('__|___|_________|_______|___', 1);
+  });
+
+  it('rising-edge regular dwell 2 3', function () {
+    const filter = new RisingEdge({ minDwell: 2, maxDwell: 3 });
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^___^^^_', 1);
+    filter.valdDigital('__|___|_________________|___', 1);
+  });
+});

package/test/transform/risingEdgeCounter.test.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const { expect } = require('chai');
+const RisingEdgeCounter = require('../../lib/transform').risingEdgeCounter;
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('rising-edge-counter transform tests', function () {
+  it('rising-edge-counter regular', function () {
+    const filter = new RisingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1'));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdCounter('  +   +       + +     ', 1);
+  });
+
+  it('rising-edge-counter regular high start', function () {
+    const filter = new RisingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1'));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('^^^^__^^^^____^_^^^^^_', 1);
+    filter.valdCounter('      +       + +     ', 1);
+  });
+
+  it('rising-edge-counter irregular', function () {
+    const filter = new RisingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1'));
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [false, 0], [true, 2], [false, 4], [true, 6], [false, 10], [true, 14], [false, 15], [true, 16], [false, 21],
+    ]);
+    filter.validate([
+      [0, 0], [1, 2], [1, 4], [2, 6], [2, 10], [3, 14], [3, 15], [4, 16], [4, 21],
+    ]);
+  });
+
+  it('rising-edge-counter irregular high start', function () {
+    const filter = new RisingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1'));
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [true, 2], [false, 4], [true, 6], [false, 10], [true, 14], [false, 15], [true, 16], [false, 21],
+    ]);
+    filter.validate([
+      [0, 2], [0, 4], [1, 6], [1, 10], [2, 14], [2, 15], [3, 16], [3, 21],
+    ]);
+  });
+
+  it('rising-edge-counter pending change', function () {
+    const filter = new RisingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1', { mergeWindow: 3 }));
+    expect(filter.supportsPendingChanges()).to.eq(true);
+    expect(filter.nextPendingChange()).to.eq(null);
+
+    const context = { sourceType: 'test', trigger: 'test' };
+
+    filter.update(context, false, 0);
+    filter.update(context, true, 1);
+    expect(filter.nextPendingChange()).to.eq(4);
+
+    filter.update(context, false, 0);
+    filter.update(context, true, 2);
+    expect(filter.nextPendingChange()).to.eq(5);
+
+    filter.update(context, false, 7);
+    expect(filter.nextPendingChange()).to.eq(null);
+  });
+
+  it('rising-edge-counter merge-window', function () {
+    const filter = new RisingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1', { mergeWindow: 3 }));
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [false, 0], [true, 1], [false, 1], [true, 2], [false, 2], [true, 4], [false, 4], [true, 8], [false, 8],
+    ]);
+    filter.validate([
+      [0, 0], [0, 1], [0, 1], [0, 2], [0, 2], [0, 4], [0, 4], [3, 8], [3, 8],
+    ]);
+  });
+});
+
+describe('rising-edge-counter full engine config file tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/risingEdgeCounter.yml');
+  });
+
+  it('no reset expression', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var1, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [0, 0], [1, 2], [1, 4], [2, 6],
+      [2, 8], [3, 10], [3, 12], [4, 14],
+    ]);
+  });
+
+  it('reset expression referencing data source', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var2, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValue('program', 5, 7);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+    source.sendValue('program', 10, 15);
+    source.sendValues('active', [[false, 16], [true, 18], [false, 20], [true, 22]]);
+    source.sendValue('program', 5, 23);
+    source.sendValues('active', [[false, 24], [true, 26], [false, 28], [true, 30]]);
+    source.sendValue('program', 10, 31);
+    source.sendValue('program', 5, 32);
+    source.sendValues('active', [[false, 34], [true, 36], [false, 38], [true, 40]]);
+
+    engine.validateFilter([
+      [0, 0], [1, 2], [1, 4], [2, 6],
+      [2, 7],
+      [2, 8], [3, 10], [3, 12], [4, 14],
+      [0, 15],
+      [0, 16], [0, 18], [0, 20], [0, 22],
+      [0, 23],
+      [0, 24], [1, 26], [1, 28], [2, 30],
+      [0, 31],
+      [0, 32],
+      [0, 34], [1, 36], [1, 38], [2, 40],
+    ]);
+  });
+
+  it('reset condition referencing this', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var3, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [0, 0], [1, 2], [1, 4], [2, 6],
+      [2, 8], [0, 10], [0, 12], [1, 14],
+    ]);
+  });
+
+  it('count by expression', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var4, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [0, 0], [5, 2], [5, 4], [10, 6],
+      [10, 8], [15, 10], [15, 12], [20, 14],
+    ]);
+  });
+
+  it('count by expression with reset', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var5, source);
+
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [0, 0], [5, 2], [5, 4], [10, 6],
+      [10, 8], [0, 10], [0, 12], [5, 14],
+    ]);
+  });
+
+  it('count with merge-window', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var6, source);
+
+    source.sendValues('active', [[false, 0], [true, 1], [false, 2], [true, 3]]);
+    source.sendValues('active', [[false, 4], [true, 8], [false, 9]]);
+
+    engine.validateFilter([
+      [0, 0], [0, 1], [0, 2], [0, 3],
+      [0, 4], [2, 6], [2, 8], [2, 9],
+    ]);
+    engine.validateEngine('var6', [
+      [0, 0], [2, 6],
+    ]);
+  });
+
+  it('count by expression 2', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var7, source);
+
+    source.sendValue('ppc', 7, 0);
+    source.sendValues('active', [[false, 0], [true, 2], [false, 4], [true, 6]]);
+    source.sendValue('ppc', 3, 7);
+    source.sendValues('active', [[false, 8], [true, 10], [false, 12], [true, 14]]);
+
+    engine.validateFilter([
+      [0, 0], [7, 2], [7, 4], [14, 6], [14, 7],
+      [14, 8], [17, 10], [17, 12], [20, 14],
+    ]);
+  });
+});

package/test/transform/sampleInterval.test.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const SampleInterval = require('../../lib/transform').sampleInterval;
+const testUtils = require('../util/testUtils');
+
+describe('sample-interval transform tests', function () {
+  it('sample-interval regular 0.002', function () {
+    const filter = new SampleInterval(0.002);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 0.002);
+    filter.valdAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 0.002, 0);
+  });
+
+  it('sample-interval regular 0.01', function () {
+    const filter = new SampleInterval(0.01);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testAnalog([1, 3, 5, 7, 9, 2, 4, 6, 8, 0], 0.002);
+    filter.valdAnalog([9, 0], 0.01, 0.008);
+  });
+});