@openedx/frontend-app-learner-dashboard 1.0.0-alpha.0

package/src/data/redux/app/selectors/courseCard.test.js

@@ -0,0 +1,398 @@
+import { keyStore } from 'utils';
+import { baseAppUrl } from 'data/services/lms/urls';
+import { EXECUTIVE_EDUCATION_COURSE_MODES } from 'data/constants/course';
+
+import simpleSelectors from './simpleSelectors';
+import * as module from './courseCard';
+
+jest.mock('data/services/lms/urls', () => ({
+  baseAppUrl: url => ({ baseAppUrl: url }),
+}));
+
+jest.mock('./simpleSelectors', () => ({
+  mkCardSelector: (simpleSelector, selector) => ({
+    mkCardSelector: { selector, simpleSelector },
+  }),
+  cardSimpleSelectors: jest.requireActual('./simpleSelectors').cardSimpleSelectors,
+}));
+
+const { courseCard } = module;
+const { cardSimpleSelectors } = simpleSelectors;
+
+const moduleKeys = keyStore(module);
+
+let testData;
+let selector;
+let simpleSelector;
+let selected;
+
+const dates = {
+  today: new Date(),
+  tomorrow: new Date(),
+  nextYear: new Date(),
+  yesterday: new Date(),
+};
+dates.tomorrow.setDate(dates.tomorrow.getDate() + 1);
+dates.nextYear.setDate(dates.nextYear.getDate() + 365);
+dates.yesterday.setDate(dates.yesterday.getDate() - 1);
+
+/*
+ * Takes a selector as input and fetches the referenced selector and simpleSelector for
+ * the selector to be tested, to be stored in global variables.
+ * Also sets `selected` global variable is loaded with the passed data, which is stored
+ * as `testData`.
+ */
+const loadSelector = (sel, data) => {
+  ({ simpleSelector, selector } = sel.mkCardSelector);
+  testData = data;
+  selected = selector(data);
+};
+
+describe('courseCard selectors module', () => {
+  describe('loadDateVal helper function', () => {
+    it('returns passed date value converted to Date', () => {
+      const testDate = '2000-10-10';
+      expect(module.loadDateVal(testDate)).toEqual(new Date(testDate));
+    });
+    it('returns null if no value is passed', () => {
+      expect(module.loadDateVal()).toEqual(null);
+    });
+  });
+  describe('courseCard selectors', () => {
+    let dateSpy;
+    beforeEach(() => {
+      dateSpy = jest.spyOn(module, moduleKeys.loadDateVal);
+      dateSpy.mockImplementation(v => new Date(v));
+    });
+    afterEach(() => {
+      dateSpy.mockRestore();
+    });
+    describe('certificate selector', () => {
+      beforeEach(() => {
+        loadSelector(courseCard.certificate, {
+          certPreviewUrl: 'test-cert-preview-url',
+          isDownloadable: 'test-is-downloadable',
+          isRestricted: 'test-is-restricted',
+          isEarned: false,
+          availableDate: '2020-10-10',
+        });
+      });
+      it('returns a card selector based on certificate cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.certificate);
+      });
+      it('returns {} object if null certificate received', () => {
+        expect(selector(null)).toEqual({});
+      });
+      it('passes availableDate, converted to a date', () => {
+        expect(selected.availableDate).toMatchObject(new Date(testData.availableDate));
+      });
+      it('passes [isDownloadable, isRestricted]', () => {
+        expect(selected.isDownloadable).toEqual(testData.isDownloadable);
+        expect(selected.isRestricted).toEqual(testData.isRestricted);
+      });
+      it('passes certPreviewUrl as app url', () => {
+        expect(selected.certPreviewUrl).toEqual(baseAppUrl(testData.certPreviewUrl));
+      });
+      describe('isEarnedButUnavailable', () => {
+        it('passes true iff certificate is earned but availableDate is in the future', () => {
+          const testSelector = (data, expected) => {
+            expect(selector({ ...testData, ...data }).isEarnedButUnavailable).toEqual(expected);
+          };
+          testSelector({ isEarned: true, availableDate: dates.today }, false);
+          testSelector({ isEarned: true, availableDate: dates.yesterday }, false);
+          testSelector({ isEarned: true, availableDate: dates.tomorrow }, true);
+          testSelector({ isEarned: false, availableDate: dates.tomorrow }, false);
+        });
+      });
+    });
+    describe('course selector', () => {
+      beforeEach(() => {
+        loadSelector(courseCard.course, {
+          bannerImgSrc: 'test-banner-img-src',
+          courseNumber: 'test-course-number',
+          courseName: 'test-course-name',
+          socialShareUrl: 'test-social-share-url',
+        });
+      });
+      it('returns a card selector based on course cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.course);
+      });
+      it('passes bannerImgSrc, converted to a baseAppUrl', () => {
+        expect(selected.bannerImgSrc).toEqual(baseAppUrl(testData.bannerImgSrc));
+      });
+      it('passes [courseNumber, courseName, socialShareUrl]', () => {
+        expect(selected.courseNumber).toEqual(testData.courseNumber);
+        expect(selected.courseName).toEqual(testData.courseName);
+        expect(selected.socialShareUrl).toEqual(testData.socialShareUrl);
+      });
+    });
+    describe('courseProvider selector', () => {
+      beforeEach(() => {
+        loadSelector(courseCard.courseProvider, { name: 'test-provider-name' });
+      });
+      it('returns a card selector based on courseProvider cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.courseProvider);
+      });
+      describe('name', () => {
+        it('passes the provider name if provider is known', () => {
+          expect(selected.name).toEqual(testData.name);
+        });
+        it('passes undefined if provider is not known', () => {
+          expect(selector().name).toEqual(undefined);
+        });
+      });
+    });
+    describe('courseRun selector', () => {
+      beforeEach(() => {
+        loadSelector(courseCard.courseRun, {
+          endDate: '3000-10-20',
+          startDate: '2000-10-20',
+          advertisedStart: 'Mid June',
+
+          courseId: 'test-course-id',
+          isArchived: 'test-is-archived',
+          isStarted: 'test-is-started',
+
+          minPassingGrade: 0.9354,
+
+          homeUrl: 'test-home-url',
+          marketingUrl: 'test-marketing-url',
+
+          progressUrl: 'test-progress-url',
+          resumeUrl: 'test-resume-url',
+          unenrollUrl: 'test-unenroll-url',
+        });
+      });
+      it('returns a card selector based on courseRun cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.courseRun);
+      });
+      it('returns {} object if null courseRun received', () => {
+        expect(selector(null)).toEqual({});
+      });
+      it('passes [endDate, startDate], converted to dates', () => {
+        expect(selected.endDate).toEqual(new Date(testData.endDate));
+        expect(selected.startDate).toEqual(new Date(testData.startDate));
+      });
+      it('passes advertised start date', () => {
+        expect(selected.advertisedStart).toEqual(testData.advertisedStart);
+      });
+      it('passes [courseId, isArchived, isStarted]', () => {
+        expect(selected.courseId).toEqual(testData.courseId);
+        expect(selected.isArchived).toEqual(testData.isArchived);
+        expect(selected.isStarted).toEqual(testData.isStarted);
+      });
+      it('passes minPassingGrade floored from float to a percentage value', () => {
+        expect(selected.minPassingGrade).toEqual(93);
+      });
+      it('passes [homeUrl, marketingUrl]', () => {
+        expect(selected.homeUrl).toEqual(testData.homeUrl);
+        expect(selected.marketingUrl).toEqual(testData.marketingUrl);
+      });
+      it('passes [progressUrl, unenrollUrl, resumeUrl], converted to baseAppUrl', () => {
+        expect(selected.progressUrl).toEqual(baseAppUrl(testData.progressUrl));
+        expect(selected.resumeUrl).toEqual(baseAppUrl(testData.resumeUrl));
+        expect(selected.unenrollUrl).toEqual(baseAppUrl(testData.unenrollUrl));
+      });
+    });
+    describe('credit selector', () => {
+      const credit = {
+        providerStatusUrl: 'test-provider-status-url',
+        providerName: 'test-provider-name',
+        providerId: 'test-provider-id',
+        error: 'test-provider-id',
+        purchased: 'test-purchased',
+        requestStatus: 'test-request-status',
+      };
+      it('returns a card selector based on credit cardSimpleSelector', () => {
+        loadSelector(courseCard.credit, {});
+        expect(simpleSelector).toEqual(cardSimpleSelectors.credit);
+      });
+      it('returns { isEligible: false } if empty object received for credit', () => {
+        loadSelector(courseCard.credit, {});
+        expect(selected).toEqual({ isEligible: false });
+      });
+      describe('credit fields when credit object is passed', () => {
+        beforeEach(() => {
+          loadSelector(courseCard.credit, credit);
+        });
+        it('returns isEligible: true', () => {
+          expect(selected.isEligible).toEqual(true);
+        });
+        it('returns provider status url, name, and id', () => {
+          expect(selected.providerStatusUrl).toEqual(credit.providerStatusUrl);
+          expect(selected.providerName).toEqual(credit.providerName);
+          expect(selected.providerId).toEqual(credit.providerId);
+        });
+        it('returns error, purchased and requestStatus fields', () => {
+          expect(selected.error).toEqual(credit.error);
+          expect(selected.purchased).toEqual(credit.purchased);
+          expect(selected.requestStatus).toEqual(credit.requestStatus);
+        });
+      });
+    });
+    describe('enrollment selector', () => {
+      const defaultData = {
+        coursewareAccess: {
+          isStaff: false,
+          hasUnmetPrereqs: false,
+          isTooEarly: false,
+        },
+        isEnrolled: 'test-is-enrolled',
+        lastEnrolled: 'test-last-enrolled',
+        hasStarted: 'test-has-started',
+        accessExpirationDate: '3000-10-20',
+        canUpgrade: 'test-can-upgrade',
+        isAudit: 'test-is-audit',
+        isAuditAccessExpired: 'test-is-audit-access-expired',
+        isVerified: 'test-is-verified',
+        isEmailEnabled: 'test-is-email-enabled',
+        mode: 'default',
+      };
+      beforeEach(() => {
+        loadSelector(courseCard.enrollment, defaultData);
+      });
+      it('returns a card selector based on enrollment cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.enrollment);
+      });
+      it('returns { isEnrolled: false } object if null enrollment received', () => {
+        expect(selector(null)).toEqual({ isEnrolled: false });
+      });
+      it('passes [coursewareAccess, hasStarted, isEnrolled, lastEnrolled]', () => {
+        expect(selected.coursewareAccess).toEqual(testData.coursewareAccess);
+        expect(selected.hasStarted).toEqual(testData.hasStarted);
+        expect(selected.isEnrolled).toEqual(testData.isEnrolled);
+        expect(selected.lastEnrolled).toEqual(testData.lastEnrolled);
+      });
+      it('passes hasAccess if staff or neither has umet prereqs nor is too early', () => {
+        const testAccess = (access, expected) => {
+          expect(selector({ ...testData, coursewareAccess: access }).hasAccess).toEqual(expected);
+        };
+        testAccess({ isStaff: false, hasUnmetPrereqs: false, isTooEarly: false }, true);
+        testAccess({ isStaff: false, hasUnmetPrereqs: false, isTooEarly: true }, false);
+        testAccess({ isStaff: false, hasUnmetPrereqs: true, isTooEarly: false }, false);
+        testAccess({ isStaff: false, hasUnmetPrereqs: true, isTooEarly: true }, false);
+        testAccess({ isStaff: true, hasUnmetPrereqs: true, isTooEarly: true }, true);
+      });
+      it('passes accessExpirationDate, converted to date', () => {
+        expect(selected.accessExpirationDate).toEqual(new Date(testData.accessExpirationDate));
+      });
+      it('passes [canUpgrade, isAudit, isAuditAccessExpired, isVerified]', () => {
+        expect(selected.canUpgrade).toEqual(testData.canUpgrade);
+        expect(selected.isAudit).toEqual(testData.isAudit);
+        expect(selected.isAuditAccessExpired).toEqual(testData.isAuditAccessExpired);
+        expect(selected.isVerified).toEqual(testData.isVerified);
+      });
+      it('passes isEmailEnabled', () => {
+        expect(selected.isEmailEnabled).toEqual(testData.isEmailEnabled);
+      });
+      it('returns isExecEd2UCourse: false if mode is not in EXECUTIVE_EDUCATION_COURSE_MODES', () => {
+        expect(selected.isExecEd2UCourse).toEqual(false);
+      });
+      it('returns isExecEd2UCourse: true if mode is in EXECUTIVE_EDUCATION_COURSE_MODES', () => {
+        loadSelector(courseCard.enrollment, { ...defaultData, mode: EXECUTIVE_EDUCATION_COURSE_MODES[0] });
+        expect(selected.isExecEd2UCourse).toEqual(true);
+      });
+    });
+    describe('entitlement selector', () => {
+      beforeEach(() => {
+        loadSelector(courseCard.entitlement, {
+          availableSessions: ['test', 'sessions'],
+          changeDeadline: '2000-10-20',
+          isExpired: 'test-is-expired',
+          isFulfilled: 'test-is-fulfilled',
+          uuid: 'test-uuid',
+        });
+      });
+      it('returns a card selector based on entilement cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.entitlement);
+      });
+      it('returns { isEntilement: false } if entitlement object is missing or empty', () => {
+        expect(selector({})).toEqual({ isEntitlement: false });
+        expect(selector()).toEqual({ isEntitlement: false });
+      });
+      it('passes isEntitlement: true for entilement data', () => {
+        expect(selected.isEntitlement).toEqual(true);
+      });
+      it('passes [availableSessions, isExpired, isFulfilled, uuid]', () => {
+        expect(selected.availableSessions).toEqual(testData.availableSessions);
+        expect(selected.isExpired).toEqual(testData.isExpired);
+        expect(selected.isFulfilled).toEqual(testData.isFulfilled);
+        expect(selected.uuid).toEqual(testData.uuid);
+      });
+      it('passess changeDeadline as changeDeadline, converted to a date', () => {
+        expect(selected.changeDeadline).toEqual(new Date(testData.changeDeadline));
+      });
+      it('passes hasSessions if availableSessions is provided and has a length > 0', () => {
+        expect(selected.hasSessions).toEqual(true);
+        expect(selector({ ...testData, availableSessions: [] }).hasSessions).toEqual(false);
+      });
+      it('passes canChange if the deadline is not before current date', () => {
+        expect(selector({ ...testData, changeDeadline: dates.yesterday }).canChange).toEqual(false);
+        expect(selector({ ...testData, changeDeadline: dates.tomorrow }).canChange).toEqual(true);
+      });
+      it('passes showExpirationWarning if the deadline is 0-6 months in the future and not fulfilled', () => {
+        const testSelector = ({ isFulfilled, changeDeadline }, expected) => {
+          expect(
+            selector({ ...testData, isFulfilled, changeDeadline }).showExpirationWarning,
+          ).toEqual(expected);
+        };
+        testSelector({ isFulfilled: false, changeDeadline: dates.yesterday }, false);
+        testSelector({ isFulfilled: false, changeDeadline: dates.tomorrow }, true);
+        testSelector({ isFulfilled: false, changeDeadline: dates.nextYear }, false);
+        testSelector({ isFulfilled: true, changeDeadline: dates.nextYear }, false);
+      });
+    });
+    describe('gradeData selector', () => {
+      beforeEach(() => {
+        loadSelector(courseCard.gradeData, { isPassing: 'test-is-passing' });
+      });
+      it('returns a card selector based on gradeData cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.gradeData);
+      });
+      it('passes isPassing', () => {
+        expect(selected.isPassing).toEqual(testData.isPassing);
+      });
+    });
+    describe('relatedPrograms selector', () => {
+      beforeEach(() => {
+        const programData = (index) => ({
+          bannerImgSrc: `test-banner-img-src-${index}`,
+          logoImgSrc: `test-logo-img-src-${index}`,
+          numberOfCourses: `test-number-of-courses-${index}`,
+          programType: `test-program-type-${index}`,
+          programUrl: `test-program-url-${index}`,
+          provider: `test-provider-${index}`,
+          title: `test-title-${index}`,
+        });
+        loadSelector(courseCard.relatedPrograms, [
+          programData(0),
+          programData(1),
+          programData(2),
+          programData(3),
+          programData(4),
+        ]);
+      });
+      it('returns a card selector based on relatedPrograms cardSimpleSelector', () => {
+        expect(simpleSelector).toEqual(cardSimpleSelectors.relatedPrograms);
+      });
+      it('passes [bannerImgSrc, logoImgSrc] for each program', () => {
+        selected.list.forEach((row, i) => {
+          expect(row.bannerImgSrc).toEqual(testData[i].bannerImgSrc);
+          expect(row.logoImgSrc).toEqual(testData[i].logoImgSrc);
+        });
+      });
+      it('passes [numberOfCourses, programType, programUrl, provider, title] for each', () => {
+        selected.list.forEach((row, i) => {
+          expect(row.numberOfCourses).toEqual(testData[i].numberOfCourses);
+          expect(row.programType).toEqual(testData[i].programType);
+          expect(row.programUrl).toEqual(testData[i].programUrl);
+          expect(row.provider).toEqual(testData[i].provider);
+          expect(row.title).toEqual(testData[i].title);
+        });
+      });
+      it('passes number of programs a length', () => {
+        expect(selected.length).toEqual(testData.length);
+      });
+    });
+  });
+});

