@openedx/frontend-app-learner-dashboard 1.0.0-alpha.1 → 1.0.0-alpha.11

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

@@ -1,398 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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,
-});