@coorpacademy/app-review 0.5.3 → 0.5.4

package/src/actions/api/test/fetch-skills.test.ts

@@ -17,14 +17,16 @@ const initialState: StoreState = {
     skills: [],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: 10, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     positions: [0, 1, 2, 3, 4],
     currentSlideRef: '',
     navigation: [],
     answers: {},
-    slide: {}
+    slide: {},
+    showQuitPopin: false
   }
 };
 

package/src/actions/api/test/fetch-slide.test.ts

@@ -19,14 +19,16 @@ const initialState: StoreState = {
     skills: [],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: 10, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     positions: [0, 1, 2, 3, 4],
     currentSlideRef: '',
     navigation: [],
     answers: {},
-    slide: {}
+    slide: {},
+    showQuitPopin: false
   }
 };
 

package/src/actions/api/test/post-answer.test.ts

@@ -22,7 +22,6 @@ import {templateSlide} from '../../../views/slides/test/fixtures/template';
 import {sliderSlide} from '../../../views/slides/test/fixtures/slider';
 import {
   RANK_FETCH_START_REQUEST,
-  RANK_FETCH_START_SUCCESS,
   RANK_FETCH_END_REQUEST,
   RANK_FETCH_END_SUCCESS
 } from '../fetch-rank';
@@ -60,9 +59,10 @@ const initialState: StoreState = {
     skills: [{skillRef, custom: false, name: skillRef, slidesToReview: 5}],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: 10, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     currentSlideRef: freeTextSlide._id,
     navigation: ['skills', 'slides'],
     positions: [0, 1, 2, 3, 4],
@@ -75,12 +75,13 @@ const initialState: StoreState = {
         animateCorrectionPopin: false,
         showCorrectionPopin: false
       }
-    }
+    },
+    showQuitPopin: false
   }
 };
 
 test('should dispatch post-answer, fetch-slide and fetch-correction and fetch-start-rank actions when the answer is submitted and when the slide ref is not "successExitNode"', async t => {
-  t.plan(9);
+  t.plan(8);
   const expectedActions = [
     {type: POST_ANSWER_REQUEST, meta: {slideRef: freeTextSlide._id}},
     {
@@ -109,10 +110,6 @@ test('should dispatch post-answer, fetch-slide and fetch-correction and fetch-st
     },
     {
       type: RANK_FETCH_START_REQUEST
-    },
-    {
-      type: RANK_FETCH_START_SUCCESS,
-      payload: {rank: 93}
     }
   ];
 
@@ -144,9 +141,10 @@ test('should dispatch post-answer, fetch-correction and fetch-end-rank actions w
       skills: [{skillRef, custom: false, name: skillRef, slidesToReview: 5}],
       token: '1234',
       corrections: {},
-      rank: {}
+      rank: {start: 10, end: Number.NaN}
     },
     ui: {
+      showCongrats: false,
       currentSlideRef: templateSlide._id,
       navigation: ['skills', 'slides'],
       positions: [-1, -1, -1, -1, 0],
@@ -177,7 +175,8 @@ test('should dispatch post-answer, fetch-correction and fetch-end-rank actions w
           animateCorrectionPopin: false,
           showCorrectionPopin: false
         }
-      }
+      },
+      showQuitPopin: false
     }
   };
 

package/src/actions/api/test/post-progression.test.ts

@@ -20,14 +20,16 @@ const initialState: StoreState = {
     skills: [],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: 10, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     positions: [0, 1, 2, 3, 4],
     currentSlideRef: '',
     navigation: [],
     answers: {},
-    slide: {}
+    slide: {},
+    showQuitPopin: false
   }
 };
 

package/src/actions/data/test/token.test.ts

@@ -11,14 +11,16 @@ const initialState: StoreState = {
     skills: [],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: Number.NaN, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     positions: [0, 1, 2, 3, 4],
     currentSlideRef: '',
     navigation: [],
     answers: {},
-    slide: {}
+    slide: {},
+    showQuitPopin: false
   }
 };
 

package/src/actions/ui/quit-popin.ts

@@ -0,0 +1,10 @@
+export const OPEN_POPIN = '@@ui/OPEN_POPIN' as const;
+export const CLOSE_POPIN = '@@ui/CLOSE_POPIN' as const;
+
+export const openQuitPopin = {
+  type: OPEN_POPIN
+};
+
+export const closeQuitPopin = {
+  type: CLOSE_POPIN
+};

package/src/actions/ui/test/answers.test.ts

