@machinemetrics/io-adapter-lib 2.32.0

package/test/config/adapter.test.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Adapter config tests', function () {
+  let config;
+  let config2;
+  let config3;
+  before(async () => {
+    config = await testUtils.loadConfig('device/labjack-t4-pins.yaml');
+    config2 = await testUtils.loadConfig('device/labjack-t4-pins-alt.yaml');
+    config3 = await testUtils.loadConfig('device/labjack-t4-condition-exprs.yaml');
+  });
+
+  it('by-expression tables filled out', function () {
+    expect(_.size(config.adapter.conditionsByExpression)).to.eq(9);
+    expect(config.adapter.conditionsByExpression['conditions.shorthand.alarm0.value.WARNING']).to.eq('shorthand');
+    expect(config.adapter.conditionsByExpression['conditions.shorthand.alarm0.code']).to.eq('shorthand');
+    expect(config.adapter.conditionsByExpression['conditions.shorthand.alarm0.message']).to.eq('shorthand');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm1.value.FAULT']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm1.code']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm1.message']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm2.value.FAULT']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm2.code']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm2.message']).to.eq('system');
+
+    expect(_.size(config.adapter.dataItemsByExpression)).to.eq(3);
+    expect(config.adapter.dataItemsByExpression['data-items.data1.value']).to.eq('data1');
+    expect(config.adapter.dataItemsByExpression['data-items.data2.value.OFF']).to.eq('data2');
+    expect(config.adapter.dataItemsByExpression['data-items.data2.value.ON']).to.eq('data2');
+  });
+
+  it('alt by-expression tables filled out', function () {
+    expect(_.size(config2.adapter.conditionsByExpression)).to.eq(9);
+    expect(config.adapter.conditionsByExpression['conditions.shorthand.alarm0.value.WARNING']).to.eq('shorthand');
+    expect(config.adapter.conditionsByExpression['conditions.shorthand.alarm0.code']).to.eq('shorthand');
+    expect(config.adapter.conditionsByExpression['conditions.shorthand.alarm0.message']).to.eq('shorthand');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm1.value.FAULT']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm1.code']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm1.message']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm2.value.FAULT']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm2.code']).to.eq('system');
+    expect(config.adapter.conditionsByExpression['conditions.system.alarm2.message']).to.eq('system');
+
+    expect(_.size(config2.adapter.dataItemsByExpression)).to.eq(2);
+    expect(config2.adapter.dataItemsByExpression['data-items.data1.value']).to.eq('data1');
+    expect(config2.adapter.dataItemsByExpression['data-items.data2.value']).to.eq('data2');
+  });
+
+  it('resolves triggered data items', function () {
+    expect(config.adapter.triggeredDataItems('pin-0')).to.deep.eq([]);
+    expect(config.adapter.triggeredDataItems('pin-4')).to.deep.eq(['data1']);
+    expect(config.adapter.triggeredDataItems('pin-5')).to.deep.eq(['data2']);
+    expect(config.adapter.triggeredDataItems('var1')).to.deep.eq([]);
+    expect(config.adapter.triggeredDataItems('var2')).to.deep.eq(['data2']);
+  });
+
+  it('alt resolves triggered data items', function () {
+    expect(config2.adapter.triggeredDataItems('AIN0')).to.deep.eq([]);
+    expect(config2.adapter.triggeredDataItems('FIO4')).to.deep.eq([]);
+    expect(config2.adapter.triggeredDataItems('FIO5')).to.deep.eq([]);
+    expect(config2.adapter.triggeredDataItems('var1')).to.deep.eq([]);
+    expect(config2.adapter.triggeredDataItems('var2')).to.deep.eq([]);
+    expect(config2.adapter.triggeredDataItems('data1')).to.deep.eq(['data1']);
+    expect(config2.adapter.triggeredDataItems('data2')).to.deep.eq(['data2']);
+  });
+
+  it('resolves triggered conditions', function () {
+    expect(config.adapter.triggeredConditions('pin-0')).to.deep.eq([]);
+    expect(config.adapter.triggeredConditions('pin-5')).to.deep.eq(['shorthand']);
+    expect(config.adapter.triggeredConditions('pin-6')).to.deep.eq(['system']);
+    expect(config.adapter.triggeredConditions('var1')).to.deep.eq([]);
+    expect(config.adapter.triggeredConditions('var2')).to.deep.eq([]);
+  });
+
+  it('alt resolves triggered conditions', function () {
+    expect(config2.adapter.triggeredConditions('AIN0')).to.deep.eq([]);
+    expect(config2.adapter.triggeredConditions('FIO5')).to.deep.eq(['shorthand']);
+    expect(config2.adapter.triggeredConditions('FIO6')).to.deep.eq(['system']);
+    expect(config2.adapter.triggeredConditions('var1')).to.deep.eq([]);
+    expect(config2.adapter.triggeredConditions('var2')).to.deep.eq([]);
+  });
+
+  it('stringexpr by-expression tables filled out', function () {
+    expect(_.size(config3.adapter.conditionsByExpression)).to.eq(9);
+    /* eslint-disable no-template-curly-in-string */
+    expect(config3.adapter.conditionsByExpression['conditions.shorthand.A${alarm-code}.value.WARNING']).to.eq('shorthand');
+    expect(config3.adapter.conditionsByExpression['conditions.shorthand.A${alarm-code}.code']).to.eq('shorthand');
+    expect(config3.adapter.conditionsByExpression['conditions.shorthand.A${alarm-code}.message']).to.eq('shorthand');
+    expect(config3.adapter.conditionsByExpression['conditions.system.A1.value.FAULT']).to.eq('system');
+    expect(config3.adapter.conditionsByExpression['conditions.system.A1.code']).to.eq('system');
+    expect(config3.adapter.conditionsByExpression['conditions.system.A1.message']).to.eq('system');
+    expect(config3.adapter.conditionsByExpression['conditions.system.B${alarm-code}.value.FAULT']).to.eq('system');
+    expect(config3.adapter.conditionsByExpression['conditions.system.B${alarm-code}.code']).to.eq('system');
+    expect(config3.adapter.conditionsByExpression['conditions.system.B${alarm-code}.message']).to.eq('system');
+  });
+
+  it('stringexpr resolves triggered conditions', function () {
+    expect(config3.adapter.triggeredConditions('AIN0')).to.deep.eq([]);
+    expect(config3.adapter.triggeredConditions('FIO5')).to.deep.eq(['shorthand']);
+    expect(config3.adapter.triggeredConditions('FIO6')).to.deep.eq(['system']);
+    expect(config3.adapter.triggeredConditions('var1')).to.deep.eq([]);
+    expect(config3.adapter.triggeredConditions('var2')).to.deep.eq([]);
+    expect(config3.adapter.triggeredConditions('alarm-code')).to.deep.eq(['shorthand', 'system']);
+    expect(config3.adapter.triggeredConditions('alarm-message')).to.deep.eq(['shorthand', 'system']);
+  });
+});

