redux-ab-test/dist/utils/generate-win-actions.jest.js

A/B testing React components with Redux and debug tools. Isomorphic with a simple, universal interface. Well documented and lightweight. Tested in popular browsers and Node.js. Includes helpers for React, Redux, and Segment.io

'use strict';

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _immutable = require('immutable');

var _immutable2 = _interopRequireDefault(_immutable);

var _sinon = require('sinon');

var _generateWinActions = require('./generate-win-actions');

var _generateWinActions2 = _interopRequireDefault(_generateWinActions);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

describe('utils/generate-win-actions.js', function () {
  var initialState = _immutable2['default'].fromJS({
    experiments: [],
    plays: {},
    active: {},
    winners: {},
    win_action_types: {}
  });

  var experiment = {
    name: 'Test-Name',
    variations: [{ name: 'Original', weight: 5000 }, { name: 'Variation #A', weight: 5000 }, { name: 'Variation #B', weight: 0 }],
    win_action_types: ['Test-action-1', 'Test-action-2']
  };

  var next = void 0;
  var win = void 0;
  beforeEach(function () {
    next = (0, _sinon.spy)();
    win = function () {
      function win(_ref) {
        var experiment = _ref.experiment,
            variation = _ref.variation,
            actionType = _ref.actionType;
        return _immutable2['default'].fromJS({ experiment: experiment, variation: variation, actionType: actionType });
      }

      return win;
    }();
  });

  it('exists', function () {
    expect(_generateWinActions2['default']).not.toBeUndefined;
    expect(typeof _generateWinActions2['default'] === 'undefined' ? 'undefined' : (0, _typeof3['default'])(_generateWinActions2['default'])).toEqual('function');
  });

  it('has empty output', function () {
    var output = (0, _generateWinActions2['default'])({
      reduxAbTest: initialState,
      win: win,
      actionType: null,
      next: next
    });
    expect(output).not.toBeUndefined;
    expect(_immutable2['default'].List.isList(output)).toBeTruthy;
    expect(output.toJS()).toEqual([]);
  });

  it('has one action', function () {
    var output = (0, _generateWinActions2['default'])({
      reduxAbTest: initialState.merge({
        experiments: [experiment],
        win_action_types: {
          'Test-action-1': [experiment.name]
        },
        active: {
          'Test-Name': 'Original'
        }
      }),
      win: win,
      actionType: 'Test-action-1',
      next: next
    });
    expect(output).not.toBeUndefined;
    expect(_immutable2['default'].List.isList(output)).toBeTruthy;
    expect(output.toJS()).toEqual([{
      experiment: experiment,
      variation: { name: 'Original', weight: 5000 },
      actionType: 'Test-action-1'
    }]);
  });

  it('has 1x actions, selects the active experiment', function () {
    var output = (0, _generateWinActions2['default'])({
      reduxAbTest: initialState.merge({
        experiments: [experiment, (0, _extends3['default'])({}, experiment, { name: 'Test-experiment-2' })],
        win_action_types: {
          'Test-action-1': [experiment.name]
        },
        active: {
          'Test-Name': 'Original'
        }
      }),
      win: win,
      actionType: 'Test-action-1',
      next: next
    });
    expect(output).not.toBeUndefined;
    expect(_immutable2['default'].List.isList(output)).toBeTruthy;
    expect(output.toJS()).toEqual([{
      experiment: experiment,
      variation: { name: 'Original', weight: 5000 },
      actionType: 'Test-action-1'
    }]);
  });

  it('has two actions', function () {
    var output = (0, _generateWinActions2['default'])({
      reduxAbTest: initialState.merge({
        experiments: [experiment, (0, _extends3['default'])({}, experiment, { name: 'Test-experiment-2' })],
        win_action_types: {
          'Test-action-1': [experiment.name, 'Test-experiment-2']
        },
        active: {
          'Test-Name': 'Original',
          'Test-experiment-2': 'Variation #A'
        }
      }),
      win: win,
      actionType: 'Test-action-1',
      next: next
    });
    expect(output).not.toBeUndefined;
    expect(_immutable2['default'].List.isList(output)).toBeTruthy;
    expect(output.toJS()).toEqual([{
      experiment: experiment,
      variation: { name: 'Original', weight: 5000 },
      actionType: 'Test-action-1'
    }, {
      experiment: (0, _extends3['default'])({}, experiment, { name: 'Test-experiment-2' }),
      variation: { name: 'Variation #A', weight: 5000 },
      actionType: 'Test-action-1'
    }]);
  });

  it('throws an Error', function () {
    var output = function () {
      function output() {
        (0, _generateWinActions2['default'])({
          reduxAbTest: initialState.merge({
            experiments: [],
            win_action_types: {
              'Test-action-1': [experiment.name]
            },
            active: {
              'Test-Name': 'Original'
            }
          }),
          win: win,
          actionType: 'Test-action-1',
          next: next
        });
      }

      return output;
    }();
    expect(output).toThrow(Error);
  });
});