@machinemetrics/io-adapter-lib 2.32.0

package/test/transform/valueIncrease.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const ValueIncrease = require('../../lib/transform').valueIncrease;
+const testUtils = require('../util/testUtils');
+
+describe('value-increase transform tests', function () {
+  it('value-increases irregular digital', function () {
+    const filter = new ValueIncrease();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1, 2], [1, 4], [2, 6], [4, 10], [0, 14], [9, 15], [10, 16], [11, 21],
+    ]);
+    filter.validate([
+      [true, 2], [false, 2], [false, 4], [true, 6], [false, 6], [true, 10], [false, 10],
+      [false, 14], [true, 15], [false, 15], [true, 16], [false, 16], [true, 21], [false, 21],
+    ]);
+  });
+
+  it('value-increases string', function () {
+    const filter = new ValueIncrease();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['1', 2], ['1', 4], ['2', 6], ['4', 10], ['0', 14], ['9', 15], ['10', 16], ['11', 21],
+    ]);
+    filter.validate([
+      [true, 2], [false, 2], [false, 4], [true, 6], [false, 6], [true, 10], [false, 10],
+      [false, 14], [true, 15], [false, 15], [true, 16], [false, 16], [true, 21], [false, 21],
+    ]);
+  });
+});

package/test/transform/valueIncreaseDiff.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const ValueIncreaseDiff = require('../../lib/transform').valueIncreaseDiff;
+const testUtils = require('../util/testUtils');
+
+describe('value-increase-diff transform tests', function () {
+  it('value-increases irregular digital', function () {
+    const filter = new ValueIncreaseDiff();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      [1, 2], [1, 4], [2, 6], [4, 10], [0, 14], [9, 15], [10, 16], [11, 21],
+    ]);
+    filter.validate([
+      [0, 2], [0, 4], [1, 6], [0, 6], [2, 10], [0, 10],
+      [0, 14], [9, 15], [0, 15], [1, 16], [0, 16], [1, 21], [0, 21],
+    ]);
+  });
+
+  it('value-increases string', function () {
+    const filter = new ValueIncreaseDiff();
+    testUtils.attachTransformValidator(filter);
+
+    filter.test([
+      ['1', 2], ['1', 4], ['2', 6], ['4', 10], ['0', 14], ['9', 15], ['10', 16], ['11', 21],
+    ]);
+    filter.validate([
+      [0, 2], [0, 4], [1, 6], [0, 6], [2, 10], [0, 10],
+      [0, 14], [9, 15], [0, 15], [1, 16], [0, 16], [1, 21], [0, 21],
+    ]);
+  });
+});

package/test/transform/whenUnavailable.test.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('when-unavailable config file tests', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/whenUnavailable.yml');
+  });
+
+  const makeSourceEngine = (varName) => {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool[varName], source);
+
+    return { source, engine };
+  };
+
+  it('converts unavailable to false', async function () {
+    const { source, engine } = makeSourceEngine('var1');
+
+    source.sendValues('active', [
+      [true, 0],
+      ['UNAVAILABLE', 2],
+      [true, 4],
+    ]);
+
+    engine.validateFilter([
+      [true, 0],
+      [false, 2],
+      [true, 4],
+    ]);
+  });
+
+  it('converts unavailable to false with expression', async function () {
+    const { source, engine } = makeSourceEngine('var2');
+
+    source.sendValue('counter', 5, 0);
+    source.sendValues('active', [
+      [true, 0],
+      ['UNAVAILABLE', 2],
+      [true, 4],
+    ]);
+
+    engine.validateFilter([
+      [5, 0],
+      [true, 0],
+      [5, 2],
+      [true, 4],
+    ]);
+  });
+
+  it('converts unavailable to false with unavail expression', async function () {
+    const { source, engine } = makeSourceEngine('var2');
+
+    source.sendValues('active', [
+      [true, 0],
+      ['UNAVAILABLE', 2],
+      [true, 4],
+    ]);
+
+    engine.validateFilter([
+      [true, 0],
+      [true, 4],
+    ]);
+  });
+
+  it('cascades through ops when handling unavail', async function () {
+    const { source, engine } = makeSourceEngine('var3');
+
+    source.sendValues('active', [
+      [true, 0],
+      ['UNAVAILABLE', 2],
+      [true, 4],
+      [false, 6],
+    ]);
+
+    // falling-edge produces two events
+    engine.validateFilter([
+      [0, 0],
+      [1, 2],
+      [1, 2],
+      [1, 4],
+      [2, 6],
+      [2, 6],
+    ]);
+  });
+});

