@instructure/outcomes-ui 2.1.2 → 2.1.3

package/es/translated/vi/store/alignments/__tests__/actions.test.js

@@ -0,0 +1,332 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { Map, fromJS } from 'immutable';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT } from "../../../constants.js";
+import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
+import * as actions from "../actions.js";
+import { setError } from "../../../store/context/actions.js";
+var scopedActions = scopeActions(_objectSpread(_objectSpread({}, actions), {}, {
+  setError: setError
+}));
+describe('alignments/actions', function () {
+  describe('setAlignments', function () {
+    it('creates an action', function () {
+      var action = actions.setAlignments([]);
+      expect(action.type).to.equal(SET_ALIGNMENTS);
+      expect(action.payload).to.deep.equal([]);
+    });
+  });
+  describe('viewAlignment', function () {
+    it('creates an action', function () {
+      var action = actions.viewAlignmentAction(12);
+      expect(action.type).to.equal(VIEW_ALIGNMENT);
+      expect(action.payload).to.deep.equal(12);
+    });
+    it('dispatches viewAlignmentAction', function () {
+      var service = {
+        viewAlignmentAction: sinon.stub().returns(Promise.resolve())
+      };
+      var state = fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: 1,
+              scoring_method: 'boom'
+            }],
+            alignmentSetId: 'badong'
+          }
+        }
+      });
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.viewAlignment(1)).then(function () {
+        expect(store.getActions()).to.have.length(1);
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.viewAlignmentAction(1));
+        return null;
+      });
+    });
+    it('fetches an outcome and dispatches updateAlignment', function () {
+      var full = {
+        id: 1,
+        scoring_method: 'boom'
+      };
+      var service = {
+        getOutcome: sinon.stub().returns(Promise.resolve(full))
+      };
+      var state = fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: 1
+            }],
+            alignmentSetId: 'badong'
+          }
+        }
+      });
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.viewAlignment(1)).then(function () {
+        expect(store.getActions()).to.have.length(3);
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.viewAlignmentAction(1));
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.updateAlignment({
+          outcome: full
+        }));
+        return null;
+      });
+    });
+  });
+  describe('updateAlignment', function () {
+    it('creates an action', function () {
+      var action = actions.updateAlignment(12);
+      expect(action.type).to.equal(UPDATE_ALIGNMENT);
+      expect(action.payload).to.deep.equal(12);
+    });
+  });
+  describe('closeAlignment', function () {
+    it('creates an action', function () {
+      var action = actions.closeAlignment();
+      expect(action.type).to.equal(CLOSE_ALIGNMENT);
+    });
+  });
+  describe('updateAlignments', function () {
+    it('dispatches setAlignments when called', function () {
+      var alignments = [{
+        id: '1'
+      }, {
+        id: '2'
+      }];
+      var service = {
+        getAlignments: sinon.stub().returns(Promise.resolve(alignments))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.updateAlignments('hexadecimal', alignments)).then(function () {
+        expect(store.getActions()).to.have.length(1);
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setAlignments({
+          guid: 'hexadecimal',
+          outcomes: alignments
+        }));
+        return null;
+      });
+    });
+    it('fires an updateCallback function if provided', function () {
+      var alignments = [{
+        id: '1'
+      }, {
+        id: '2'
+      }];
+      var callback = sinon.stub();
+      var service = {
+        getAlignments: sinon.stub().returns(Promise.resolve(alignments))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.updateAlignments('hexadecimal', alignments, callback)).then(function () {
+        expect(callback.calledOnce).to.be.true;
+        expect(callback.calledWith({
+          guid: 'hexadecimal',
+          outcomes: alignments
+        })).to.be.true;
+        return null;
+      });
+    });
+  });
+  describe('loadAlignments', function () {
+    it('responds with a null guid and empty outcome array if the alignmentSetId does not match the scope', function () {
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }],
+            alignmentSetId: 'badong'
+          }
+        }
+      }));
+      return store.dispatch(actions.loadAlignments('gnodab')).then(function () {
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setAlignments({
+          guid: null,
+          outcomes: []
+        }));
+        return null;
+      });
+    });
+    it('responds with a null guid and empty outcome array if there is no alignment set id', function () {
+      var service = {
+        clearAlignmentSet: sinon.stub().returns(Promise.resolve()),
+        getAlignments: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.loadAlignments(null)).then(function () {
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setAlignments({
+          guid: null,
+          outcomes: []
+        }));
+        return null;
+      });
+    });
+    it('calls outcome service to load alignments', function () {
+      var service = {
+        getAlignments: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadAlignments('hexadecimal')).then(function () {
+        expect(service.getAlignments.calledOnce).to.be.true;
+        return null;
+      });
+    });
+    it('dispatches setError on outcome service failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        getAlignments: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadAlignments('hexadecimal')).then(function () {
+        expect(store.getActions()).to.have.length(3);
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+  });
+  describe('loadArtifact', function () {
+    it('calls outcome service to load artfiact', function () {
+      var response = {
+        guid: 'guid',
+        outcomes: [{
+          id: '1'
+        }]
+      };
+      var service = {
+        getArtifact: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadArtifact({
+        artifactType: 'type',
+        artifactId: '1'
+      })).then(function () {
+        expect(store.getActions()).to.have.length(3);
+        expect(service.getArtifact.calledOnce).to.be.true;
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setAlignments(response));
+        return null;
+      });
+    });
+    it('dispatches setError on outcome service failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        getArtifact: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadArtifact({
+        artifactType: '',
+        artifactId: ''
+      })).then(function () {
+        expect(store.getActions()).to.have.length(3);
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+  });
+  describe('removeAlignment', function () {
+    it('calls outcomes service to create new alignment set', function () {
+      var service = {
+        createAlignmentSet: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }, {
+              id: '12'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.removeAlignment('12')).then(function () {
+        expect(service.createAlignmentSet.calledOnce).to.be.true;
+        expect(service.createAlignmentSet.calledWith([]));
+        return null;
+      });
+    });
+    it('responds with a null guid and empty outcome array if no alignments remain', function () {
+      var service = {
+        clearAlignmentSet: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.removeAlignment('1')).then(function () {
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setAlignments({
+          guid: null,
+          outcomes: []
+        }));
+        return null;
+      });
+    });
+    it('dispatches setError on outcome service failure', function () {
+      var error = {
+        message: 'baz bar foo'
+      };
+      var service = {
+        createAlignmentSet: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '12'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.removeAlignment('1')).then(function () {
+        expect(store.getActions()).to.have.length(2);
+        expect(store.getActions()[1]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+    it('calls upsertArtifact if shouldUpdateArtifact is true', function () {
+      var response = {
+        guid: 'my-guid-1',
+        outcomes: [{
+          id: '1'
+        }]
+      };
+      var service = {
+        upsertArtifact: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }, {
+              id: '12'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.removeAlignment('12', null, true)).then(function () {
+        expect(service.upsertArtifact.calledOnce).to.be.true;
+        expect(store.getActions()[0].payload.args.slice(-1)).to.deep.equal([['1']]);
+        expect(store.getActions()).to.deep.include(scopedActions.setAlignments(response));
+        return null;
+      });
+    });
+  });
+});

package/es/translated/vi/store/alignments/__tests__/reducers.test.js

@@ -0,0 +1,70 @@
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT } from "../../../constants.js";
+import reducer from "../reducers.js";
+describe('alignments/reducers', function () {
+  var reduce = function reduce(state, type, payload) {
+    return reducer(state, {
+      type: type,
+      payload: payload
+    });
+  };
+
+  var state = fromJS({
+    alignmentSetId: 'originalguid',
+    alignedOutcomes: [{
+      id: '2'
+    }, {
+      id: '3'
+    }],
+    openAlignmentId: 10
+  });
+  describe('alignedOutcomes', function () {
+    it('is updated by SET_ALIGNMENTS', function () {
+      var newAlignments = {
+        guid: 'imaguid',
+        outcomes: [{
+          id: '1'
+        }, {
+          id: '2'
+        }, {
+          id: '3'
+        }]
+      };
+      var newState = reduce(state, SET_ALIGNMENTS, newAlignments);
+      expect(newState.get('alignedOutcomes').toJS()).to.deep.equal(newAlignments.outcomes);
+    });
+    it('is updated by UPDATE_ALIGNMENT', function () {
+      var outcome = {
+        id: '3',
+        scoring_method: 'boom'
+      };
+      var newState = reduce(state, UPDATE_ALIGNMENT, {
+        outcome: outcome
+      });
+      expect(newState.getIn(['alignedOutcomes', 1]).toJS()).to.deep.equal(outcome);
+    });
+  });
+  describe('openAlignmentId', function () {
+    it('is set by VIEW_ALIGNMENT', function () {
+      var newState = reduce(state, VIEW_ALIGNMENT, 99);
+      expect(newState.get('openAlignmentId')).to.equal(99);
+    });
+    it('is cleared by CLOSE_ALIGNMENT', function () {
+      var newState = reduce(state, CLOSE_ALIGNMENT, null);
+      expect(newState.get('openAlignmentId')).to.equal(null);
+    });
+  });
+  describe('alignmentSetId', function () {
+    it('is updated by SET_ALIGNMENTS', function () {
+      var newAlignmentSet = {
+        guid: 'iamgroot',
+        outcomes: [{
+          id: '5'
+        }]
+      };
+      var newState = reduce(state, SET_ALIGNMENTS, newAlignmentSet);
+      expect(newState.get('alignmentSetId')).to.deep.equal(newAlignmentSet.guid);
+    });
+  });
+});

package/es/translated/vi/store/alignments/__tests__/selectors.test.js

@@ -0,0 +1,127 @@
+import { expect } from 'chai';
+import { Map, fromJS } from 'immutable';
+import { getAlignedOutcomeIds, getAlignedOutcomes, getAlignedOutcome, getAlignedOutcomeCount, getAnyOutcome, makeIsOpen } from "../selectors.js";
+describe('alignments/selectors', function () {
+  var state = fromJS({
+    scopeForTest: {
+      alignments: {
+        alignedOutcomes: [{
+          id: '101',
+          label: 'l1',
+          title: 't2'
+        }, {
+          id: '102',
+          label: 'l2',
+          title: 't1'
+        }, {
+          id: '103',
+          label: 'l3',
+          title: 't3'
+        }],
+        openAlignmentId: 12
+      }
+    }
+  });
+  describe('getAlignedOutcomeIds', function () {
+    it('retrieves the correct value', function () {
+      expect(getAlignedOutcomeIds(state, 'scopeForTest')).to.deep.equal(['102', '101', '103']);
+    });
+    it('returns [] when not set', function () {
+      var newState = Map();
+      expect(getAlignedOutcomeIds(newState, 'scopeForTest')).to.deep.equal([]);
+    });
+  });
+  describe('getAlignedOutcomes', function () {
+    it('retrieves the outcomes for each aligned outcome id', function () {
+      var outcomes = getAlignedOutcomes(state, 'scopeForTest');
+      expect(outcomes).to.have.length(3);
+      expect(outcomes).to.deep.equal([{
+        id: '102',
+        label: 'l2',
+        title: 't1'
+      }, {
+        id: '101',
+        label: 'l1',
+        title: 't2'
+      }, {
+        id: '103',
+        label: 'l3',
+        title: 't3'
+      }]);
+    });
+    it('memoizes alignedOutcomes by scope', function () {
+      getAlignedOutcomes.resetRecomputations();
+      getAlignedOutcomes.clearCache();
+      getAlignedOutcomes(state, 'scopeForTest');
+      getAlignedOutcomes(Map(), 'newScope');
+      getAlignedOutcomes(state, 'scopeForTest');
+      expect(getAlignedOutcomes.recomputations()).to.equal(2);
+    });
+  });
+  describe('getAlignedOutcomeCount', function () {
+    it('returns the count when the list of outcomes is defined', function () {
+      var count = getAlignedOutcomeCount(state, 'scopeForTest');
+      expect(count).to.equal(3);
+    });
+    it('returns 0 when the list is not defined', function () {
+      var count = getAlignedOutcomeCount(state, 'anotherScope');
+      expect(count).to.equal(0);
+    });
+  });
+  describe('makeIsOpen', function () {
+    it('returns true if alignment id is openAlignmentId', function () {
+      expect(makeIsOpen(state, 'scopeForTest')(12)).to.be.true;
+    });
+    it('returns false if another alignment id is openAlignmentId', function () {
+      expect(makeIsOpen(state, 'scopeForTest')(13)).to.be.false;
+    });
+    it('returns false if no alignment is openAlignmentId', function () {
+      var newState = Map();
+      expect(makeIsOpen(newState, 'scopeForTest')(12)).to.be.false;
+    });
+  });
+  describe('getAlignedOutcome', function () {
+    it('retrieves an aligned outcome by its id', function () {
+      var outcome = getAlignedOutcome(state, 'scopeForTest', '101');
+      expect(outcome).to.deep.equal({
+        id: '101',
+        label: 'l1',
+        title: 't2'
+      });
+    });
+  });
+  describe('getAnyOutcome', function () {
+    it('can pull outcomes from aligned outcomes', function () {
+      var outcome = getAnyOutcome(state, 'scopeForTest', '101');
+      expect(outcome.label).to.equal('l1');
+    });
+    it('can pull outcomes from context outcomes', function () {
+      var state = fromJS({
+        scopeForTest: {
+          config: {
+            contextUuid: 'course_100'
+          }
+        },
+        context: {
+          outcomes: {
+            course_100: {
+              1: {
+                id: 1,
+                label: 'l1',
+                title: 't1',
+                child_ids: ['2', '3']
+              }
+            }
+          }
+        }
+      });
+      var outcome = getAnyOutcome(state, 'scopeForTest', '1');
+      expect(outcome.label).to.equal('l1');
+    });
+    it('returns null if neither present', function () {
+      var state = Map();
+      var outcome = getAnyOutcome(state, 'scopeForTest', '101');
+      expect(outcome).to.be.null;
+    });
+  });
+});

package/es/translated/vi/store/alignments/actions.js

@@ -0,0 +1,173 @@
+import { createAction } from 'redux-actions';
+import { CALL_SERVICE } from '@instructure/redux-service-middleware';
+import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT } from "../../constants.js";
+import { getAlignedOutcomeIds, getAlignedOutcome, getOutcomeAlignmentSetId } from "./selectors.js";
+import { getConfig } from "../config/selectors.js";
+import { setError } from "../context/actions.js";
+/*
+ * action creators
+ */
+
+export var setAlignments = createAction(SET_ALIGNMENTS);
+export var viewAlignmentAction = createAction(VIEW_ALIGNMENT);
+export var closeAlignment = createAction(CLOSE_ALIGNMENT);
+export var updateAlignment = createAction(UPDATE_ALIGNMENT);
+export var viewAlignment = function viewAlignment(outcomeId) {
+  return function (dispatch, getState, _arg, scope) {
+    var outcome = getAlignedOutcome(getState(), scope, outcomeId);
+    dispatch(viewAlignmentAction(outcomeId));
+
+    if (outcome && outcome.scoring_method) {
+      return Promise.resolve();
+    }
+
+    var _getConfig = getConfig(getState(), scope),
+        host = _getConfig.host,
+        jwt = _getConfig.jwt,
+        contextUuid = _getConfig.contextUuid;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getOutcome',
+        args: [host, jwt, outcomeId, contextUuid]
+      }
+    }).then(function (json) {
+      return dispatch(updateAlignment({
+        outcome: json
+      }));
+    });
+  };
+};
+export var updateAlignments = function updateAlignments(guid, outcomes, updateCallback) {
+  return function (dispatch) {
+    dispatch(setAlignments({
+      guid: guid,
+      outcomes: outcomes
+    }));
+
+    if (updateCallback) {
+      updateCallback({
+        guid: guid,
+        outcomes: outcomes
+      });
+    }
+
+    return Promise.resolve();
+  };
+};
+export var loadAlignments = function loadAlignments(alignmentSetId, updateCallback) {
+  return function (dispatch, getState, _arg, scope) {
+    if (alignmentSetId && getOutcomeAlignmentSetId(getState(), scope) === alignmentSetId) {
+      return Promise.resolve();
+    }
+
+    var _getConfig2 = getConfig(getState(), scope),
+        host = _getConfig2.host,
+        jwt = _getConfig2.jwt,
+        contextUuid = _getConfig2.contextUuid;
+
+    return dispatch(clearAlignmentSet()).then(function () {
+      return dispatch({
+        type: CALL_SERVICE,
+        payload: {
+          service: 'outcomes',
+          method: 'getAlignments',
+          args: [host, jwt, alignmentSetId, contextUuid]
+        }
+      });
+    }).then(function (json) {
+      return dispatch(updateAlignments(json.guid, json.outcomes, updateCallback));
+    }).catch(function (e) {
+      return dispatch(setError(e));
+    });
+  };
+};
+export var removeAlignment = function removeAlignment(alignmentId, updateCallback) {
+  var shouldUpdateArtifact = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  return function (dispatch, getState, _arg, scope) {
+    var newIds = getAlignedOutcomeIds(getState(), scope).filter(function (id) {
+      return id !== alignmentId;
+    });
+
+    if (newIds.length === 0 && !shouldUpdateArtifact) {
+      return dispatch(clearAlignmentSet(updateCallback));
+    }
+
+    var updateAlignmentFunc = shouldUpdateArtifact ? upsertArtifact : createAlignmentSet;
+    return dispatch(updateAlignmentFunc(newIds)).then(function (response) {
+      var newOutcomes = newIds.map(function (id) {
+        return getAlignedOutcome(getState(), scope, id);
+      });
+      dispatch(updateAlignments(response.guid, newOutcomes, updateCallback));
+    }).catch(function (e) {
+      return dispatch(setError(e));
+    });
+  };
+};
+export var createAlignmentSet = function createAlignmentSet(outcomeIds) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig3 = getConfig(getState(), scope),
+        host = _getConfig3.host,
+        jwt = _getConfig3.jwt;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'createAlignmentSet',
+        args: [host, jwt, outcomeIds]
+      }
+    });
+  };
+};
+export var clearAlignmentSet = function clearAlignmentSet(updateCallback) {
+  return function (dispatch) {
+    dispatch(updateAlignments(null, [], updateCallback));
+    return Promise.resolve();
+  };
+};
+export var loadArtifact = function loadArtifact() {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig4 = getConfig(getState(), scope),
+        host = _getConfig4.host,
+        jwt = _getConfig4.jwt,
+        artifactType = _getConfig4.artifactType,
+        artifactId = _getConfig4.artifactId;
+
+    return dispatch(clearAlignmentSet()).then(function () {
+      return dispatch({
+        type: CALL_SERVICE,
+        payload: {
+          service: 'outcomes',
+          method: 'getArtifact',
+          args: [host, jwt, artifactType, artifactId]
+        }
+      });
+    }).then(function (json) {
+      return dispatch(updateAlignments(json.guid, json.outcomes));
+    }).catch(function (e) {
+      return dispatch(setError(e));
+    });
+  };
+};
+export var upsertArtifact = function upsertArtifact(outcomeIds) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig5 = getConfig(getState(), scope),
+        host = _getConfig5.host,
+        jwt = _getConfig5.jwt,
+        artifactType = _getConfig5.artifactType,
+        artifactId = _getConfig5.artifactId,
+        contextUuid = _getConfig5.contextUuid;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'upsertArtifact',
+        args: [host, jwt, artifactType, artifactId, contextUuid, outcomeIds]
+      }
+    });
+  };
+};