@openedx/frontend-app-learner-dashboard 1.0.0-alpha.5 → 1.0.0-alpha.6

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

@@ -1,187 +0,0 @@
-import { keyStore } from '@src/utils';
-import { FilterKeys, SortKeys } from '@src/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/simpleSelectors.js

@@ -1,38 +0,0 @@
-import { createSelector } from 'reselect';
-import { StrictDict } from '../../../../utils';
-
-import * as module from './simpleSelectors';
-
-export const appSelector = (state) => state.app;
-const mkSimpleSelector = (cb) => createSelector([module.appSelector], cb);
-
-// top-level app data selectors
-export const simpleSelectors = StrictDict({
-  courseData: mkSimpleSelector(app => app.courseData),
-  platformSettings: mkSimpleSelector(app => app.platformSettings),
-  suggestedCourses: mkSimpleSelector(app => app.suggestedCourses),
-  emailConfirmation: mkSimpleSelector(app => app.emailConfirmation),
-  enterpriseDashboard: mkSimpleSelector(app => app.enterpriseDashboard || {}),
-  selectSessionModal: mkSimpleSelector(app => app.selectSessionModal),
-  pageNumber: mkSimpleSelector(app => app.pageNumber),
-  filters: mkSimpleSelector(app => app.filters),
-  socialShareSettings: mkSimpleSelector(app => app.socialShareSettings),
-});
-
-export const cardSimpleSelectors = StrictDict({
-  certificate: ({ certificate }) => certificate,
-  course: ({ course }) => course,
-  courseProvider: ({ courseProvider }) => courseProvider,
-  courseRun: ({ courseRun }) => courseRun,
-  credit: ({ credit }) => credit,
-  enrollment: ({ enrollment }) => enrollment,
-  entitlement: ({ entitlement }) => entitlement,
-  gradeData: ({ gradeData }) => gradeData,
-  relatedPrograms: ({ programs: { relatedPrograms } }) => relatedPrograms,
-});
-
-export const mkCardSelector = (simpleSelector, selector) => (state, cardId) => (
-  selector(simpleSelector(module.simpleSelectors.courseData(state)[cardId]))
-);
-
-export default simpleSelectors;

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

@@ -1,75 +0,0 @@
-import { keyStore } from '@src/utils';
-import * as module from './simpleSelectors';
-
-const {
-  appSelector,
-  simpleSelectors,
-  cardSimpleSelectors,
-  mkCardSelector,
-} = module;
-
-let keys;
-let testData;
-
-let testState;
-const testString = 'test-STRING';
-const testCardId = 'testCARD-id';
-
-describe('app simple selectors', () => {
-  describe('base app selector', () => {
-  });
-  describe('simple selectors', () => {
-    keys = keyStore(simpleSelectors);
-    test.each([
-      keys.courseData,
-      keys.platformSettings,
-      keys.suggestedCourses,
-      keys.emailConfirmation,
-      keys.enterpriseDashboard,
-      keys.selectSessionModal,
-      keys.pageNumber,
-      keys.socialShareSettings,
-      keys.filters,
-    ])('%s app simple selector forwards corresponding data from app store', (key) => {
-      testState = { app: { [key]: testString, otherField: 'fake string' } };
-      const { preSelectors, cb } = simpleSelectors[key];
-      expect(preSelectors).toEqual([appSelector]);
-      expect(cb(testState.app)).toEqual(testString);
-    });
-    describe('cardSimpleSelectors', () => {
-      keys = keyStore(cardSimpleSelectors);
-      test.each([
-        keys.certificate,
-        keys.course,
-        keys.courseProvider,
-        keys.courseRun,
-        keys.credit,
-        keys.enrollment,
-        keys.entitlement,
-        keys.gradeData,
-      ])('%s card simple selector forwards corresponding data from passed object', (key) => {
-        testState = { [key]: testString };
-        expect(cardSimpleSelectors[key](testState)).toEqual(testString);
-      });
-      test('relatedPrograms simple selector forwards relatedPrograms from programs obj', () => {
-        expect(
-          cardSimpleSelectors.relatedPrograms({ programs: { relatedPrograms: testString } }),
-        ).toEqual(testString);
-      });
-    });
-    describe('mkCardSelector util', () => {
-      it('takes [card simpleSelector, selector] and creates card selector from cardData', () => {
-        const selector = (data) => ({ selector: data });
-        const simpleSelector = (data) => ({ simpleSelector: data });
-        testData = { some: 'test data' };
-        const oldCourseData = simpleSelectors.courseData;
-        simpleSelectors.courseData = jest.fn().mockReturnValueOnce({ [testCardId]: testData });
-        expect(mkCardSelector(simpleSelector, selector)(testState, testCardId)).toEqual(
-          selector(simpleSelector(testData)),
-        );
-        expect(simpleSelectors.courseData).toHaveBeenCalledWith(testState);
-        simpleSelectors.courseData = oldCourseData;
-      });
-    });
-  });
-});

