@instructure/outcomes-ui 2.1.2 → 2.1.3

package/lib/translated/vi/store/OutcomePicker/__tests__/actions.test.js

@@ -0,0 +1,319 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _chai = require("chai");
+
+var _immutable = require("immutable");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _constants = require("../../../constants.js");
+
+var _createMockStore = _interopRequireWildcard(require("../../../test/createMockStore.js"));
+
+var actions = _interopRequireWildcard(require("../actions.js"));
+
+var _actions2 = require("../../../store/context/actions.js");
+
+var _actions3 = require("../../alignments/actions.js");
+
+var _actions4 = require("../../activePicker/actions.js");
+
+/* eslint-disable promise/always-return */
+var scopedActions = (0, _createMockStore.scopeActions)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, actions), {}, {
+  setError: _actions2.setError,
+  setScoringMethod: _actions2.setScoringMethod,
+  setAlignments: _actions3.setAlignments,
+  setScope: _actions4.setScope
+}));
+describe('OutcomePicker/actions', function () {
+  describe('selectOutcomeIds', function () {
+    it('creates an action', function () {
+      var action = actions.selectOutcomeIds([1, 2, 3]);
+      (0, _chai.expect)(action.type).to.equal(_constants.SELECT_OUTCOME_IDS);
+      (0, _chai.expect)(action.payload).to.deep.equal([1, 2, 3]);
+    });
+  });
+  describe('deselectOutcomeIds', function () {
+    it('creates an action', function () {
+      var action = actions.deselectOutcomeIds([1, 2]);
+      (0, _chai.expect)(action.type).to.equal(_constants.UNSELECT_OUTCOME_IDS);
+      (0, _chai.expect)(action.payload).to.deep.equal([1, 2]);
+    });
+  });
+  describe('setSelectedOutcomeIds', function () {
+    it('creates an action', function () {
+      var action = actions.setSelectedOutcomeIds([1, 2, 3]);
+      (0, _chai.expect)(action.type).to.equal(_constants.SET_SELECTED_OUTCOME_IDS);
+      (0, _chai.expect)(action.payload).to.deep.equal([1, 2, 3]);
+    });
+  });
+  describe('setOutcomePickerState', function () {
+    it('creates an action', function () {
+      var action = actions.setOutcomePickerState('foo');
+      (0, _chai.expect)(action.type).to.equal(_constants.SET_OUTCOME_PICKER_STATE);
+      (0, _chai.expect)(action.payload).to.deep.equal('foo');
+    });
+  });
+  describe('loadOutcomePicker', function () {
+    it('dispatches state change to loading', function () {
+      var store = (0, _createMockStore.default)();
+      return store.dispatch(actions.loadOutcomePicker()).then(function () {
+        (0, _chai.expect)(store.getActions()[0]).to.deep.equal(scopedActions.setOutcomePickerState('loading'));
+      });
+    });
+    it('dispatches loadOutcomes', function () {
+      var service = {
+        loadOutcomes: _sinon.default.stub().returns(Promise.resolve({}))
+      };
+      var store = (0, _createMockStore.default)((0, _immutable.Map)(), service);
+      return store.dispatch(actions.loadOutcomePicker()).then(function () {
+        (0, _chai.expect)(service.loadOutcomes.calledOnce).to.be.true;
+        (0, _chai.expect)(service.loadOutcomes.args[0][3]).to.be.null;
+      });
+    });
+    it('dispatches set selected outcome ids', function () {
+      var state = (0, _immutable.fromJS)({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '101'
+            }, {
+              id: '202'
+            }]
+          }
+        }
+      });
+      var store = (0, _createMockStore.default)(state);
+      return store.dispatch(actions.loadOutcomePicker()).then(function () {
+        (0, _chai.expect)(store.getActions()).to.deep.include(scopedActions.setSelectedOutcomeIds(['101', '202']));
+      });
+    });
+    it('dispatches state change to choosing', function () {
+      var store = (0, _createMockStore.default)();
+      return store.dispatch(actions.loadOutcomePicker()).then(function () {
+        (0, _chai.expect)(store.getActions()).to.deep.include(scopedActions.setOutcomePickerState('choosing'));
+      });
+    });
+  });
+  describe('setActiveCollection', function () {
+    it('sets the underlying collection id', function () {
+      var store = (0, _createMockStore.default)();
+      return store.dispatch(actions.setActiveCollection(12)).then(function () {
+        (0, _chai.expect)(store.getActions()).to.deep.include(scopedActions.setActiveCollectionFrd(12));
+      });
+    });
+    it('calls loadMoreOutcomes', function () {
+      var service = {
+        loadOutcomes: _sinon.default.stub().returns(Promise.resolve({}))
+      };
+      var store = (0, _createMockStore.default)((0, _immutable.Map)(), service);
+      return store.dispatch(actions.setActiveCollection(12)).then(function () {
+        (0, _chai.expect)(service.loadOutcomes.calledOnce).to.be.true;
+        (0, _chai.expect)(service.loadOutcomes.args[0][3]).to.deep.equal([12]);
+      });
+    });
+  });
+  describe('setFocusedOutcome', function () {
+    it('dispatches setFocusedOutcomeAction', function () {
+      var service = {
+        setFocusedOutcome: _sinon.default.stub().returns(Promise.resolve())
+      };
+      var store = (0, _createMockStore.default)((0, _immutable.Map)(), service);
+      var full = {
+        id: 1,
+        scoring_method: {}
+      };
+      return store.dispatch(actions.setFocusedOutcome(full)).then(function () {
+        (0, _chai.expect)(store.getActions()).to.have.length(1);
+        (0, _chai.expect)(store.getActions()[0]).to.deep.equal(scopedActions.setFocusedOutcomeAction(full));
+        return null;
+      });
+    });
+    it('fetches an outcome and dispatches setFocusedOutcomeAction twice', function () {
+      var full = {
+        id: 1,
+        scoring_method: {}
+      };
+      var service = {
+        getOutcome: _sinon.default.stub().returns(Promise.resolve(full)),
+        setFocusedOutcome: _sinon.default.stub().returns(Promise.resolve())
+      };
+      var store = (0, _createMockStore.default)((0, _immutable.Map)(), service);
+      var partial = {
+        id: 1
+      };
+      return store.dispatch(actions.setFocusedOutcome(partial)).then(function () {
+        (0, _chai.expect)(store.getActions()).to.have.length(4);
+        (0, _chai.expect)(store.getActions()[0]).to.deep.equal(scopedActions.setFocusedOutcomeAction(partial));
+        (0, _chai.expect)(store.getActions()[2]).to.deep.equal(scopedActions.setScoringMethod({
+          context_uuid: void 0,
+          id: 1,
+          scoring_method: {}
+        }));
+        (0, _chai.expect)(store.getActions()[3]).to.deep.equal(scopedActions.setFocusedOutcomeAction(full));
+        return null;
+      });
+    });
+  });
+  describe('saveOutcomePickerAlignments', function () {
+    var state = (0, _immutable.fromJS)({
+      context: {
+        outcomes: {
+          course_100: {
+            1: {
+              id: '1'
+            },
+            2: {
+              id: '2'
+            }
+          }
+        }
+      },
+      scopeForTest: {
+        config: {
+          contextUuid: 'course_100'
+        },
+        OutcomePicker: {
+          selected: ['1', '2'],
+          scope: 'scopeForTest'
+        }
+      }
+    });
+    it('wraps its calls in setOutcomePickerState', function () {
+      var store = (0, _createMockStore.default)(state);
+      return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
+        (0, _chai.expect)(store.getActions()[0]).to.deep.equal(scopedActions.setOutcomePickerState('saving'));
+        (0, _chai.expect)(store.getActions()).to.deep.include(scopedActions.setAlignments({
+          guid: 'newguid',
+          outcomes: [{
+            id: '1'
+          }, {
+            id: '2'
+          }]
+        }));
+        (0, _chai.expect)(store.getActions()[store.getActions().length - 1]).to.deep.equal(scopedActions.setOutcomePickerState('complete'));
+      });
+    });
+    it('fires an updateCallback function if provided', function () {
+      var store = (0, _createMockStore.default)(state);
+
+      var callback = _sinon.default.stub();
+
+      return store.dispatch(actions.saveOutcomePickerAlignments(callback)).then(function () {
+        (0, _chai.expect)(callback.calledOnce).to.be.true;
+        (0, _chai.expect)(callback.calledWith({
+          guid: 'newguid',
+          outcomes: [{
+            id: '1'
+          }, {
+            id: '2'
+          }]
+        })).to.be.true;
+      });
+    });
+    it('creates alignment set from selection', function () {
+      var newState = state.setIn(['OutcomePicker', 'selected'], (0, _immutable.List)(['1', '2', '3']));
+      var service = {
+        createAlignmentSet: _sinon.default.stub().returns(Promise.resolve())
+      };
+      var store = (0, _createMockStore.default)(newState, service);
+      return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
+        (0, _chai.expect)(service.createAlignmentSet.calledOnce).to.be.true;
+        (0, _chai.expect)(service.createAlignmentSet.calledWith(['1', '2', '3']));
+      });
+    });
+    it('can pull aligned outcomes from previously aligned outcomes', function () {
+      var newState = state.deleteIn(['context', 'outcomes', 'course_100', '1']).setIn(['alignments', 'alignedOutcomes'], (0, _immutable.fromJS)([{
+        id: '1'
+      }]));
+      var service = {
+        createAlignmentSet: _sinon.default.stub().returns(Promise.resolve())
+      };
+      var store = (0, _createMockStore.default)(newState, service);
+      return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
+        (0, _chai.expect)(service.createAlignmentSet.calledWith(['1', '2']));
+      });
+    });
+    it('dispatches setError on save alignments failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        createAlignmentSet: _sinon.default.stub().returns(Promise.reject(error))
+      };
+      var store = (0, _createMockStore.default)((0, _immutable.Map)(), service);
+      return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
+        (0, _chai.expect)(store.getActions()).to.have.length(3);
+        (0, _chai.expect)(store.getActions()[2]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+    it('calls upsertArtifact if shouldUpdateArtifact is true', function () {
+      var service = {
+        upsertArtifact: _sinon.default.stub().returns(Promise.resolve({
+          guid: 'guid-1',
+          outcomes: ['1', '2']
+        }))
+      };
+      var store = (0, _createMockStore.default)(state, service);
+      return store.dispatch(actions.saveOutcomePickerAlignments(null, true)).then(function () {
+        (0, _chai.expect)(service.upsertArtifact.calledWith(['1', '2']));
+        (0, _chai.expect)(store.getActions()).to.deep.include(scopedActions.setAlignments({
+          guid: 'guid-1',
+          outcomes: [{
+            id: '1'
+          }, {
+            id: '2'
+          }]
+        }));
+        (0, _chai.expect)(store.getActions()[store.getActions().length - 1]).to.deep.equal(scopedActions.setOutcomePickerState('complete'));
+      });
+    });
+  });
+  describe('resetOutcomePicker', function () {
+    it('creates an action', function () {
+      var action = actions.resetOutcomePicker();
+      (0, _chai.expect)(action.type).to.equal(_constants.RESET_OUTCOME_PICKER);
+    });
+  });
+  describe('openOutcomePicker', function () {
+    it('dispatches flow in the correct order', function () {
+      var store = (0, _createMockStore.default)();
+      store.dispatch(actions.openOutcomePicker());
+      (0, _chai.expect)(store.getActions()[0]).to.deep.equal(scopedActions.setScope('scopeForTest'));
+      (0, _chai.expect)(store.getActions()[1]).to.deep.equal(scopedActions.setOutcomePickerState('loading'));
+      (0, _chai.expect)(store.getActions()).to.have.length(2);
+    });
+    it('does not try to open an already open picker', function () {
+      var state = (0, _immutable.fromJS)({
+        scopeForTest: {
+          config: {
+            contextUuid: 'course_100'
+          },
+          OutcomePicker: {
+            scope: 'scopeForTest',
+            state: 'choosing'
+          }
+        }
+      });
+      var store = (0, _createMockStore.default)(state);
+      store.dispatch(actions.openOutcomePicker());
+      (0, _chai.expect)(store.getActions()).to.have.length(0);
+    });
+  });
+  describe('closeOutcomePicker', function () {
+    it('dispatches flow in the correct order', function () {
+      var store = (0, _createMockStore.default)();
+      store.dispatch(actions.closeOutcomePicker());
+      (0, _chai.expect)(store.getActions()[0]).to.deep.equal(scopedActions.setScope(''));
+      (0, _chai.expect)(store.getActions()[1]).to.deep.equal(scopedActions.setOutcomePickerState('closed'));
+      (0, _chai.expect)(store.getActions()).to.have.length(2);
+    });
+  });
+});

