@coorpacademy/app-review 0.1.15 → 0.1.17

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

@@ -0,0 +1,80 @@
+import test from 'ava';
+import type {Services} from '../../../types/common';
+import {
+  fetchSlide,
+  SLIDE_FETCH_FAILURE,
+  SLIDE_FETCH_REQUEST,
+  SLIDE_FETCH_SUCCESS
+} from '../fetch-slide';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+import {services as mockedServices} from '../../../test/util/services.mock';
+import type {StoreState} from '../../../reducers';
+import {SET_CURRENT_SLIDE} from '../../ui/slides';
+import {createTestStore} from '../../test/create-test-store';
+
+const initialState: StoreState = {
+  data: {
+    progression: null,
+    slides: {},
+    skills: [],
+    token: '1234'
+  },
+  ui: {
+    currentSlideRef: '',
+    navigation: [],
+    answers: [],
+    slide: {
+      validateButton: false
+    }
+  }
+};
+
+test('should dispatch FETCH_SUCCESS and SET_CURRENT_SLIDE actions when fetchSlide return a slide', async t => {
+  const services: Services = {
+    ...mockedServices,
+    fetchSlide: (slideRef, token) => {
+      t.is(token, '1234');
+      t.is(slideRef, 'sli_VJYjJnJhg');
+      return Promise.resolve(freeTextSlide);
+    }
+  };
+
+  const expectedActions = [
+    {type: SLIDE_FETCH_REQUEST, meta: {slideRef: 'sli_VJYjJnJhg'}},
+    {
+      type: SLIDE_FETCH_SUCCESS,
+      meta: {slideRef: 'sli_VJYjJnJhg'},
+      payload: freeTextSlide
+    },
+    {type: SET_CURRENT_SLIDE, payload: freeTextSlide}
+  ];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+
+  await dispatch(fetchSlide('sli_VJYjJnJhg'));
+});
+
+test('should dispatch SLIDE_FETCH_FAILURE action when fetchSlide fails', async t => {
+  const services: Services = {
+    ...mockedServices,
+    fetchSlide: (slideRef, token) => {
+      t.is(token, '1234');
+      t.is(slideRef, 'slide_ref');
+      return Promise.reject(new Error('error'));
+    }
+  };
+
+  const expectedActions = [
+    {type: SLIDE_FETCH_REQUEST, meta: {slideRef: 'slide_ref'}},
+    {
+      type: SLIDE_FETCH_FAILURE,
+      meta: {slideRef: 'slide_ref'},
+      payload: new Error('error'),
+      error: true
+    }
+  ];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+
+  await dispatch(fetchSlide('slide_ref'));
+});

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

@@ -0,0 +1,101 @@
+import test from 'ava';
+import {createTestStore} from '../../test/create-test-store';
+import {postAnswerResponse, services} from '../../../test/util/services.mock';
+import {
+  postAnswer,
+  POST_ANSWER_FAILURE,
+  POST_ANSWER_REQUEST,
+  POST_ANSWER_SUCCESS
+} from '../post-answer';
+import type {StoreState} from '../../../reducers';
+import {SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS} from '../fetch-slide';
+import {qcmGraphicSlide} from '../../../views/slides/test/fixtures/qcm-graphic';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+import {SET_CURRENT_SLIDE} from '../../ui/slides';
+
+const progressionId = '123456789123';
+const skillRef = '_skill-ref';
+const answer = ['Lister vos tâches pour vous libérer l’esprit', 'Vous isoler dans un lieu calme'];
+
+const initialState: StoreState = {
+  data: {
+    progression: {
+      _id: progressionId,
+      content: {type: 'skill', ref: skillRef},
+      engine: {
+        ref: 'review'
+      },
+      state: {
+        allAnswers: [],
+        isCorrect: true,
+        nextContent: {
+          ref: 'sli_VJYjJnJhg',
+          type: 'slide'
+        },
+        pendingSlides: [],
+        slides: [],
+        step: {
+          current: 1
+        },
+        stars: 0
+      }
+    },
+    slides: {
+      [freeTextSlide.id]: freeTextSlide
+    },
+    skills: [{skillRef, custom: false, name: skillRef, slidesToReview: 5}],
+    token: '1234'
+  },
+  ui: {
+    currentSlideRef: 'sli_VJYjJnJhg',
+    navigation: ['skills', 'slides'],
+    answers: answer,
+    slide: {
+      validateButton: false
+    }
+  }
+};
+
+test('should dispatch POST_ANSWER_REQUEST, then POST_ANSWER_SUCCESS when the updated progression is returned', async t => {
+  const expectedActions = [
+    {type: POST_ANSWER_REQUEST},
+    {
+      type: POST_ANSWER_SUCCESS,
+      payload: postAnswerResponse
+    },
+    {type: SLIDE_FETCH_REQUEST, meta: {slideRef: 'sli_VkSQroQnx'}},
+    {
+      type: SLIDE_FETCH_SUCCESS,
+      meta: {slideRef: 'sli_VkSQroQnx'},
+      payload: qcmGraphicSlide
+    },
+    {type: SET_CURRENT_SLIDE, payload: qcmGraphicSlide}
+  ];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+
+  await dispatch(postAnswer);
+});
+
+test('should dispatch POST_ANSWER_REQUEST, then POST_ANSWER_FAILURE on error', async t => {
+  const expectedActions = [
+    {type: POST_ANSWER_REQUEST},
+    {
+      type: POST_ANSWER_FAILURE,
+      payload: new Error('unexpected'),
+      error: true
+    }
+  ];
+
+  const {dispatch} = createTestStore(
+    t,
+    initialState,
+    {
+      ...services,
+      postAnswer: () => Promise.reject(new Error('unexpected'))
+    },
+    expectedActions
+  );
+
+  await dispatch(postAnswer);
+});

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

