@instructure/outcomes-ui 3.1.0 → 3.2.0

package/es/translated/nb-x-k12/store/OutcomePicker/actions.js

@@ -1,15 +1,14 @@
 import { createAction } from 'redux-actions';
 import { CALL_SERVICE } from '@instructure/redux-service-middleware';
 import { getConfig } from "../config/selectors.js";
-import { SELECT_OUTCOME_IDS, UNSELECT_OUTCOME_IDS, SET_SELECTED_OUTCOME_IDS, SET_OUTCOME_PICKER_STATE, SET_FOCUSED_OUTCOME, SET_ACTIVE_COLLECTION_ID, TOGGLE_EXPANDED_IDS, RESET_OUTCOME_PICKER, SET_SHARED_CONTEXTS, SET_SELECTED_SHARED_CONTEXT, RESET_EXPANDED_IDS } from "../../constants.js";
+import { SELECT_OUTCOME_IDS, UNSELECT_OUTCOME_IDS, SET_SELECTED_OUTCOME_IDS, SET_OUTCOME_PICKER_STATE, SET_FOCUSED_OUTCOME, SET_ACTIVE_COLLECTION_ID, TOGGLE_EXPANDED_IDS, RESET_OUTCOME_PICKER, SET_SELECTED_LAUNCH_CONTEXT, RESET_EXPANDED_IDS } from "../../constants.js";
 import { loadRootOutcomes, loadMoreOutcomes, setError, setScoringMethod } from "../context/actions.js";
-import { getAlignedOutcomeIds, getAnyOutcome } from "../alignments/selectors.js";
-import { getSelectedOutcomeIds, getOutcomePickerState, getSelectedSharedContext, getSharedContexts } from "./selectors.js";
+import { getAlignedOutcomeIds, getAnyOutcome, getLaunchContexts } from "../alignments/selectors.js";
+import { getSelectedOutcomeIds, getOutcomePickerState, getSelectedLaunchContext } from "./selectors.js";
 import { createAlignmentSet, updateAlignments, upsertArtifact } from "../alignments/actions.js";
 import { setScope } from "../activePicker/actions.js";
 import { Set } from 'immutable';
-export var setSharedContexts = createAction(SET_SHARED_CONTEXTS);
-export var setSelectedSharedContext = createAction(SET_SELECTED_SHARED_CONTEXT);
+export var setSelectedLaunchContext = createAction(SET_SELECTED_LAUNCH_CONTEXT);
 export var selectOutcomeIds = createAction(SELECT_OUTCOME_IDS);
 export var deselectOutcomeIds = createAction(UNSELECT_OUTCOME_IDS);
 export var setSelectedOutcomeIds = createAction(SET_SELECTED_OUTCOME_IDS);
@@ -19,26 +18,20 @@ export var setFocusedOutcomeAction = createAction(SET_FOCUSED_OUTCOME);
 export var toggleExpandedIds = createAction(TOGGLE_EXPANDED_IDS);
 export var resetExpandedIds = createAction(RESET_EXPANDED_IDS);
 export var resetOutcomePicker = createAction(RESET_OUTCOME_PICKER);
