@apidaze/node-red-contrib-apidaze/test/nodes/rtc-processor.js

Node-RED module for Apidaze

const test = require('ava');
const helper = require('node-red-node-test-helper');
const sinon = require('sinon');
const nosql = require('nosql');
const { prepareFlow } = require('../helpers');

sinon.stub(nosql, 'load').returns([]);

const rtcProcessorNode = require('../../nodes/rtc-processor/rtc-processor');
const callStore = require('../../helpers/call-store');

helper.init(require.resolve('node-red'));

test.serial.before.cb((t) => {
  helper.startServer(t.end);
});

test.serial.afterEach(async () => {
  await helper.unload();
});

test.serial.after.cb((t) => {
  helper.stopServer(t.end);
});

test.serial.cb('should be loaded properly', (t) => {
  const sampleRTCProcessorNode = {
    id: 'n1',
    type: 'rtc-processor',
    name: 'Sample call processor',
  };

  const nodes = [rtcProcessorNode];
  const flow = [sampleRTCProcessorNode];

  prepareFlow(flow);

  helper.load(nodes, flow, () => {
    const loadedNode = helper.getNode(sampleRTCProcessorNode.id);

    t.is(loadedNode.name, loadedNode.name);

    t.end();
  });
});

test.serial.cb('should let flow proceed for RTC payloads', (t) => {
  t.plan(1);

  const sampleHelperNode = {
    id: 'n2',
    type: 'helper',
  };

  const sampleRTCProcessorNode = {
    id: 'n1',
    type: 'rtc-processor',
    name: 'Sample RTC processor',
    wires: [[sampleHelperNode.id]],
  };

  const flow = [sampleRTCProcessorNode, sampleHelperNode];

  prepareFlow(flow);

  helper.load(rtcProcessorNode, flow, () => {
    const loadedNode = helper.getNode(sampleRTCProcessorNode.id);
    const loadedHelperNode = helper.getNode(sampleHelperNode.id);
    const callUUID = 'fake-uuid';
    const callPayloadFixture = { uuid: callUUID };
    const payloadFixture = { hookType: 'rtcCall', query: callPayloadFixture };
    const msgData = { payload: payloadFixture };

    sinon.stub(callStore, 'fetch').withArgs(callUUID).returns([]);

    sinon.stub(callStore, 'add').returns(callPayloadFixture);

    loadedHelperNode.on('input', (msg) => {
      t.deepEqual(msg, msgData);

      t.end();
    });

    loadedNode.receive(msgData);
  });
});

test.serial.cb('should not let flow proceed for non-RTC payloads', (t) => {
  t.timeout(2000);
  t.plan(1);

  const sampleHelperNode = {
    id: 'n2',
    type: 'helper',
  };

  const sampleRTCProcessorNode = {
    id: 'n1',
    type: 'rtc-processor',
    name: 'Sample RTC processor',
    wires: [[sampleHelperNode.id]],
  };

  const flow = [sampleRTCProcessorNode, sampleHelperNode];

  prepareFlow(flow);

  helper.load(rtcProcessorNode, flow, () => {
    const loadedNode = helper.getNode(sampleRTCProcessorNode.id);
    const loadedHelperNode = helper.getNode(sampleHelperNode.id);
    const msgData = { payload: { hookType: 'nonRTCType' } };

    setTimeout(() => {
      const filterFailMessage = ([{ type, msg }]) =>
        type === 'helper' && msg === 'fail';
      const logEvents = helper.log().args.filter(filterFailMessage);
      t.is(logEvents.length, 0);

      t.end();
    }, 100);

    loadedHelperNode.on('input', (msg, send) => {
      loadedHelperNode.debug('fail');
      t.fail('The flow should not have continued, but continued.');
    });

    loadedNode.receive(msgData);
  });
});