package/test/config/brother-http.test.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Brother HTTP config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/brother-http-default.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.endpoint).to.eq('192.168.1.100');
+    expect(defaultConfig.device.host).to.eq('192.168.1.100');
+    expect(defaultConfig.device.port).to.eq(21);
+    expect(defaultConfig.device.scanInterval).to.eq(1000);
+    expect(defaultConfig.device.httpInterval).to.eq(50);
+  });
+});

package/test/config/ethernet-ip.test.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Ethernet/IP config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/ethernet-ip-default.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.host).to.eq('192.168.1.100');
+    expect(defaultConfig.device.slot).to.eq(0);
+    expect(defaultConfig.device.scanRate).to.eq(200);
+    expect(defaultConfig.device.groupRead).to.eq(true);
+    expect(defaultConfig.device.tags).to.deep.eq({});
+  });
+});

package/test/config/ifm-iot.test.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('IFM IoT config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/ifm-iot-default.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.endpoint).to.eq('http://192.168.1.100');
+    expect(defaultConfig.device.iolink).to.deep.eq([]);
+    expect(defaultConfig.device.findIODD).to.eq(true);
+    expect(defaultConfig.device.scanInterval).to.eq(1000);
+    expect(defaultConfig.device.deviceScanInterval).to.eq(10000);
+    expect(defaultConfig.device.declaredKeys).to.deep.eq([]);
+  });
+});

