@machinemetrics/io-adapter-lib 2.32.0

package/test/expressionServiceCondition.test.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const Builder = require('../lib/engine/transformBuilderV2');
+const EngineV2 = require('../lib/engine/engineV2');
+const testUtils = require('./util/testUtils');
+
+describe('ExpressionService condition tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('expressionCond.yml');
+  });
+
+  const playCond1 = (source) => {
+    source.sendCondition('cond1', { level: 'NORMAL' }, 0);
+    source.sendCondition('cond1', { code: 'X01', level: 'WARNING', message: 'Warning X01' }, 2000);
+    source.sendCondition('cond1', { code: 'X01', level: 'NORMAL' }, 4000);
+    source.sendCondition('cond1', { code: 'X01', level: 'FAULT', message: 'Fault X01' }, 6000);
+    source.sendCondition('cond1', { level: 'NORMAL' }, 8000);
+    source.sendCondition('cond1', { level: 'UNAVAILABLE' }, 10000);
+  };
+
+  const makeSource = (attach) => {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.mtconnectSource(config.device.keys);
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool[attach], source);
+
+    return { engine, source };
+  };
+
+  it('supports code level lookup', function () {
+    const { engine, source } = makeSource('level1');
+
+    playCond1(source);
+    engine.validateFilter([
+      ['NORMAL', 0],
+      ['WARNING', 2],
+      ['NORMAL', 4],
+      ['FAULT', 6],
+      ['NORMAL', 8],
+      ['UNAVAILABLE', 10],
+    ]);
+  });
+
+  it('supports code level lookup not seen', function () {
+    const { engine, source } = makeSource('level2');
+
+    playCond1(source);
+    engine.validateFilter([
+      ['NORMAL', 0],
+      ['NORMAL', 2],
+      ['NORMAL', 4],
+      ['NORMAL', 6],
+      ['NORMAL', 8],
+      ['UNAVAILABLE', 10],
+    ]);
+  });
+
+  it('supports code level lookup square brackets', function () {
+    const { engine, source } = makeSource('level3');
+
+    playCond1(source);
+    engine.validateFilter([
+      ['NORMAL', 0],
+      ['WARNING', 2],
+      ['NORMAL', 4],
+      ['FAULT', 6],
+      ['NORMAL', 8],
+      ['UNAVAILABLE', 10],
+    ]);
+  });
+
+  it('supports seen code', function () {
+    const { engine, source } = makeSource('seen1');
+
+    playCond1(source);
+    engine.validateFilter([
+      [false, 0],
+      [true, 2],
+      [true, 4],
+      [true, 6],
+      [true, 8],
+      [true, 10],
+    ]);
+  });
+
+  it('supports unseen code', function () {
+    const { engine, source } = makeSource('seen2');
+
+    playCond1(source);
+    engine.validateFilter([
+      [false, 0],
+      [false, 2],
+      [false, 4],
+      [false, 6],
+      [false, 8],
+      [false, 10],
+    ]);
+  });
+
+  it('supports code message lookup', function () {
+    const { engine, source } = makeSource('message1');
+
+    playCond1(source);
+    engine.validateFilter([
+      ['', 0],
+      ['Warning X01', 2],
+      ['', 4],
+      ['Fault X01', 6],
+      ['', 8],
+      ['', 10],
+    ]);
+  });
+
+  it('supports code message lookup not seen', function () {
+    const { engine, source } = makeSource('message2');
+
+    playCond1(source);
+    engine.validateFilter([
+      ['', 0],
+      ['', 2],
+      ['', 4],
+      ['', 6],
+      ['', 8],
+      ['', 10],
+    ]);
+  });
+});

