@coorpacademy/progression-engine/lib/compute-next-step/test/compute-initial-step.js

"use strict";

var _filter2 = _interopRequireDefault(require("lodash/fp/filter"));
var _omit2 = _interopRequireDefault(require("lodash/fp/omit"));
var _ava = _interopRequireDefault(require("ava"));
var _config = require("../../config");
var _ = require("..");
var _slides = _interopRequireDefault(require("./fixtures/slides"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const config = (0, _config.getConfig)({
  ref: 'learner',
  version: '1'
});
const availableContent = [{
  ref: '1.A1',
  slides: (0, _filter2.default)({
    chapter_id: '1.A1'
  }, _slides.default),
  rules: null
}, {
  ref: '2.A1',
  slides: (0, _filter2.default)({
    chapter_id: '2.A1'
  }, _slides.default),
  rules: []
}];
(0, _ava.default)('should return successExitNode if availableContent is empty', t => {
  t.deepEqual((0, _.computeInitialStep)(config, []), {
    type: 'move',
    payload: {
      nextContent: {
        type: 'success',
        ref: 'successExitNode'
      },
      instructions: null
    }
  });
});
(0, _ava.default)('should return a success exitNode if there are no slides in all chapters', t => {
  const action = (0, _.computeInitialStep)(config, [{
    ref: '1.A1',
    slides: [],
    rules: null
  }]);
  if (!action) {
    throw new Error('action should not be falsy');
  }
  t.deepEqual(action, {
    type: 'move',
    payload: {
      instructions: null,
      nextContent: {
        type: 'success',
        ref: 'successExitNode'
      }
    }
  });
});
(0, _ava.default)('should return a slide in next chapter if there are no slides for the first chapter', t => {
  const action = (0, _.computeInitialStep)(config, [{
    ref: '1.A1',
    slides: [],
    rules: null
  }, {
    ref: '1.1.A1',
    slides: [],
    rules: null
  }, {
    ref: '2.A1',
    slides: (0, _filter2.default)({
      chapter_id: '2.A1'
    }, _slides.default),
    rules: null
  }]);
  if (!action) {
    throw new Error('action should not be falsy');
  }
  t.deepEqual((0, _omit2.default)(['payload.nextContent.ref'], action), {
    type: 'move',
    payload: {
      instructions: null,
      nextContent: {
        type: 'slide'
      }
    }
  });
  t.regex(action.payload.nextContent.ref, /^2\.A1\.[1-9]+$/);
});
(0, _ava.default)('should create an initial action from the slides', t => {
  const action = (0, _.computeInitialStep)(config, availableContent);
  if (!action) {
    throw new Error('action should not be falsy');
  }
  t.deepEqual((0, _omit2.default)(['payload.nextContent.ref'], action), {
    type: 'move',
    payload: {
      instructions: null,
      nextContent: {
        type: 'slide'
      }
    }
  });
  t.regex(action.payload.nextContent.ref, /^1\.A1\.[1-9]+$/);
});
(0, _ava.default)('should create an adaptive initial Action', t => {
  const initialRule = {
    source: {
      type: 'slide',
      ref: ''
    },
    destination: {
      type: 'slide',
      ref: '1.A1.1'
    },
    instructions: [{
      field: 'foo',
      type: 'set',
      value: 0
    }],
    conditions: [],
    priority: 10
  };
  const randomRule = {
    source: {
      type: 'slide',
      ref: '1.A1.1'
    },
    destination: {
      type: 'slide',
      ref: '1.A1.2'
    },
    instructions: [],
    conditions: [],
    priority: 10
  };
  const content = [{
    ref: 'chapter1',
    slides: _slides.default,
    rules: [initialRule, randomRule]
  }];
  const action = (0, _.computeInitialStep)(config, content);
  t.deepEqual(action, {
    type: 'move',
    payload: {
      instructions: [{
        field: 'foo',
        type: 'set',
        value: 0
      }],
      nextContent: {
        type: 'slide',
        ref: '1.A1.1'
      }
    }
  });
});
//# sourceMappingURL=compute-initial-step.js.map