package/test/config/json-http.test.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('JSON-HTTP config tests', function () {
+  let config;
+  let defaultConfig;
+  before(async () => {
+    config = await testUtils.loadConfig('device/json-http-std.yml');
+    defaultConfig = await testUtils.loadConfig('device/json-http-default.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.scanInterval).to.eq(1000);
+    expect(defaultConfig.device.props).to.deep.eq({});
+    expect(defaultConfig.device.endpoint).to.eq('http://localhost:5000');
+    expect(defaultConfig.device.insecure).to.eq(undefined);
+  });
+
+  it('reads props', async function () {
+    expect(_.keys(config.device.props)).to.deep.eq(['file', 'part_number', 'process_status']);
+  });
+
+  it('catches bad prop definition (bad path syntax)', async function () {
+    try {
+      await testUtils.loadConfig('device/json-http-bad-prop.yml');
+      throw new Error('Malformed prop accepted');
+    } catch (err) {
+      expect(err.section).to.deep.eq(['props']);
+      expect(err.attribute).to.eq('process_status');
+      expect(err.message.indexOf('Malformed prop definition')).to.eq(0);
+    }
+  });
+
+  it('catches bad prop definition (missing path)', async function () {
+    try {
+      await testUtils.loadConfig('device/json-http-bad-prop2.yml');
+      throw new Error('Malformed prop accepted');
+    } catch (err) {
+      expect(err.section).to.deep.eq(['props']);
+      expect(err.attribute).to.eq('process_status');
+      expect(err.message.indexOf('Malformed prop definition')).to.eq(0);
+    }
+  });
+});

package/test/config/labjack-t4.test.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+const stdPins = [
+  'AIN0', 'AIN1', 'AIN2', 'AIN3', 'FIO4', 'FIO5', 'FIO6', 'FIO7',
+  'EIO0', 'EIO1', 'EIO2', 'EIO3', 'EIO4', 'EIO5', 'EIO6', 'EIO7',
+  'CIO0', 'CIO1', 'CIO2', 'CIO3',
+];
+const aliasPins = [
+  'pin-0', 'pin-1', 'pin-2', 'pin-3', 'pin-4', 'pin-5', 'pin-6', 'pin-7',
+  'pin-8', 'pin-9', 'pin-10', 'pin-11',
+];
+const configPins = [
+  'DAC0', 'DAC1',
+];
+
+describe('Labjack-T4 config tests', function () {
+  it('loads minimal config with defaults', async function () {
+    const config = await testUtils.loadConfig('device/labjack-t4-default.yml');
+
+    expect(config.device.host).to.eq('192.168.1.100');
+    expect(config.device.scanInterval).to.eq(0.002);
+    expect(_.size(config.device.pins)).to.eq(34);
+  });
+  it('defines pins object', async function () {
+    const config = await testUtils.loadConfig('device/labjack-t4-pins.yaml');
+
+    expect(_.keys(config.device.pins).sort()).to.deep.eq([...stdPins, ...configPins, ...aliasPins].sort());
+  });
+
+  it('loaded expression service', async function () {
+    const config = await testUtils.loadConfig('device/labjack-t4-pins.yaml');
+
+    const vars = ['var1', 'var2', 'var3', 'var4'];
+    const sys = ['device-connected'];
+
+    expect(config.expressionService.definedNames().sort()).to.deep.eq([
+      ...stdPins, ...sys, ...aliasPins, ...vars
+    ].sort());
+    expect(config.expressionService.definedNames('device').sort()).to.deep.eq([...stdPins, ...aliasPins].sort());
+    expect(config.expressionService.definedNames('engine').sort()).to.deep.eq([...vars].sort());
+
+    expect(config.expressionService.referencedNames().sort()).to.deep.eq([
+      'pin-0', 'pin-1', 'pin-2', 'pin-3', 'pin-4', 'pin-5', 'pin-6', 'var2',
+    ]);
+    expect(config.expressionService.referencedNames('device').sort()).to.deep.eq([
+      'pin-0', 'pin-1', 'pin-2', 'pin-3', 'pin-4', 'pin-5', 'pin-6',
+    ]);
+    expect(config.expressionService.referencedNames('engine').sort()).to.deep.eq(['var2']);
+  });
+
+  it('loads in V1 config', async function () {
+    const config = await testUtils.loadConfig('device/labjack-t4-v1.yaml');
+
+    expect(_.keys(config.device.pins).sort()).to.deep.eq([...stdPins, ...configPins, ...aliasPins].sort());
+    expect(config.device.pins['pin-0']).to.deep.eq({ name: 'pin-0', mode: 'analog', direction: 'input' });
+    expect(config.device.pins['pin-1']).to.deep.eq({ name: 'pin-1', mode: 'analog', direction: 'input' });
+    expect(config.device.pins['pin-4']).to.deep.eq({ name: 'pin-4', mode: 'digital', direction: 'input', value: undefined });
+    expect(config.device.pins['pin-5']).to.deep.eq({ name: 'pin-5', mode: 'analog', direction: 'input' });
+
+    const vars = ['var1', 'var2', 'var3', 'var4'];
+
+    expect(config.expressionService.definedNames().sort()).to.deep.eq([...stdPins, ...aliasPins, ...vars].sort());
+    expect(config.expressionService.definedNames('device').sort()).to.deep.eq([...stdPins, ...aliasPins].sort());
+    expect(config.expressionService.definedNames('engine').sort()).to.deep.eq([...vars].sort());
+
+    expect(config.expressionService.referencedNames().sort()).to.deep.eq([
+      'pin-0', 'pin-1', 'pin-2', 'pin-5', 'var1', 'var2', 'var4',
+    ]);
+    expect(config.expressionService.referencedNames('device').sort()).to.deep.eq([
+      'pin-0', 'pin-1', 'pin-2', 'pin-5',
+    ]);
+    expect(config.expressionService.referencedNames('engine').sort()).to.deep.eq(['var1', 'var2', 'var4']);
+  });
+});

package/test/config/labjack-t7.test.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Labjack-T7 config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/labjack-t7-default.yml');
+  });
+
+  it('loads minimal config with defaults', async function () {
+    expect(defaultConfig.device.host).to.eq('192.168.1.100');
+    expect(defaultConfig.device.scanInterval).to.eq(0.002);
+    expect(_.size(defaultConfig.device.pins)).to.eq(39);
+  });
+});

