@coorpacademy/app-review 0.1.5 → 0.1.7

package/es/actions/data/progression.d.ts

@@ -0,0 +1,30 @@
+export declare type ProgressionFromAPI = {
+    _id: string;
+    state: {
+        isCorrect: boolean;
+        step: {
+            current: number;
+        };
+        nextContent: {
+            type: 'success' | 'slide';
+            ref: 'successExitNode' | string;
+        };
+        pendingSlides: [];
+    };
+};
+export declare const RECEIVE_PROGRESSION = "@@data/progression/RECEIVE_PROGRESSION";
+export declare const ERROR_CREATING_PROGRESSION = "@@data/progression/ERROR_CREATING_PROGRESSION";
+export declare type ReceiveProgressionPayload = {
+    progression: ProgressionFromAPI;
+    token: string;
+};
+export declare type ReceiveProgression = {
+    type: typeof RECEIVE_PROGRESSION;
+    payload: ReceiveProgressionPayload;
+};
+export declare type ErrorCreatingProgression = {
+    type: typeof ERROR_CREATING_PROGRESSION;
+    payload: Error;
+};
+export declare const receiveProgression: (payload: ReceiveProgressionPayload) => ReceiveProgression;
+export declare const errorCreatingProgression: (error: Error) => ErrorCreatingProgression;

package/es/actions/data/progression.js

@@ -0,0 +1,12 @@
+// -----------------------------------------------------------------------------
+export const RECEIVE_PROGRESSION = '@@data/progression/RECEIVE_PROGRESSION';
+export const ERROR_CREATING_PROGRESSION = '@@data/progression/ERROR_CREATING_PROGRESSION';
+// -----------------------------------------------------------------------------
+export const receiveProgression = (payload) => ({
+    type: RECEIVE_PROGRESSION,
+    payload
+});
+export const errorCreatingProgression = (error) => ({
+    type: ERROR_CREATING_PROGRESSION,
+    payload: error
+});

package/es/actions/data/slides.d.ts

@@ -1,32 +1,35 @@
-import { Slide as SlideFromAPI } from '../../types/slides';
+import { Slide as UISlide } from '../../types/slides';
 export declare const STORE_FIRST_SLIDE = "@@slide/STORE_FIRST_SLIDE";
 export declare const UPDATE_SLIDES_ON_VALIDATION = "@@slide/UPDATE_SLIDES_ON_VALIDATION";
 export declare const UPDATE_SLIDES_ON_NEXT = "@@slide/UPDATE_SLIDES_ON_NEXT";
 export declare const VALIDATE_SLIDE = "@@slide/VALIDATE";
 export declare const FETCH_NEXT_CONTENT = "@@slide/FETCH_NEXT_CONTENT";
+export declare const ERROR_FETCHING_SLIDE = "@@data/slide/ERROR_FETCHING_SLIDE";
 declare type SlideUIAnimations = 'unstack' | 'restack';
