@coorpacademy/progression-engine/lib/create-progression/test/index.js

"use strict";

var _keys2 = _interopRequireDefault(require("lodash/fp/keys"));
var _ava = _interopRequireDefault(require("ava"));
var _slides = _interopRequireDefault(require("../../compute-next-step/test/fixtures/slides"));
var _ = _interopRequireDefault(require(".."));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const initialRule = {
  source: {
    type: 'slide',
    ref: ''
  },
  destination: {
    type: 'slide',
    ref: '1.A1.1'
  },
  instructions: [{
    field: 'foo',
    type: 'set',
    value: 0
  }],
  conditions: [],
  priority: 10
};
const availableContentWithRules = [{
  ref: '1.A1',
  slides: _slides.default,
  rules: [initialRule, {
    source: {
      type: 'slide',
      ref: '1.A1.1'
    },
    destination: {
      type: 'slide',
      ref: '1.A1.2'
    },
    instructions: [],
    conditions: [],
    priority: 10
  }]
}];
(0, _ava.default)('should create a new progression with the latest version of the engine and the given engine options', t => {
  const engine = {
    ref: 'learner',
    version: 'latest'
  };
  const content = {
    ref: '1.A1',
    type: 'level'
  };
  const engineOptions = {
    version: '2',
    livesDisabled: true
  };
  const progression = (0, _.default)(engine, content, engineOptions, availableContentWithRules);
  if (!progression) {
    throw new Error('progression should not be falsy');
  }
  t.deepEqual((0, _keys2.default)(progression).sort(), ['actions', 'content', 'engine', 'engineOptions'].sort());
  t.deepEqual(progression.engine, {
    ref: 'learner',
    version: '2'
  });
  t.is(progression.content, content);
  t.is(progression.engineOptions, engineOptions);
  t.true(Array.isArray(progression.actions));
});
(0, _ava.default)('should create a new progression for external engine', t => {
  const engine = {
    ref: 'external',
    version: 'latest'
  };
  const content = {
    ref: 'ext_1',
    type: 'scorm'
  };
  const engineOptions = {
    version: '1'
  };
  const progression = (0, _.default)(engine, content, engineOptions, availableContentWithRules);
  if (!progression) {
    throw new Error('progression should not be falsy');
  }
  t.deepEqual(progression, {
    engine: {
      ref: 'external',
      version: '1'
    },
    content: {
      ref: 'ext_1',
      type: 'scorm'
    },
    engineOptions: {
      version: '1'
    },
    actions: []
  });
});
(0, _ava.default)('should create a new progression for review engine', t => {
  const engine = {
    ref: 'review',
    version: 'latest'
  };
  const content = {
    ref: 'skill_41BBqFKoS',
    type: 'skill'
  };
  const engineOptions = {
    version: '1'
  };
  const progression = (0, _.default)(engine, content, engineOptions, availableContentWithRules);
  if (!progression) {
    throw new Error('progression should not be falsy');
  }
  t.deepEqual(progression, {
    engine: {
      ref: 'review',
      version: '1'
    },
    content: {
      ref: 'skill_41BBqFKoS',
      type: 'skill'
    },
    engineOptions: {
      version: '1'
    },
    actions: [{
      type: 'move',
      payload: {
        nextContent: {
          type: 'slide',
          ref: '1.A1.1'
        },
        instructions: null
      }
    }]
  });
});
(0, _ava.default)('should create a new progression with a custom version of the engine', t => {
  const engine = {
    ref: 'learner',
    version: '1'
  };
  const content = {
    ref: '1.A1',
    type: 'level'
  };
  const engineOptions = {
    version: '1',
    livesDisabled: true
  };
  const progression = (0, _.default)(engine, content, engineOptions, availableContentWithRules);
  if (!progression) {
    throw new Error('progression should not be falsy');
  }
  t.deepEqual((0, _keys2.default)(progression).sort(), ['actions', 'content', 'engine', 'engineOptions'].sort());
  t.deepEqual(progression.engine, {
    ref: 'learner',
    version: '1'
  });
  t.is(progression.content, content);
  t.is(progression.engineOptions, engineOptions);
  t.true(Array.isArray(progression.actions));
});
(0, _ava.default)("progression should have 'move' action that links to the initial rule's destination in adaptive", t => {
  const engine = {
    ref: 'learner',
    version: 'latest'
  };
  const content = {
    ref: '1.A1',
    type: 'level'
  };
  const engineOptions = {
    version: '2',
    livesDisabled: true
  };
  const progression = (0, _.default)(engine, content, engineOptions, availableContentWithRules);
  if (!progression) {
    throw new Error('progression should not be falsy');
  }
  t.deepEqual(progression.actions, [{
    type: 'move',
    payload: {
      nextContent: initialRule.destination,
      instructions: initialRule.instructions
    }
  }]);
});
(0, _ava.default)('progression should have "move" action that links to a random slide from the first chapter in non-adaptive', t => {
  const engine = {
    ref: 'learner',
    version: 'latest'
  };
  const content = {
    ref: '1.A1',
    type: 'level'
  };
  const engineOptions = {
    version: '2',
    livesDisabled: true
  };
  const availableContent = [{
    ref: '1.A1',
    slides: [_slides.default.filter(slide => slide.chapter_id === '1.A1')[0]],
    rules: []
  }];
  const progression = (0, _.default)(engine, content, engineOptions, availableContent);
  if (!progression) {
    throw new Error('progression should not be falsy');
  }
  const actions = progression.actions || [];
  const action = {
    type: 'move',
    payload: {
      instructions: null,
      nextContent: {
        ref: '1.A1.1',
        type: 'slide'
      }
    }
  };
  t.deepEqual(actions, [action]);
});
(0, _ava.default)('should return null if no there is no available content', t => {
  const engine = {
    ref: 'learner',
    version: 'latest'
  };
  const content = {
    ref: '1.A1',
    type: 'level'
  };
  const engineOptions = {
    version: '2',
    livesDisabled: true
  };
  const progression = (0, _.default)(engine, content, engineOptions, []);
  t.deepEqual(progression, {
    engine: {
      ref: 'learner',
      version: '2'
    },
    content: {
      ref: '1.A1',
      type: 'level'
    },
    engineOptions: {
      version: '2',
      livesDisabled: true
    },
    actions: [{
      type: 'move',
      payload: {
        nextContent: {
          type: 'success',
          ref: 'successExitNode'
        },
        instructions: null
      }
    }]
  });
});
//# sourceMappingURL=index.js.map