@@ -46,14 +46,16 @@ const initialState: StoreState = {
     skills: [],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: 10, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     positions: [0, 1, 2, 3, 4],
     currentSlideRef: '',
     navigation: [],
     answers: {},
-    slide: {}
+    slide: {},
+    showQuitPopin: false
   }
 };
 

package/src/actions/ui/test/next-slide.test.ts

@@ -26,9 +26,10 @@ const state: StoreState = {
     skills: [{skillRef, custom: false, name: skillRef, slidesToReview: 5}],
     token: '1234',
     corrections: {[freeTextSlide.universalRef]: getChoicesCorrection(freeTextSlide.universalRef)},
-    rank: {start: 93}
+    rank: {start: 93, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     currentSlideRef: freeTextSlide._id,
     navigation: ['loader', 'slides'],
     positions: [0, 1, 2, 3, 4],
@@ -41,9 +42,11 @@ const state: StoreState = {
         animateCorrectionPopin: true,
         showCorrectionPopin: true
       }
-    }
+    },
+    showQuitPopin: false
   }
 };
+
 test('should dispatch NEXT_SLIDE action when nextSlide is called and the progression state is correct', t => {
   const expectedActions = [
     {

package/src/actions/ui/test/quit-popin.test.ts

@@ -0,0 +1,39 @@
+import test from 'ava';
+import {createTestStore} from '../../test/create-test-store';
+import type {StoreState} from '../../../reducers';
+import {closeQuitPopin, CLOSE_POPIN, openQuitPopin, OPEN_POPIN} from '../quit-popin';
+import {services} from '../../../test/util/services.mock';
+
+const initialState: StoreState = {
+  data: {
+    progression: null,
+    slides: {},
+    skills: [],
+    token: '1234',
+    corrections: {},
+    rank: {start: Number.NaN, end: Number.NaN}
+  },
+  ui: {
+    showCongrats: false,
+    currentSlideRef: '',
+    navigation: [],
+    answers: {},
+    slide: {},
+    positions: [],
+    showQuitPopin: false
+  }
+};
+
+test('should dispatch OPEN_POPIN when openQuitPopin action is called', async t => {
+  const expectedAction = [{type: OPEN_POPIN}];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedAction);
+  await dispatch(openQuitPopin);
+});
+
+test('should dispatch CLOSE_POPIN when closeQuitPopin action is called', async t => {
+  const expectedAction = [{type: CLOSE_POPIN}];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedAction);
+  await dispatch(closeQuitPopin);
+});

package/src/actions/ui/test/slides.test.ts

@@ -12,14 +12,16 @@ const initialState: StoreState = {
     skills: [],
     token: '1234',
     corrections: {},
-    rank: {}
+    rank: {start: Number.NaN, end: Number.NaN}
   },
   ui: {
+    showCongrats: false,
     currentSlideRef: '',
     navigation: [],
     positions: [0, 1, 2, 3, 4],
     answers: {},
-    slide: {}
+    slide: {},
+    showQuitPopin: false
   }
 };
 

package/src/reducers/data/rank.ts

@@ -1,57 +1,41 @@
-import {get, isNull, isUndefined, pipe, set, unset, update} from 'lodash/fp';
+import set from 'lodash/fp/set';
+import {
+  POST_PROGRESSION_SUCCESS,
+  type ReceivedProgression
+} from '../../actions/api/post-progression';
 import {
   RankAction,
-  RANK_FETCH_START_REQUEST,
   RANK_FETCH_START_SUCCESS,
-  RANK_FETCH_START_FAILURE,
-  RANK_FETCH_END_REQUEST,
-  RANK_FETCH_END_SUCCESS,
-  RANK_FETCH_END_FAILURE
+  RANK_FETCH_END_SUCCESS
 } from '../../actions/api/fetch-rank';
 
 export type RankState = {
-  start?: number | null;
-  end?: number | null;
+  start: number;
+  end: number;
 };
 
-const initialState: RankState = {};
+const initialState: RankState = {
+  start: Number.NaN,
+  end: Number.NaN
+};
 
 const reducer = (
   // eslint-disable-next-line default-param-last
   state: RankState = initialState,
-  action: RankAction
+  action: RankAction | ReceivedProgression
 ): RankState => {
   switch (action.type) {
-    case RANK_FETCH_START_REQUEST: {
-      return update(
-        'start',
-        (startRank: RankState['start']) => (isUndefined(startRank) ? null : startRank),
-        state
-      );
+    case POST_PROGRESSION_SUCCESS: {
+      return initialState;
     }
     case RANK_FETCH_START_SUCCESS: {
       const {payload} = action;
       return set('start', payload.rank, state);
     }
-    case RANK_FETCH_START_FAILURE: {
-      if (pipe(get('start'), isNull)(state)) return unset('start', state);
-      return state;
-    }
-    case RANK_FETCH_END_REQUEST: {
-      return update(
-        'end',
-        (endRank: RankState['end']) => (isUndefined(endRank) ? null : endRank),
-        state
-      );
-    }
     case RANK_FETCH_END_SUCCESS: {
       const {payload} = action;
       return set('end', payload.rank, state);
     }
-    case RANK_FETCH_END_FAILURE: {
-      if (pipe(get('end'), isNull)(state)) return unset('end', state);
-      return state;
-    }
     default:
       return state;
   }

package/src/reducers/data/test/rank.test.ts

@@ -2,77 +2,58 @@ import test from 'ava';
 import reducer from '../rank';
 import {
   RankAction,
-  RANK_FETCH_START_REQUEST,
   RANK_FETCH_START_SUCCESS,
-  RANK_FETCH_START_FAILURE,
-  RANK_FETCH_END_REQUEST,
-  RANK_FETCH_END_SUCCESS,
-  RANK_FETCH_END_FAILURE
+  RANK_FETCH_END_SUCCESS
 } from '../../../actions/api/fetch-rank';
+import {POST_PROGRESSION_SUCCESS} from '../../../actions/api/post-progression';
+import {postProgressionResponse} from '../../../test/util/services.mock';
 
 test('should have initial value', t => {
   const state = reducer(undefined, {} as RankAction);
-  t.deepEqual(state, {});
-});
-
-test("should set the start value to null if the value doesn't exist of FETCH_START_REQUEST action", t => {
-  const state = reducer({}, {type: RANK_FETCH_START_REQUEST});
-  t.deepEqual(state, {
-    start: null
-  });
-});
-
-test('should do nothing if a start value already exists of FETCH_START_REQUEST action', t => {
-  const state = reducer({start: 93}, {type: RANK_FETCH_START_REQUEST});
   t.deepEqual(state, {
-    start: 93
+    start: Number.NaN,
+    end: Number.NaN
   });
 });
 
 test('should set the start value of FETCH_START_SUCCESS action', t => {
-  const state = reducer({}, {type: RANK_FETCH_START_SUCCESS, payload: {rank: 93}});
+  const state = reducer(
+    {
+      start: Number.NaN,
+      end: Number.NaN
+    },
+    {type: RANK_FETCH_START_SUCCESS, payload: {rank: 93}}
+  );
   t.deepEqual(state, {
-    start: 93
+    start: 93,
+    end: Number.NaN
   });
 });
 
-test('should unset the start value if the value is null of FETCH_START_FAILURE action', t => {
-  const state = reducer({start: null}, {type: RANK_FETCH_START_FAILURE});
-  t.deepEqual(state, {});
-});
-
-test('should do nothing if the start value already exists of FETCH_START_FAILURE action', t => {
-  const state = reducer({start: 93}, {type: RANK_FETCH_START_FAILURE});
-  t.deepEqual(state, {start: 93});
-});
-
-test("should set the end value to null if the value doesn't exist of FETCH_END_REQUEST action", t => {
-  const state = reducer({}, {type: RANK_FETCH_END_REQUEST});
-  t.deepEqual(state, {
-    end: null
-  });
-});
-
-test('should do nothing if an end value already exists of FETCH_END_REQUEST action', t => {
-  const state = reducer({end: 94}, {type: RANK_FETCH_END_REQUEST});
+test('should set the end value of FETCH_END_SUCCESS action', t => {
+  const state = reducer(
+    {
+      start: 93,
+      end: Number.NaN
+    },
+    {type: RANK_FETCH_END_SUCCESS, payload: {rank: 94}}
+  );
   t.deepEqual(state, {
+    start: 93,
     end: 94
   });
 });
 
-test('should set the end value of FETCH_END_SUCCESS action', t => {
-  const state = reducer({}, {type: RANK_FETCH_END_SUCCESS, payload: {rank: 94}});
+test('should unset the start and end value if the action is POST_PROGRESSION_SUCCESS', t => {
+  const state = reducer(
+    {
+      start: 93,
+      end: 94
+    },
+    {type: POST_PROGRESSION_SUCCESS, payload: postProgressionResponse}
+  );
   t.deepEqual(state, {
-    end: 94
+    start: Number.NaN,
+    end: Number.NaN
   });
 });
-
-test('should unset the end value if the value is null of FETCH_END_FAILURE action', t => {
-  const state = reducer({end: null}, {type: RANK_FETCH_END_FAILURE});
-  t.deepEqual(state, {});
-});
-
-test('should do nothing if the end value already exists of FETCH_END_FAILURE action', t => {
-  const state = reducer({end: 94}, {type: RANK_FETCH_END_FAILURE});
-  t.deepEqual(state, {end: 94});
-});

package/src/reducers/ui/index.ts

@@ -5,6 +5,8 @@ import navigation, {NavigationState} from './navigation';
 import answers, {UIAnswerState} from './answers';
 import positions, {UIPositionState} from './positions';
 import slide, {UISlideState} from './slide';
+import showQuitPopin, {type ShowQuitPopinState} from './quit-popin';
+import showCongrats, {UIShowCongratsState} from './show-congrats';
 
 export type UIState = {
   currentSlideRef: CurrentSlideRefState;
@@ -12,6 +14,8 @@ export type UIState = {
   answers: UIAnswerState;
   slide: UISlideState;
   positions: UIPositionState;
+  showQuitPopin: ShowQuitPopinState;
+  showCongrats: UIShowCongratsState;
 };
 
 export default combineReducers({
@@ -19,5 +23,7 @@ export default combineReducers({
   navigation,
   answers,
   slide,
-  positions
+  positions,
+  showQuitPopin,
+  showCongrats
 });

package/src/reducers/ui/navigation.ts

@@ -26,6 +26,4 @@ const reducer = (
   }
 };
 
-// -----------------------------------------------------------------------------
-
 export default reducer;

package/src/reducers/ui/positions.ts

@@ -17,7 +17,9 @@ const reducer = (
       return initialState;
     }
     case NEXT_SLIDE: {
-      const {totalCorrectAnswers, answeredSlides, currentSlideRef, animationType} = action.payload;
+      const {totalCorrectAnswers, answeredSlides, currentSlideRef, animationType, nextSlideRef} =
+        action.payload;
+      if (nextSlideRef === 'successExitNode') return state;
 
       const nextCurrentSlidePosition = animationType === 'unstack' ? -1 : 4 - totalCorrectAnswers;
       const currentSlideIndex = findIndex(ref => ref === currentSlideRef, answeredSlides);

package/src/reducers/ui/quit-popin.ts

@@ -0,0 +1,22 @@
+import {closeQuitPopin, CLOSE_POPIN, openQuitPopin, OPEN_POPIN} from '../../actions/ui/quit-popin';
+
+export type ShowQuitPopinState = boolean;
+
+const reducer = (
+  // eslint-disable-next-line default-param-last
+  state: ShowQuitPopinState = false,
+  action: typeof openQuitPopin | typeof closeQuitPopin
+): ShowQuitPopinState => {
+  switch (action.type) {
+    case OPEN_POPIN: {
+      return true;
+    }
+    case CLOSE_POPIN: {
+      return false;
+    }
+    default:
+      return state;
+  }
+};
+
+export default reducer;

package/src/reducers/ui/show-congrats.ts

@@ -0,0 +1,26 @@
+import {NextSlideAction, NEXT_SLIDE} from '../../actions/ui/next-slide';
+import {ReceivedProgression, POST_PROGRESSION_SUCCESS} from '../../actions/api/post-progression';
+
+export type UIShowCongratsState = boolean;
+
+const reducer = (
+  // eslint-disable-next-line default-param-last
+  state: UIShowCongratsState = false,
+  action: NextSlideAction | ReceivedProgression
+): UIShowCongratsState => {
+  switch (action.type) {
+    case POST_PROGRESSION_SUCCESS: {
+      return false;
+    }
+    case NEXT_SLIDE: {
+      const {nextSlideRef} = action.payload;
+      if (nextSlideRef === 'successExitNode') return true;
+
+      return false;
+    }
+    default:
+      return state;
+  }
+};
+
+export default reducer;

package/src/reducers/ui/slide.ts

@@ -72,9 +72,11 @@ const reducer = (
       )(state);
     }
     case NEXT_SLIDE: {
+      const {currentSlideRef, nextSlideRef} = action.payload;
+      if (nextSlideRef === 'successExitNode') return state;
       return pipe(
-        set([action.payload.currentSlideRef, 'animateCorrectionPopin'], false),
-        set([action.payload.currentSlideRef, 'animationType'], action.payload.animationType)
+        set([currentSlideRef, 'animateCorrectionPopin'], false),
+        set([currentSlideRef, 'animationType'], action.payload.animationType)
       )(state);
     }
     default:

package/src/reducers/ui/test/positions.test.ts

@@ -66,3 +66,17 @@ test('should set position for currentSlide according to the animationType and th
   });
   t.deepEqual(_state, [-1, 0, -1, 1, -1]);
 });
+
+test('should return same state when nextContent is successExitNode', t => {
+  const state = reducer([-1, 0, -1, 1, -1], {
+    type: NEXT_SLIDE,
+    payload: {
+      totalCorrectAnswers: 2,
+      answeredSlides: ['sli_1', 'sli_2', 'sli_3', 'sli_4', 'sli_5', 'sli_1'],
+      currentSlideRef: 'sli_1',
+      nextSlideRef: 'successExitNode',
+      animationType: 'unstack'
+    }
+  });
+  t.deepEqual(state, [-1, 0, -1, 1, -1]);
+});

package/src/reducers/ui/test/quit-popin.test.ts

@@ -0,0 +1,24 @@
+import test from 'ava';
+import {CLOSE_POPIN, OPEN_POPIN} from '../../../actions/ui/quit-popin';
+import reducer from '../quit-popin';
+
+test('should have showQuitPopin intial value to false', t => {
+  const state = reducer(undefined, {
+    type: '@@ui/CLOSE_POPIN'
+  });
+  t.is(state, false);
+});
+
+test('should set showQuitPopin to true if OPEN_POPIN is received', t => {
+  const state = reducer(false, {
+    type: OPEN_POPIN
+  });
+  t.is(state, true);
+});
+
+test('should set showQuitPopin to false if CLOSE_POPIN is received', t => {
+  const state = reducer(true, {
+    type: CLOSE_POPIN
+  });
+  t.is(state, false);
+});

package/src/reducers/ui/test/show-congrats.test.ts

@@ -0,0 +1,40 @@
+import test from 'ava';
+import reducer from '../show-congrats';
+import {
+  POST_PROGRESSION_SUCCESS,
+  type ReceivedProgression
+} from '../../../actions/api/post-progression';
+import {NEXT_SLIDE} from '../../../actions/ui/next-slide';
+
+test('should set state to false when received action is POST_ANSWER_REQUEST', t => {
+  const state = reducer(true, {type: POST_PROGRESSION_SUCCESS} as ReceivedProgression);
+  t.is(state, false);
+});
+
+test('should set state to false when received action is NEXT_SLIDE with nextSlideRef other than successExitNode', t => {
+  const state = reducer(undefined, {
+    type: NEXT_SLIDE,
+    payload: {
+      currentSlideRef: '1234',
+      nextSlideRef: '5678',
+      animationType: 'unstack',
+      totalCorrectAnswers: 1,
+      answeredSlides: ['1234']
+    }
+  });
+  t.is(state, false);
+});
+
+test('should set state to false when received action is NEXT_SLIDE with nextSlideRef successExitNode', t => {
+  const state = reducer(false, {
+    type: NEXT_SLIDE,
+    payload: {
+      currentSlideRef: '1234',
+      nextSlideRef: 'successExitNode',
+      animationType: 'unstack',
+      totalCorrectAnswers: 1,
+      answeredSlides: ['1234']
+    }
+  });
+  t.is(state, true);
+});

package/src/reducers/ui/test/slide.test.ts

@@ -87,3 +87,24 @@ test('should return state directly when there is no corresponding action handler
   const state = reducer(undefined, {type: 'NOPE'} as unknown as PostAnswerRequestAction);
   t.deepEqual(state, initialState);
 });
+
+test('should return same state when nextContent is successExitNode', t => {
+  const _initialState = {
+    '1234': {
+      validateButton: false,
+      animateCorrectionPopin: true,
+      showCorrectionPopin: true
+    }
+  };
+  const state = reducer(_initialState, {
+    type: NEXT_SLIDE,
+    payload: {
+      currentSlideRef: '1234',
+      nextSlideRef: 'successExitNode',
+      animationType: 'unstack',
+      totalCorrectAnswers: 5,
+      answeredSlides: ['1234']
+    }
+  });
+  t.deepEqual(state, _initialState);
+});