@coorpacademy/app-review 0.1.15 → 0.1.16

package/src/reducers/data/slides.ts

@@ -1,9 +1,14 @@
 import set from 'lodash/fp/set';
 import {ValidateSlide} from '../../actions/ui/slides';
-import {ReceivedSlide, SLIDE_FETCH_SUCCESS} from '../../actions/api/fetch-slide';
+import {
+  ReceivedSlide,
+  FetchSlide,
+  SLIDE_FETCH_REQUEST,
+  SLIDE_FETCH_SUCCESS
+} from '../../actions/api/fetch-slide';
 import {SlideFromAPI} from '../../types/common';
 
-export type SlidesAction = ReceivedSlide | ValidateSlide;
+export type SlidesAction = FetchSlide | ReceivedSlide | ValidateSlide;
 
 export type SlidesState = Record<string, SlideFromAPI>;
 export const initialState: SlidesState = {};
@@ -11,6 +16,10 @@ export const initialState: SlidesState = {};
 // eslint-disable-next-line default-param-last
 const reducer = (state: SlidesState = initialState, action: SlidesAction): SlidesState => {
   switch (action.type) {
+    case SLIDE_FETCH_REQUEST: {
+      const {meta} = action;
+      return set(meta.slideRef, null, state);
+    }
     case SLIDE_FETCH_SUCCESS: {
       const slide = action.payload;
       return set(slide.id, slide, state);

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

@@ -0,0 +1,42 @@
+import test from 'ava';
+import reducer from '../progression';
+import {POST_PROGRESSION_SUCCESS, ReceiveProgression} from '../../../actions/api/post-progression';
+import {ProgressionFromAPI} from '../../../types/common';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as ReceiveProgression);
+  t.is(state, null);
+});
+
+test('should set the value of POST_PROGRESSION_SUCCESS action', t => {
+  const progression: ProgressionFromAPI = {
+    _id: '62b1d1087aa12f00253f40ee',
+    content: {
+      ref: '_skill-ref',
+      type: 'skill'
+    },
+    engine: {
+      ref: 'review'
+    },
+    state: {
+      allAnswers: [],
+      isCorrect: true,
+      nextContent: {
+        ref: 'sli_N1XACJobn',
+        type: 'slide'
+      },
+      pendingSlides: [],
+      slides: [],
+      step: {
+        current: 1
+      },
+      stars: 0
+    }
+  };
+
+  const state = reducer(null, {
+    type: POST_PROGRESSION_SUCCESS,
+    payload: progression
+  });
+  t.deepEqual(state, progression);
+});

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

@@ -0,0 +1,14 @@
+import test from 'ava';
+import reducer from '../skills';
+import {ReceivedSkills, SKILLS_FETCH_SUCCESS} from '../../../actions/api/fetch-skills';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as ReceivedSkills);
+  t.deepEqual(state, []);
+});
+
+test('should set the value of SKILLS_FETCH_SUCCESS action', t => {
+  const skills = [{skillRef: 'skill', name: 'skill name', slidesToReview: 5, custom: false}];
+  const state = reducer([], {type: SKILLS_FETCH_SUCCESS, payload: skills});
+  t.deepEqual(state, skills);
+});

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

@@ -0,0 +1,26 @@
+import test from 'ava';
+import reducer, {type SlidesAction} from '../slides';
+import {SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS} from '../../../actions/api/fetch-slide';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as SlidesAction);
+  t.deepEqual(state, {});
+});
+
+test('should set the value of SLIDE_FETCH_REQUEST action', t => {
+  const state = reducer({}, {type: SLIDE_FETCH_REQUEST, meta: {slideRef: 'slideRef'}});
+  t.deepEqual(state, {
+    slideRef: null
+  });
+});
+
+test('should set the value of SLIDE_FETCH_SUCCESS action', t => {
+  const state = reducer(
+    {},
+    {type: SLIDE_FETCH_SUCCESS, payload: freeTextSlide, meta: {slideRef: 'sli_VJYjJnJhg'}}
+  );
+  t.deepEqual(state, {
+    sli_VJYjJnJhg: freeTextSlide
+  });
+});

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

@@ -0,0 +1,13 @@
+import test from 'ava';
+import reducer from '../token';
+import {StoreToken, STORE_TOKEN} from '../../../actions/data/token';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as StoreToken);
+  t.is(state, null);
+});
+
+test('should set the value of STORE_TOKEN action', t => {
+  const state = reducer(null, {type: STORE_TOKEN, payload: 'token'});
+  t.is(state, 'token');
+});

package/src/reducers/ui/answers.ts

