@instructure/outcomes-ui 2.1.2 → 2.1.3

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

@@ -0,0 +1,39 @@
+import { handleActions } from 'redux-actions';
+import { combineReducers } from 'redux-immutable';
+import { fromJS, Map, List } from 'immutable';
+var alignedOutcomes = handleActions({
+  SET_ALIGNMENTS: function SET_ALIGNMENTS(state, action) {
+    return fromJS(action.payload.outcomes || []);
+  },
+  UPDATE_ALIGNMENT: function UPDATE_ALIGNMENT(state, action) {
+    var outcomeId = action.payload.outcome.id;
+    var idx = state.findIndex(function (o) {
+      return o.get('id') === outcomeId;
+    });
+
+    if (idx === -1) {
+      return state;
+    }
+
+    var outcome = action.payload.outcome;
+    return state.set(idx, Map(outcome));
+  }
+}, List());
+var openAlignmentId = handleActions({
+  VIEW_ALIGNMENT: function VIEW_ALIGNMENT(state, action) {
+    return action.payload;
+  },
+  CLOSE_ALIGNMENT: function CLOSE_ALIGNMENT() {
+    return null;
+  }
+}, null);
+var alignmentSetId = handleActions({
+  SET_ALIGNMENTS: function SET_ALIGNMENTS(state, action) {
+    return action.payload.guid || null;
+  }
+}, null);
+export default combineReducers({
+  alignedOutcomes: alignedOutcomes,
+  openAlignmentId: openAlignmentId,
+  alignmentSetId: alignmentSetId
+});

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

@@ -0,0 +1,60 @@
+import { Map, List } from 'immutable';
+import { createSelector } from 'reselect';
+import createCachedSelector from 're-reselect';
+import { getOutcome } from "../context/selectors.js";
+
+var restrict = function restrict(state, scope) {
+  return state.getIn([scope, 'alignments']) || Map();
+};
+
+var alignedOutcomes = function alignedOutcomes(state, scope) {
+  return restrict(state, scope).get('alignedOutcomes') || List();
+};
+
+var openAlignmentId = function openAlignmentId(state, scope) {
+  return restrict(state, scope).get('openAlignmentId');
+};
+
+export var getAlignedOutcomes = createCachedSelector(alignedOutcomes, function (alignedOutcomes) {
+  return alignedOutcomes.toJS().sort(function (a, b) {
+    var titleA = a && a.title || 'ZZZZZZZZZZZZ'; // treat null as really large
+
+    var titleB = b && b.title || 'ZZZZZZZZZZZZ'; // treat null as really large
+
+    return titleA.localeCompare(titleB);
+  });
+})(function (_state, scope) {
+  return scope;
+});
+export var getAlignedOutcomeIds = createSelector(getAlignedOutcomes, function (outcomes) {
+  return outcomes.map(function (o) {
+    return o.id;
+  });
+});
+export function getAlignedOutcomeCount(state, scope) {
+  if (state && restrict(state, scope).get('alignedOutcomes')) {
+    return restrict(state, scope).get('alignedOutcomes').size;
+  }
+
+  return 0;
+}
+export var getAlignedOutcome = createSelector(function (state, scope, id) {
+  return getAlignedOutcomes(state, scope).find(function (o) {
+    return o.id === id;
+  });
+}, function (outcome) {
+  return outcome;
+});
+export function getAnyOutcome(state, scope, id) {
+  return getAlignedOutcome(state, scope, id) || getOutcome(state, scope, id);
+}
+export function getOutcomeAlignmentSetId(state, scope) {
+  return restrict(state, scope).get('alignmentSetId');
+}
+export var makeIsOpen = createCachedSelector(openAlignmentId, function (openAlignments) {
+  return function (id) {
+    return openAlignments === id;
+  };
+})(function (_state, scope) {
+  return scope;
+});

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

@@ -0,0 +1,19 @@
+import { Map } from 'immutable';
+import { expect } from 'chai';
+import reducerFactory from "../reducers.js";
+describe('config/reducers', function () {
+  describe('config', function () {
+    it('remains constant', function () {
+      var reducer = reducerFactory({
+        host: 'myhost',
+        jwt: 'myjwt'
+      });
+      var newState = reducer(Map(), {
+        type: 'foo',
+        payload: 'bar'
+      });
+      expect(newState.get('host')).to.equal('myhost');
+      expect(newState.get('jwt')).to.equal('myjwt');
+    });
+  });
+});

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

