@instructure/outcomes-ui 2.1.2 → 2.1.3

package/es/translated/vi/store/index.js

@@ -0,0 +1,111 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { createStore as reduxCreateStore, applyMiddleware, compose as reduxCompose } from 'redux';
+import { combineReducers } from 'redux-immutable';
+import thunkMiddleware from 'redux-thunk';
+import { createLogger } from 'redux-logger';
+import serviceMiddleware from '@instructure/redux-service-middleware';
+import multireducer from 'multireducer/immutable';
+import OutcomesService from "../services/OutcomesService.js";
+import context from "./context/reducers.js";
+import config from "./config/reducers.js";
+import { loadFeatures } from "./features/actions.js";
+import { loadContext } from "./context/actions.js";
+import features from "./features/reducers.js";
+import OutcomePicker from "./OutcomePicker/reducers.js";
+import alignments from "./alignments/reducers.js";
+import report from "./report/reducers.js";
+import activePicker from "./activePicker/reducers.js";
+/**
+ * The outcomes redux store is shared between components on a page.
+ * The shape has the form:
+ *    OutcomePicker:
+ *    context:
+ *    quiz:::99:
+ *      alignments
+ *    question:::100:
+ *      alignments
+ *    ...
+ *
+ * When a new component retrieves the store using getStore,
+ * its scope (artifactType:::artifactId) is added to the
+ * store's shape via `dynamicReducers` if necessary.
+ */
+
+export function makeScope(artifactType, artifactId) {
+  return "".concat(artifactType, ":::").concat(artifactId);
+}
+export function makeUserScope(artifactType, artifactId, userUuid) {
+  if (userUuid === null) {
+    return null;
+  }
+
+  return "user::".concat(artifactType, ":").concat(artifactId, ":").concat(userUuid);
+}
+var dynamicReducers = {};
+
+function createRootReducer() {
+  return combineReducers(_objectSpread({
+    context: context,
+    features: features,
+    activePicker: activePicker
+  }, dynamicReducers));
+}
+
+function createStore() {
+  var loggerMiddleware = createLogger({
+    stateTransformer: function stateTransformer(state) {
+      return state.toJS();
+    }
+  });
+  var services = serviceMiddleware({
+    outcomes: new OutcomesService()
+  });
+  var compose = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || reduxCompose;
+  var dev = process.env.NODE_ENV === 'development';
+  var devMiddleware = applyMiddleware(thunkMiddleware, loggerMiddleware, services);
+  var prodMiddleware = applyMiddleware(thunkMiddleware, services);
+  var middleware = dev ? devMiddleware : prodMiddleware;
+  return reduxCreateStore(createRootReducer(), void 0, compose(middleware));
+}
+
+function addScopeToStore(store, key, host, jwt, contextUuid, artifactType, artifactId) {
+  if (!dynamicReducers[key]) {
+    dynamicReducers[key] = multireducer(combineReducers({
+      // eslint-disable-line immutable/no-mutation
+      config: config({
+        host: host,
+        jwt: jwt,
+        contextUuid: contextUuid,
+        artifactType: artifactType,
+        artifactId: artifactId
+      }),
+      alignments: alignments,
+      report: report,
+      OutcomePicker: OutcomePicker
+    }), key);
+    store.replaceReducer(createRootReducer());
+  }
+
+  return store;
+}
+
+function initializeStore(store, _ref) {
+  var host = _ref.host,
+      jwt = _ref.jwt;
+  store.dispatch(loadFeatures(host, jwt));
+}
+
+var store = null;
+export function getStore(host, jwt, key, contextUuid, artifactType, artifactId) {
+  if (!store) {
+    store = createStore();
+    initializeStore(store, {
+      host: host,
+      jwt: jwt
+    });
+  }
+
+  store.dispatch(loadContext(host, jwt, contextUuid));
+  addScopeToStore(store, key, host, jwt, contextUuid, artifactType, artifactId);
+  return store;
+}

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