@@ -0,0 +1,19 @@
+import {EditBasicAction, EDIT_BASIC} from '../../actions/ui/answers';
+
+export type AnswerState = string[];
+
+const reducer = (
+  // eslint-disable-next-line default-param-last
+  state: AnswerState = [],
+  action: EditBasicAction
+): AnswerState => {
+  switch (action.type) {
+    case EDIT_BASIC: {
+      return action.payload;
+    }
+    default:
+      return state;
+  }
+};
+
+export default reducer;

package/src/reducers/ui/index.ts

@@ -2,16 +2,16 @@ import {combineReducers} from 'redux';
 
 import currentSlideRef, {CurrentSlideRefState} from './current-slide-ref';
 import navigation, {NavigationState} from './navigation';
-import slides, {UISlidesState} from './slides';
+import answers, {AnswerState} from './answers';
 
 export type UIState = {
   currentSlideRef: CurrentSlideRefState;
   navigation: NavigationState;
-  slides: UISlidesState;
+  answers: AnswerState;
 };
 
 export default combineReducers({
   currentSlideRef,
   navigation,
-  slides
+  answers
 });

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

@@ -0,0 +1,13 @@
+import test from 'ava';
+import reducer from '../answers';
+import {EditBasicAction, EDIT_BASIC} from '../../../actions/ui/answers';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as EditBasicAction);
+  t.deepEqual(state, []);
+});
+
+test('should set the value of EDIT_BASIC action', t => {
+  const state = reducer([], {type: EDIT_BASIC, payload: ['value']});
+  t.deepEqual(state, ['value']);
+});

package/src/reducers/ui/test/current-slide-ref.test.ts

@@ -0,0 +1,14 @@
+import test from 'ava';
+import reducer from '../current-slide-ref';
+import {SetCurrentSlide, SET_CURRENT_SLIDE} from '../../../actions/ui/slides';
+import {freeTextSlide} from '../../../views/slides/test/fixtures/free-text';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as SetCurrentSlide);
+  t.is(state, '');
+});
+
+test('should set the value of SET_CURRENT_SLIDE action', t => {
+  const state = reducer('', {type: SET_CURRENT_SLIDE, payload: freeTextSlide});
+  t.is(state, 'sli_VJYjJnJhg');
+});

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

@@ -0,0 +1,19 @@
+import test from 'ava';
+import reducer from '../navigation';
+import {NavigateTo, NAVIGATE_TO, NAVIGATE_BACK} from '../../../actions/ui/navigation';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as NavigateTo);
+  t.deepEqual(state, []);
+});
+
+test('should set the value of NAVIGATE_TO and NAVIGATE_BACK action', t => {
+  const state = reducer([], {type: NAVIGATE_TO, payload: 'loader'});
+  t.deepEqual(state, ['loader']);
+
+  const updatedState = reducer(state, {type: NAVIGATE_TO, payload: 'skills'});
+  t.deepEqual(updatedState, ['loader', 'skills']);
+
+  const _updatedState = reducer(updatedState, {type: NAVIGATE_BACK});
+  t.deepEqual(_updatedState, ['loader']);
+});

package/src/services/fetch-slide.ts