@@ -0,0 +1,122 @@
+import test from 'ava';
+import type {ProgressionFromAPI, Services} from '../../../types/common';
+import {
+  postProgression,
+  POST_PROGRESSION_REQUEST,
+  POST_PROGRESSION_SUCCESS,
+  POST_PROGRESSION_FAILURE
+} from '../post-progression';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+import {services as mockedServices} from '../../../test/util/services.mock';
+import type {StoreState} from '../../../reducers';
+import {SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS} from '../fetch-slide';
+import {SET_CURRENT_SLIDE} from '../../ui/slides';
+import {createTestStore} from '../../test/create-test-store';
+
+const initialState: StoreState = {
+  data: {
+    progression: null,
+    slides: {},
+    skills: [],
+    token: '1234'
+  },
+  ui: {
+    currentSlideRef: '',
+    navigation: [],
+    answers: [],
+    slide: {
+      validateButton: false
+    }
+  }
+};
+
+test('should dispatch POST_PROGRESSION_SUCCESS and SLIDE_FETCH_REQUEST actions when postProgression return a progression', async t => {
+  const progression: ProgressionFromAPI = {
+    _id: '62b1d1087aa12f00253f40ee',
+    content: {
+      ref: '_skill-ref',
+      type: 'skill'
+    },
+    engine: {
+      ref: 'review'
+    },
+    state: {
+      allAnswers: [],
+      isCorrect: true,
+      nextContent: {
+        ref: 'sli_VJYjJnJhg',
+        type: 'slide'
+      },
+      pendingSlides: [],
+      slides: [],
+      step: {
+        current: 1
+      },
+      stars: 0
+    }
+  };
+
+  const services: Services = {
+    ...mockedServices,
+    postProgression: (skillRef, token) => {
+      t.is(token, '1234');
+      t.is(skillRef, 'skill_12345');
+      return Promise.resolve(progression);
+    },
+    fetchSlide: (slideRef, token) => {
+      t.is(token, '1234');
+      t.is(slideRef, 'sli_VJYjJnJhg');
+      return Promise.resolve(freeTextSlide);
+    }
+  };
+
+  const expectedActions = [
+    {type: POST_PROGRESSION_REQUEST},
+    {
+      type: POST_PROGRESSION_SUCCESS,
+      payload: progression
+    },
+    {
+      type: SLIDE_FETCH_REQUEST,
+      meta: {
+        slideRef: 'sli_VJYjJnJhg'
+      }
+    },
+    {
+      type: SLIDE_FETCH_SUCCESS,
+      meta: {
+        slideRef: 'sli_VJYjJnJhg'
+      },
+      payload: freeTextSlide
+    },
+    {type: SET_CURRENT_SLIDE, payload: freeTextSlide}
+  ];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+
+  await dispatch(postProgression('skill_12345'));
+});
+
+test('should dispatch POST_PROGRESSION_FAILURE action when postProgression fails', async t => {
+  const services: Services = {
+    ...mockedServices,
+    postProgression: (skillRef, token) => {
+      t.is(token, '1234');
+      t.is(skillRef, 'skill_12345');
+      return Promise.reject(new Error('error'));
+    }
+  };
+
+  const expectedActions = [
+    {type: POST_PROGRESSION_REQUEST},
+    {
+      type: POST_PROGRESSION_FAILURE,
+      payload: new Error('error'),
+      error: true
+    }
+  ];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+
+  await dispatch(postProgression('skill_12345'));
+});

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