package/src/data/redux/hooks/app.js

@@ -1,106 +0,0 @@
-/* eslint-disable react-hooks/rules-of-hooks */
-import { useSelector, useDispatch } from 'react-redux';
-
-import * as redux from '../../../data/redux';
-import * as module from './app';
-
-const selectors = redux.selectors.app;
-const actions = redux.actions.app;
-
-/** Simple Selectors **/
-export const usePageNumber = () => useSelector(selectors.pageNumber);
-export const useFilters = () => useSelector(selectors.filters);
-export const useEmailConfirmationData = () => useSelector(selectors.emailConfirmation);
-export const useEnterpriseDashboardData = () => useSelector(selectors.enterpriseDashboard);
-export const usePlatformSettingsData = () => useSelector(selectors.platformSettings);
-export const useSelectSessionModalData = () => useSelector(selectors.selectSessionModal);
-export const useSocialShareSettings = () => useSelector(selectors.socialShareSettings);
-
-/** global-level meta-selectors **/
-export const useHasCourses = () => useSelector(selectors.hasCourses);
-export const useCurrentCourseList = (opts) => useSelector(
-  state => selectors.currentList(state, opts),
-);
-export const useShowSelectSessionModal = () => useSelector(selectors.showSelectSessionModal);
-
-export const useCourseCardData = (selector) => (cardId) => useSelector(
-  (state) => selector(state, cardId),
-);
-/** Course Card selectors **/
-const { courseCard } = selectors;
-export const useCardCertificateData = useCourseCardData(courseCard.certificate);
-export const useCardCourseData = useCourseCardData(courseCard.course);
-export const useCardCourseRunData = useCourseCardData(courseCard.courseRun);
-export const useCardCreditData = useCourseCardData(courseCard.credit);
-export const useCardEnrollmentData = useCourseCardData(courseCard.enrollment);
-export const useCardEntitlementData = useCourseCardData(courseCard.entitlement);
-export const useCardGradeData = useCourseCardData(courseCard.gradeData);
-export const useCardProviderData = useCourseCardData(courseCard.courseProvider);
-export const useCardRelatedProgramsData = useCourseCardData(courseCard.relatedPrograms);
-
-export const useCardSocialSettingsData = (cardId) => {
-  const socialShareSettings = module.useSocialShareSettings();
-  const { socialShareUrl } = module.useCardCourseData(cardId);
-  const defaultSettings = { isEnabled: false, shareUrl: '' };
-
-  if (!socialShareSettings) {
-    return { facebook: defaultSettings, twitter: defaultSettings };
-  }
-  const { facebook, twitter } = socialShareSettings;
-  const loadSettings = (target) => ({
-    isEnabled: target.isEnabled,
-    shareUrl: `${socialShareUrl}?${target.utmParams}`,
-  });
-  return { facebook: loadSettings(facebook), twitter: loadSettings(twitter) };
-};
-
-export const useCardExecEdTrackingParam = (cardId) => {
-  const { isExecEd2UCourse } = module.useCardEnrollmentData(cardId);
-  const { authOrgId } = module.useEnterpriseDashboardData(cardId);
-  return isExecEd2UCourse ? `?org_id=${authOrgId}` : '';
-};
-
-/** Events **/
-export const useUpdateSelectSessionModalCallback = (cardId) => {
-  const dispatch = useDispatch();
-  return () => dispatch(actions.updateSelectSessionModal(cardId));
-};
-
-export const useTrackCourseEvent = (tracker, cardId, ...args) => {
-  const { courseId } = module.useCardCourseRunData(cardId);
-  return (e) => tracker(courseId, ...args)(e);
-};
-
-export const useSetPageNumber = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.setPageNumber(value));
-};
-
-export const useSetFilters = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.setFilters(value));
-};
-
-export const useAddFilter = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.addFilter(value));
-};
-
-export const useRemoveFilter = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.removeFilter(value));
-};
-
-export const useClearFilters = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.clearFilters(value));
-};
-
-export const useLoadData = () => {
-  const dispatch = useDispatch();
-  return ({ courses, ...globalData }) => {
-    dispatch(actions.setPageNumber(1));
-    dispatch(actions.loadGlobalData(globalData));
-    dispatch(actions.loadCourses({ courses }));
-  };
-};