@@ -6,7 +6,7 @@ import {toJSON} from './tools/fetch-responses';
 
 export const fetchSlide = async (slideRef: string, token: string): Promise<SlideFromAPI | void> => {
   const {host}: JWT = decode(token);
-  const response = await crossFetch(`${host}/api/v2/slide/${slideRef}`, {
+  const response = await crossFetch(`${host}/api/v2/slide/${slideRef}/parentContentTitle`, {
     headers: {authorization: token}
   });
 

package/src/services/index.ts

@@ -2,9 +2,11 @@ import {Services} from '../types/common';
 import {fetchSkills} from './fetch-skills';
 import {postProgression} from './post-progression';
 import {fetchSlide} from './fetch-slide';
+import {postAnswer} from './post-answer';
 
 export const getServices = (): Services => ({
   fetchSkills,
   fetchSlide,
-  postProgression
+  postProgression,
+  postAnswer
 });

package/src/services/post-answer.ts

@@ -0,0 +1,27 @@
+import crossFetch from 'cross-fetch';
+import decode from 'jwt-decode';
+
+import {JWT, ProgressionFromAPI} from '../types/common';
+import {toJSON} from './tools/fetch-responses';
+
+export const postAnswer = async (
+  skillRef: string,
+  token: string,
+  progressionId: string,
+  answer: string[]
+): Promise<ProgressionFromAPI> => {
+  const {host}: JWT = decode(token);
+  const response = await crossFetch(`${host}/api/v2/progressions/${progressionId}/answers`, {
+    method: 'post',
+    headers: {authorization: token},
+    body: JSON.stringify({
+      content: {
+        ref: skillRef,
+        type: 'slide'
+      },
+      answer
+    })
+  });
+
+  return toJSON<ProgressionFromAPI>(response);
+};

package/src/services/test/fetch-slide.test.ts

@@ -0,0 +1,30 @@
+import test from 'ava';
+import nock from 'nock';
+import {qcmDragSlide} from '../../views/slides/test/fixtures/qcm-drag';
+import {fetchSlide} from '../fetch-slide';
+
+test.before(() => {
+  nock('http://localhost:3000')
+    .get('/api/v2/slide/sli_123546/parentContentTitle')
+    .reply(200, qcmDragSlide);
+});
+
+test.after(() => {
+  nock.cleanAll();
+});
+
+test('should fetch a slide with the parentTitleContent info successfully', async t => {
+  const token = process.env.API_TEST_TOKEN || '';
+  const slide = await fetchSlide('sli_123546', token);
+  t.deepEqual(qcmDragSlide, slide);
+});
+
+test('should reject if a bad token is passed', async t => {
+  const badToken = 'token is not a jwt';
+  const error = await t.throwsAsync(() => fetchSlide('sli_123546', badToken));
+
+  t.is(
+    error?.message,
+    "Invalid token specified: Cannot read properties of undefined (reading 'replace')"
+  );
+});

package/src/services/test/post-answer.test.ts

@@ -0,0 +1,68 @@
+import test from 'ava';
+import nock from 'nock';
+import type {ProgressionFromAPI} from '../../types/common';
+import {postAnswer} from '../post-answer';
+
+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 result: ProgressionFromAPI = {
+  content: {
+    type: 'skill',
+    ref: skillRef
+  },
+  engine: {
+    ref: 'review'
+  },
+  _id: '123456123456',
+  state: {
+    allAnswers: [
+      {
+        slideRef: 'sli_NkvrWPFF2',
+        isCorrect: true,
+        answer
+      }
+    ],
+    isCorrect: true,
+    nextContent: {
+      type: 'slide',
+      ref: 'sli_NJ3m5KtWh'
+    },
+    pendingSlides: [],
+    slides: ['sli_NkvrWPFF2'],
+    content: {
+      ref: 'sli_NkvrWPFF2',
+      type: 'slide'
+    },
+    step: {
+      current: 2
+    },
+    stars: 4
+  }
+};
+
+test.before(() => {
+  const moocApi = nock('http://localhost:3000');
+  moocApi.post(`/api/v2/progressions/${progressionId}/answers`).reply(200, result);
+});
+
+test.after(() => {
+  nock.cleanAll();
+});
+
+test('should post the answers successfully', async t => {
+  const token = process.env.API_TEST_TOKEN || '';
+  const progression = await postAnswer(skillRef, token, progressionId, answer);
+  t.deepEqual(result, progression);
+});
+
+test('should reject bad token', async t => {
+  const badToken = 'token is not a jwt';
+  const error = await t.throwsAsync(() => postAnswer(skillRef, badToken, progressionId, answer));
+
+  t.is(
+    error?.message,
+    "Invalid token specified: Cannot read properties of undefined (reading 'replace')"
+  );
+});

package/src/services/test/post-progression.test.ts

@@ -6,6 +6,13 @@ import {postProgression} from '../post-progression';
 const skillRef = '_skill-ref';
 const result: ProgressionFromAPI = {
   _id: '123456123456',
+  content: {
+    ref: '_skill-ref',
+    type: 'skill'
+  },
+  engine: {
+    ref: 'review'
+  },
   state: {
     allAnswers: [],
     isCorrect: true,
@@ -17,7 +24,8 @@ const result: ProgressionFromAPI = {
     slides: [],
     step: {
       current: 1
-    }
+    },
+    stars: 0
   }
 };
 

package/src/test/util/services.mock.ts

@@ -1,4 +1,4 @@
-import {qcmSlide} from '../../helpers/test/fixtures/qcm';
+import {freeTextSlide} from '../../views/slides/test/fixtures/free-text';
 import {Services} from '../../types/common';
 
 export const services: Services = {
@@ -9,20 +9,17 @@ export const services: Services = {
         slidesToReview: 2,
         name: 'skill-test',
         custom: false
-        // TODO parentContentTitle
       },
       {
         skillRef: '_skill-ref-2',
         slidesToReview: 2,
         name: 'skill-test-2',
-        custom: true,
-        parentContentTitle: 'parentContentTitle 2'
-        // TODO parentContentTitle
+        custom: true
       }
     ]);
   },
   fetchSlide: ref => {
-    return Promise.resolve({...qcmSlide, universalRef: ref, id: ref});
+    return Promise.resolve({...freeTextSlide, universalRef: ref, id: ref});
   },
   postProgression: () => {
     return Promise.resolve({
@@ -45,7 +42,40 @@ export const services: Services = {
         slides: [],
         step: {
           current: 1
-        }
+        },
+        stars: 0
+      }
+    });
+  },
+  postAnswer: () => {
+    return Promise.resolve({
+      _id: '62b1d1087aa12f00253f40ee',
+      content: {
+        ref: '_skill-ref',
+        type: 'skill'
+      },
+      engine: {
+        ref: 'review'
+      },
+      state: {
+        allAnswers: [
+          {
+            slideRef: 'sli_N1XACJobn',
+            isCorrect: true,
+            answer: ['Le créateur peut fixer un pourcentage pour chaque transaction future']
+          }
+        ],
+        isCorrect: true,
+        nextContent: {
+          ref: 'sli_VkSQroQnx',
+          type: 'slide'
+        },
+        pendingSlides: [],
+        slides: ['sli_N1XACJobn'],
+        step: {
+          current: 2
+        },
+        stars: 4
       }
     });
   }