@@ -0,0 +1,294 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { expect } from 'chai';
+import { fromJS, Map } from 'immutable';
+import { wrapAction } from 'multireducer';
+import sinon from 'sinon';
+import * as actions from "../actions.js";
+import { SET_ERROR, VIEW_REPORT_ALIGNMENT, CLOSE_REPORT_ALIGNMENT } from "../../../constants.js";
+import { setError } from "../../context/actions.js";
+import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
+var scopedActions = scopeActions(_objectSpread(_objectSpread({}, actions), {}, {
+  setError: setError
+}));
+var getUsersResponse = {
+  users: [{
+    uuid: '100'
+  }, {
+    uuid: '100'
+  }],
+  perPage: 50,
+  total: 2
+};
+var rollupResponse = [{
+  count: 2,
+  mastery_count: 1,
+  average_score: 0.3,
+  outcome: {
+    id: 2848,
+    guid: '7DE656A0-7440-11DF-93FA-01FD9CFF4B22',
+    title: 'Read grade-level text with purpose and understanding.',
+    parent_id: 2257,
+    position: 0,
+    created_at: '2017-05-09T20:46:26.411Z',
+    updated_at: '2017-05-09T20:46:26.411Z',
+    label: 'CCSS.ELA-Literacy.RF.1.4.a',
+    description: 'Read grade-level text with purpose and understanding.'
+  }
+}, {
+  count: 2,
+  mastery_count: 2,
+  average_score: 0.7,
+  uses_bank: false,
+  outcome: {
+    id: 2849,
+    guid: '7DE6D0EE-7440-11DF-93FA-01FD9CFF4B22',
+    title: 'Read grade-level text orally with accuracy, appropriate rate, and expression on successive readings.',
+    parent_id: 2257,
+    position: 1,
+    created_at: '2017-05-09T20:12:06.430Z',
+    updated_at: '2017-05-09T20:12:06.430Z',
+    label: 'CCSS.ELA-Literacy.RF.1.4.b',
+    description: 'Read grade-level text orally with accuracy, appropriate rate, and expression on successive readings.' // eslint-disable-line max-len
+
+  }
+}];
+var fakeResults = {
+  2848: [{
+    user_uuid: 'bc5c4f0e-bfbb-46a7-98f3-1ee8c86a1c6f',
+    percent_score: 0.3,
+    points: 30.0,
+    points_possible: 100
+  }, {
+    user_uuid: '560fddd9-9b16-4e3a-969c-2f095e7afc78',
+    percent_score: 0.8,
+    points: 80.0,
+    points_possible: 100
+  }],
+  2849: [{
+    user_uuid: 'bc5c4f0e-bfbb-46a7-98f3-1ee8c86a1c6f',
+    percent_score: 0.9,
+    points: 90.0,
+    points_possible: 100
+  }, {
+    user_uuid: '560fddd9-9b16-4e3a-969c-2f095e7afc78',
+    percent_score: 0.8,
+    points: 80.0,
+    points_possible: 100
+  }]
+};
+var rollups = rollupResponse.map(function (_ref) {
+  var count = _ref.count,
+      masteryCount = _ref.mastery_count,
+      outcome = _ref.outcome,
+      averageScore = _ref.average_score,
+      childArtifactCount = _ref.child_artifact_count,
+      usesBank = _ref.uses_bank;
+  return {
+    outcomeId: outcome.id,
+    count: count,
+    masteryCount: masteryCount,
+    averageScore: averageScore,
+    childArtifactCount: childArtifactCount,
+    usesBank: usesBank
+  };
+});
+var userList = fakeResults['2848'].map(function (user) {
+  return user.user_uuid;
+});
+var users = userList.map(function (uuid) {
+  return {
+    uuid: uuid
+  };
+});
+var service = {
+  getUsers: sinon.stub().resolves({
+    users: users
+  }),
+  getOutcomeRollups: sinon.stub().resolves(rollupResponse),
+  getOutcomeResults: function getOutcomeResults(host, jwt, t, i, outcomeId) {
+    return Promise.resolve(fakeResults[outcomeId.toString()]);
+  }
+};
+var failedService = {
+  getOutcomeRollups: sinon.stub().rejects({
+    error: 'OHNO'
+  })
+};
+describe('report/actions', function () {
+  describe('loadRollups', function () {
+    it('calls outcome service to load rollups and individual results', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            users: users
+          }
+        }
+      };
+      var store = createMockStore(Map(fromJS(state)), service);
+      return store.dispatch(actions.loadRollups('quiz', 101)).then(function () {
+        var _store$getActions$sli = store.getActions().slice(1),
+            _store$getActions$sli2 = _slicedToArray(_store$getActions$sli, 2),
+            add = _store$getActions$sli2[0],
+            update = _store$getActions$sli2[1];
+
+        expect(add.type).to.equal(actions.setReportOutcomes.toString());
+        rollupResponse.forEach(function (r) {
+          expect(add.payload[r.outcome.id]).to.deep.equal(r.outcome);
+        });
+        expect(update.type).to.equal(actions.setRollups.toString());
+        expect(update.payload).to.deep.equal(rollups);
+        store.getActions().filter(function (act) {
+          return act.payload.method === 'getOutcomeResults';
+        }).forEach(function (act) {
+          var _act$payload$args$sli = act.payload.args.slice(-1),
+              _act$payload$args$sli2 = _slicedToArray(_act$payload$args$sli, 1),
+              requestedUsers = _act$payload$args$sli2[0];
+
+          expect(requestedUsers).to.deep.equal(userList);
+        });
+        var resultActions = store.getActions().slice(-2);
+        resultActions.forEach(function (act) {
+          var outcomeId = act.payload.outcomeId;
+          var results = fakeResults[outcomeId];
+          expect(act).to.deep.equal(scopedActions.setResults({
+            outcomeId: outcomeId,
+            results: results
+          }));
+        });
+        return null;
+      });
+    });
+    it('dispatches failure action on failure', function () {
+      var store = createMockStore(Map(), failedService);
+      return store.dispatch(actions.loadRollups('quiz', 101)).then(function () {
+        var _store$getActions$sli3 = store.getActions().slice(1),
+            _store$getActions$sli4 = _slicedToArray(_store$getActions$sli3, 1),
+            err = _store$getActions$sli4[0];
+
+        expect(err.type).to.equal(SET_ERROR);
+        return null;
+      });
+    });
+    describe('viewReportAlignment', function () {
+      it('creates an action', function () {
+        var action = actions.viewReportAlignment(12);
+        expect(action.type).to.equal(VIEW_REPORT_ALIGNMENT);
+        expect(action.payload).to.deep.equal(12);
+      });
+    });
+    describe('closeReportAlignment', function () {
+      it('creates an action', function () {
+        var action = actions.closeReportAlignment();
+        expect(action.type).to.equal(CLOSE_REPORT_ALIGNMENT);
+      });
+    });
+  });
+  describe('loadPage', function () {
+    it('changes the page, then loads users / score data', function () {
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadPage('quiz', 101, 2)).then(function () {
+        expect(store.getActions()).to.deep.include.members([wrapAction(actions.setPage({
+          number: 2,
+          loading: true
+        }), 'scopeForTest'), wrapAction(actions.setUsers(users), 'scopeForTest'), wrapAction(actions.setRollups(rollups), 'scopeForTest'), wrapAction(actions.setPage({
+          number: 2,
+          loading: false
+        }), 'scopeForTest')]);
+        return null;
+      });
+    });
+    it('will reload the current page', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 10,
+              loading: false
+            }
+          }
+        }
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadPage('quiz', 101, 10)).then(function () {
+        expect(store.getActions()).to.deep.include.members([wrapAction(actions.setPage({
+          number: 10,
+          loading: true
+        }), 'scopeForTest'), wrapAction(actions.setUsers(users), 'scopeForTest'), wrapAction(actions.setRollups(rollups), 'scopeForTest'), wrapAction(actions.setPage({
+          number: 10,
+          loading: false
+        }), 'scopeForTest')]);
+        return null;
+      });
+    });
+    it('will not change to a new page until the prior page has loaded', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 5,
+              loading: true
+            }
+          }
+        }
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadPage('quiz', 101, 2)).then(function () {
+        expect(store.getActions()).to.deep.equal([]);
+        return null;
+      });
+    });
+    it('dispatches setUsers / setPageData on outcome service success', function () {
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadPage('quiz', 101, 2)).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setUsers(getUsersResponse.users));
+        expect(store.getActions()).to.deep.include(scopedActions.setPageData({
+          perPage: 50,
+          total: 2
+        }));
+        return null;
+      });
+    });
+    it('dispatches setError on outcome service failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadPage('quiz', 101, 2)).then(function () {
+        expect(store.getActions()).to.have.length(4);
+        expect(store.getActions()[3]).to.deep.equal(scopedActions.setError(error));
+        return null;
+      });
+    });
+    it('dispatches an alternative loadUsers function if specified', function () {
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var loadUsers = sinon.stub().returns(Promise.resolve());
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadPage('quiz', 101, 2, loadUsers)).then(function () {
+        expect(service.getUsers).not.to.have.been.called;
+        expect(loadUsers).to.have.been.calledOnce;
+        return null;
+      });
+    });
+  });
+  describe('loadUsers', function () {
+    it('calls outcome service to load users', function () {
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadUsers()).then(function () {
+        expect(service.getUsers).to.have.been.calledOnce;
+        return null;
+      });
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import { setPage, setPageData, setRollups, setResults, setUsers, viewReportAlignment, closeReportAlignment } from "../actions.js";
+import reducer from "../reducers.js";
+describe('reports/reducers', function () {
+  // eslint-disable-next-line camelcase
+  var user_uuid = '560fddd9-9b16-4e3a-969c-2f095e7afc78';
+  var state = fromJS({
+    rollups: {
+      100: {
+        id: 100,
+        label: 'blue',
+        title: 'green'
+      }
+    },
+    results: {
+      1955: _defineProperty({}, user_uuid, {
+        user_uuid: user_uuid,
+        percent_score: 0.8,
+        points: 80.0,
+        points_possible: 100.0
+      })
+    },
+    users: [{
+      uuid: '100'
+    }, {
+      uuid: '200'
+    }],
+    openReportAlignmentId: 10
+  });
+  describe('page', function () {
+    it('is updated by setPage', function () {
+      var newPage = {
+        number: 10,
+        loading: true
+      };
+      var newState = reducer(state, setPage(newPage));
+      expect(newState.get('page').toJS()).to.deep.equal(newPage);
+    });
+  });
+  describe('pageData', function () {
+    it('is updated by setPageData', function () {
+      var newPageData = {
+        perPage: 50,
+        total: 597
+      };
+      var newState = reducer(state, setPageData(newPageData));
+      expect(newState.get('pageData').toJS()).to.deep.equal(newPageData);
+    });
+  });
+  describe('rollups', function () {
+    it('is updated by setRollups', function () {
+      var newRollup = {
+        id: 200,
+        label: 'yellow',
+        title: 'red'
+      };
+      var newState = reducer(state, setRollups([newRollup]));
+      expect(newState.get('rollups').toJS()).to.deep.equal([newRollup]);
+    });
+  });
+  describe('results', function () {
+    it('is updated by setResults', function () {
+      var result = {
+        user_uuid: user_uuid,
+        points: 95.0,
+        points_possible: 100
+      };
+      var newResults = {
+        outcomeId: '1955',
+        results: [result]
+      };
+      var newState = reducer(state, setResults(newResults));
+      expect(newState.getIn(['results', '1955', user_uuid.toString()]).toJS()).to.deep.equal({
+        userId: user_uuid,
+        percentScore: result.percent_score,
+        points: result.points,
+        pointsPossible: result.points_possible
+      });
+    });
+  });
+  describe('openReportAlignmentId', function () {
+    it('is set by VIEW_REPORT_ALIGNMENT', function () {
+      var newState = reducer(state, viewReportAlignment(99));
+      expect(newState.get('openReportAlignmentId')).to.equal(99);
+    });
+    it('is cleared by CLOSE_REPORT_ALIGNMENT', function () {
+      var newState = reducer(state, closeReportAlignment(null));
+      expect(newState.get('openReportAlignmentId')).to.equal(null);
+    });
+  });
+  describe('users', function () {
+    it('is updated by setUsers', function () {
+      var newUsers = [{
+        uuid: '200'
+      }, {
+        uuid: '300'
+      }];
+      var newState = reducer(state, setUsers(newUsers));
+      expect(newState.get('users').toJS()).to.deep.equal(newUsers);
+    });
+  });
+});

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

@@ -0,0 +1,121 @@
+import { expect } from 'chai';
+import { Map, fromJS } from 'immutable';
+import { getPageCount, getPageNumber, getRollups, getScore, isOpen, getUsers, getReportOutcome } from "../selectors.js";
+describe('report/selectors', function () {
+  var state = fromJS({
+    scopeForTest: {
+      report: {
+        page: {
+          number: 2,
+          loaded: true
+        },
+        pageData: {
+          perPage: 50,
+          total: 149
+        },
+        rollups: [{
+          a: 1,
+          b: 2
+        }],
+        results: {
+          1: {
+            2: {
+              percentScore: 0.5,
+              points: 100,
+              pointsPossible: 200
+            }
+          }
+        },
+        users: [{
+          uuid: '100'
+        }, {
+          uuid: '200'
+        }],
+        openReportAlignmentId: 12,
+        outcomes: {
+          123: {
+            id: '123',
+            label: 'foo'
+          }
+        }
+      }
+    }
+  });
+  describe('getPageCount', function () {
+    it('returns the right page count', function () {
+      expect(getPageCount(state, 'scopeForTest')).to.deep.equal(3);
+    });
+    it('returns null on initial load', function () {
+      var newState = Map();
+      expect(getPageCount(newState, 'scopeForTest')).to.deep.equal(null);
+    });
+  });
+  describe('getCurrentPage', function () {
+    it('returns the current page', function () {
+      expect(getPageNumber(state, 'scopeForTest')).to.deep.equal(2);
+    });
+  });
+  describe('getRollups', function () {
+    it('retrieves the correct rollups', function () {
+      expect(getRollups(state, 'scopeForTest')).to.deep.equal([{
+        a: 1,
+        b: 2
+      }]);
+    });
+    it('returns an empty array if no outcomes are selected', function () {
+      var newState = Map();
+      expect(getRollups(newState, 'scopeForTest')).to.deep.equal([]);
+    });
+  });
+  describe('getScore', function () {
+    it('returns score if outcome id and user id are present', function () {
+      expect(getScore(state, 'scopeForTest', '1', '2')).to.deep.equal({
+        percentScore: 0.5,
+        points: 100,
+        pointsPossible: 200
+      });
+    });
+    it('returns null if outcome is not present', function () {
+      expect(getScore(state, 'scopeForTest', '2', '2')).to.equal(null);
+    });
+    it('returns null if user is not present', function () {
+      expect(getScore(state, 'scopeForTest', '1', '3')).to.equal(null);
+    });
+  });
+  describe('isOpen', function () {
+    it('returns true if alignment id is openReportAlignmentId', function () {
+      expect(isOpen(state, 'scopeForTest', 12)).to.be.true;
+    });
+    it('returns false if another alignment id is openReportAlignmentId', function () {
+      expect(isOpen(state, 'scopeForTest', 13)).to.be.false;
+    });
+    it('returns false if no alignment is openReportAlignmentId', function () {
+      var newState = Map();
+      expect(isOpen(newState, 'scopeForTest', 12)).to.be.false;
+    });
+  });
+  describe('getUsers', function () {
+    it('retrieves the correct users', function () {
+      expect(getUsers(state, 'scopeForTest')).to.deep.equal([{
+        uuid: '100'
+      }, {
+        uuid: '200'
+      }]);
+    });
+    it('returns an empty array if no users are present', function () {
+      var newState = Map();
+      expect(getUsers(newState, 'scopeForTest')).to.deep.equal([]);
+    });
+  });
+  describe('getReportOutcome', function () {
+    it('retrieves the correct outcome', function () {
+      expect(getReportOutcome(state, 'scopeForTest', '123')).to.deep.equal({
+        id: '123',
+        label: 'foo'
+      });
+    });
+    it('returns nil if no outcome is found', function () {
+      expect(getReportOutcome(state, 'scopeForTest', '124')).to.equal(null);
+    });
+  });
+});