package/src/data/redux/requests/reducer.js

@@ -1,53 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-
-import { StrictDict } from '../../../utils';
-
-import { RequestStates, RequestKeys } from '../../../data/constants/requests';
-
-const initialState = {
-  [RequestKeys.initialize]: { status: RequestStates.inactive },
-  [RequestKeys.refreshList]: { status: RequestStates.inactive },
-  [RequestKeys.enrollEntitlementSession]: { status: RequestStates.inactive },
-  [RequestKeys.leaveEntitlementSession]: { status: RequestStates.inactive },
-  [RequestKeys.masquerade]: { status: RequestStates.inactive },
-};
-
-const requests = createSlice({
-  name: 'requests',
-  initialState,
-  reducers: {
-    startRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {
-        status: RequestStates.pending,
-      },
-    }),
-    completeRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {
-        status: RequestStates.completed,
-        response: payload.response,
-      },
-    }),
-    failRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {
-        status: RequestStates.failed,
-        error: payload.error,
-      },
-    }),
-    clearRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {},
-    }),
-  },
-});
-
-const actions = StrictDict(requests.actions);
-const { reducer } = requests;
-
-export {
-  actions,
-  reducer,
-  initialState,
-};

package/src/data/redux/requests/reducer.test.js

@@ -1,62 +0,0 @@
-import { RequestStates } from '@src/data/constants/requests';
-import { initialState, actions, reducer } from './reducer';
-
-const testingState = {
-  ...initialState,
-  arbitraryField: 'arbitrary',
-};
-
-describe('requests reducer', () => {
-  it('has initial state', () => {
-    expect(reducer(undefined, {})).toEqual(initialState);
-  });
-
-  const testValue = 'roll for initiative';
-  const testKey = 'test-key';
-  describe('handling actions', () => {
-    describe('startRequest', () => {
-      it('adds a pending status for the given key', () => {
-        expect(reducer(
-          testingState,
-          actions.startRequest({ requestKey: testKey }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: { status: RequestStates.pending },
-        });
-      });
-    });
-    describe('completeRequest', () => {
-      it('adds a completed status with passed response', () => {
-        expect(reducer(
-          testingState,
-          actions.completeRequest({ requestKey: testKey, response: testValue }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: { status: RequestStates.completed, response: testValue },
-        });
-      });
-    });
-    describe('failRequest', () => {
-      it('adds a failed status with passed error', () => {
-        expect(reducer(
-          testingState,
-          actions.failRequest({ requestKey: testKey, error: testValue }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: { status: RequestStates.failed, error: testValue },
-        });
-      });
-    });
-    describe('clearRequest', () => {
-      it('cleanup status and error', () => {
-        expect(reducer(
-          testingState,
-          actions.clearRequest({ requestKey: testKey, error: testValue }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: {},
-        });
-      });
-    });
-  });
-});

package/src/data/redux/requests/selectors.js

@@ -1,28 +0,0 @@
-import { StrictDict } from '../../../utils';
-import { RequestStates } from '../../../data/constants/requests';
-
-export const requestStatus = (state, { requestKey }) => state.requests[requestKey];
-
-const statusSelector = (fn) => (requestKey) => (state) => fn(state.requests[requestKey]);
-
-export const isInactive = ({ status }) => status === RequestStates.inactive;
-export const isPending = ({ status }) => status === RequestStates.pending;
-export const isCompleted = ({ status }) => status === RequestStates.completed;
-export const isFailed = ({ status }) => status === RequestStates.failed;
-export const error = (request) => request.error;
-export const errorStatus = (request) => request.error?.response?.status;
-export const errorCode = (request) => request.error?.response?.data;
-
-export const data = (request) => request.data;
-
-export default StrictDict({
-  requestStatus,
-  isInactive: statusSelector(isInactive),
-  isPending: statusSelector(isPending),
-  isCompleted: statusSelector(isCompleted),
-  isFailed: statusSelector(isFailed),
-  error: statusSelector(error),
-  errorCode: statusSelector(errorCode),
-  errorStatus: statusSelector(errorStatus),
-  data: statusSelector(data),
-});

package/src/data/redux/requests/selectors.test.js

@@ -1,82 +0,0 @@
-import { RequestStates } from '@src/data/constants/requests';
-
-import selectors from './selectors';
-
-const requestKey = 'my-test-request-key';
-const requestData = { some: 'request-data' };
-const inactiveRequest = { status: RequestStates.inactive, some: 'request-data' };
-const pendingRequest = { status: RequestStates.pending, some: 'request-data' };
-const completedRequest = { status: RequestStates.completed, some: 'request-data' };
-const failedRequest = { status: RequestStates.failed, some: 'request-data' };
-
-const testValue = 'my-test-value';
-
-const testErrorValue = {
-  response: {
-    status: 500,
-    data: 'my-test-error',
-  },
-};
-
-const testState = {
-  requests: {
-    [requestKey]: requestData,
-  },
-};
-const mockUseSelector = (selector, state) => selector(state);
-const genRequests = (request) => ({
-  requests: { [requestKey]: request },
-});
-const select = (selector, request) => (
-  mockUseSelector(selector(requestKey), genRequests(request))
-);
-describe('requests selectors unit tests', () => {
-  test('requestStatus returns data associated with given key', () => {
-    expect(selectors.requestStatus(testState, { requestKey })).toEqual(requestData);
-  });
-  const testStatusSelector = (selector, matchingRequest) => {
-    expect(mockUseSelector(selector(requestKey), testState)).toEqual(false);
-    expect(mockUseSelector(
-      selector(requestKey),
-      { requests: { [requestKey]: matchingRequest } },
-    )).toEqual(true);
-  };
-  test('isInactive returns true iff the given request is inactive', () => {
-    testStatusSelector(selectors.isInactive, inactiveRequest);
-  });
-  test('isPending returns true iff the given request is pending', () => {
-    testStatusSelector(selectors.isPending, pendingRequest);
-  });
-  test('isCompleted returns true iff the given request is completed', () => {
-    testStatusSelector(selectors.isCompleted, completedRequest);
-  });
-  test('isFailed returns true iff the given request is failed', () => {
-    testStatusSelector(selectors.isFailed, failedRequest);
-  });
-  test('error returns the error from the request', () => {
-    expect(select(selectors.error, { error: testValue })).toEqual(testValue);
-  });
-  test('errorStatus returns the error response status', () => {
-    expect(select(selectors.errorStatus, {})).toEqual(undefined);
-    expect(select(selectors.errorStatus, { error: {} })).toEqual(undefined);
-    expect(select(selectors.errorStatus, { error: { response: {} } })).toEqual(undefined);
-    expect(select(selectors.errorStatus, { error: { response: { status: testValue } } }))
-      .toEqual(testValue);
-    expect(select(selectors.errorStatus, { error: testErrorValue })).toEqual(
-      testErrorValue.response.status,
-    );
-  });
-  test('errorCode returns the error response data', () => {
-    expect(select(selectors.errorCode, {})).toEqual(undefined);
-    expect(select(selectors.errorCode, { error: {} })).toEqual(undefined);
-    expect(select(selectors.errorCode, { error: { response: {} } })).toEqual(undefined);
-    expect(select(selectors.errorCode, { error: { response: { data: testValue } } }))
-      .toEqual(testValue);
-    expect(select(selectors.errorCode, { error: testErrorValue })).toEqual(
-      testErrorValue.response.data,
-    );
-  });
-  test('data reurns the request data', () => {
-    expect(select(selectors.data, { data: testValue })).toEqual(testValue);
-  });
-});