@instructure/outcomes-ui 2.1.3 → 2.1.5

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

@@ -5,7 +5,7 @@ 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 { SET_ERROR, VIEW_REPORT_ALIGNMENT, CLOSE_REPORT_ALIGNMENT, NOT_FETCHING, IN_PROGRESS, COMPLETED, ERROR } from "../../../constants.js";
 import { setError } from "../../context/actions.js";
 import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
 var scopedActions = scopeActions(_objectSpread(_objectSpread({}, actions), {}, {
@@ -121,7 +121,12 @@ describe('report/actions', function () {
       var state = {
         scopeForTest: {
           report: {
-            users: users
+            page: {
+              number: 0
+            },
+            users: {
+              '0': users
+            }
           }
         }
       };
@@ -149,11 +154,14 @@ describe('report/actions', function () {
         });
         var resultActions = store.getActions().slice(-2);
         resultActions.forEach(function (act) {
-          var outcomeId = act.payload.outcomeId;
+          var _act$payload = act.payload,
+              outcomeId = _act$payload.outcomeId,
+              seenResults = _act$payload.seenResults;
           var results = fakeResults[outcomeId];
           expect(act).to.deep.equal(scopedActions.setResults({
             outcomeId: outcomeId,
-            results: results
+            results: results,
+            seenResults: seenResults
           }));
         });
         return null;
@@ -186,12 +194,25 @@ describe('report/actions', function () {
   });
   describe('loadPage', function () {
     it('changes the page, then loads users / score data', function () {
-      var store = createMockStore(Map(), service);
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {}
+          }
+        }
+      };
+      var store = createMockStore(fromJS(state), 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({
+        }), 'scopeForTest'), wrapAction(actions.setUsers({
+          2: users
+        }), 'scopeForTest'), wrapAction(actions.setRollups(rollups), 'scopeForTest'), wrapAction(actions.setPage({
           number: 2,
           loading: false
         }), 'scopeForTest')]);
@@ -205,7 +226,8 @@ describe('report/actions', function () {
             page: {
               number: 10,
               loading: false
-            }
+            },
+            users: {}
           }
         }
       };
@@ -214,7 +236,9 @@ describe('report/actions', 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({
+        }), 'scopeForTest'), wrapAction(actions.setUsers({
+          10: users
+        }), 'scopeForTest'), wrapAction(actions.setRollups(rollups), 'scopeForTest'), wrapAction(actions.setPage({
           number: 10,
           loading: false
         }), 'scopeForTest')]);
@@ -228,6 +252,10 @@ describe('report/actions', function () {
             page: {
               number: 5,
               loading: true
+            },
+            users: {
+              1: [],
+              2: []
             }
           }
         }
@@ -239,12 +267,24 @@ describe('report/actions', function () {
       });
     });
     it('dispatches setUsers / setPageData on outcome service success', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 1
+            },
+            users: {}
+          }
+        }
+      };
       var service = {
         getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
       };
-      var store = createMockStore(Map(), service);
+      var store = createMockStore(fromJS(state), 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.setUsers({
+          2: getUsersResponse.users
+        }));
         expect(store.getActions()).to.deep.include(scopedActions.setPageData({
           perPage: 50,
           total: 2
@@ -253,13 +293,25 @@ describe('report/actions', function () {
       });
     });
     it('dispatches setError on outcome service failure', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 1
+            },
+            users: {
+              1: []
+            }
+          }
+        }
+      };
       var error = {
         message: 'foo bar baz'
       };
       var service = {
         getUsers: sinon.stub().returns(Promise.reject(error))
       };
-      var store = createMockStore(Map(), service);
+      var store = createMockStore(fromJS(state), 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));
@@ -267,11 +319,23 @@ describe('report/actions', function () {
       });
     });
     it('dispatches an alternative loadUsers function if specified', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 1
+            },
+            users: {
+              1: []
+            }
+          }
+        }
+      };
       var service = {
         getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
       };
       var loadUsers = sinon.stub().returns(Promise.resolve());
-      var store = createMockStore(Map(), service);
+      var store = createMockStore(fromJS(state), 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;
@@ -291,4 +355,340 @@ describe('report/actions', function () {
       });
     });
   });