-export declare type Slide = SlideFromAPI & {
+export declare type Slide = UISlide & {
     hidden?: boolean;
     position: number;
     animationType?: SlideUIAnimations;
     isCorrect?: boolean;
     endReview?: boolean;
-    nextSlide?: Omit<Slide, 'endReview' | 'hidden' | 'position' | 'nextSlide'>;
+    nextContent?: Omit<Slide, 'endReview' | 'hidden' | 'position' | 'nextContent'>;
+};
+export declare type SlideFromAPI = {
+    question: {
+        content: {
+            choices: Record<string, unknown>[];
+        };
+    };
+    klf: string;
+    universalRef: string;
 };
 export declare type ValidationPayload = {
     slideNumber: number;
     newSlideContent: Slide;
     numberOfFinishedSlides: number;
-    nextSlide: Slide;
-};
-export declare type OnNextPayload = Omit<ValidationPayload, 'nextSlide'>;
-export declare type FetchNextPayload = {
-    answer: string[];
-    content: {
-        ref: string;
-        type: string;
-    };
+    nextContent: Slide;
 };
+export declare type OnNextPayload = Omit<ValidationPayload, 'nextContent'>;
 export declare type StoreFirstSlide = {
     type: typeof STORE_FIRST_SLIDE;
     payload: SlideFromAPI;
@@ -42,13 +45,14 @@ export declare type UpdateSlidesOnNext = {
 export declare type ValidateSlide = {
     type: typeof VALIDATE_SLIDE;
 };
-export declare type FetchNextContent = {
-    type: typeof FETCH_NEXT_CONTENT;
-    payload: FetchNextPayload;
+export declare type ErrorFetchingSlide = {
+    type: typeof ERROR_FETCHING_SLIDE;
+    payload: Error;
 };
 export declare type SlidesAction = StoreFirstSlide | UpdateSlidesOnValidation | UpdateSlidesOnNext;
 export declare const storeFirstSlide: (slide: SlideFromAPI) => StoreFirstSlide;
 export declare const updateSlidesOnValidation: (payload: ValidationPayload) => UpdateSlidesOnValidation;
 export declare const updateSlidesOnNext: (payload: OnNextPayload) => UpdateSlidesOnNext;
 export declare const validateSlide: () => ValidateSlide;
+export declare const errorFetchingSlide: (error: Error) => ErrorFetchingSlide;
 export {};

package/es/actions/data/slides.js

@@ -4,6 +4,7 @@ export const UPDATE_SLIDES_ON_VALIDATION = '@@slide/UPDATE_SLIDES_ON_VALIDATION'
 export const UPDATE_SLIDES_ON_NEXT = '@@slide/UPDATE_SLIDES_ON_NEXT';
 export const VALIDATE_SLIDE = '@@slide/VALIDATE';
 export const FETCH_NEXT_CONTENT = '@@slide/FETCH_NEXT_CONTENT';
+export const ERROR_FETCHING_SLIDE = '@@data/slide/ERROR_FETCHING_SLIDE';
 // -----------------------------------------------------------------------------
 export const storeFirstSlide = (slide) => ({
     type: STORE_FIRST_SLIDE,
@@ -20,3 +21,7 @@ export const updateSlidesOnNext = (payload) => ({
 export const validateSlide = () => ({
     type: VALIDATE_SLIDE
 });
+export const errorFetchingSlide = (error) => ({
+    type: ERROR_FETCHING_SLIDE,
+    payload: error
+});

package/es/actions/data/token.d.ts

@@ -1,6 +1,6 @@
-export declare const STORE_TOKEN = "@@token/STORE_TOKEN";
+export declare const STORE_TOKEN = "@@data/token/STORE_TOKEN";
 export declare type StoreToken = {
-    type: '@@token/STORE_TOKEN';
+    type: typeof STORE_TOKEN;
     payload: string;
 };
 export declare const storeToken: (token: string) => StoreToken;

package/es/actions/data/token.js

@@ -1,4 +1,4 @@
-export const STORE_TOKEN = '@@token/STORE_TOKEN';
+export const STORE_TOKEN = '@@data/token/STORE_TOKEN';
 export const storeToken = (token) => ({
     type: STORE_TOKEN,
     payload: token

package/es/actions/index.d.ts

@@ -5,7 +5,8 @@ import { updateFinishedSlides } from './ui/finished-slides';
 import { navigateBack, navigateTo, NavigateBack, NavigateTo, StartApp } from './ui/navigation';
 import { updateReviewStatus } from './ui/review-status';
 import { updateStepItemsOnValidation, updateStepItemsOnNext } from './ui/step-items';
-export declare type Action = NavigateBack | NavigateTo | ReceivedSkills | ErrorFetchingSkills | StartApp | StoreFirstSlide | StoreToken;
+import { ErrorCreatingProgression, ReceiveProgression } from './data/progression';
+export declare type Action = NavigateBack | NavigateTo | ReceivedSkills | ErrorFetchingSkills | StartApp | StoreFirstSlide | StoreToken | ErrorCreatingProgression | ReceiveProgression;
 export declare type Dispatchers = {
     navigateTo: typeof navigateTo;
     navigateBack: typeof navigateBack;

package/es/configure-store.d.ts

@@ -6,18 +6,10 @@ import { NavigationState } from './reducers/ui/navigation';
 import { ReviewStatusState } from './reducers/ui/review-status';
 import { StepItemsState } from './reducers/ui/step-items';
 import { FinishedSlidesState } from './reducers/ui/finished-slides';
-import { AnswerUI } from './types/slides';
+import { ProgressionState } from './reducers/data/progression';
 declare type DataState = {
     isFetching?: boolean;
-    progression?: {
-        slideNumber: number;
-        isCorrect?: boolean;
-        exitNode?: 'successExitNode' | 'failExitNode';
-        nextSlide?: {
-            questionText?: string;
-            answerUI?: AnswerUI;
-        };
-    } | null;
+    progression?: ProgressionState;
     skills: SkillsState;
     slides: SlidesState;
     token?: TokenState;

package/es/configure-store.js

@@ -2,6 +2,7 @@ import { applyMiddleware, compose, createStore } from 'redux';
 import thunk from 'redux-thunk';
 import rootReducer from './reducers';
 import onStartApp from './middlewares/on-start-app';
+import onReceiveProgression from './middlewares/on-receive-progression';
 // -----------------------------------------------------------------------------
 export default function configureStore() {
     const _compose = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
@@ -11,7 +12,7 @@ export default function configureStore() {
             traceLimit: 25
         })
         : compose;
-    const enhancer = _compose(applyMiddleware(thunk, onStartApp));
+    const enhancer = _compose(applyMiddleware(thunk, onStartApp, onReceiveProgression));
     const store = createStore(rootReducer, undefined, enhancer);
     return store;
 }

package/es/index.d.ts

@@ -1,7 +1,7 @@
 import type { AppOptions } from './types/common';
 declare const AppReview: ({ options }: {
     options: AppOptions;
-}) => JSX.Element;
+}) => JSX.Element | null;
 declare global {
     interface Window {
         __REDUX_DEVTOOLS_EXTENSION__?: boolean;

package/es/index.js

@@ -1,6 +1,7 @@
 import React, { useEffect, useState } from 'react';
 import { connect, Provider } from 'react-redux';
 import AppReviewTemplate from '@coorpacademy/components/es/template/app-review';
+import { TemplateContext } from '@coorpacademy/components/es/template/app-review/template-context';
 import configureStore from './configure-store';
 import { congratsProps, correctionPopinProps } from './fixtures/temp-fixture';
 import { updateSlidesOnNext, updateSlidesOnValidation, validateSlide } from './actions/data/slides';
@@ -21,29 +22,38 @@ const mapDispatchToProps = {
     updateFinishedSlides
 };
 const getCurrentViewName = (storeState) => storeState.ui.navigation[storeState.ui.navigation.length - 1];
-const mapStateToSkillsProps = (state) => ({
-    title: '@todo title',
-    titleNoSkills: '@todo titleNoSkills',
-    textNoSkills: '@todo textNoSkills',
-    iconSkillAriaLabel: '@todo iconSkillAriaLabel',
-    isLoading: false,
-    isLoadingAriaLabel: '@todo loading',
-    listSkills: state.data.skills.map(skill => ({
-        'aria-label': '',
-        isCustom: skill.custom,
-        skillTitle: skill.name,
-        skillAriaLabel: '@todo skill aria label',
-        buttonLabel: '@todo button',
-        buttonAriaLabel: '@todo button aria label',
-        reviseLabel: '@todo revise',
-        reviseAriaLabel: '@todo revise aria label',
-        // eslint-disable-next-line no-console
-        onClick: () => console.log('@todo plug dispatcher select skill')
-    }))
-});
-const mapStateToProps = (state) => ({
-    viewName: getCurrentViewName(state),
-    slides: {
+// -----------------------------------------------------------------------------
+const mapStateToSkillsProps = (state) => {
+    if (!state.data.skills) {
+        return null;
+    }
+    return {
+        title: '@todo title',
+        titleNoSkills: '@todo titleNoSkills',
+        textNoSkills: '@todo textNoSkills',
+        iconSkillAriaLabel: '@todo iconSkillAriaLabel',
+        isLoading: false,
+        isLoadingAriaLabel: '@todo loading',
+        listSkills: state.data.skills.map(skill => ({
+            'aria-label': '',
+            isCustom: skill.custom,
+            skillTitle: skill.name,
+            skillAriaLabel: '@todo skill aria label',
+            buttonLabel: '@todo button',
+            buttonAriaLabel: '@todo button aria label',
+            reviseLabel: '@todo revise',
+            reviseAriaLabel: '@todo revise aria label',
+            // eslint-disable-next-line no-console
+            onClick: () => console.log('@todo plug dispatcher select skill')
+        }))
+    };
+};
+// -----------------------------------------------------------------------------
+const mapStateToSlidesProps = (state) => {
+    if (!state.data.slides) {
+        return null;
+    }
+    return {
         headerProps: {
             mode: '__revision_mode',
             skillName: '__agility',
@@ -64,7 +74,12 @@ const mapStateToProps = (state) => ({
         correctionPopinProps,
         congratsProps,
         progression: state.data.progression
-    },
+    };
+};
+// -----------------------------------------------------------------------------
+const mapStateToProps = (state) => ({
+    viewName: getCurrentViewName(state),
+    slides: mapStateToSlidesProps(state),
     skills: mapStateToSkillsProps(state)
 });
 // Props = StaticProps && Dispatchers
@@ -87,9 +102,11 @@ const AppReview = ({ options }) => {
         }
     }, [options, store]);
     if (!store || !appStarted)
-        return React.createElement("div", null);
+        return null;
+    const { templateContext: values } = options;
     return (React.createElement(Provider, { store: store },
-        React.createElement(App, null)));
+        React.createElement(TemplateContext, { values: values },
+            React.createElement(App, null))));
 };
 // -----------------------------------------------------------------------------
 export default AppReview;

package/es/index.test.js

@@ -2,13 +2,10 @@ import browserEnv from 'browser-env';
 import test from 'ava';
 import React from 'react';
 import { render, fireEvent, act } from '@testing-library/react';
-import { slide } from './fixtures/qcm-slide';
+import { sleep } from './services/tools/sleep';
 import AppReview from '.';
 browserEnv({ pretendToBeVisual: true });
 const elementExists = (foundElements) => foundElements && foundElements[0];
-const sleep = (msToSleep) => new Promise(resolve => {
-    setTimeout(resolve, msToSleep);
-});
 const waitForChanges = async (msToWait = 3000) => {
     await act(async () => {
         await sleep(msToWait); // wait *just* a little longer than the timeout in the component
@@ -37,7 +34,10 @@ const clickAllSlides = async (t, container, accumulator = 0) => {
 };
 const appOptions = {
     token: process.env.API_TEST_TOKEN || '',
-    slide
+    templateContext: {
+        theme: { color: { primary: '#123' } }
+    },
+    skillRef: 'skill_NJC0jFKoH'
 };
 test('should validate all the slides (all correct scenario)', async (t) => {
     t.plan(13);

package/es/middlewares/on-receive-progression.d.ts

@@ -0,0 +1,6 @@
+import type { Middleware, Store } from 'redux';
+import { Dispatch } from 'redux';
+import { ErrorFetchingSlide, StoreFirstSlide } from '../actions/data/slides';
+import { ReceiveProgression } from '../actions/data/progression';
+declare const onReceiveProgression: Middleware<{}, Store, Dispatch<ReceiveProgression | StoreFirstSlide | ErrorFetchingSlide>>;
+export default onReceiveProgression;

package/es/middlewares/on-receive-progression.js

@@ -0,0 +1,22 @@
+import get from 'lodash/fp/get';
+// eslint-disable-next-line import/no-named-as-default
+import fetchSlide from '../services/fetch-slide';
+import { errorFetchingSlide, storeFirstSlide } from '../actions/data/slides';
+import { RECEIVE_PROGRESSION } from '../actions/data/progression';
+const onReceiveProgression = ({ dispatch }) => next => (action) => {
+    if (action.type === RECEIVE_PROGRESSION) {
+        const { progression, token } = action.payload;
+        const slideRef = get('state.nextContent.ref', progression);
+        // TOASK: do we need to check for exit nodes before fetching??
+        // TODO: To implement fetchSlide in next ticket
+        fetchSlide(slideRef, token)
+            .then(slide => {
+            return dispatch(storeFirstSlide(slide));
+        })
+            .catch(err => {
+            return dispatch(errorFetchingSlide(err));
+        });
+    }
+    return next(action);
+};
+export default onReceiveProgression;

package/es/middlewares/on-receive-progression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/middlewares/on-receive-progression.test.js

@@ -0,0 +1,43 @@
+import test from 'ava';
+import { receiveProgression } from '../actions/data/progression';
+import { mockedProgression } from '../services/post-progression.mock';
+import { sleep } from '../services/tools/sleep';
+import { STORE_FIRST_SLIDE } from '../actions/data/slides';
+import onReceiveProgression from './on-receive-progression';
+const appOptions = {
+    token: process.env.API_TEST_TOKEN || ''
+};
+const otherAction = (payload) => ({
+    type: '@@other/OTHER',
+    payload
+});
+test('should not dispatch anything if action is not RECEIVE_PROGRESSION', t => {
+    t.plan(1);
+    const dispatch = () => {
+        t.fail();
+    };
+    const next = () => {
+        return t.pass();
+    };
+    onReceiveProgression({ dispatch })(next)(otherAction('other'));
+});
+test('should dispatch actions: STORE_FIRST_SLIDE', async (t) => {
+    t.plan(2);
+    const dispatch = (action) => {
+        switch (action.type) {
+            case STORE_FIRST_SLIDE: {
+                const slide = action.payload;
+                t.deepEqual(slide, {});
+                return;
+            }
+            default:
+                t.fail();
+                break;
+        }
+    };
+    const next = () => {
+        return t.pass();
+    };
+    onReceiveProgression({ dispatch })(next)(receiveProgression({ token: appOptions.token, progression: mockedProgression }));
+    await sleep(1000); // wait for the .then to fire
+});

package/es/middlewares/on-start-app.js

@@ -1,16 +1,24 @@
 import { VIEWS } from '../common';
 import { storeToken } from '../actions/data/token';
 import { receivedSkills, errorFetchingSkills } from '../actions/data/skills';
-import { storeFirstSlide } from '../actions/data/slides';
 import { navigateTo, START_APP } from '../actions/ui/navigation';
 // eslint-disable-next-line import/no-named-as-default
 import fetchSkills from '../services/fetch-skills';
+// eslint-disable-next-line import/no-named-as-default
+import postProgression from '../services/post-progression';
+import { errorCreatingProgression, receiveProgression } from '../actions/data/progression';
 const onStartApp = ({ dispatch }) => next => (action) => {
     if (action.type === START_APP) {
-        const { slide, token } = action.payload;
+        const { skillRef, token } = action.payload;
         dispatch(storeToken(token));
-        if (slide) {
-            dispatch(storeFirstSlide(slide));
+        if (skillRef) {
+            postProgression(skillRef, token)
+                .then(progression => {
+                return dispatch(receiveProgression({ progression, token }));
+            })
+                .catch(err => {
+                return dispatch(errorCreatingProgression(err));
+            });
         }
         else {
             fetchSkills(token)
@@ -21,7 +29,7 @@ const onStartApp = ({ dispatch }) => next => (action) => {
                 return dispatch(errorFetchingSkills(err));
             });
         }
-        const initialView = slide ? VIEWS.slides : VIEWS.skills;
+        const initialView = skillRef ? VIEWS.slides : VIEWS.skills;
         dispatch(navigateTo(initialView));
     }
     return next(action);

package/es/middlewares/on-start-app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/middlewares/on-start-app.test.js

@@ -0,0 +1,53 @@
+import test from 'ava';
+import { STORE_TOKEN } from '../actions/data/token';
+import { RECEIVE_PROGRESSION } from '../actions/data/progression';
+import { NAVIGATE_TO, startApp } from '../actions/ui/navigation';
+import { mockedProgression } from '../services/post-progression.mock';
+import { VIEWS } from '../common';
+import { sleep } from '../services/tools/sleep';
+import onStartApp from './on-start-app';
+const appOptions = {
+    token: process.env.API_TEST_TOKEN || '',
+    skillRef: 'skill_NJC0jFKoH'
+};
+const otherAction = (payload) => ({
+    type: '@@other/OTHER',
+    payload
+});
+test('should not dispatch anything if action is not START_APP', t => {
+    t.plan(1);
+    const dispatch = () => {
+        t.fail();
+    };
+    const next = () => {
+        return t.pass();
+    };
+    onStartApp({ dispatch })(next)(otherAction('other'));
+});
+test('should dispatch actions: STORE_TOKEN && RECEIVE_PROGRESSION if an skillRef is given, on a successful response', async (t) => {
+    t.plan(5);
+    const dispatch = (action) => {
+        switch (action.type) {
+            case STORE_TOKEN:
+                t.is(action.payload, appOptions.token);
+                return;
+            case RECEIVE_PROGRESSION: {
+                const { token, progression } = action.payload;
+                t.is(token, appOptions.token);
+                t.deepEqual(progression, JSON.parse(JSON.stringify(mockedProgression)));
+                return;
+            }
+            case NAVIGATE_TO:
+                t.is(action.payload, VIEWS.slides);
+                return;
+            default:
+                t.fail();
+                break;
+        }
+    };
+    const next = () => {
+        return t.pass();
+    };
+    onStartApp({ dispatch })(next)(startApp(appOptions));
+    await sleep(1000); // wait for the .then to fire
+});

package/es/reducers/data/index.d.ts

@@ -3,5 +3,5 @@ declare const _default: import("redux").Reducer<import("redux").CombinedState<{
     skills: import("../../types/skills").Skills;
     slides: import("./slides").SlidesState;
     token: import("./token").TokenState;
-}>, import("../../actions/data/slides").ValidateSlide | import("../../actions/data/slides").SlidesAction | import("../../actions/data/skills").ReceivedSkills | import("../../actions/data/token").StoreToken>;
+}>, import("../../actions/data/progression").ReceiveProgression | import("../../actions/data/slides").ValidateSlide | import("../../actions/data/slides").SlidesAction | import("../../actions/data/skills").ReceivedSkills | import("../../actions/data/token").StoreToken>;
 export default _default;

package/es/reducers/data/progression.d.ts

@@ -1,14 +1,20 @@
+import { ReceiveProgression } from '../../actions/data/progression';
 import { ValidateSlide } from '../../actions/data/slides';
-import { AnswerUI } from '../../types/slides';
 export declare type ProgressionState = {
-    slideNumber: number;
-    isCorrect?: boolean;
-    exitNode?: 'successExitNode' | 'failExitNode';
-    nextSlide?: {
-        questionText?: string;
-        answerUI?: AnswerUI;
+    _id?: string;
+    state: {
+        isCorrect: boolean;
+        nextContent: {
+            ref: 'successExitNode' | string;
+            type: 'success' | 'slide';
+        };
+        pendingSlides: string[];
+        step: {
+            current: number;
+        };
     };
+    slideNumber?: number;
 } | null;
 export declare const initialState: ProgressionState;
-declare const reducer: (state: ProgressionState | undefined, action: ValidateSlide) => ProgressionState;
+declare const reducer: (state: ProgressionState | undefined, action: ValidateSlide | ReceiveProgression) => ProgressionState;
 export default reducer;

package/es/reducers/data/progression.js

@@ -1,4 +1,5 @@
-import { getOr, noop } from 'lodash/fp';
+import { getOr } from 'lodash/fp';
+import { RECEIVE_PROGRESSION } from '../../actions/data/progression';
 import { VALIDATE_SLIDE } from '../../actions/data/slides';
 // -----------------------------------------------------------------------------
 export const initialState = null;
@@ -10,66 +11,28 @@ state = initialState, action) => {
         case VALIDATE_SLIDE: {
             const previousSlideNumber = getOr(-1, 'slideNumber', state);
             // hard coded for now
+            // TODO: fix on VALIDATE ticket
             return {
+                _id: '1234',
                 // virtual field
                 slideNumber: previousSlideNumber + 1,
-                isCorrect: true,
-                // exitNode
-                // TODO: create another action, to retrieve the next slide
-                // nextSlide should be corrected to nextContent, when this new action is created
-                // ex: nextContent: {ref: "sli_E1n2i2sBo", type: "slide"}
-                // the middleware should trigger a next content request once the result is
-                // received && update the state accordingly,
-                //
-                nextSlide: {
-                    questionText: 'Test',
-                    answerUI: {
-                        model: {
-                            answers: [
-                                {
-                                    title: 'There is no need for a password',
-                                    // TODO: onClick of each answer should use a dispatcher to
-                                    // update selected answers (in order to use them on validation)
-                                    // in each retrieval, the answers of answerUI need to be augmented
-                                    // for the onClick prop to achieve this.
-                                    onClick: noop,
-                                    selected: false,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'Lorem ipsum',
-                                    onClick: noop,
-                                    selected: false,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'Lorem',
-                                    onClick: noop,
-                                    selected: true,
-                                    order: 1,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'You need to have a password',
-                                    onClick: noop,
-                                    selected: false,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'Pouet',
-                                    onClick: noop,
-                                    selected: true,
-                                    order: 0,
-                                    help: 'help'
-                                }
-                            ],
-                            type: 'qcmDrag'
-                        },
-                        help: 'Help text will appear here'
+                state: {
+                    pendingSlides: [],
+                    step: {
+                        current: Number.NaN
+                    },
+                    isCorrect: true,
+                    nextContent: {
+                        ref: 'sli_V1gKpYYZ2',
+                        type: 'slide'
                     }
                 }
             };
         }
+        case RECEIVE_PROGRESSION: {
+            const { progression } = action.payload;
+            return progression;
+        }
         default:
             return state;
     }