@@ -0,0 +1,22 @@
+import { expect } from 'chai';
+import { fromJS, Map } from 'immutable';
+import { getConfig } from "../selectors.js";
+describe('context/selectors', function () {
+  var state = fromJS({
+    scopeForTest: {
+      config: {
+        foo: 'bar'
+      }
+    }
+  });
+  describe('getConfig', function () {
+    it('retrieves the correct value', function () {
+      expect(getConfig(state, 'scopeForTest')).to.deep.equal({
+        foo: 'bar'
+      });
+    });
+    it('returns an empty object if no config present', function () {
+      expect(getConfig(Map(), 'scopeForTest')).to.deep.equal({});
+    });
+  });
+});

package/es/translated/vi/store/config/reducers.js

@@ -0,0 +1,9 @@
+import { fromJS } from 'immutable';
+
+var config = function config(conf) {
+  return function () {
+    return fromJS(conf);
+  };
+};
+
+export default config;

package/es/translated/vi/store/config/selectors.js

@@ -0,0 +1,10 @@
+import { Map } from 'immutable';
+import { createSelector } from 'reselect';
+
+function restrict(state, scope) {
+  return state.getIn([scope, 'config']) || Map();
+}
+
+export var getConfig = createSelector(restrict, function (config) {
+  return config.toJS();
+});

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