@@ -0,0 +1,29 @@
+import test from 'ava';
+import {createTestStore} from '../../test/create-test-store';
+import {services} from '../../../test/util/services.mock';
+import {StoreState} from '../../../reducers';
+import {storeToken, STORE_TOKEN} from '../token';
+
+const initialState: StoreState = {
+  data: {
+    progression: null,
+    slides: {},
+    skills: [],
+    token: '1234'
+  },
+  ui: {
+    currentSlideRef: '',
+    navigation: [],
+    answers: [],
+    slide: {
+      validateButton: false
+    }
+  }
+};
+
+test('should dispatch STORE_TOKEN action when storeToken is called', async t => {
+  const expectedActions = [{type: STORE_TOKEN, payload: 'JWT.token'}];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+  await dispatch(storeToken('JWT.token'));
+});

package/src/actions/index.ts

@@ -1,22 +1,6 @@
-import {StoreToken} from './data/token';
-
-import {navigateBack, navigateTo, NavigateBack, NavigateTo, StartApp} from './ui/navigation';
-import {ReceivedSlide} from './api/fetch-slide';
-import {ReceiveProgression} from './api/post-progression';
-import {ReceivedSkills} from './api/fetch-skills';
-import {validateSlide} from './ui/slides';
-
-export type Action =
-  | NavigateBack
-  | NavigateTo
-  | ReceivedSkills
-  | StartApp
-  | ReceivedSlide
-  | StoreToken
-  | ReceiveProgression;
+import {navigateBack, navigateTo} from './ui/navigation';
 
 export type Dispatchers = {
   navigateTo: typeof navigateTo;
   navigateBack: typeof navigateBack;
-  validateSlide: typeof validateSlide;
 };

package/src/actions/test/create-test-store.ts

@@ -0,0 +1,25 @@
+import type {ExecutionContext} from 'ava';
+import constant from 'lodash/fp/constant';
+import {AnyAction, applyMiddleware, compose, createStore, Dispatch, Middleware, Store} from 'redux';
+import thunk from 'redux-thunk';
+import rootReducer, {StoreState} from '../../reducers';
+import {Services} from '../../types/common';
+
+const assertActionsMiddleware = (t: ExecutionContext, ACTIONS: AnyAction[]): Middleware =>
+  constant((next: Dispatch) => (action: AnyAction): unknown => {
+    const expectedAction = ACTIONS.shift();
+    if (!expectedAction) throw new Error(`Missing {type: "${action.type}"} action`);
+    t.deepEqual(action, expectedAction);
+    return next(action);
+  });
+
+export const createTestStore = (
+  t: ExecutionContext,
+  initialState: StoreState,
+  services: Services,
+  actions: AnyAction[]
+): Store => {
+  const thunkMiddleware = thunk.withExtraArgument({services});
+  const enhancer = compose(applyMiddleware(thunkMiddleware, assertActionsMiddleware(t, actions)));
+  return createStore(rootReducer, initialState, enhancer);
+};

package/src/actions/ui/answers.ts