+  describe('loadRemainingPages', function () {
+    it('starts loading remaining pages if we are not already loading them', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users
+            },
+            pageData: {
+              total: 6,
+              perPage: 2
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingPages('quiz', 101)).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setLoadingRemainingPages(IN_PROGRESS));
+      });
+    });
+    it('does not load remaining pages if we are already loading them', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            loadingRemainingPages: IN_PROGRESS,
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users
+            },
+            pageData: {
+              total: 6,
+              perPage: 2
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingPages('quiz', 101)).then(function () {
+        expect(store.getActions()).not.to.deep.include(scopedActions.setLoadingRemainingPages(IN_PROGRESS));
+      });
+    });
+    it('loads the remaining pages from the current page if there was an error while fetching last time', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            loadingRemainingPages: ERROR,
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users,
+              2: users
+            },
+            pageData: {
+              total: 6,
+              perPage: 2
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingPages('quiz', 101)).then(function () {
+        expect(service.getUsers).to.have.callCount(3);
+      });
+    });
+    it('sets loadRemainingPages as fetching_error if an error is thrown while fetching users', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            loadingRemainingPages: NOT_FETCHING,
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users
+            },
+            pageData: {
+              total: 6,
+              perPage: 2
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.reject({
+          message: 'error!'
+        }))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingPages('quiz', 101)).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setLoadingRemainingPages(ERROR));
+        expect(store.getActions()).not.to.deep.include(scopedActions.setLoadingRemainingPages(COMPLETED));
+      });
+    });
+    it('sets loadRemainingPages as fetching_error if an error is thrown while fetching results', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            loadingRemainingPages: NOT_FETCHING,
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users
+            },
+            pageData: {
+              total: 6,
+              perPage: 2
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse)),
+        getOutcomeResults: sinon.stub().returns(Promise.reject({
+          message: 'error!'
+        }))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingPages('quiz', 101)).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setLoadingRemainingPages(ERROR));
+        expect(store.getActions()).not.to.deep.include(scopedActions.setLoadingRemainingPages(COMPLETED));
+      });
+    });
+  });
+  describe('loadRemainingUsers', function () {
+    it('calls outcomes service for each remaining page and sets the users', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users
+            }
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.resolve(getUsersResponse))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingUsers('quiz', 101, 2, 3)).then(function () {
+        expect(service.getUsers).to.have.been.calledTwice;
+        expect(store.getActions()).to.deep.include(scopedActions.setUsers({
+          1: users,
+          2: getUsersResponse.users
+        }));
+        expect(store.getActions()).to.deep.include(scopedActions.setUsers({
+          1: users,
+          3: getUsersResponse.users
+        }));
+      });
+    });
+    it('sets loadRemainingPages as fetching_error if an error is thrown while fetching', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            loadingRemainingPages: IN_PROGRESS,
+            page: {
+              number: 1,
+              loading: false
+            },
+            users: {
+              1: users
+            },
+            pageData: {
+              total: 6,
+              perPage: 2
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var service = {
+        getUsers: sinon.stub().returns(Promise.reject({
+          message: 'error!'
+        }))
+      };
+      var store = createMockStore(fromJS(state), service);
+      return store.dispatch(actions.loadRemainingUsers('quiz', 101, 2, 3)).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setLoadingRemainingPages(ERROR));
+      });
+    });
+  });
+  describe('loadRemainingResults', function () {
+    it('calls outcome service for each remaining page and rollups and sets the results', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 0
+            },
+            users: {
+              1: users
+            },
+            rollups: rollups
+          }
+        }
+      };
+      var store = createMockStore(Map(fromJS(state)), service);
+      return store.dispatch(actions.loadRemainingResults('quiz', 101, 2, 3)).then(function () {
+        var resultActions = store.getActions().slice(-5);
+        var completeAction = resultActions.pop();
+        resultActions.forEach(function (act) {
+          var _act$payload2 = act.payload,
+              outcomeId = _act$payload2.outcomeId,
+              seenResults = _act$payload2.seenResults;
+          var results = fakeResults[outcomeId];
+          expect(act).to.deep.equal(scopedActions.setResults({
+            outcomeId: outcomeId,
+            results: results,
+            seenResults: seenResults
+          }));
+        });
+        expect(completeAction).to.deep.equal(scopedActions.setLoadingRemainingPages(COMPLETED));
+      });
+    });
+  });
+  describe('getUserList', function () {
+    it('returns a list of user uuids from page 1', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 0
+            },
+            users: {
+              1: users,
+              2: getUsersResponse.users
+            },
+            rollups: rollups
+          }
+        }
+      };
+      expect(actions.getUserList(fromJS(state), 'scopeForTest', 1)).to.deep.eq(users.map(function (user) {
+        return user.uuid;
+      }));
+    });
+    it('returns a list of user uuids from page 2', function () {
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 0
+            },
+            users: {
+              1: users,
+              2: getUsersResponse.users
+            },
+            rollups: rollups
+          }
+        }
+      };
+      expect(actions.getUserList(fromJS(state), 'scopeForTest', 2)).to.deep.eq(getUsersResponse.users.map(function (user) {
+        return user.uuid;
+      }));
+    });
+  });
+  describe('getPaginatedUserList', function () {
+    it('returns a paginated list of all users', function () {
+      var users1 = users.map(function (user) {
+        return user.uuid;
+      });
+      var users2 = getUsersResponse.users.map(function (user) {
+        return user.uuid;
+      });
+      var allUsers = [users1, users2];
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 0
+            },
+            users: {
+              1: users,
+              2: getUsersResponse.users
+            },
+            rollups: rollups
+          }
+        }
+      };
+      expect(actions.getPaginatedUserList(fromJS(state), 'scopeForTest', 1, 2)).to.deep.eq(allUsers);
+    });
+    it('returns a paginated list of a subset of users', function () {
+      var users2 = getUsersResponse.users.map(function (user) {
+        return user.uuid;
+      });
+      var users3 = users.map(function (user) {
+        return user.uuid;
+      });
+      var allUsers = [users2, users3];
+      var state = {
+        scopeForTest: {
+          report: {
+            page: {
+              number: 0
+            },
+            users: {
+              1: users,
+              2: getUsersResponse.users,
+              3: users
+            },
+            rollups: rollups
+          }
+        }
+      };
+      expect(actions.getPaginatedUserList(fromJS(state), 'scopeForTest', 2, 3)).to.deep.eq(allUsers);
+    });
+  });
 });

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