package/src/types/common.ts

@@ -25,25 +25,25 @@ type BaseContent = {
   choices: ChoiceFromAPI[];
 };
 
-type Question = {
+type BaseQuestion = {
   header?: string;
   content: BaseContent;
   explanation?: string;
 };
 
-export type QcmQuestion = Question & {
+export type QcmQuestion = BaseQuestion & {
   type: 'qcm';
 };
 
-export type QcmGraphicQuestion = Question & {
+export type QcmGraphicQuestion = BaseQuestion & {
   type: 'qcmGraphic';
 };
 
-export type QcmDragQuestion = Question & {
+export type QcmDragQuestion = BaseQuestion & {
   type: 'qcmDrag';
 };
 
-export type BasicQuestion = Omit<Question, 'content'> & {
+export type BasicQuestion = Omit<BaseQuestion, 'content'> & {
   type: 'basic';
   content: {
     media?: unknown;
@@ -53,7 +53,7 @@ export type BasicQuestion = Omit<Question, 'content'> & {
   };
 };
 
-export type SliderQuestion = Omit<Question, 'content'> & {
+export type SliderQuestion = Omit<BaseQuestion, 'content'> & {
   content: {
     media?: unknown;
     unitLabel: string;
@@ -64,27 +64,33 @@ export type SliderQuestion = Omit<Question, 'content'> & {
   type: 'slider';
 };
 
-export type TemplateQuestion = Omit<Question, 'content'> & {
+export type TemplateQuestion = Omit<BaseQuestion, 'content'> & {
   content: BaseContent & {
     template: string;
   };
   type: 'template';
 };
 
+export type Question =
+  | QcmQuestion
+  | QcmGraphicQuestion
+  | QcmDragQuestion
+  | BasicQuestion
+  | SliderQuestion
+  | TemplateQuestion;
+
 export type SlideFromAPI = {
-  question:
-    | QcmQuestion
-    | QcmGraphicQuestion
-    | QcmDragQuestion
-    | BasicQuestion
-    | SliderQuestion
-    | TemplateQuestion;
+  question: Question;
   klf: string;
   universalRef: string;
   tips?: string;
   clue?: string;
   hasClue?: boolean;
   id: string;
+  parentContentTitle: {
+    title: string;
+    type: 'chapter' | 'course';
+  };
 };
 
 type ProgressionAnswerItem = {
@@ -109,10 +115,18 @@ export type ProgressionState = {
   step: {
     current: number;
   };
+  stars: number;
 };
 
 export type ProgressionFromAPI = {
   _id: string;
+  content: {
+    type: 'skill';
+    ref: string;
+  };
+  engine: {
+    ref: 'review';
+  };
   state: ProgressionState;
 };
 
@@ -127,6 +141,12 @@ export type Services = {
   fetchSkills(token: string): Promise<Skill[]>;
   fetchSlide(slideRef: string, token: string): Promise<SlideFromAPI | void>;
   postProgression(skillRef: string, token: string): Promise<ProgressionFromAPI>;
+  postAnswer(
+    skillRef: string,
+    token: string,
+    progressionId: string,
+    answer: string[]
+  ): Promise<ProgressionFromAPI>;
 };
 
 export type Options = {