@@ -0,0 +1,63 @@
+import {Dispatch} from 'redux';
+import {flatten, get, includes, pull} from 'lodash/fp';
+import type {StoreState} from '../../reducers';
+
+export const EDIT_QCM = '@@answer/EDIT_QCM' as const;
+export const EDIT_QCM_GRAPHIC = '@@answer/EDIT_QCM_GRAPHIC' as const;
+export const EDIT_QCM_DRAG = '@@answer/EDIT_QCM_DRAG' as const;
+export const EDIT_TEMPLATE = '@@answer/EDIT_TEMPLATE' as const;
+export const EDIT_BASIC = '@@answer/EDIT_BASIC' as const;
+export const EDIT_SLIDER = '@@answer/EDIT_SLIDER' as const;
+
+export const ANSWER_EDIT = {
+  qcm: EDIT_QCM,
+  qcmGraphic: EDIT_QCM_GRAPHIC,
+  qcmDrag: EDIT_QCM_DRAG,
+  template: EDIT_TEMPLATE,
+  basic: EDIT_BASIC,
+  slider: EDIT_SLIDER
+} as const;
+
+export type EditAnswerAction = {
+  type:
+    | typeof EDIT_QCM
+    | typeof EDIT_QCM_GRAPHIC
+    | typeof EDIT_QCM_DRAG
+    | typeof EDIT_TEMPLATE
+    | typeof EDIT_BASIC
+    | typeof EDIT_SLIDER;
+  payload: string[];
+};
+
+const buildAnswer = (userAnswers: string[], questionType: string, newValue: string): string[] => {
+  switch (questionType) {
+    case 'qcm':
+    case 'qcmGraphic':
+    case 'qcmDrag': {
+      return includes(newValue, userAnswers)
+        ? pull(newValue, userAnswers)
+        : flatten([...userAnswers, newValue]);
+    }
+    case 'basic':
+    case 'slider':
+      return [newValue];
+    default:
+      return [];
+  }
+};
+
+export const editAnswer =
+  (answer: string) =>
+  (dispatch: Dispatch, getState: () => StoreState): EditAnswerAction => {
+    const state = getState();
+    const currentSlideRef = get(['ui', 'currentSlideRef'])(state);
+    const userAnswers = get(['ui', 'answers'])(state);
+    const slide = get(['data', 'slides', currentSlideRef])(state);
+    const questionType = get(['question', 'type'])(slide);
+    const type = get(questionType, ANSWER_EDIT);
+
+    return dispatch({
+      type,
+      payload: buildAnswer(userAnswers, questionType, answer)
+    });
+  };

package/src/actions/ui/slides.ts

@@ -15,6 +15,7 @@ export type Slide = {
 };
 
 export const SET_CURRENT_SLIDE = '@@slide/SET_CURRENT_SLIDE' as const;