package/test/transform/windowCount.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const WindowCount = require('../../lib/transform').windowCount;
+const testUtils = require('../util/testUtils');
+
+describe('window-count transform tests', function () {
+  it('window-count regular', function () {
+    const filter = new WindowCount(5);
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    filter.valdInteger('0011112111100011222110', 1);
+  });
+
+  it('rising-edge-counter irregular', function () {
+    const filter = new WindowCount(5);
+    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], [1, 7], [1, 10], [0, 11], [1, 14], [1, 15], [2, 16], [1, 19], [0, 21],
+    ]);
+  });
+});

package/test/util/testUtils.js

@@ -0,0 +1,405 @@
+'use strict';
+
+/* eslint-disable no-console */
+
+const _ = require('lodash');
+const path = require('path');
+const fs = require('fs/promises');
+const expect = require('chai').expect;
+const EventEmitter = require('eventemitter3');
+const Config = require('../../lib/config');
+const EngineV2 = require('../../lib/engine/engineV2');
+
+module.exports = {
+  testValue: (filter, input, output) => {
+    const dummyTime = filter.lastSampleTime + 1;
+    return new Promise((resolve, reject) => {
+      const onUpdate = (value, time) => {
+        try {
+          expect(value).to.deep.eq(output);
+          expect(time).to.eq(dummyTime);
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      };
+
+      const context = { sourceType: 'test', trigger: 'test' };
+
+      const endFilter = filter.chainEnd();
+      endFilter.on('update', onUpdate);
+      filter.update(context, input, dummyTime);
+      endFilter.removeListener('update', onUpdate);
+    });
+  },
+
+  attachTransformValidator: (filter) => {
+    const updates = [];
+    const endFilter = filter.chainEnd();
+
+    endFilter.on('update', (value, time) => {
+      updates.push({ time, value });
+    });
+
+    filter.test = (arr, options = {}) => {
+      const context = { sourceType: 'test', trigger: 'test' };
+      _.each(arr, ([value, time]) => {
+        if (options.itemPreProcess) {
+          options.itemPreProcess(value, time);
+        }
+        filter.update(context, value, time);
+        if (options.itemPostProcess) {
+          options.itemPostProcess(value, time);
+        }
+      });
+    };
+
+    filter.testAnalog = (arr, timeStep, timeStart = 0, options = {}) => {
+      filter.test(_.map(arr, (value, time) => [value, (time * timeStep) + timeStart]), options);
+    };
+
+    filter.testDigital = (str, timeStep, options) => {
+      filter.test(generateDigital(str, timeStep), options);
+    };
+
+    filter.printUpdates = () => {
+      console.log(updates);
+    };
+
+    filter.validate = (ref) => {
+      expect(updates.length).to.eq(ref.length);
+      ref = _.map(ref, ([value, time]) => {
+        return { time, value };
+      });
+      _.times(ref.length, (i) => {
+        expect(updates[i].time).to.be.closeTo(ref[i].time, 0.000001);
+        if (_.isNumber(ref[i].value)) {
+          expect(updates[i].value).to.be.closeTo(ref[i].value, 0.000001);
+        } else {
+          expect(updates[i].value).to.eq(ref[i].value);
+        }
+      });
+    };
+
+    filter.valdAnalog = (arr, timeStep, timeStart) => {
+      if (_.isUndefined(timeStart)) {
+        timeStart = timeStep - 1;
+      }
+      filter.validate(_.map(arr, (value, time) => [value, timeStart + (time * timeStep)]));
+    };
+
+    filter.valdDigital = (str, timeStep, validateArray = true) => {
+      const upd = recodeDigital(updates);
+      expect(upd).to.eq(str);
+
+      if (validateArray) {
+        filter.validate(generateDigital(str, timeStep));
+      }
+    };
+
+    filter.valdCounter = (str, timeStep) => {
+      const upd = recodeCounter(updates);
+      expect(upd).to.eq(str);
+
+      filter.validate(generateCounter(str, timeStep));
+    };
+
+    filter.valdInteger = (str, timeStep) => {
+      const upd = recodeInts(updates);
+      expect(upd).to.eq(str);
+
+      filter.validate(generateInts(str, timeStep));
+    };
+  },
+
+  attachEngineTransformValidator: (engine, filter, source) => {
+    const filterUpdates = [];
+    const engineUpdates = {};
+
+    if (!source) {
+      source = new ValueSource();
+    }
+    if (source instanceof MTConnectSource) {
+      engine.addMtconnectSource(source);
+    } else {
+      engine.addValueSource(source);
+    }
+
+    if (filter) {
+      const endFilter = filter.chainEnd();
+      endFilter.on('update', (value, time) => {
+        filterUpdates.push({ time, value });
+      });
+    }
+
+    engine.on('update', (name, value, time) => {
+      if (!engineUpdates[name]) {
+        engineUpdates[name] = [];
+      }
+      engineUpdates[name].push({ time, value });
+    });
+
+    engine.test = (arr) => {
+      source.sendValues('pin-1', arr);
+    };
+
+    engine.printFilterUpdates = () => {
+      console.log(filterUpdates);
+    };
+
+    engine.printEngineUpdates = () => {
+      console.log(engineUpdates);
+    };
+
+    engine.validateFilter = (arr) => {
+      expect(filterUpdates.length).to.eq(arr.length);
+      const ref = _.map(arr, ([value, time]) => {
+        return { time, value };
+      });
+      _.times(ref.length, (i) => {
+        expect(filterUpdates[i].time).to.be.closeTo(ref[i].time, 0.000001);
+        expect(filterUpdates[i].value).to.deep.eq(ref[i].value);
+      });
+    };
+
+    engine.validateEngine = (name, arr) => {
+      expect(engineUpdates[name].length).to.eq(arr.length);
+      const ref = _.map(arr, ([value, time]) => {
+        return { time, value };
+      });
+      _.times(ref.length, (i) => {
+        expect(engineUpdates[name][i].time).to.be.closeTo(ref[i].time, 0.000001);
+        expect(engineUpdates[name][i].value).to.eq(ref[i].value);
+      });
+    };
+  },
+
+  pinSource: () => {
+    return new PinSource();
+  },
+
+  valueSource: () => {
+    return new ValueSource();
+  },
+
+  mtconnectSource: (keys) => {
+    return new MTConnectSource(keys);
+  },
+
+  standardBuilderArgs: (config, path, args = {}) => {
+    if (!config) {
+      config = new Config({
+        version: 2,
+        device: 'mtconnect-adapter',
+        endpoint: 'localhost:8000',
+        'mtconnect-port': 8002,
+      });
+    }
+
+    const engine = new EngineV2(config);
+    return {
+      engine,
+      path,
+      args,
+    };
+  },
+
+  loadConfig: async (filename, options) => {
+    const filepath = path.join(process.cwd(), 'test', 'configFiles', filename);
+    return Config.loadFile(filepath, options);
+  },
+
+  loadData: async (filename) => {
+    const filepath = path.join(process.cwd(), 'test', 'dataFiles', filename);
+    const data = await fs.readFile(filepath, 'utf8');
+
+    const lines = data.split('\n');
+    return _.map(lines, (line) => {
+      const item = line.split('\t');
+      const time = +item[0];
+      const value = +item[1];
+      return {
+        value,
+        time,
+      };
+    });
+  },
+};
+
+function generateDigital(str, timeStep) {
+  const signal = [];
+  let lastState = false;
+  let time = 0;
+
+  for (const c of str) {
+    if (c === '^') {
+      signal.push([true, time]);
+      lastState = true;
+    } else if (c === '_') {
+      signal.push([false, time]);
+      lastState = false;
+    } else if (c === '|') {
+      let pstate = lastState;
+      if (time === 0 && str[1] === '^') {
+        pstate = true;
+      }
+
+      if (pstate) {
+        signal.push([false, time]);
+        signal.push([true, time]);
+      } else {
+        signal.push([true, time]);
+        signal.push([false, time]);
+      }
+    }
+    time += timeStep;
+  }
+
+  return signal;
+}
+
+function generateCounter(str, timeStep) {
+  const signal = [];
+  let count = 0;
+  let time = 0;
+
+  for (const c of str) {
+    if (c === '+') {
+      count += 1;
+    }
+    signal.push([count, time]);
+    time += timeStep;
+  }
+
+  return signal;
+}
+
+function generateInts(str, timeStep) {
+  const signal = [];
+  let time = 0;
+
+  for (const c of str) {
+    signal.push([parseInt(c, 10), time]);
+    time += timeStep;
+  }
+
+  return signal;
+}
+
+function recodeDigital(arr) {
+  const signal = [];
+  for (let i = 0; i < arr.length; i += 1) {
+    if (i < arr.length - 1 && arr[i].time === arr[i + 1].time) {
+      if (i > 0 && arr[i - 1].value === arr[i].value) {
+        continue; // eslint-disable-line
+      }
+      if (arr[i].value !== arr[i + 1].value) {
+        signal.push('|');
+        i += 1;
+      }
+    } else if (arr[i].value) {
+      signal.push('^');
+    } else {
+      signal.push('_');
+    }
+  }
+
+  return signal.join('');
+}
+
+function recodeCounter(arr) {
+  const signal = [];
+  for (let i = 0; i < arr.length; i += 1) {
+    if (i === 0 && arr[i].value === 1) {
+      signal.push('+');
+    } else if (i > 1 && arr[i].value === arr[i - 1].value + 1) {
+      signal.push('+');
+    } else {
+      signal.push(' ');
+    }
+  }
+
+  return signal.join('');
+}
+
+function recodeInts(arr) {
+  const signal = [];
+  for (let i = 0; i < arr.length; i += 1) {
+    signal.push(arr[i].value.toString());
+  }
+
+  return signal.join('');
+}
+
+class PinSource extends EventEmitter {
+  constructor() {
+    super();
+    this.config = {};
+    this.config.pins = {
+      0: { pin: 0, mode: 'analog' },
+      1: { pin: 1, mode: 'analog' },
+      4: { pin: 4, mode: 'digital' },
+    };
+  }
+
+  sendValue(pin, value, time) {
+    this.emit('update', pin, value, time);
+  }
+
+  sendValues(pin, arr) {
+    _.each(arr, ([value, time]) => {
+      this.emit('update', pin, value, time);
+    });
+  }
+
+  probe(time) {
+    this.emit('probe', time);
+  }
+}
+
+class ValueSource extends EventEmitter {
+  sendValue(name, value, time) {
+    this.emit('update', name, value, time);
+  }
+
+  sendValues(name, arr) {
+    _.each(arr, ([value, time]) => {
+      this.emit('update', name, value, time);
+    });
+  }
+
+  probe(time) {
+    this.emit('probe', time);
+  }
+
+  unavailable(time) {
+    this.emit('unavailable', time);
+  }
+}
+
+class MTConnectSource extends EventEmitter {
+  constructor(keys) {
+    super();
+    this.keys = keys;
+  }
+
+  sendSample(name, value, time) {
+    this.emit('update-sample', name, value, time);
+  }
+
+  sendCondition(name, fields, time) {
+    this.emit('update-condition', name, fields, time);
+  }
+
+  probe(time) {
+    this.emit('probe', time);
+  }
+
+  unavailable(time) {
+    this.emit('unavailable', time);
+  }
+
+  mtconnectKeys() {
+    return this.keys;
+  }
+}