package/src/data/redux/app/selectors/currentList.js

@@ -0,0 +1,60 @@
+import { StrictDict } from '../../../../utils';
+import { FilterKeys, SortKeys } from '../../../../data/constants/app';
+
+import simpleSelectors from './simpleSelectors';
+import * as module from './currentList';
+
+export const sortFn = (transform, { reverse }) => (v1, v2) => {
+  const [a, b] = [v1, v2].map(transform);
+  if (a === b) {
+    return 0;
+  }
+  return ((a > b) ? 1 : -1) * (reverse ? -1 : 1);
+};
+
+export const courseFilters = StrictDict({
+  [FilterKeys.notEnrolled]: (course) => !course.enrollment.isEnrolled,
+  [FilterKeys.done]: (course) => course.courseRun !== null && course.courseRun.isArchived,
+  [FilterKeys.upgraded]: (course) => course.enrollment.isVerified,
+  [FilterKeys.inProgress]: (course) => course.enrollment.hasStarted,
+  [FilterKeys.notStarted]: (course) => !course.enrollment.hasStarted,
+});
+
+export const transforms = StrictDict({
+  [SortKeys.enrolled]: ({ enrollment }) => new Date(enrollment.lastEnrolled),
+  [SortKeys.title]: ({ course }) => course.courseName.toLowerCase(),
+});
+
+export const courseFilterFn = filters => (filters.length
+  ? course => filters.reduce((match, filter) => match && courseFilters[filter](course), true)
+  : () => true);
+
+export const currentList = (allCourses, {
+  sortBy,
+  filters,
+}) => allCourses
+  .filter(module.courseFilterFn(filters))
+  .sort(module.sortFn(transforms[sortBy], { reverse: sortBy === SortKeys.enrolled }));
+
+export const visibleList = (state, {
+  sortBy,
+  filters,
+  pageSize,
+}) => {
+  const courses = Object.values(simpleSelectors.courseData(state));
+  const list = module.currentList(courses, { sortBy, filters });
+  const pageNumber = simpleSelectors.pageNumber(state);
+
+  if (pageSize === 0) {
+    return {
+      visible: list,
+      numPages: 1,
+    };
+  }
+  return {
+    visibleList: list.slice((pageNumber - 1) * pageSize, pageNumber * pageSize),
+    numPages: Math.ceil(list.length / pageSize),
+  };
+};
+
+export default visibleList;