package/test/repro/buffer-convert-repro.test.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro convert data through buffer', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/buffer-convert-repro.yml');
+  });
+
+  const replayStream = (source) => {
+    source.sendValue('color1', 0x4C42, normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('color2', 0x4555, normalizeTime('2020-08-25T17:48:02.594+00:00'));
+  };
+
+  // Tests that a value is returned from the ternary expression with the options are named variables.
+  // Previously they were not matched due to being adjacent to a colon
+  it('emits result of ternary operation', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+
+    engine.validateEngine('color', [
+      ['BLUE', normalizeTime('2020-08-25T17:48:02.594+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}

package/test/repro/chained-delay-timing-repro.test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const _ = require('lodash');
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro missing time delay in chained delay', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/chained-delay-timing-repro.yml');
+  });
+
+  it('completes successfully', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    const ain0 = [0, 0, 0, 2, 5, 5, 0, 0, 0, 0];
+    const times = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    _.each(_.zip(ain0, times), ([val, time]) => {
+      source.sendValue('AIN0', val, time);
+    });
+
+    engine.validateEngine('delay', [
+      [false, 0],
+      [true, 6],
+      [false, 8],
+    ]);
+  });
+});

package/test/repro/count-init-repro.test.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro count skipping first event', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/count-init-repro.yml');
+  });
+
+  const replayStream = (source) => {
+    source.sendValue('Fovr', '100', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('part_count', '2312478', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('program', '1289', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('execution', 'ACTIVE', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+
+    source.sendValue('part_count', '2312479', normalizeTime('2020-08-25T17:50:04.712+00:00'));
+    source.sendValue('part_count', '2312480', normalizeTime('2020-08-25T17:52:42.712+00:00'));
+  };
+
+  // Tests that the modified-part-count variable appropriately responds to change in
+  // dependent variable in-warmup, so the count is initialized to 0 as soon as the program
+  // is set.
+  it('emits part count at first part change', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+
+    engine.validateEngine('modified-part-count', [
+      [0, normalizeTime('2020-08-25T17:48:02.594+00:00')],
+      [1, normalizeTime('2020-08-25T17:50:04.712+00:00')],
+      [2, normalizeTime('2020-08-25T17:52:42.712+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}

package/test/repro/cylce-break-repro.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const expect = require('chai').expect;
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro engine breaking script cycles', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/cycle-break-repro.yml');
+  });
+
+  it('completes successfully', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    source.sendValue('AIN0', 0, 0);
+    source.sendValue('AIN1', 0, 0);
+
+    source.sendValue('AIN0', 8, 1);
+    source.sendValue('AIN1', 0, 1);
+    source.sendValue('AIN0', 0, 1);
+
+    source.sendValue('AIN0', 8, 2);
+    source.sendValue('AIN1', 0, 2);
+    source.sendValue('AIN0', 0, 2);
+
+    source.sendValue('AIN0', 8, 3);
+    source.sendValue('AIN1', 8, 3);
+    source.sendValue('AIN0', 0, 3);
+    source.sendValue('AIN1', 0, 3);
+
+    // engine.printEngineUpdates();
+
+    expect(engine.stats.unavailCyclesDetected).to.be.greaterThan(0);
+    expect(engine.stats.updateCyclesDetected).to.be.greaterThan(0);
+
+    expect(engine.pool['latch-1'].available).to.eq(false);
+    expect(engine.pool['latch-2'].available).to.eq(false);
+    expect(engine.pool['latch-3'].available).to.eq(true);
+    expect(engine.pool['latch-4'].available).to.eq(true);
+
+    engine.validateEngine('latch-3', [
+      [false, 0],
+      [true, 1],
+    ]);
+
+    engine.validateEngine('latch-4', [
+      [false, 0],
+    ]);
+  });
+});

package/test/repro/debounce-repro.test.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro debounce not triggering correctly', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/debounce-repro.yml');
+  });
+
+  const replayStream = (source) => {
+    source.sendValue('Fovr', '100', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('program', '1582', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('execution', 'READY', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('Fovr', '0', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('Fovr', '0', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('execution', 'ACTIVE', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('execution', 'ACTIVE', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+    source.sendValue('Fovr', '110', normalizeTime('2020-08-13T10:35:38.165+00:00'));
+  };
+
+  it('triggers change after event update', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+    source.sendValue('part_count', '100', normalizeTime('2020-08-13T10:36:38.165+00:00'));
+
+    engine.validateEngine('f_override_low', [
+      [false, normalizeTime('2020-08-13T10:35:38.165+00:00')],
+    ]);
+    engine.validateEngine('f_override_high', [
+      [false, normalizeTime('2020-08-13T10:35:38.165+00:00')], [true, normalizeTime('2020-08-13T10:35:58.165+00:00')],
+    ]);
+  });
+
+  it('triggers change after unavailable', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+    source.unavailable(normalizeTime('2020-08-13T10:36:38.165+00:00'));
+
+    engine.validateEngine('f_override_low', [
+      [false, normalizeTime('2020-08-13T10:35:38.165+00:00')],
+    ]);
+    engine.validateEngine('f_override_high', [
+      [false, normalizeTime('2020-08-13T10:35:38.165+00:00')], [true, normalizeTime('2020-08-13T10:35:58.165+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}

package/test/repro/diff-count-repro.test.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro count by diff', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/diff-count-repro.yml');
+  });
+
+  const replayStream = (source) => {
+    source.sendValue('mode', 'AUTOMATIC', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('partcount', '100', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('mode', 'AUTOMATIC', normalizeTime('2020-08-25T17:49:02.594+00:00'));
+    source.sendValue('partcount', '103', normalizeTime('2020-08-25T17:49:02.594+00:00'));
+    source.sendValue('mode', 'AUTOMATIC', normalizeTime('2020-08-25T17:49:02.594+00:00'));
+    source.sendValue('mode', 'MANUAL', normalizeTime('2020-08-25T17:49:32.594+00:00'));
+    source.sendValue('partcount', '106', normalizeTime('2020-08-25T17:50:02.594+00:00'));
+    source.sendValue('mode', 'AUTOMATIC', normalizeTime('2020-08-25T17:50:32.594+00:00'));
+    source.sendValue('partcount', '109', normalizeTime('2020-08-25T17:51:02.594+00:00'));
+  };
+
+  // Tests that the modified-part-count variable appropriately responds to change in
+  // dependent variable in-warmup, so the count is initialized to 0 as soon as the program
+  // is set.
+  it('conditionally filters diff part counts', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream(source);
+
+    engine.validateEngine('modified1', [
+      [0, normalizeTime('2020-08-25T17:48:02.594+00:00')],
+      [3, normalizeTime('2020-08-25T17:49:02.594+00:00')],
+      [6, normalizeTime('2020-08-25T17:50:02.594+00:00')],
+      [9, normalizeTime('2020-08-25T17:51:02.594+00:00')],
+    ]);
+
+    engine.validateEngine('modified2', [
+      [0, normalizeTime('2020-08-25T17:48:02.594+00:00')],
+      [3, normalizeTime('2020-08-25T17:49:02.594+00:00')],
+      [6, normalizeTime('2020-08-25T17:51:02.594+00:00')],
+    ]);
+  });
+
+  const replayStream2 = (source) => {
+    source.sendValue('partcount', '100', normalizeTime('2020-08-25T17:48:02.594+00:00'));
+    source.sendValue('partcount', '101', normalizeTime('2020-08-25T17:58:02.594+00:00'));
+    source.sendValue('partcount', '102', normalizeTime('2020-08-25T18:01:02.594+00:00'));
+    source.sendValue('partcount', '103', normalizeTime('2020-08-25T18:09:02.594+00:00'));
+  };
+
+  it('conditionally filters diff part counts 2', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    replayStream2(source);
+
+    engine.validateEngine('modified3', [
+      [0, normalizeTime('2020-08-25T17:48:02.594+00:00')],
+      [1, normalizeTime('2020-08-25T17:58:02.594+00:00')],
+      [2, normalizeTime('2020-08-25T18:09:02.594+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}

package/test/repro/engine-hang-repro.test.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const _ = require('lodash');
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro engine hanging processing data', async function () {
+  let config;
+  let data;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/engine-hang-repro.yml');
+    data = await testUtils.loadData('noisy-pulse.txt');
+  });
+
+  it('completes successfully', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    _.each(data, ({ value, time }) => {
+      source.sendValue('AIN0', value, time);
+    });
+
+    engine.validateEngine('exec-raw', [
+      [false, 1584975134.744],
+      [true, 1584975138.744],
+      [false, 1584975141.744],
+      [true, 1584975148.744],
+      [false, 1584975151.744],
+      [true, 1584975152.744],
+      [false, 1584975155.744],
+    ]);
+  });
+});

package/test/repro/latch-apm-repro.test.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('repro latch apm', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('repro/latch-apm-repro.yml');
+  });
+
+  it('emits extracted program name', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    source.sendValue(
+      'execution1',
+      'ACTIVE',
+      normalizeTime('2020-08-25T17:48:02.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'G62',
+      normalizeTime('2020-08-25T17:48:02.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'O1608(301608 SOFT REV 2 HEAD 1 KG 61421 HE)',
+      normalizeTime('2020-08-25T17:48:03.000+00:00')
+    );
+    source.sendValue(
+      'execution1',
+      'READY',
+      normalizeTime('2020-08-25T17:48:03.000+00:00')
+    );
+    source.sendValue(
+      'execution1',
+      'ACTIVE',
+      normalizeTime('2020-08-25T17:48:06.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'G45',
+      normalizeTime('2020-08-25T17:48:07.000+00:00')
+    );
+
+    engine.validateEngine('program_comment', [
+      ['UNAVAILABLE', normalizeTime('2020-08-25T17:48:02.000+00:00')],
+      ['(301608 SOFT REV 2 HEAD 1 KG 61421 HE)', normalizeTime('2020-08-25T17:48:03.000+00:00')],
+      ['UNAVAILABLE', normalizeTime('2020-08-25T17:48:06.000+00:00')],
+    ]);
+    engine.validateEngine('operation_name', [
+      ['301608', normalizeTime('2020-08-25T17:48:03.000+00:00')],
+    ]);
+  });
+
+  it('emits extracted program name block priority order', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, null, source);
+
+    source.sendValue(
+      'execution1',
+      'ACTIVE',
+      normalizeTime('2020-08-25T17:48:02.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'G62',
+      normalizeTime('2020-08-25T17:48:02.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'O1608(301608 SOFT REV 2 HEAD 1 KG 61421 HE)',
+      normalizeTime('2020-08-25T17:48:03.000+00:00')
+    );
+    source.sendValue(
+      'execution1',
+      'READY',
+      normalizeTime('2020-08-25T17:48:03.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'O1608(301608 SOFT REV 2 HEAD 1 KG 61421 HE)',
+      normalizeTime('2020-08-25T17:48:06.000+00:00')
+    );
+    source.sendValue(
+      'execution1',
+      'ACTIVE',
+      normalizeTime('2020-08-25T17:48:06.000+00:00')
+    );
+    source.sendValue(
+      'block1',
+      'G45',
+      normalizeTime('2020-08-25T17:48:07.000+00:00')
+    );
+
+    engine.validateEngine('program_comment', [
+      ['UNAVAILABLE', normalizeTime('2020-08-25T17:48:02.000+00:00')],
+      ['(301608 SOFT REV 2 HEAD 1 KG 61421 HE)', normalizeTime('2020-08-25T17:48:03.000+00:00')],
+      ['UNAVAILABLE', normalizeTime('2020-08-25T17:48:06.000+00:00')],
+    ]);
+    engine.validateEngine('operation_name', [
+      ['301608', normalizeTime('2020-08-25T17:48:03.000+00:00')],
+    ]);
+  });
+});
+
+function normalizeTime(time) {
+  return Date.parse(time) / 1000.0;
+}