@@ -65,18 +65,44 @@ describe('reports/reducers', function () {
       var result = {
         user_uuid: user_uuid,
         points: 95.0,
-        points_possible: 100
+        points_possible: 100,
+        attempt: 1
       };
       var newResults = {
         outcomeId: '1955',
-        results: [result]
+        results: [result],
+        seenResults: new Map()
       };
       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
+        pointsPossible: result.points_possible,
+        attempt: result.attempt
+      });
+    });
+    it('retains seenResults when updated', function () {
+      var seenResult = {
+        userId: 'old_user',
+        points: 90.0,
+        pointsPossible: 100
+      };
+      var result = {
+        user_uuid: user_uuid,
+        points: 95.0,
+        points_possible: 100
+      };
+      var newResults = {
+        outcomeId: '1955',
+        results: [result],
+        seenResults: new Map([[seenResult.userId, seenResult]])
+      };
+      var newState = reducer(state, setResults(newResults));
+      expect(newState.getIn(['results', '1955', seenResult.userId])).to.deep.equal({
+        userId: seenResult.userId,
+        points: seenResult.points,
+        pointsPossible: seenResult.pointsPossible
       });
     });
   });
@@ -92,11 +118,13 @@ describe('reports/reducers', function () {
   });
   describe('users', function () {
     it('is updated by setUsers', function () {
-      var newUsers = [{
-        uuid: '200'
-      }, {
-        uuid: '300'
-      }];
+      var newUsers = {
+        0: [{
+          uuid: '200'
+        }, {
+          uuid: '300'
+        }]
+      };
       var newState = reducer(state, setUsers(newUsers));
       expect(newState.get('users').toJS()).to.deep.equal(newUsers);
     });