+
 export type SetCurrentSlide = {
   type: typeof SET_CURRENT_SLIDE;
   payload: SlideFromAPI;
@@ -24,12 +25,4 @@ export const setCurrentSlide = (payload: SlideFromAPI): SetCurrentSlide => ({
   payload
 });
 
-export const VALIDATE_SLIDE = '@@slide/VALIDATE';
-export type ValidateSlide = {
-  type: typeof VALIDATE_SLIDE;
-};
-export const validateSlide = (): ValidateSlide => ({
-  type: VALIDATE_SLIDE
-});
-
 export type UISlidesAction = SetCurrentSlide;

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

@@ -0,0 +1,103 @@
+import test from 'ava';
+import pipe from 'lodash/fp/pipe';
+import set from 'lodash/fp/set';
+import {SlideFromAPI} from '../../../types/common';
+import {createTestStore} from '../../test/create-test-store';
+import {services} from '../../../test/util/services.mock';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+import {qcmDragSlide} from '../../../views/slides/test/fixtures/qcm-drag';
+import {qcmSlide} from '../../../views/slides/test/fixtures/qcm';
+import {qcmGraphicSlide} from '../../../views/slides/test/fixtures/qcm-graphic';
+import {sliderSlide} from '../../../views/slides/test/fixtures/slider';
+import {StoreState} from '../../../reducers';
+import {editAnswer, ANSWER_EDIT} from '../answers';
+
+const initialState: StoreState = {
+  data: {
+    progression: {
+      _id: '62b1d1087aa12f00253f40ee',
+      content: {
+        ref: '_skill-ref',
+        type: 'skill'
+      },
+      engine: {
+        ref: 'review'
+      },
+      state: {
+        allAnswers: [],
+        isCorrect: true,
+        nextContent: {
+          ref: '',
+          type: 'slide'
+        },
+        pendingSlides: [],
+        slides: [],
+        step: {
+          current: 1
+        },
+        stars: 0
+      }
+    },
+    slides: {},
+    skills: [],
+    token: '1234'
+  },
+  ui: {
+    currentSlideRef: '',
+    navigation: [],
+    answers: [],
+    slide: {
+      validateButton: false
+    }
+  }
+};
+
+const buildInitialState = (state: StoreState, question: SlideFromAPI): StoreState => {
+  return pipe(
+    set(['data', 'progression', 'state', 'nextContent', 'ref'], question.id),
+    set(['data', 'slides', question.id], question),
+    set(['ui', 'currentSlideRef'], question.id)
+  )(state);
+};
+
+test('should dispatch EDIT_BASIC action when editAnswer is called', async t => {
+  const state = buildInitialState(initialState, freeTextSlide);
+  const expectedActions = [{type: ANSWER_EDIT.basic, payload: ['My Answer']}];
+  const {dispatch} = createTestStore(t, state, services, expectedActions);
+  await dispatch(editAnswer('My Answer'));
+});
+
+test('should dispatch EDIT_QCM action when editAnswer is called', async t => {
+  let state = buildInitialState(initialState, qcmSlide);
+  state = set(['ui', 'answers'], ['My First Answer', 'My Second Answer'], state);
+  const expectedActions = [{type: ANSWER_EDIT.qcm, payload: ['My First Answer']}];
+  const {dispatch} = createTestStore(t, state, services, expectedActions);
+  await dispatch(editAnswer('My Second Answer'));
+});
+
+test('should dispatch EDIT_QCM_GRAPHIC action when editAnswer is called', async t => {
+  let state = buildInitialState(initialState, qcmGraphicSlide);
+  state = set(['ui', 'answers'], ['My First Answer', 'My Second Answer', 'My Third Answer'], state);
+  const expectedActions = [
+    {type: ANSWER_EDIT.qcmGraphic, payload: ['My First Answer', 'My Third Answer']}
+  ];
+  const {dispatch} = createTestStore(t, state, services, expectedActions);
+  await dispatch(editAnswer('My Second Answer'));
+});
+
+test('should dispatch EDIT_QCM_DRAG action when editAnswer is called', async t => {
+  let state = buildInitialState(initialState, qcmDragSlide);
+  state = set(['ui', 'answers'], ['My First Answer', 'My Second Answer'], state);
+  const expectedActions = [
+    {type: ANSWER_EDIT.qcmDrag, payload: ['My First Answer', 'My Second Answer', 'My Third Answer']}
+  ];
+  const {dispatch} = createTestStore(t, state, services, expectedActions);
+  await dispatch(editAnswer('My Third Answer'));
+});
+
+test('should dispatch EDIT_SLIDER action when editAnswer is called', async t => {
+  const state = buildInitialState(initialState, sliderSlide);
+  const expectedActions = [{type: ANSWER_EDIT.slider, payload: ['5']}];
+  const {dispatch} = createTestStore(t, state, services, expectedActions);
+  await dispatch(editAnswer('5'));
+});

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

@@ -0,0 +1,30 @@
+import test from 'ava';
+import {createTestStore} from '../../test/create-test-store';
+import {services} from '../../../test/util/services.mock';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+import {StoreState} from '../../../reducers';
+import {setCurrentSlide, SET_CURRENT_SLIDE} from '../slides';
+
+const initialState: StoreState = {
+  data: {
+    progression: null,
+    slides: {},
+    skills: [],
+    token: '1234'
+  },
+  ui: {
+    currentSlideRef: '',
+    navigation: [],
+    answers: [],
+    slide: {
+      validateButton: false
+    }
+  }
+};
+
+test('should dispatch SET_CURRENT_SLIDE action when setCurrentSlide is called', async t => {
+  const expectedActions = [{type: SET_CURRENT_SLIDE, payload: freeTextSlide}];
+
+  const {dispatch} = createTestStore(t, initialState, services, expectedActions);
+  await dispatch(setCurrentSlide(freeTextSlide));
+});

package/src/common/index.ts

@@ -1,8 +1,3 @@
-import _toString from 'lodash/fp/toString';
-
-export const TOTAL_SLIDES_STACK = 5;
-export const HIGHEST_INDEX = TOTAL_SLIDES_STACK - 1;
-
 export const VIEWS: {
   readonly skills: 'skills';
   readonly onboarding: 'onboarding';
@@ -16,5 +11,3 @@ export const VIEWS: {
 export const slideIndexes = ['0', '1', '2', '3', '4'] as const;
 
 export type SlideIndexes = typeof slideIndexes[number];
-
-export const indexToString = (index: number): SlideIndexes => _toString(index) as SlideIndexes;