@apidaze/node-red-contrib-apidaze/test/macros.js

Node-RED module for Apidaze

const { prepareFlow } = require('./helpers');

function loadTest(t, nodeType, node, helper) {
  const sampleNode = {
    id: 'n1',
    type: nodeType,
    name: `Sample ${nodeType}`,
  };

  const nodes = [node];
  const flow = prepareFlow([sampleNode]);

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

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

      t.end();
    })
    .catch(console.error);
}

function validTypeTest(t, nodeType, node, helper, hookType) {
  t.plan(1);

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

  const sampleNode = {
    id: 'n1',
    type: nodeType,
    name: `Sample ${nodeType} processor`,
    wires: [[sampleHelperNode.id]],
  };

  const flow = prepareFlow([sampleNode, sampleHelperNode]);

  helper
    .load(node, flow, () => {
      const loadedNode = helper.getNode(sampleNode.id);
      const loadedHelperNode = helper.getNode(sampleHelperNode.id);
      const msgData = { payload: { hookType } };

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

        t.end();
      });

      loadedNode.receive(msgData);
    })
    .catch(console.error);
}

function invalidTypeTest(t, nodeType, node, helper) {
  t.plan(1);

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

  const sampleNode = {
    id: 'n1',
    type: nodeType,
    name: `Sample ${nodeType} processor`,
    wires: [[sampleHelperNode.id]],
  };

  const flow = prepareFlow([sampleNode, sampleHelperNode]);

  helper
    .load(node, flow, () => {
      const loadedNode = helper.getNode(sampleNode.id);
      const loadedHelperNode = helper.getNode(sampleHelperNode.id);
      const msgData = { payload: { hookType: 'anInvalidType' } };

      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);
    })
    .catch(console.error);
}

module.exports = function createNodeMacros(nodeType, node, helper) {
  return {
    loadTest: (t) => loadTest(t, nodeType, node, helper),
    validTypeTest: (t, hookType) =>
      validTypeTest(t, nodeType, node, helper, hookType),
    invalidTypeTest: (t) => invalidTypeTest(t, nodeType, node, helper),
  };
};