package/test/config/labjack-u3.test.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Labjack-U3 config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/labjack-u3-default.yml');
+  });
+
+  it('loads minimal config with defaults', async function () {
+    expect(defaultConfig.device.scanInterval).to.eq(0.002);
+    expect(_.size(defaultConfig.device.pins)).to.eq(34);
+  });
+});

package/test/config/modbusTcp.test.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Modbus-TCP config tests', function () {
+  let config;
+  let configExt;
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/modbus-tcp-default.yml');
+    config = await testUtils.loadConfig('device/modbus-std.yaml');
+    configExt = await testUtils.loadConfig('device/modbus-std-extended.yaml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.port).to.eq(502);
+    expect(defaultConfig.device.unitId).to.eq(0);
+    expect(defaultConfig.device.byteOrder).to.eq('big');
+    expect(defaultConfig.device.wordOrder).to.eq('big');
+    expect(defaultConfig.device.addressSpace).to.eq('mixed');
+    expect(defaultConfig.device.stringEncoding).to.eq('ascii');
+    expect(defaultConfig.device.scanInterval).to.eq(1000);
+    expect(defaultConfig.device.coils).to.deep.eq({});
+    expect(defaultConfig.device.registers).to.deep.eq({});
+  });
+
+  it('reads coils', async function () {
+    expect(_.keys(config.device.coils)).to.deep.eq(['button', 'switch', 'flipper']);
+    expect(config.device.coils.button.func).to.eq(2);
+    expect(config.device.coils.button.address).to.eq(1); // 10002 (- 10001)
+    expect(config.device.coils.switch.func).to.eq(2);
+    expect(config.device.coils.switch.address).to.eq(2); // 10003 (- 10001)
+    expect(config.device.coils.flipper.func).to.eq(1);
+    expect(config.device.coils.flipper.address).to.eq(4); // 5 (- 00001)
+  });
+
+  it('reads coils extended', async function () {
+    expect(_.keys(configExt.device.coils)).to.deep.eq(['button', 'switch', 'flipper', 'gizmo']);
+    expect(configExt.device.coils.button.func).to.eq(2);
+    expect(configExt.device.coils.button.address).to.eq(1); // 100002 (- 100001)
+    expect(configExt.device.coils.switch.func).to.eq(2);
+    expect(configExt.device.coils.switch.address).to.eq(2); // 100003 (- 100001)
+    expect(configExt.device.coils.flipper.func).to.eq(1);
+    expect(configExt.device.coils.flipper.address).to.eq(4); // 5 (- 000001)
+    expect(configExt.device.coils.gizmo.func).to.eq(1);
+    expect(configExt.device.coils.gizmo.address).to.eq(6); // 000007 (- 000001)
+  });
+
+  it('reads registers', async function () {
+    expect(_.keys(config.device.registers)).to.deep.eq(['temp', 'hitemp', 'program']);
+    expect(config.device.registers.temp.func).to.eq(3);
+    expect(config.device.registers.temp.address).to.eq(4); // 40005 (- 40001)
+    expect(config.device.registers.temp.type).to.eq('float32');
+    expect(config.device.registers.hitemp.func).to.eq(3);
+    expect(config.device.registers.hitemp.address).to.eq(6); // 40007 (- 40001)
+    expect(config.device.registers.hitemp.type).to.eq('uint32');
+    expect(config.device.registers.program.func).to.eq(4);
+    expect(config.device.registers.program.address).to.eq(2); // 30003 (- 30001)
+    expect(config.device.registers.program.type).to.eq('string');
+    expect(config.device.registers.program.size).to.eq(10); // 20 -> 10
+  });
+
+  it('reads registers extended', async function () {
+    expect(_.keys(configExt.device.registers)).to.deep.eq(['temp', 'hitemp', 'program']);
+    expect(configExt.device.registers.temp.func).to.eq(3);
+    expect(configExt.device.registers.temp.address).to.eq(4); // 400005 (- 400001)
+    expect(configExt.device.registers.temp.type).to.eq('float32');
+    expect(configExt.device.registers.hitemp.func).to.eq(3);
+    expect(configExt.device.registers.hitemp.address).to.eq(6); // 400007 (- 400001)
+    expect(configExt.device.registers.hitemp.type).to.eq('uint32');
+    expect(configExt.device.registers.program.func).to.eq(4);
+    expect(configExt.device.registers.program.address).to.eq(2); // 300003 (- 300001)
+    expect(configExt.device.registers.program.type).to.eq('string');
+    expect(configExt.device.registers.program.size).to.eq(10); // 20 -> 10
+  });
+
+  it('loaded expression service', async function () {
+    const names = ['button', 'switch', 'flipper', 'temp', 'hitemp', 'program'];
+    expect(config.expressionService.definedNames()).to.deep.eq(names);
+    expect(config.expressionService.definedNames('device')).to.deep.eq(names);
+
+    expect(config.expressionService.referencedNames()).to.deep.eq(['switch', 'program', 'hitemp']);
+    expect(config.expressionService.referencedNames('device')).to.deep.eq(['switch', 'program', 'hitemp']);
+  });
+});

