both.io/src/execute/execute.unit.js

let both    = require('../both');
let sinonChai = require('sinon-chai');
let sinon = require('sinon');
let chai    = require('chai');
chai.use(sinonChai);
let expect  = chai.expect;

/* JSHint-Rule: ignore W030 Lint-Errors */
/* jshint -W030 */

describe('Execute Module', () => {

  describe('Error handling', () => {

    let dummyCommandFunc = null;

    beforeEach(() => {
      dummyCommandFunc = sinon.spy();
    });

    it('throws error if no argument is given', () => {
      expect(() => {
        both();
      }).to.throw(Error);
    });

    it('throws error if more than 1 argument is given', () => {
      expect(() => {
        both('eins', 'zwei', 'drei');
      }).to.throw(Error);
    });

    it('throws error if argument isn`t a string', () => {
      expect(() => {
        both(12345);
      }).to.throw(Error);
    });

    it('throws error if second argument isn`t a object or function', () => {
      expect(() => {
        both('dummyCommand', 'noObjectOrFunction');
      }).to.throw(Error);
    });

    it('throws no error if second argument is a object or function', () => {
      expect(() => {
        both('dummyCommand', {});
      }).to.not.throw(Error);
    });

    it('throw error if third argument isnt a function', () => {
      expect(() => {
        both('dummyCommand', {}, 'notAllowed');
      }).to.throw(Error);
    });

    it('throw nor error if third argument isnt a function', () => {
      expect(() => {
        both('dummyCommand', {}, () => {});
      }).to.not.throw(Error);
    });
  });

  describe('executing commands / queries / listeners', () => {

    let dummyCommandFunc = null;
    let dummyListenerFunc = null;

    beforeEach(() => {
      dummyCommandFunc = sinon.spy();
      dummyListenerFunc = sinon.spy();
    });

    it('registered command without defined listener', () => {
      both.command('dummyCommand', dummyCommandFunc);

      both('dummyCommand');

      expect(dummyCommandFunc).to.have.been.called;
    });

    it('registered listener', () => {
      both.command('dummyCommand', dummyCommandFunc);
      both.on('dummyCommand', dummyListenerFunc);

      both('dummyCommand');

      expect(dummyListenerFunc).to.have.been.calledOnce;
    });

    it('global listener', () => {
      both.command('dummyCommand', dummyCommandFunc);
      both.on(dummyListenerFunc);

      both('dummyCommand');

      expect(dummyListenerFunc).to.have.been.called;
    });

    it('ship payload to global listener with commandName', () => {
      both.command('dummyCommand', dummyCommandFunc);

      both.on(dummyListenerFunc);

      both('dummyCommand');

      expect(dummyListenerFunc).to.have.been.calledWith('dummyCommand');
    });

    it('ship payload to listener with methodName and payload from executed command', () => {
      both.command('dummyCommand', dummyListenerFunc);

      both.on(dummyListenerFunc);

      both('dummyCommand', {
        dummyAttribute: true
      });

      expect(dummyListenerFunc).to.have.been.calledWith('dummyCommand', {
        dummyAttribute: true
      });
    });

    it('executes a query and runs the expected callback', () => {
      let dummyCallback = sinon.spy();

      both.query('dummyQuery', dummyCallback);

      both('dummyQuery');

      expect(dummyCallback).to.have.been.called;
    });
  });

  describe('Shipps callback', () => {
    it('should executes the callback in commands', () => {
      let dummyCallback = sinon.spy();

      both.command('dummyCommand', (name, payload, callback) => {
        callback();
      });

      both('dummyCommand', {}, (dummyArgument) => {
        dummyCallback();
      });

      expect(dummyCallback).to.have.been.called;
    });

    it('should executes the callback in queries', () => {
      let dummyCallback = sinon.spy();

      both.query('dummyCommand', (name, payload, callback) => {
        callback();
      });

      both('dummyCommand', {}, () => {
        dummyCallback();
      });

      expect(dummyCallback).to.have.been.called;
    });
  });
});