package/lib/translated/vi/store/OutcomePicker/__tests__/reducers.test.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+
+var _chai = require("chai");
+
+var _immutable = require("immutable");
+
+var _constants = require("../../../constants.js");
+
+var actions = _interopRequireWildcard(require("../actions.js"));
+
+var _reducers = _interopRequireDefault(require("../reducers.js"));
+
+describe('OutcomePicker/reducers', function () {
+  var state = (0, _immutable.fromJS)({
+    focusedOutcome: null,
+    selected: (0, _immutable.Set)(['1', '2', '3']),
+    state: 'testing',
+    scope: 'scopeForTest'
+  });
+
+  var reduce = function reduce(state, type, payload) {
+    return (0, _reducers.default)(state, {
+      type: type,
+      payload: payload
+    });
+  };
+
+  describe('state (outcomePickerState)', function () {
+    it('is set by SET_OUTCOME_PICKER_STATE', function () {
+      var newState = reduce(state, _constants.SET_OUTCOME_PICKER_STATE, 'monkey');
+      (0, _chai.expect)(newState.get('state')).to.equal('monkey');
+    });
+  });
+  describe('focusedOutcome', function () {
+    it('is set by setFocusedOutcomeAction', function () {
+      var next = (0, _reducers.default)(state, actions.setFocusedOutcomeAction('rhino'));
+      (0, _chai.expect)(next.get('focusedOutcome')).to.equal('rhino');
+    });
+  });
+  describe('selected', function () {
+    describe('adds ids on SELECT_OUTCOME_IDS', function () {
+      it('when distinct', function () {
+        var newState = reduce(state, _constants.SELECT_OUTCOME_IDS, [4, 5]);
+        (0, _chai.expect)(newState.get('selected').toJS().sort()).to.deep.equal(['1', '2', '3', '4', '5']);
+      });
+      it('when not distinct', function () {
+        var newState = reduce(state, _constants.SELECT_OUTCOME_IDS, [1, 2, 5]);
+        (0, _chai.expect)(newState.get('selected').toJS().sort()).to.deep.equal(['1', '2', '3', '5']);
+      });
+    });
+    describe('removes ids on UNSELECT_OUTCOME_IDS', function () {
+      it('when present', function () {
+        var newState = reduce(state, _constants.UNSELECT_OUTCOME_IDS, ['1', '2']);
+        (0, _chai.expect)(newState.get('selected').toJS()).to.deep.equal(['3']);
+      });
+      it('when absent', function () {
+        var newState = reduce(state, _constants.UNSELECT_OUTCOME_IDS, ['3', '4']);
+        (0, _chai.expect)(newState.get('selected').toJS().sort()).to.deep.equal(['1', '2']);
+      });
+    });
+    it('replaces ids on SET_SELECTED_OUTCOME_IDS', function () {
+      var newState = reduce(state, _constants.SET_SELECTED_OUTCOME_IDS, ['2', '5']);
+      (0, _chai.expect)(newState.get('selected').toJS().sort()).to.deep.equal(['2', '5']);
+    });
+  });
+  describe('activeCollection', function () {
+    it('is set by SET_ACTIVE_COLLECTION_ID', function () {
+      var newState = reduce(state, _constants.SET_ACTIVE_COLLECTION_ID, '1701');
+      (0, _chai.expect)(newState.get('activeCollection')).to.equal('1701');
+    });
+  });
+  describe('expandedIds', function () {
+    it('is set by toggleExpandedIds', function () {
+      var next = (0, _reducers.default)(state, actions.toggleExpandedIds({
+        id: 1
+      }));
+      (0, _chai.expect)(next.get('expandedIds').toJS()).to.deep.equal(['1']);
+    });
+    it('properly adds and removes ids from the set', function () {
+      var firstState = (0, _reducers.default)(state, actions.toggleExpandedIds({
+        id: 1
+      }));
+      var secondState = (0, _reducers.default)(firstState, actions.toggleExpandedIds({
+        id: 2
+      }));
+      (0, _chai.expect)(secondState.get('expandedIds').toJS()).to.deep.equal(['1', '2']);
+      var thirdState = (0, _reducers.default)(secondState, actions.toggleExpandedIds({
+        id: 1
+      }));
+      (0, _chai.expect)(thirdState.get('expandedIds').toJS()).to.deep.equal(['2']);
+    });
+    it('does not remove an id if collection is forced open', function () {
+      var firstState = (0, _reducers.default)(state, actions.toggleExpandedIds({
+        id: 1
+      }));
+      var secondState = (0, _reducers.default)(firstState, actions.toggleExpandedIds({
+        id: 1,
+        forceOpen: true
+      }));
+      (0, _chai.expect)(secondState.get('expandedIds').toJS()).to.deep.equal(['1']);
+    });
+  });
+  describe('when action type is RESET_OUTCOME_PICKER ', function () {
+    it('resets state to default', function () {
+      var newState = reduce(state, _constants.RESET_OUTCOME_PICKER, 'scopeForTest');
+      (0, _chai.expect)(newState.get('state')).to.equal('closed'); // eslint-disable-line no-console
+
+      (0, _chai.expect)(newState.get('selected').toJS()).to.deep.equal([]);
+    });
+  });
+});