package/test/config/mqtt.test.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('MQTT config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/mqtt-default.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.endpoint).to.eq('mqtt://localhost');
+    expect(defaultConfig.device.telemetryRate).to.eq(1);
+    expect(defaultConfig.device.username).to.eq(null);
+    expect(defaultConfig.device.password).to.eq(null);
+    expect(defaultConfig.device.topics).to.deep.eq({});
+  });
+});

package/test/config/mqttLincoln.test.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('MQTT (Lincoln Electric) config tests', function () {
+  let config;
+  let config2;
+  before(async () => {
+    config = await testUtils.loadConfig('device/mqtt-lincoln-default.yml');
+    config2 = await testUtils.loadConfig('device/mqtt-lincoln-full.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(config.device.serial).to.eq(null);
+    expect(config.device.telemetryRate).to.eq(1);
+    expect(config.device.username).to.eq(null);
+    expect(config.device.password).to.eq(null);
+    expect(config.device.endpoint).to.eq('mqtt://localhost');
+  });
+
+  it('reads full config', async function () {
+    expect(config2.device.serial).to.eq('6413920132840067');
+    expect(config2.device.telemetryRate).to.eq(0.1);
+    expect(config2.device.endpoint).to.eq('mqtt://localhost');
+    expect(config2.device.username).to.eq('lincoln_internal');
+    expect(config2.device.password).to.eq('abc123');
+  });
+});

package/test/config/mtconnect.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('MTConnect Agent config tests', function () {
+  let config;
+  let complexConfig;
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/mtconnect-default.yml');
+    config = await testUtils.loadConfig('device/mtconnect-std.yaml');
+    complexConfig = await testUtils.loadConfig('device/mtconnect-complex-keys.yaml');
+  });
+
+  it('loads minimal config with defaults', async function () {
+    expect(defaultConfig.device.endpoint).to.eq('http://localhost:5000/');
+    expect(defaultConfig.device.verboseScanning).to.eq(false);
+    expect(defaultConfig.device.haasMode).to.eq(false);
+    expect(defaultConfig.device.mtconnectPassthrough).to.eq(true);
+    expect(defaultConfig.device.allowKeyPatterns).to.deep.eq([]);
+    expect(defaultConfig.device.denyKeyPatterns).to.deep.eq([]);
+    expect(defaultConfig.device.keys).to.deep.eq([]);
+    expect(defaultConfig.device.sourceKeys).to.deep.eq([]);
+  });
+
+  it('reads declare-keys', async function () {
+    expect(_.keys(config.device.keys)).to.deep.eq(['key1', 'key12']);
+  });
+
+  it('loaded expression service', async function () {
+    expect(config.expressionService.definedNames()).to.deep.eq(['key1', 'key12', 'device-connected']);
+    expect(config.expressionService.definedNames('device')).to.deep.eq(['key1', 'key12']);
+
+    expect(complexConfig.expressionService.definedNames()).to.deep.eq(['key1', 'alias2', 'alias3', 'alias4', 'alias5', 'key6', 'aliasdup', 'device-connected']);
+  });
+
+  it('calculates source keys', async function () {
+    expect(_.keys(complexConfig.device.keys)).to.deep.eq(['key1', 'alias2', 'alias3', 'alias4', 'alias5', 'key6', 'aliasdup']);
+    expect(complexConfig.device.sourceKeys).to.deep.eq(['key1', 'key2', 'key3', 'key4', 'key5', 'key6']);
+  });
+
+  it('creates aliases', async function () {
+    expect(_.keys(complexConfig.device.aliasMap)).to.deep.eq(['key1', 'key2', 'key3', 'key4', 'key5', 'key6']);
+
+    expect(complexConfig.device.aliasMap.key1).to.deep.eq([]);
+    expect(complexConfig.device.aliasMap.key2).to.deep.eq(['alias2']);
+    expect(complexConfig.device.aliasMap.key3).to.deep.eq(['alias3', 'aliasdup']);
+    expect(complexConfig.device.aliasMap.key4).to.deep.eq(['alias4']);
+    expect(complexConfig.device.aliasMap.key5).to.deep.eq(['alias5']);
+    expect(complexConfig.device.aliasMap.key6).to.deep.eq([]);
+  });
+
+  it('sets key types', async function () {
+    expect(complexConfig.device.keys.key1.type).to.eq('value');
+    expect(complexConfig.device.keys.alias2.type).to.eq('value');
+    expect(complexConfig.device.keys.alias3.type).to.eq('value');
+    expect(complexConfig.device.keys.alias4.type).to.eq('value');
+    expect(complexConfig.device.keys.alias5.type).to.eq('condition');
+    expect(complexConfig.device.keys.key6.type).to.eq('condition');
+  });
+});