@@ -0,0 +1,301 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Map, fromJS } from 'immutable';
+import { SET_OUTCOMES, SET_ROOT_OUTCOME_IDS, SET_ERROR, SET_SCORING_METHOD } from "../../../constants.js";
+import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
+import * as actions from "../actions.js";
+var scopedActions = scopeActions(actions);
+var response = {
+  outcomes: [{
+    id: 1
+  }, {
+    id: 2
+  }],
+  root_ids: [1, 2]
+};
+var stateWithoutOutcomes = fromJS({
+  scopeForTest: {
+    config: {
+      contextUuid: 'course_100'
+    }
+  }
+});
+var stateWithOutcomes = fromJS({
+  context: {
+    outcomes: {
+      course_100: [{
+        id: 1
+      }]
+    },
+    rootOutcomeIds: {
+      course_100: [1]
+    }
+  },
+  scopeForTest: {
+    config: {
+      contextUuid: 'course_100'
+    }
+  }
+});
+describe('context/actions', function () {
+  describe('setOutcomes', function () {
+    it('creates an action', function () {
+      var action = actions.setOutcomes([]);
+      expect(action.type).to.equal(SET_OUTCOMES);
+      expect(action.payload).to.deep.equal([]);
+    });
+  });
+  describe('setRootOutcomeIds', function () {
+    it('creates an action', function () {
+      var action = actions.setRootOutcomeIds([]);
+      expect(action.type).to.equal(SET_ROOT_OUTCOME_IDS);
+      expect(action.payload).to.deep.equal([]);
+    });
+  });
+  describe('setError', function () {
+    it('creates an action', function () {
+      var action = actions.setError('foo');
+      expect(action.type).to.equal(SET_ERROR);
+      expect(action.payload).to.deep.equal('foo');
+    });
+  });
+  describe('setScoringMethod', function () {
+    it('creates an action', function () {
+      var payload = {
+        id: 1,
+        context_uuid: '',
+        scoring_method: {}
+      };
+      var action = actions.setScoringMethod(payload);
+      expect(action.type).to.equal(SET_SCORING_METHOD);
+      expect(action.payload).to.deep.equal(payload);
+    });
+  });
+  describe('loadOutcomes', function () {
+    it('does not call any actions when outcomes already loaded', function () {
+      var store = createMockStore(stateWithOutcomes);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(store.getActions()).to.have.length(0);
+        return null;
+      });
+    });
+    it('calls outcome service to load outcomes', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(service.loadOutcomes.calledOnce).to.be.true;
+        return null;
+      });
+    });
+    it('dispatches setOutcomes on outcome service success', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithoutOutcomes, service);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setOutcomes({
+          course_100: response.outcomes
+        }));
+        expect(store.getActions()[0].payload.root).to.be.present;
+        return null;
+      });
+    });
+    it('creates a root level outcome to store roots if root ids are present', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(store.getActions()[0].payload.root).to.be.present;
+        return null;
+      });
+    });
+    it('does not create a root level outcome if root ids are not present', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve({
+          outcomes: [{
+            id: 1
+          }, {
+            id: 2
+          }],
+          root_ids: []
+        }))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(store.getActions()[0].payload.root).not.to.be.present;
+        return null;
+      });
+    });
+    it('dispatches setRootOutcomeIds on outcome service success', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithoutOutcomes, service);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setRootOutcomeIds({
+          course_100: response.root_ids
+        }));
+        return null;
+      });
+    });
+    it('dispatches setError on outcome service failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadRootOutcomes()).then(function () {
+        expect(store.getActions()).to.have.length(2);
+        expect(store.getActions()[1]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+  });
+  describe('loadMoreOutcomes', function () {
+    it('calls loadOutcomes for unloaded children', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithOutcomes, service);
+      return store.dispatch(actions.loadMoreOutcomes('1')).then(function () {
+        expect(service.loadOutcomes.calledOnce).to.be.true;
+        expect(service.loadOutcomes.args[0][3]).to.deep.equal(['1']);
+        return null;
+      });
+    });
+    it('adds its outcomes to the state', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithOutcomes, service);
+      return store.dispatch(actions.loadMoreOutcomes('1')).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setOutcomes({
+          course_100: response.outcomes
+        }));
+        return null;
+      });
+    });
+    it('does not add its root ids to the state', function () {
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithoutOutcomes, service);
+      return store.dispatch(actions.loadMoreOutcomes('1')).then(function () {
+        expect(store.getActions()).not.to.deep.include(scopedActions.setRootOutcomeIds({
+          course_100: response.root_ids
+        }));
+        return null;
+      });
+    });
+    it('dispatches setError on outcome service failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        loadOutcomes: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadMoreOutcomes('12')).then(function () {
+        expect(store.getActions()).to.have.length(2);
+        expect(store.getActions()[1]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+  });
+  describe('loadContext', function () {
+    var response = {
+      id: 1
+    };
+    var stateWithoutContext = fromJS({
+      context: {
+        contexts: {}
+      }
+    });
+    var stateWithContext = fromJS({
+      context: {
+        contexts: {
+          '1': {
+            loading: false,
+            data: {
+              id: 1
+            }
+          }
+        }
+      }
+    });
+    var stateWithContextLoading = fromJS({
+      context: {
+        contexts: {
+          '1': {
+            loading: true
+          }
+        }
+      }
+    });
+    it('calls getContext for unloaded children', function () {
+      var service = {
+        getContext: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithoutContext, service);
+      return store.dispatch(actions.loadContext('host', 'jwt', '1')).then(function () {
+        expect(service.getContext.calledOnce).to.be.true;
+        expect(service.getContext.args[0][2]).to.equal('1');
+        return null;
+      });
+    });
+    it('adds its context to the state', function () {
+      var service = {
+        getContext: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithoutContext, service);
+      return store.dispatch(actions.loadContext('host', 'jwt', '1')).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setContext({
+          '1': {
+            loading: false,
+            data: response
+          }
+        }));
+        return null;
+      });
+    });
+    it('does not calls service when its already loaded', function () {
+      var service = {
+        getContext: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithContext, service);
+      return store.dispatch(actions.loadContext('host', 'jwt', '1')).then(function () {
+        expect(store.getActions().length).to.be.equal(0);
+        return null;
+      });
+    });
+    it('does not calls service when its loading', function () {
+      var service = {
+        getContext: sinon.stub().returns(Promise.resolve(response))
+      };
+      var store = createMockStore(stateWithContextLoading, service);
+      return store.dispatch(actions.loadContext('host', 'jwt', '1')).then(function () {
+        expect(store.getActions().length).to.be.equal(0);
+        return null;
+      });
+    });
+    it('dispatches setError on service failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        getContext: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadContext('host', 'jwt', '12')).then(function () {
+        expect(store.getActions()).to.have.length(3);
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+  });
+});

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