package/lib/translated/vi/store/OutcomePicker/__tests__/selectors.test.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _chai = require("chai");
+
+var _immutable = require("immutable");
+
+var _selectors = require("../selectors.js");
+
+describe('OutcomePicker/selectors', function () {
+  var scope = 'scopeForTest';
+  var state = (0, _immutable.fromJS)({
+    scopeForTest: {
+      config: {
+        contextUuid: 'course_100'
+      },
+      OutcomePicker: {
+        selected: ['1', '2', '3'],
+        state: 'testing',
+        expandedIds: ['1'],
+        scope: scope
+      }
+    },
+    context: {
+      outcomes: {
+        course_100: {
+          1: {
+            id: 1,
+            title: 'Some outcome 1',
+            description: 'Description 1',
+            child_ids: ['2', '3']
+          },
+          2: {
+            id: 2,
+            title: 'Some outcome 2',
+            description: 'Description 2',
+            child_ids: ['4']
+          },
+          3: {
+            id: 3,
+            title: 'Some outcome 3',
+            description: 'Description 3',
+            child_ids: []
+          },
+          4: {
+            id: 4,
+            title: 'Some outcome 4',
+            description: 'Description 4'
+          }
+        }
+      }
+    }
+  });
+  describe('getSelectedOutcomeIds', function () {
+    it('retrieves the correct ids', function () {
+      (0, _chai.expect)((0, _selectors.getSelectedOutcomeIds)(state, scope)).to.deep.equal(['1', '2', '3']);
+    });
+    it('returns an empty array if no outcomes are selected', function () {
+      var newState = (0, _immutable.Map)();
+      (0, _chai.expect)((0, _selectors.getSelectedOutcomeIds)(newState, scope)).to.deep.equal([]);
+    });
+  });
+  describe('makeIsOutcomeSelected', function () {
+    it('returns true if outcome id is selected', function () {
+      (0, _chai.expect)((0, _selectors.makeIsOutcomeSelected)(state, scope)('2')).to.be.true;
+    });
+    it('returns false if outcome is not selected', function () {
+      (0, _chai.expect)((0, _selectors.makeIsOutcomeSelected)(state, scope)('4')).to.be.false;
+    });
+    it('returns false if no outcomes are selected', function () {
+      var newState = (0, _immutable.Map)();
+      (0, _chai.expect)((0, _selectors.makeIsOutcomeSelected)(newState, scope)('1')).to.be.false;
+    });
+  });
+  describe('anyOutcomeSelected', function () {
+    it('returns true when outcomes are selected', function () {
+      (0, _chai.expect)((0, _selectors.anyOutcomeSelected)(state, scope)).to.be.true;
+    });
+    it('returns false if empty selected outcomes', function () {
+      var newState = state.setIn([scope, 'OutcomePicker', 'selected'], new _immutable.List());
+      (0, _chai.expect)((0, _selectors.anyOutcomeSelected)(newState, scope)).to.be.false;
+    });
+    it('returns false if no selected outcomes', function () {
+      var newState = (0, _immutable.Map)();
+      (0, _chai.expect)((0, _selectors.anyOutcomeSelected)(newState)).to.be.false;
+    });
+  });
+  describe('getActiveCollection', function () {
+    it('returns correct values if there is no active collection', function () {
+      var data = (0, _selectors.getActiveCollection)(state, scope);
+      (0, _chai.expect)(data.id).to.equal('');
+      (0, _chai.expect)(data.header).to.equal('');
+      (0, _chai.expect)(data.summary).to.equal('');
+      (0, _chai.expect)(data.description).to.equal('');
+    });
+    it('returns the correct values if id if present', function () {
+      var newState = state.setIn([scope, 'OutcomePicker', 'activeCollection'], '1');
+      var data = (0, _selectors.getActiveCollection)(newState, scope);
+      (0, _chai.expect)(data.id).to.equal(1);
+      (0, _chai.expect)(data.header).to.equal('Some outcome 1');
+      (0, _chai.expect)(data.summary).to.equal('1 Group | 1 Outcome');
+      (0, _chai.expect)(data.description).to.equal('Description 1');
+    });
+  });
+  describe('getActiveChildren', function () {
+    it('returns an empty map when no set active', function () {
+      (0, _chai.expect)((0, _selectors.getActiveChildren)(state, scope)).to.deep.equal({
+        groups: [],
+        nonGroups: []
+      });
+    });
+    it('returns the list of groups and non groups when present', function () {
+      var newState = state.setIn([scope, 'OutcomePicker', 'activeCollection'], '1');
+
+      var _getActiveChildren = (0, _selectors.getActiveChildren)(newState, scope),
+          groups = _getActiveChildren.groups,
+          nonGroups = _getActiveChildren.nonGroups;
+
+      (0, _chai.expect)(groups).to.deep.equal([{
+        id: 2,
+        title: 'Some outcome 2',
+        description: 'Description 2',
+        child_ids: ['4']
+      }]);
+      (0, _chai.expect)(nonGroups).to.deep.equal([{
+        id: 3,
+        title: 'Some outcome 3',
+        description: 'Description 3',
+        child_ids: []
+      }]);
+    });
+    it('returns an empty map when no child ids are present', function () {
+      var newState = state.setIn([scope, 'OutcomePicker', 'activeCollection'], '4');
+      (0, _chai.expect)((0, _selectors.getActiveChildren)(newState, scope)).to.deep.equal({
+        groups: [],
+        nonGroups: []
+      });
+    });
+  });
+  describe('getOutcomePickerState', function () {
+    it('retrieves the correct value', function () {
+      (0, _chai.expect)((0, _selectors.getOutcomePickerState)(state, scope)).to.equal('testing');
+    });
+  });
+  describe('getExpandedIds', function () {
+    it('retrieves the correct value', function () {
+      (0, _chai.expect)((0, _selectors.getExpandedIds)(state, scope)).to.deep.equal(['1']);
+    });
+  });
+});