package/src/data/redux/app/selectors/currentList.test.js

@@ -0,0 +1,185 @@
+import { keyStore } from 'utils';
+import { FilterKeys, SortKeys } from 'data/constants/app';
+import simpleSelectors from './simpleSelectors';
+import * as module from './currentList';
+
+jest.mock('./simpleSelectors', () => ({
+  __esModule: true,
+  default: {
+    courseData: jest.fn(),
+    pageNumber: jest.fn(),
+  },
+}));
+
+const {
+  sortFn,
+  courseFilters,
+  transforms,
+  courseFilterFn,
+  currentList,
+  visibleList,
+} = module;
+
+const moduleKeys = keyStore(module);
+
+const testDate = '2000-10-10';
+const testString = 'test-STRING';
+
+describe('courseList selector module', () => {
+  describe('utilities', () => {
+    describe('sortFn', () => {
+      it('performs comparison sort after running both values through transform', () => {
+        const transform = ({ val }) => val;
+        expect(sortFn(transform, { reverse: false })({ val: 2 }, { val: 1 })).toEqual(1);
+        expect(sortFn(transform, { reverse: false })({ val: 1 }, { val: 1 })).toEqual(0);
+        expect(sortFn(transform, { reverse: false })({ val: 1 }, { val: 2 })).toEqual(-1);
+        expect(sortFn(transform, { reverse: true })({ val: 2 }, { val: 1 })).toEqual(-1);
+        expect(sortFn(transform, { reverse: true })({ val: 1 }, { val: 1 })).toEqual(0);
+        expect(sortFn(transform, { reverse: true })({ val: 1 }, { val: 2 })).toEqual(1);
+      });
+    });
+    describe('courseFilters', () => {
+      let filterFn;
+      test('notEnrolled returns true iff course is not enrolled', () => {
+        filterFn = courseFilters[FilterKeys.notEnrolled];
+        expect(filterFn({ enrollment: { isEnrolled: true } })).toEqual(false);
+        expect(filterFn({ enrollment: { isEnrolled: false } })).toEqual(true);
+      });
+      test('done returns true iff learner has finished course', () => {
+        filterFn = courseFilters[FilterKeys.done];
+        expect(filterFn({ courseRun: null })).toEqual(false);
+        expect(filterFn({ courseRun: { isArchived: true } })).toEqual(true);
+        expect(filterFn({ courseRun: { isArchived: false } })).toEqual(false);
+      });
+      test('upgraded returns true if learner is verified', () => {
+        filterFn = courseFilters[FilterKeys.upgraded];
+        expect(filterFn({ enrollment: { isVerified: true } })).toEqual(true);
+        expect(filterFn({ enrollment: { isVerified: false } })).toEqual(false);
+      });
+      test('inProgress returns true iff learner has started course', () => {
+        filterFn = courseFilters[FilterKeys.inProgress];
+        expect(filterFn({ enrollment: { hasStarted: true } })).toEqual(true);
+        expect(filterFn({ enrollment: { hasStarted: false } })).toEqual(false);
+      });
+      test('notStarted returns true iff learner has not started course', () => {
+        filterFn = courseFilters[FilterKeys.notStarted];
+        expect(filterFn({ enrollment: { hasStarted: true } })).toEqual(false);
+        expect(filterFn({ enrollment: { hasStarted: false } })).toEqual(true);
+      });
+    });
+    describe('transforms', () => {
+      test('enrolled transform returns date transform of enrollment.lastEnrolled', () => {
+        const data = { enrollment: { lastEnrolled: testDate } };
+        expect(transforms[SortKeys.enrolled](data)).toEqual(new Date(testDate));
+      });
+      test('title transform returns lowercase transform of course.courseName', () => {
+        const data = { course: { courseName: testString } };
+        expect(transforms[SortKeys.title](data)).toEqual(testString.toLowerCase());
+      });
+    });
+    describe('courseFilterFn', () => {
+      it('returns always-true filter if filter list is empty', () => {
+        expect(courseFilterFn([])()).toEqual(true);
+      });
+      it('takes filters and then course, and returns true if course matches all filters', () => {
+        const filters = [FilterKeys.inProgress, FilterKeys.upgraded];
+        const inProgressSpy = jest.spyOn(courseFilters, FilterKeys.inProgress);
+        const upgradedSpy = jest.spyOn(courseFilters, FilterKeys.upgraded);
+        inProgressSpy.mockImplementation(v => v > 3);
+        upgradedSpy.mockImplementation(v => v > 5);
+
+        expect(courseFilterFn(filters)(6)).toEqual(true);
+        expect(courseFilterFn(filters)(5)).toEqual(false);
+        upgradedSpy.mockImplementation(v => v > 2);
+        expect(courseFilterFn(filters)(3)).toEqual(false);
+
+        inProgressSpy.mockRestore();
+        upgradedSpy.mockRestore();
+      });
+    });
+    describe('currentList selector', () => {
+      it('returns passed courses filtered and sorted', () => {
+        const sortSpy = jest.spyOn(module, moduleKeys.sortFn);
+        const filterSpy = jest.spyOn(module, moduleKeys.courseFilterFn);
+        filterSpy.mockReturnValue(({ val }) => val > 0);
+        sortSpy.mockReturnValue((v1, v2) => {
+          const [a, b] = [v1, v2].map(({ val }) => val);
+          if (a === b) { return 0; }
+          return (a > b) ? 1 : -1;
+        });
+        const testCourses = {
+          empty: { val: 0 },
+          v1: { val: 1 },
+          v2: { val: 2 },
+          v3: { val: 3 },
+        };
+        const {
+          empty,
+          v1,
+          v2,
+          v3,
+        } = testCourses;
+        let sortBy = SortKeys.enrolled;
+        const testFilters = [1, 2, 3];
+        expect(currentList(
+          [empty, v2, v1, empty, empty, v3, empty],
+          { sortBy, filters: testFilters },
+        )).toEqual([v1, v2, v3]);
+        expect(sortSpy).toHaveBeenCalledWith(transforms[sortBy], { reverse: true });
+        expect(filterSpy).toHaveBeenCalledWith(testFilters);
+
+        sortSpy.mockClear();
+        sortBy = SortKeys.title;
+        expect(currentList(
+          [empty, v2, v1, empty, empty, v3, empty],
+          { sortBy, filters: testFilters },
+        )).toEqual([v1, v2, v3]);
+        expect(sortSpy).toHaveBeenCalledWith(transforms[sortBy], { reverse: false });
+        expect(filterSpy).toHaveBeenCalledWith(testFilters);
+        sortSpy.mockRestore();
+        filterSpy.mockRestore();
+      });
+    });
+  });
+  describe('visibleList selector', () => {
+    let listSpy;
+    let out;
+    const pageSize = 2;
+    const pageNumber = 3;
+    const testState = { some: 'state' };
+    const sortBy = SortKeys.enrolled;
+    const testFilters = [1, 2, 3];
+    const testCourseData = { test: 'course-data' };
+    const testList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    beforeEach(() => {
+      listSpy = jest.spyOn(module, moduleKeys.currentList);
+      listSpy.mockReturnValue(testList);
+      simpleSelectors.courseData.mockReturnValue(testCourseData);
+      simpleSelectors.pageNumber.mockReturnValue(pageNumber);
+      out = visibleList(testState, { sortBy, filters: testFilters, pageSize });
+    });
+    afterEach(() => {
+      listSpy.mockRestore();
+    });
+    it('loads currentList from courseData values and passed sortBy and filters values', () => {
+      expect(simpleSelectors.courseData).toHaveBeenCalledWith(testState);
+      expect(simpleSelectors.pageNumber).toHaveBeenCalledWith(testState);
+      expect(listSpy).toHaveBeenCalledWith(
+        Object.values(testCourseData),
+        { sortBy, filters: testFilters },
+      );
+    });
+    it('returns visible page based on passed page size and stored pageNumber', () => {
+      // page 3, 2 per page. [0 1] [2 3] [4 5] ...
+      expect(out.visibleList).toEqual([testList[4], testList[5]]);
+    });
+    it('returns number of pages based on page size and list length', () => {
+      expect(out.numPages).toEqual(6);
+    });
+    it('disable pagination if page size is 0', () => {
+      out = visibleList(testState, { sortBy, filters: testFilters, pageSize: 0 });
+      expect(out.visible).toEqual(testList);
+      expect(out.numPages).toEqual(1);
+    });
+  });
+});

package/src/data/redux/app/selectors/index.js

@@ -0,0 +1,13 @@
+import { StrictDict } from '../../../../utils';
+
+import simpleSelectors from './simpleSelectors';
+import appSelectors from './appSelectors';
+import courseCard from './courseCard';
+import currentList from './currentList';
+
+export default StrictDict({
+  ...simpleSelectors,
+  ...appSelectors,
+  courseCard,
+  currentList,
+});