@@ -0,0 +1,138 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { fromJS } from 'immutable';
+import { expect } from 'chai';
+import { SET_OUTCOMES, SET_SCORING_METHOD, SET_ROOT_OUTCOME_IDS, SET_CONTEXT } from "../../../constants.js";
+import reducer from "../reducers.js";
+describe('context/reducers', function () {
+  var reduce = function reduce(state, type, payload) {
+    return reducer(state, {
+      type: type,
+      payload: payload
+    });
+  };
+
+  var state = fromJS({
+    contexts: {
+      1: {
+        loading: false,
+        data: {
+          id: 1,
+          key: 'foo'
+        }
+      }
+    },
+    outcomes: {
+      course_100: {
+        10: {
+          id: 10,
+          label: 'foo',
+          title: 'bar'
+        },
+        11: {
+          id: 11,
+          label: 'baz',
+          title: 'bat'
+        }
+      }
+    },
+    rootOutcomeIds: {
+      course_100: [1, 2, 3]
+    }
+  });
+  describe('outcomes', function () {
+    it('is merged with SET_OUTCOMES', function () {
+      var newOutcomes = {
+        course_100: {
+          100: {
+            id: 100,
+            label: 'blue',
+            title: 'green'
+          },
+          200: {
+            id: 200,
+            label: 'yellow',
+            title: 'red'
+          }
+        }
+      };
+      var newState = reduce(state, SET_OUTCOMES, newOutcomes);
+      expect(newState.getIn(['outcomes', 'course_100']).toJS()).to.deep.equal(_objectSpread(_objectSpread({}, state.toJS().outcomes.course_100), newOutcomes.course_100));
+    });
+    it('does not replace other context outcomes', function () {
+      var newOutcomes = {
+        course_101: [{
+          id: 100,
+          label: 'blue',
+          title: 'green'
+        }, {
+          id: 200,
+          label: 'yellow',
+          title: 'red'
+        }]
+      };
+      var newState = reduce(state, SET_OUTCOMES, newOutcomes);
+      expect(Object.keys(newState.get('outcomes').toJS()).length).to.equal(2);
+    });
+    it('sets the scoring method on SET_SCORING_METHOD', function () {
+      var request = {
+        context_uuid: 'course_100',
+        id: 10,
+        scoring_method: {
+          points_possible: 5
+        }
+      };
+      var newState = reduce(state, SET_SCORING_METHOD, request);
+      expect(newState.getIn(['outcomes', 'course_100', 10, 'scoring_method', 'points_possible'])).to.equal(5);
+    });
+  });
+  describe('rootOutcomeIds', function () {
+    it('is replaced by SET_ROOT_OUTCOME_IDS', function () {
+      var newState = reduce(state, SET_ROOT_OUTCOME_IDS, {
+        course_100: [4, 5, 6]
+      });
+      expect(newState.get('rootOutcomeIds').toJS()).to.deep.equal({
+        course_100: [4, 5, 6]
+      });
+    });
+    it('does not replace other context root outcome ids', function () {
+      var newState = reduce(state, SET_ROOT_OUTCOME_IDS, {
+        course_101: [7, 8, 9]
+      });
+      expect(Object.keys(newState.get('rootOutcomeIds').toJS()).length).to.equal(2);
+    });
+  });
+  describe('contexts', function () {
+    it('is replaced by SET_CONTEXT', function () {
+      var newState = reduce(state, SET_CONTEXT, {
+        1: {
+          loading: false,
+          data: {
+            id: 1,
+            key: 'bar'
+          }
+        }
+      });
+      expect(newState.get('contexts').toJS()).to.deep.equal({
+        1: {
+          loading: false,
+          data: {
+            id: 1,
+            key: 'bar'
+          }
+        }
+      });
+    });
+    it('does not replace other context', function () {
+      var newState = reduce(state, SET_CONTEXT, {
+        2: {
+          loading: false,
+          data: {
+            id: 2,
+            key: 'bar'
+          }
+        }
+      });
+      expect(Object.keys(newState.get('contexts').toJS()).length).to.equal(2);
+    });
+  });
+});