redux-observable-sans/lib/esm/__tests__/socket-spec.js

Use redux without any boilerplate

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

import { ActionsObservable, combineEpics } from 'redux-observable';
import { Subject } from 'rxjs';

import { socketEpics, commandAction, queryAction, toAction } from '../index';

describe('socketEpic', function () {
  var me = { token: 'key', name: 'AB Normal', userId: '3f43f' };
  var state$ = { value: { me: me } };
  var subject = void 0;
  var action$ = void 0;
  var emittedActions = void 0;
  var socketEvents = void 0;
  var socket = {
    emit: function emit(type, msg) {
      return socketEvents.push([type, msg]);
    }
  };
  var pushAction = function pushAction(emittedAction) {
    return emittedActions.push(emittedAction);
  };

  var cA = commandAction(function (i) {
    return i;
  })('doSomething')({ data: 'whatevs' });

  var qA = queryAction(function (i) {
    return i;
  })('getSomething')({ payload: 'whatevs' });

  beforeEach(function () {
    subject = new Subject();
    action$ = new ActionsObservable(subject);
    emittedActions = [];
    socketEvents = [];
  });

  it('should return action and emit command event', function () {
    var result$ = combineEpics.apply(undefined, _toConsumableArray(socketEpics(socket)))(action$, state$);
    result$.subscribe(pushAction, console.error, console.error);

    subject.next(cA);
    subject.next(qA);

    expect(emittedActions).toEqual([_extends({}, cA.payload, { type: 'DO_SOMETHING' }), _extends({}, qA.payload, { type: 'GET_SOMETHING' })]);

    expect(socketEvents).toEqual([['command', _extends({}, cA.payload, { type: 'doSomething' })], ['query', _extends({}, qA.payload, { type: 'getSomething' })]]);
  });

  it('should add token only to socket msg', function () {
    var auth = function auth(state$) {
      return { token: state$.value.me.token, userId: state$.value.me.userId };
    };

    var result$ = combineEpics.apply(undefined, _toConsumableArray(socketEpics(socket, auth)))(action$, state$);
    result$.subscribe(pushAction, console.error, console.error);

    subject.next(cA);
    subject.next(qA);

    expect(emittedActions).toEqual([_extends({}, cA.payload, { type: 'DO_SOMETHING' }), _extends({}, qA.payload, { type: 'GET_SOMETHING' })]);

    expect(socketEvents).toEqual([['command', _extends({}, cA.payload, { type: 'doSomething', token: me.token, userId: me.userId })], ['query', _extends({}, qA.payload, { type: 'getSomething', token: me.token, userId: me.userId })]]);
  });
});

describe('toAction', function () {
  it('should dispatch constant-case', function () {
    var dispatch = function dispatch(action) {
      expect(action).toEqual({
        type: 'DID_SOMETHING',
        data: { what: 'evs' }
      });
    };

    toAction(dispatch)({ type: 'DidSomething', data: { what: 'evs' } });
  });

  it('should dispatch _FAILURE', function () {
    var expectedActions = [{ type: 'COMMAND_REJECTED', payload: { type: 'DidSomething', data: { what: 'evs' } } }, { type: 'DID_SOMETHING_FAILURE', data: { what: 'evs' } }];
    var count = 0;

    var dispatch = function dispatch(action) {
      expect(action).toEqual(expectedActions[count]);
      count++;
    };

    toAction(dispatch)({
      type: 'CommandRejected',
      payload: { type: 'DidSomething', data: { what: 'evs' } }
    });

    expect(count).toEqual(expectedActions.length);
  });
});