-export var loadSharedContexts = function loadSharedContexts(sharedContexts) {
-  return function (dispatch, _getState) {
-    return dispatch(setSharedContexts(sharedContexts));
-  };
-};
-export var loadSelectedSharedContext = function loadSelectedSharedContext() {
+export var loadSelectedLaunchContext = function loadSelectedLaunchContext() {
   return function (dispatch, getState, _arg, scope) {
-    var selected = getSelectedSharedContext(getState(), scope);
-    var sharedContexts = getSharedContexts(getState(), scope);
-    if (sharedContexts === null || selected) {
+    var selected = getSelectedLaunchContext(getState(), scope);
+    var launchContexts = getLaunchContexts(getState(), scope);
+    if (launchContexts === null || selected) {
       return Promise.resolve();
     }
-    return dispatch(setSelectedSharedContext(sharedContexts[0]));
+    return dispatch(setSelectedLaunchContext(launchContexts[0]));
   };
 };
-export var loadOutcomePicker = function loadOutcomePicker(sharedContexts) {
+export var loadOutcomePicker = function loadOutcomePicker() {
   return function (dispatch, getState, _arg, scope) {
     dispatch(setOutcomePickerState('loading'));
-    dispatch(loadSharedContexts(sharedContexts));
-    dispatch(loadSelectedSharedContext());
+    dispatch(loadSelectedLaunchContext());
     return dispatch(loadRootOutcomes()).then(function () {
       return dispatch(setSelectedOutcomeIds(getAlignedOutcomeIds(getState(), scope)));
     }).then(function () {
@@ -48,10 +41,10 @@ export var loadOutcomePicker = function loadOutcomePicker(sharedContexts) {
     }); // allows chaining other thunks
   };
 };
-export var changeSelectedSharedContext = function changeSelectedSharedContext(newSelectedSharedContext) {
+export var changeSelectedLaunchContext = function changeSelectedLaunchContext(newSelectedLaunchContext) {
   return function (dispatch, getState, _arg, scope) {
     dispatch(setOutcomePickerState('loading'));
-    dispatch(setSelectedSharedContext(newSelectedSharedContext));
+    dispatch(setSelectedLaunchContext(newSelectedLaunchContext));
     // Reset activeCollection and expanded ids since we are moving to another context hierarchy
     dispatch(setActiveCollectionFrd(null));
     dispatch(resetExpandedIds(Set()));
@@ -78,7 +71,7 @@ export var setFocusedOutcome = function setFocusedOutcome(outcome) {
       host = _getConfig.host,
       jwt = _getConfig.jwt,
       contextUuid = _getConfig.contextUuid;
-    var selected = getSelectedSharedContext(getState(), scope);
+    var selected = getSelectedLaunchContext(getState(), scope);
     var context = (selected === null || selected === void 0 ? void 0 : selected.uuid) || contextUuid;
     // First dispatch brings up the outcome view,
     // second dispatch provides the scoring method
@@ -106,12 +99,15 @@ export var saveOutcomePickerAlignments = function saveOutcomePickerAlignments(up
     dispatch(setOutcomePickerState('saving'));
     var state = getState();
     var outcomeIds = getSelectedOutcomeIds(state, scope);
-    var outcomes = outcomeIds.map(function (id) {
-      return getAnyOutcome(state, scope, id);
-    });
     var updateAlignmentFunc = shouldUpdateArtifact ? upsertArtifact : createAlignmentSet;
     return dispatch(updateAlignmentFunc(outcomeIds)).then(function (response) {
-      return dispatch(updateAlignments(response.guid, outcomes, updateCallback));
+      if (shouldUpdateArtifact) {
+        var outcomes = outcomeIds.map(function (id) {
+          return getAnyOutcome(state, scope, id);
+        });
+        return dispatch(updateAlignments(response.guid, outcomes, updateCallback));
+      }
+      return dispatch(updateAlignments(response.guid, response.outcomes, updateCallback));
     }).then(function () {
       return dispatch(setOutcomePickerState('complete'));
     }).catch(function (err) {

package/es/translated/nb-x-k12/store/OutcomePicker/reducers.js

@@ -6,13 +6,8 @@ import { RESET_OUTCOME_PICKER } from "../../constants.js";
 import { resetExpandedIds, setFocusedOutcomeAction, toggleExpandedIds } from "./actions.js";
 import search from "../search/reducers.js";
 import tray from "../OutcomeTray/reducers.js";
-var sharedContexts = handleActions({
-  SET_SHARED_CONTEXTS: function SET_SHARED_CONTEXTS(state, action) {
-    return fromJS(action.payload);
-  }
-}, null);
-var selectedSharedContext = handleActions({
-  SET_SELECTED_SHARED_CONTEXT: function SET_SELECTED_SHARED_CONTEXT(state, action) {
+var selectedLaunchContext = handleActions({
+  SET_SELECTED_LAUNCH_CONTEXT: function SET_SELECTED_LAUNCH_CONTEXT(state, action) {
     return fromJS(action.payload);
   }
 }, null);
@@ -54,8 +49,7 @@ var state = handleActions({
   }
 }, 'closed');
 var OutcomePickerReducer = combineReducers({
-  sharedContexts: sharedContexts,
-  selectedSharedContext: selectedSharedContext,
+  selectedLaunchContext: selectedLaunchContext,
   state: state,
   selected: selected,
   focusedOutcome: focusedOutcome,

package/es/translated/nb-x-k12/store/OutcomePicker/selectors.js

@@ -31,15 +31,10 @@ export var makeIsOutcomeSelected = createCachedSelector(selectedOutcomeIds, func
 })(function (_state, scope) {
   return scope;
 });
-export var getSharedContexts = createSelector(function (state, scope) {
-  return restrict(state, scope).get('sharedContexts');
-}, function (sharedContexts) {
-  return sharedContexts ? sharedContexts.toJS() : null;
-});
-export var getSelectedSharedContext = createSelector(function (state, scope) {
-  return restrict(state, scope).get('selectedSharedContext');
-}, function (selectedSharedContext) {
-  return selectedSharedContext ? selectedSharedContext.toJS() : null;
+export var getSelectedLaunchContext = createSelector(function (state, scope) {
+  return restrict(state, scope).get('selectedLaunchContext');
+}, function (selectedLaunchContext) {
+  return selectedLaunchContext ? selectedLaunchContext.toJS() : null;
 });
 export function anyOutcomeSelected(state, scope) {
   var ids = restrict(state, scope).get('selected');

package/es/translated/nb-x-k12/store/alignments/__tests__/actions.test.js

@@ -180,6 +180,26 @@ describe('alignments/actions', function () {
         return null;
       });
     });
+    it('calls outcome service with launchContext to load alignments', function () {
+      var service = {
+        getAlignments: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(Map(fromJS({
+        scopeForTest: {
+          alignments: {
+            launchContexts: [{
+              uuid: 'foo',
+              name: 'Dave University'
+            }]
+          }
+        }
+      })), service);
+      return store.dispatch(actions.loadAlignments('hexadecimal')).then(function () {
+        expect(service.getAlignments.calledOnce).to.be.true;
+        expect(service.getAlignments.getCall(0).args).to.include('foo');
+        return null;
+      });
+    });
     it('dispatches setError on outcome service failure', function () {
       var error = {
         message: 'foo bar baz'
@@ -253,7 +273,36 @@ describe('alignments/actions', function () {
       }), service);
       return store.dispatch(actions.removeAlignment('12')).then(function () {
         expect(service.createAlignmentSet.calledOnce).to.be.true;
-        expect(service.createAlignmentSet.calledWith([]));
+        expect(service.createAlignmentSet.getCall(0).args[2]).to.deep.equal(['1']);
+        return null;
+      });
+    });
+    it('calls outcomes service to create new alignment set with launch context', function () {
+      var service = {
+        createAlignmentSet: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }, {
+              id: '12'
+            }],
+            launchContexts: [{
+              uuid: 'foo',
+              name: 'bar'
+            }, {
+              uuid: 'fuz',
+              name: 'baz'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.removeAlignment('12')).then(function () {
+        expect(service.createAlignmentSet.calledOnce).to.be.true;
+        expect(service.createAlignmentSet.getCall(0).args[2]).to.deep.equal(['1']);
+        expect(service.createAlignmentSet.getCall(0).args[3]).to.deep.equal('fuz');
         return null;
       });
     });

package/es/translated/nb-x-k12/store/alignments/__tests__/selectors.test.js

@@ -1,18 +1,18 @@
 import { expect } from 'chai';
 import { Map, fromJS } from 'immutable';
-import { getAlignedOutcomeIds, getAlignedOutcomes, getAlignedOutcome, getAlignedOutcomeCount, getAnyOutcome, makeIsOpen } from "../selectors.js";
+import { getAlignedOutcomeIds, getAlignedOutcomes, getAlignedOutcome, getAlignedOutcomeCount, getAnyOutcome, makeIsOpen, getLaunchContextUuid, getRootAccountContextUuid, isLaunchingFromRootAccount } 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: '101',
+          label: 'l1',
+          title: 't2'
         }, {
           id: '103',
           label: 'l3',
@@ -118,16 +118,16 @@ describe('alignments/selectors', function () {
       var outcome = getAnyOutcome(state, 'scopeForTest', '1');
       expect(outcome.label).to.equal('l1');
     });
-    it('can pull outcomes from sharedContext outcomes', function () {
+    it('can pull outcomes from launchContext outcomes', function () {
       var state = fromJS({
         scopeForTest: {
           config: {
             contextUuid: 'course_100'
           },
-          OutcomePicker: {
-            sharedContexts: [{
-              uuid: 'sharedContext',
-              name: 'sharedContext'
+          alignments: {
+            launchContexts: [{
+              uuid: 'launchContext',
+              name: 'LaunchContext'
             }]
           }
         },
@@ -141,7 +141,7 @@ describe('alignments/selectors', function () {
                 child_ids: ['2', '3']
               }
             },
-            sharedContext: {
+            launchContext: {
               4: {
                 id: 4,
                 label: 'l4',
@@ -161,4 +161,41 @@ describe('alignments/selectors', function () {
       expect(outcome).to.be.null;
     });
   });
+  describe('launchContexts', function () {
+    var scope = 'scopeForTest';
+    function setLaunchContexts(state, launchContexts) {
+      return state.setIn([scope, 'alignments', 'launchContexts'], fromJS(launchContexts));
+    }
+    it('is null if launchContexts is null', function () {
+      expect(getLaunchContextUuid(state, scope)).to.deep.equal(null);
+    });
+    it('is null if launchContexts is empty', function () {
+      var launchContexts = [];
+      var newState = setLaunchContexts(state, launchContexts);
+      expect(getLaunchContextUuid(newState, scope)).to.deep.equal(null);
+    });
+    it('is only element if launchContexts has one element', function () {
+      var launchContexts = [{
+        uuid: 'foo',
+        name: 'bar'
+      }];
+      var newState = setLaunchContexts(state, launchContexts);
+      expect(getLaunchContextUuid(newState, scope)).to.deep.equal('foo');
+      expect(getRootAccountContextUuid(newState, scope)).to.deep.equal('foo');
+      expect(isLaunchingFromRootAccount(newState, scope)).to.equal(true);
+    });
+    it('is last if launchContexts has multiple entries', function () {
+      var launchContexts = [{
+        uuid: 'foo',
+        name: 'bar'
+      }, {
+        uuid: 'fuz',
+        name: 'baz'
+      }];
+      var newState = setLaunchContexts(state, launchContexts);
+      expect(getLaunchContextUuid(newState, scope)).to.deep.equal('fuz');
+      expect(getRootAccountContextUuid(newState, scope)).to.deep.equal('foo');
+      expect(isLaunchingFromRootAccount(newState, scope)).to.equal(false);
+    });
+  });
 });

package/es/translated/nb-x-k12/store/alignments/actions.js

@@ -1,16 +1,23 @@
 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 { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT, SET_LAUNCH_CONTEXTS } from "../../constants.js";
+import { getAlignedOutcomeIds, getAlignedOutcome, getOutcomeAlignmentSetId, getLaunchContextUuid, isLaunchingFromRootAccount } from "./selectors.js";
 import { getConfig } from "../config/selectors.js";
 import { setError } from "../context/actions.js";
+import { loadSelectedLaunchContext } from "../OutcomePicker/actions.js";
 /*
  * action creators
  */
+export var setLaunchContexts = createAction(SET_LAUNCH_CONTEXTS);
 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 loadLaunchContexts = function loadLaunchContexts(launchContexts) {
+  return function (dispatch, _getState) {
+    return dispatch(setLaunchContexts(launchContexts));
+  };
+};
 export var viewAlignment = function viewAlignment(outcomeId) {
   return function (dispatch, getState, _arg, scope) {
     var outcome = getAlignedOutcome(getState(), scope, outcomeId);
@@ -51,22 +58,28 @@ export var updateAlignments = function updateAlignments(guid, outcomes, updateCa
     return Promise.resolve();
   };
 };
-export var loadAlignments = function loadAlignments(alignmentSetId, updateCallback) {
+export var loadAlignments = function loadAlignments(alignmentSetId, launchContexts, updateCallback) {
   return function (dispatch, getState, _arg, scope) {
     if (alignmentSetId && getOutcomeAlignmentSetId(getState(), scope) === alignmentSetId) {
       return Promise.resolve();
     }
+    if (launchContexts) {
+      dispatch(loadLaunchContexts(launchContexts));
+      dispatch(loadSelectedLaunchContext());
+    }
     var _getConfig2 = getConfig(getState(), scope),
       host = _getConfig2.host,
       jwt = _getConfig2.jwt,
       contextUuid = _getConfig2.contextUuid;
+    var launchContext = getLaunchContextUuid(getState(), scope);
+    var launchingFromRoot = isLaunchingFromRootAccount(getState(), scope);
     return dispatch(clearAlignmentSet()).then(function () {
       return dispatch({
         type: CALL_SERVICE,
         payload: {
           service: 'outcomes',
           method: 'getAlignments',
-          args: [host, jwt, alignmentSetId, contextUuid]
+          args: [host, jwt, alignmentSetId, contextUuid, launchContext, launchingFromRoot]
         }
       });
     }).then(function (json) {
@@ -87,10 +100,13 @@ export var removeAlignment = function removeAlignment(alignmentId, updateCallbac
     }
     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));
+      if (shouldUpdateArtifact) {
+        var newOutcomes = newIds.map(function (id) {
+          return getAlignedOutcome(getState(), scope, id);
+        });
+        return dispatch(updateAlignments(response.guid, newOutcomes, updateCallback));
+      }
+      return dispatch(updateAlignments(response.guid, response.outcomes, updateCallback));
     }).catch(function (e) {
       return dispatch(setError(e));
     });
@@ -101,12 +117,14 @@ export var createAlignmentSet = function createAlignmentSet(outcomeIds) {
     var _getConfig3 = getConfig(getState(), scope),
       host = _getConfig3.host,
       jwt = _getConfig3.jwt;
+    var launchContext = getLaunchContextUuid(getState(), scope);
+    var launchingFromRoot = isLaunchingFromRootAccount(getState(), scope);
     return dispatch({
       type: CALL_SERVICE,
       payload: {
         service: 'outcomes',
         method: 'createAlignmentSet',
-        args: [host, jwt, outcomeIds]
+        args: [host, jwt, outcomeIds, launchContext, launchingFromRoot]
       }
     });
   };

package/es/translated/nb-x-k12/store/alignments/reducers.js

@@ -17,6 +17,11 @@ var alignedOutcomes = handleActions({
     return state.set(idx, Map(outcome));
   }
 }, List());
+var launchContexts = handleActions({
+  SET_LAUNCH_CONTEXTS: function SET_LAUNCH_CONTEXTS(state, action) {
+    return fromJS(action.payload);
+  }
+}, null);
 var openAlignmentId = handleActions({
   VIEW_ALIGNMENT: function VIEW_ALIGNMENT(state, action) {
     return action.payload;
@@ -32,6 +37,7 @@ var alignmentSetId = handleActions({
 }, null);
 export default combineReducers({
   alignedOutcomes: alignedOutcomes,
+  launchContexts: launchContexts,
   openAlignmentId: openAlignmentId,
   alignmentSetId: alignmentSetId
 });

package/es/translated/nb-x-k12/store/alignments/selectors.js

@@ -3,7 +3,6 @@ import { Map, List } from 'immutable';
 import { createSelector } from 'reselect';
 import createCachedSelector from 're-reselect';
 import { getOutcome } from "../context/selectors.js";
-import { getSharedContexts } from "../OutcomePicker/selectors.js";
 var restrict = function restrict(state, scope) {
   return state.getIn([scope, 'alignments']) || Map();
 };
@@ -13,12 +12,44 @@ var alignedOutcomes = function alignedOutcomes(state, scope) {
 var openAlignmentId = function openAlignmentId(state, scope) {
   return restrict(state, scope).get('openAlignmentId');
 };
+
+/**
+ * LaunchContexts will be a list of at most 2 elements. It is only populated when we are aligning
+ * outcomes to items in banks. The first element will always represent the root account context.
+ * The second will be the context that the current user is in (root account, sub-account, or course).
+ */
+export var getLaunchContexts = createSelector(function (state, scope) {
+  return restrict(state, scope).get('launchContexts');
+}, function (launchContexts) {
+  return (launchContexts === null || launchContexts === void 0 ? void 0 : launchContexts.toJS()) || null;
+});
+
+/**
+ * This returns the last element in the list of launch contexts. This will be equivalent to the
+ * context that the current user is in (root account, sub-account, or course).
+ */
+export function getLaunchContextUuid(state, scope) {
+  var _launchContexts$slice;
+  var launchContexts = getLaunchContexts(state, scope);
+  return (launchContexts === null || launchContexts === void 0 ? void 0 : (_launchContexts$slice = launchContexts.slice(-1)[0]) === null || _launchContexts$slice === void 0 ? void 0 : _launchContexts$slice.uuid) || null;
+}
+
+/**
+ * This returns the first element in the list of launch contexts. This will be equivalent to the
+ * root account context.
+ */
+export function getRootAccountContextUuid(state, scope) {
+  var _launchContexts$slice2;
+  var launchContexts = getLaunchContexts(state, scope);
+  return (launchContexts === null || launchContexts === void 0 ? void 0 : (_launchContexts$slice2 = launchContexts.slice(0)[0]) === null || _launchContexts$slice2 === void 0 ? void 0 : _launchContexts$slice2.uuid) || null;
+}
+export function isLaunchingFromRootAccount(state, scope) {
+  var rootAccountContextUuid = getRootAccountContextUuid(state, scope);
+  var launchContextUuid = getLaunchContextUuid(state, scope);
+  return rootAccountContextUuid && rootAccountContextUuid === launchContextUuid;
+}
 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);
-  });
+  return alignedOutcomes.toJS();
 })(function (_state, scope) {
   return scope;
 });
@@ -41,14 +72,14 @@ export var getAlignedOutcome = createSelector(function (state, scope, id) {
   return outcome;
 });
 function getOutcomeFromAnyContext(state, scope, id) {
-  var sharedContexts = getSharedContexts(state, scope);
-  if (sharedContexts) {
-    var _iterator = _createForOfIteratorHelper(sharedContexts),
+  var launchContexts = getLaunchContexts(state, scope);
+  if (launchContexts) {
+    var _iterator = _createForOfIteratorHelper(launchContexts),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var sharedContext = _step.value;
-        var uuid = sharedContext.uuid;
+        var launchContext = _step.value;
+        var uuid = launchContext.uuid;
         var o = state.getIn(['context', 'outcomes', uuid, id.toString()]);
         if (o) {
           return o.toJS();

package/es/translated/nb-x-k12/store/context/__tests__/actions.test.js

@@ -37,12 +37,12 @@ var stateWithOutcomes = fromJS({
     }
   }
 });
-var stateWithSelectedSharedContext = stateWithOutcomes.merge({
+var stateWithSelectedLaunchContext = stateWithOutcomes.merge({
   scopeForTest: {
     OutcomePicker: {
-      selectedSharedContext: {
-        uuid: 'selectedSharedContext',
-        name: 'selectedSharedContext'
+      selectedLaunchContext: {
+        uuid: 'selectedLaunchContext',
+        name: 'selectedLaunchContext'
       }
     }
   }
@@ -101,14 +101,14 @@ describe('context/actions', function () {
         return null;
       });
     });
-    it('calls outcome service to load outcomes with selected shared context', function () {
+    it('calls outcome service to load outcomes with selected launch context', function () {
       var service = {
         loadOutcomes: sinon.stub().returns(Promise.resolve(response))
       };
-      var store = createMockStore(stateWithSelectedSharedContext, service);
+      var store = createMockStore(stateWithSelectedLaunchContext, service);
       return store.dispatch(actions.loadRootOutcomes()).then(function () {
         expect(service.loadOutcomes.calledOnce).to.be.true;
-        expect(service.loadOutcomes.getCall(0).args).to.include('selectedSharedContext');
+        expect(service.loadOutcomes.getCall(0).args).to.include('selectedLaunchContext');
         return null;
       });
     });
@@ -125,14 +125,14 @@ describe('context/actions', function () {
         return null;
       });
     });
-    it('dispatches setOutcomes on outcome service success with selected shared context', function () {
+    it('dispatches setOutcomes on outcome service success with selected launch context', function () {
       var service = {
         loadOutcomes: sinon.stub().returns(Promise.resolve(response))
       };
-      var store = createMockStore(stateWithSelectedSharedContext, service);
+      var store = createMockStore(stateWithSelectedLaunchContext, service);
       return store.dispatch(actions.loadRootOutcomes()).then(function () {
         expect(store.getActions()).to.deep.include(scopedActions.setOutcomes({
-          selectedSharedContext: response.outcomes
+          selectedLaunchContext: response.outcomes
         }));
         expect(store.getActions()[0].payload.root).to.be.present;
         return null;
@@ -205,14 +205,14 @@ describe('context/actions', function () {
         return null;
       });
     });
-    it('calls loadOutcomes for unloaded children when shared context is selected', function () {
+    it('calls loadOutcomes for unloaded children when launch context is selected', function () {
       var service = {
         loadOutcomes: sinon.stub().returns(Promise.resolve(response))
       };
-      var store = createMockStore(stateWithSelectedSharedContext, service);
+      var store = createMockStore(stateWithSelectedLaunchContext, service);
       return store.dispatch(actions.loadMoreOutcomes('1')).then(function () {
         expect(service.loadOutcomes.calledOnce).to.be.true;
-        expect(service.loadOutcomes.args[0][contextUuidIndex]).to.deep.equal('selectedSharedContext');
+        expect(service.loadOutcomes.args[0][contextUuidIndex]).to.deep.equal('selectedLaunchContext');
         expect(service.loadOutcomes.args[0][outcomeIdsIndex]).to.deep.equal(['1']);
         return null;
       });
@@ -229,14 +229,14 @@ describe('context/actions', function () {
         return null;
       });
     });
-    it('adds its outcomes to the state under the selected shared context', function () {
+    it('adds its outcomes to the state under the selected launch context', function () {
       var service = {
         loadOutcomes: sinon.stub().returns(Promise.resolve(response))
       };
-      var store = createMockStore(stateWithSelectedSharedContext, service);
+      var store = createMockStore(stateWithSelectedLaunchContext, service);
       return store.dispatch(actions.loadMoreOutcomes('1')).then(function () {
         expect(store.getActions()).to.deep.include(scopedActions.setOutcomes({
-          selectedSharedContext: response.outcomes
+          selectedLaunchContext: response.outcomes
         }));
         return null;
       });

package/es/translated/nb-x-k12/store/context/__tests__/selectors.test.js

@@ -36,7 +36,7 @@ describe('context/selectors', function () {
             title: 't4'
           }
         },
-        selectedSharedContext: {
+        selectedLaunchContext: {
           5: {
             id: 5,
             label: 'l5',
@@ -57,12 +57,12 @@ describe('context/selectors', function () {
       }
     }
   });
-  var stateWithSelectedSharedContext = state.merge({
+  var stateWithSelectedLaunchContext = state.merge({
     scopeForTest: {
       OutcomePicker: {
-        selectedSharedContext: {
-          uuid: 'selectedSharedContext',
-          name: 'selectedSharedContext'
+        selectedLaunchContext: {
+          uuid: 'selectedLaunchContext',
+          name: 'selectedLaunchContext'
         }
       }
     }
@@ -116,11 +116,11 @@ describe('context/selectors', function () {
     it('returns null if not present', function () {
       expect(getOutcome(state, scope, '10')).to.be.null;
     });
-    it('returns null if not present in the selected shared context', function () {
-      expect(getOutcome(stateWithSelectedSharedContext, scope, '3')).to.be.null;
+    it('returns null if not present in the selected launch context', function () {
+      expect(getOutcome(stateWithSelectedLaunchContext, scope, '3')).to.be.null;
     });
-    it('retrieves the correct value from the selected shared context', function () {
-      expect(getOutcome(stateWithSelectedSharedContext, scope, '5')).to.have.property('id', 5);
+    it('retrieves the correct value from the selected launch context', function () {
+      expect(getOutcome(stateWithSelectedLaunchContext, scope, '5')).to.have.property('id', 5);
     });
   });
   describe('getRootOutcomeIds', function () {