@coorpacademy/app-review 0.1.15 → 0.1.16

package/es/actions/api/fetch-skills.d.ts

@@ -1,13 +1,11 @@
-import type { ThunkAction } from 'redux-thunk';
-import { AnyAction } from 'redux';
+import { Dispatch } from 'redux';
 import type { StoreState } from '../../reducers';
 import { Options, Skill } from '../../types/common';
 export declare const SKILLS_FETCH_REQUEST: "@@skills/FETCH_REQUEST";
 export declare const SKILLS_FETCH_SUCCESS: "@@skills/FETCH_SUCCESS";
 export declare const SKILLS_FETCH_FAILURE: "@@skills/FETCH_FAILURE";
-export interface ReceivedSkills extends AnyAction {
+export declare type ReceivedSkills = {
     type: '@@skills/FETCH_SUCCESS';
     payload: Skill[];
-}
-export declare type FetchSkillsAction = ThunkAction<Promise<void>, StoreState, Options, AnyAction>;
-export declare const fetchSkills: (token: string) => FetchSkillsAction;
+};
+export declare const fetchSkills: (token: string) => (dispatch: Dispatch, getState: () => StoreState, { services }: Options) => Promise<void>;

package/es/actions/api/fetch-skills.js

@@ -2,7 +2,10 @@ import buildTask from '@coorpacademy/redux-task';
 export const SKILLS_FETCH_REQUEST = '@@skills/FETCH_REQUEST';
 export const SKILLS_FETCH_SUCCESS = '@@skills/FETCH_SUCCESS';
 export const SKILLS_FETCH_FAILURE = '@@skills/FETCH_FAILURE';
-export const fetchSkills = (token) => buildTask({
-    types: [SKILLS_FETCH_REQUEST, SKILLS_FETCH_SUCCESS, SKILLS_FETCH_FAILURE],
-    task: (dispatch, getState, { services }) => services.fetchSkills(token)
-});
+export const fetchSkills = (token) => async (dispatch, getState, { services }) => {
+    const action = buildTask({
+        types: [SKILLS_FETCH_REQUEST, SKILLS_FETCH_SUCCESS, SKILLS_FETCH_FAILURE],
+        task: () => services.fetchSkills(token)
+    });
+    await dispatch(action);
+};

package/es/actions/api/fetch-slide.d.ts

@@ -1,13 +1,20 @@
-import type { AnyAction } from 'redux';
-import type { ThunkAction } from 'redux-thunk';
+import type { Dispatch } from 'redux';
 import type { StoreState } from '../../reducers';
-import type { Options, ProgressionFromAPI, SlideFromAPI } from '../../types/common';
+import type { Options, SlideFromAPI } from '../../types/common';
 export declare const SLIDE_FETCH_REQUEST: "@@slides/FETCH_REQUEST";
 export declare const SLIDE_FETCH_SUCCESS: "@@slides/FETCH_SUCCESS";
 export declare const SLIDE_FETCH_FAILURE: "@@slides/FETCH_FAILURE";
-export interface ReceivedSlide extends AnyAction {
+export declare type FetchSlide = {
+    type: typeof SLIDE_FETCH_REQUEST;
+    meta: {
+        slideRef: string;
+    };
+};
+export declare type ReceivedSlide = {
     type: typeof SLIDE_FETCH_SUCCESS;
     payload: SlideFromAPI;
-}
-export declare type FetchSlideAction = ThunkAction<Promise<SlideFromAPI>, StoreState, Options, AnyAction>;
-export declare const fetchSlide: (progressionFromAPI: ProgressionFromAPI, token: string) => FetchSlideAction;
+    meta: {
+        slideRef: string;
+    };
+};
+export declare const fetchSlide: (slideRef: string, token: string) => (dispatch: Dispatch, getState: () => StoreState, { services }: Options) => Promise<void>;

package/es/actions/api/fetch-slide.js

@@ -6,23 +6,26 @@ import { setCurrentSlide } from '../ui/slides';
 export const SLIDE_FETCH_REQUEST = '@@slides/FETCH_REQUEST';
 export const SLIDE_FETCH_SUCCESS = '@@slides/FETCH_SUCCESS';
 export const SLIDE_FETCH_FAILURE = '@@slides/FETCH_FAILURE';
-export const fetchSlide = (progressionFromAPI, token) => buildTask({
-    types: [SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS, SLIDE_FETCH_FAILURE],
-    bailout: (state) => {
-        const { ref: slideRef } = get('state.nextContent', progressionFromAPI);
-        return has(`data.slide.${slideRef}`, state);
-    },
-    task: (dispatch, getState, { services }) => {
-        const { ref: slideRef } = get('state.nextContent', progressionFromAPI);
-        return services.fetchSlide(slideRef, token).then((slideFromAPI) => {
-            if (!slideFromAPI)
-                throw new Error('Slide not found');
-            const state = getState();
-            const slides = get('data.progression.state.slides', state);
-            if (isEmpty(slides)) {
-                dispatch(setCurrentSlide(slideFromAPI));
-            }
-            return slideFromAPI;
-        });
+export const fetchSlide = (slideRef, token) => async (dispatch, getState, { services }) => {
+    const action = buildTask({
+        types: [SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS, SLIDE_FETCH_FAILURE],
+        bailout: (state) => {
+            return has(`data.slide.${slideRef}`, state);
+        },
+        task: () => {
+            return services.fetchSlide(slideRef, token);
+        },
+        meta: { slideRef }
+    });
+    const response = await dispatch(action);
+    if (response.type === SLIDE_FETCH_SUCCESS) {
+        const slideFromAPI = response.payload;
+        if (!slideFromAPI)
+            throw new Error('Slide not found');
+        const state = getState();
+        const slides = get('data.progression.state.slides', state);
+        if (isEmpty(slides)) {
+            dispatch(setCurrentSlide(slideFromAPI));
+        }
     }
-});
+};

package/es/actions/api/post-progression.d.ts

@@ -1,13 +1,11 @@
-import type { AnyAction } from 'redux';
-import type { ThunkAction } from 'redux-thunk';
+import type { Dispatch } from 'redux';
 import { Options, ProgressionFromAPI } from '../../types/common';
 import type { StoreState } from '../../reducers';
 export declare const POST_PROGRESSION_REQUEST: "@@progression/POST_REQUEST";
 export declare const POST_PROGRESSION_SUCCESS: "@@progression/POST_SUCCESS";
 export declare const POST_PROGRESSION_FAILURE: "@@progression/POST_FAILURE";
-export interface ReceiveProgression extends AnyAction {
+export declare type ReceiveProgression = {
     type: typeof POST_PROGRESSION_SUCCESS;
     payload: ProgressionFromAPI;
-}
-export declare type PostProgressionAction = ThunkAction<Promise<ProgressionFromAPI>, StoreState, Options, AnyAction>;
-export declare const postProgression: (skillRef: string, token: string) => PostProgressionAction;
+};
+export declare const postProgression: (skillRef: string, token: string) => (dispatch: Dispatch, getState: () => StoreState, { services }: Options) => Promise<void>;

package/es/actions/api/post-progression.js

@@ -3,12 +3,17 @@ import { fetchSlide } from './fetch-slide';
 export const POST_PROGRESSION_REQUEST = '@@progression/POST_REQUEST';
 export const POST_PROGRESSION_SUCCESS = '@@progression/POST_SUCCESS';
 export const POST_PROGRESSION_FAILURE = '@@progression/POST_FAILURE';
-export const postProgression = (skillRef, token) => buildTask({
-    types: [POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS, POST_PROGRESSION_FAILURE],
-    task: (dispatch, getState, { services }) => {
-        return services.postProgression(skillRef, token).then((progression) => {
-            dispatch(fetchSlide(progression, token));
-            return progression;
-        });
+export const postProgression = (skillRef, token) => async (dispatch, getState, { services }) => {
+    const action = buildTask({
+        types: [POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS, POST_PROGRESSION_FAILURE],
+        task: () => {
+            return services.postProgression(skillRef, token);
+        }
+    });
+    const response = await dispatch(action);
+    if (response.type === POST_PROGRESSION_SUCCESS) {
+        const progression = response.payload;
+        const slideRef = progression.state.nextContent.ref;
+        await dispatch(fetchSlide(slideRef, token));
     }
-});
+};

package/es/actions/api/test/create-test-store.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutionContext } from 'ava';
+import { AnyAction, Store } from 'redux';
+import { StoreState } from '../../../reducers';
+import { Services } from '../../../types/common';
+export declare const createTestStore: (t: ExecutionContext, initialState: StoreState, services: Services, actions: AnyAction[]) => Store;

package/es/actions/api/test/create-test-store.js

@@ -0,0 +1,16 @@
+import constant from 'lodash/fp/constant';
+import { applyMiddleware, compose, createStore } from 'redux';
+import thunk from 'redux-thunk';
+import rootReducer from '../../../reducers';
+const assertActionsMiddleware = (t, ACTIONS) => constant((next) => (action) => {
+    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, initialState, services, actions) => {
+    const thunkMiddleware = thunk.withExtraArgument({ services });
+    const enhancer = compose(applyMiddleware(thunkMiddleware, assertActionsMiddleware(t, actions)));
+    return createStore(rootReducer, initialState, enhancer);
+};

package/es/actions/api/test/fetch-skills.test.js

@@ -0,0 +1,54 @@
+import test from 'ava';
+import { fetchSkills, SKILLS_FETCH_FAILURE, SKILLS_FETCH_REQUEST, SKILLS_FETCH_SUCCESS } from '../fetch-skills';
+import { services as mockedServices } from '../../../test/util/services.mock';
+import { createTestStore } from './create-test-store';
+const initialState = {
+    data: {
+        progression: null,
+        slides: {},
+        skills: [],
+        token: '1234'
+    },
+    ui: {
+        currentSlideRef: '',
+        navigation: [],
+        answers: []
+    }
+};
+test('should dispatch SKILLS_FETCH_SUCCESS actions when fetchSkills return a list of skills', async (t) => {
+    const services = {
+        ...mockedServices,
+        fetchSkills: token => {
+            t.is(token, '1234');
+            return Promise.resolve([]);
+        }
+    };
+    const expectedActions = [
+        { type: SKILLS_FETCH_REQUEST },
+        {
+            type: SKILLS_FETCH_SUCCESS,
+            payload: []
+        }
+    ];
+    const { dispatch } = createTestStore(t, initialState, services, expectedActions);
+    await dispatch(fetchSkills('1234'));
+});
+test('should dispatch SKILLS_FETCH_FAILURE action when fetchSkills fails', async (t) => {
+    const services = {
+        ...mockedServices,
+        fetchSkills: token => {
+            t.is(token, '1234');
+            return Promise.reject(new Error('unexpected'));
+        }
+    };
+    const expectedActions = [
+        { type: SKILLS_FETCH_REQUEST },
+        {
+            type: SKILLS_FETCH_FAILURE,
+            payload: new Error('unexpected'),
+            error: true
+        }
+    ];
+    const { dispatch } = createTestStore(t, initialState, services, expectedActions);
+    await dispatch(fetchSkills('1234'));
+});

package/es/actions/api/test/fetch-slide.test.js

@@ -0,0 +1,61 @@
+import test from 'ava';
+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 { SET_CURRENT_SLIDE } from '../../ui/slides';
+import { createTestStore } from './create-test-store';
+const initialState = {
+    data: {
+        progression: null,
+        slides: {},
+        skills: [],
+        token: '1234'
+    },
+    ui: {
+        currentSlideRef: '',
+        navigation: [],
+        answers: []
+    }
+};
+test('should dispatch FETCH_SUCCESS and SET_CURRENT_SLIDE actions when fetchSlide return a slide', async (t) => {
+    const 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', '1234'));
+});
+test('should dispatch SLIDE_FETCH_FAILURE action when fetchSlide fails', async (t) => {
+    const 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', '1234'));
+});

package/es/actions/api/test/post-progression.test.d.ts

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

package/es/actions/api/test/post-progression.test.js

@@ -0,0 +1,102 @@
+import test from 'ava';
+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 { SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS } from '../fetch-slide';
+import { SET_CURRENT_SLIDE } from '../../ui/slides';
+import { createTestStore } from './create-test-store';
+const initialState = {
+    data: {
+        progression: null,
+        slides: {},
+        skills: [],
+        token: '1234'
+    },
+    ui: {
+        currentSlideRef: '',
+        navigation: [],
+        answers: []
+    }
+};
+test('should dispatch POST_PROGRESSION_SUCCESS and SLIDE_FETCH_REQUEST actions when postProgression return a progression', async (t) => {
+    const progression = {
+        _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 = {
+        ...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', '1234'));
+});
+test('should dispatch POST_PROGRESSION_FAILURE action when postProgression fails', async (t) => {
+    const 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', '1234'));
+});

package/es/actions/ui/answers.d.ts

@@ -0,0 +1,7 @@
+import { Dispatch } from 'redux';
+export declare const EDIT_BASIC: "@@answer/EDIT_BASIC";
+export declare type EditBasicAction = {
+    type: typeof EDIT_BASIC;
+    payload: string[];
+};
+export declare const editAnswer: (answer: string) => (dispatch: Dispatch) => EditBasicAction;

package/es/actions/ui/answers.js

@@ -0,0 +1,7 @@
+export const EDIT_BASIC = '@@answer/EDIT_BASIC';
+export const editAnswer = (answer) => (dispatch) => {
+    return dispatch({
+        type: EDIT_BASIC,
+        payload: [answer]
+    });
+};

package/es/fixtures/temp-fixture.d.ts

@@ -1,3 +1,3 @@
-import { SlidesViewProps, CorrectionPopinProps } from '../types/views/slides';
+import { SlidesViewProps, CorrectionPopinProps } from '../views/slides';
 export declare const correctionPopinProps: CorrectionPopinProps;
 export declare const congratsProps: SlidesViewProps['congratsProps'];

package/es/index.js

@@ -1,32 +1,26 @@
 import React, { useEffect, useState } from 'react';
-import { connect, Provider } from 'react-redux';
+import { useSelector, useDispatch, 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 isEmpty from 'lodash/fp/isEmpty';
 import get from 'lodash/fp/get';
 import configureStore from './configure-store';
-import { validateSlide } from './actions/ui/slides';
-import { navigateTo, navigateBack } from './actions/ui/navigation';
+import { navigateTo } from './actions/ui/navigation';
 import { storeToken } from './actions/data/token';
 import { fetchSkills } from './actions/api/fetch-skills';
 import { postProgression } from './actions/api/post-progression';
 import { VIEWS } from './common';
 import { mapStateToSlidesProps } from './views/slides';
 import { mapStateToSkillsProps } from './views/skills';
-const mapDispatchToProps = {
-    navigateTo,
-    navigateBack,
-    validateSlide
-};
-const getCurrentViewName = (storeState) => storeState.ui.navigation[storeState.ui.navigation.length - 1];
-const mapStateToProps = (state) => {
-    return {
-        viewName: getCurrentViewName(state),
-        slides: mapStateToSlidesProps(state),
-        skills: mapStateToSkillsProps(state)
+const ConnectedApp = () => {
+    const dispatch = useDispatch();
+    const props = {
+        viewName: useSelector((state) => state.ui.navigation[state.ui.navigation.length - 1]),
+        slides: useSelector((state) => mapStateToSlidesProps(state, dispatch)),
+        skills: useSelector((state) => mapStateToSkillsProps(state))
     };
+    return React.createElement(AppReviewTemplate, { ...props });
 };
-const App = connect(mapStateToProps, mapDispatchToProps)(AppReviewTemplate);
 const AppReview = ({ options }) => {
     const [store, setStore] = useState(null);
     const [isProgressionCreated, setIsProgressionCreated] = useState(false);
@@ -77,6 +71,6 @@ const AppReview = ({ options }) => {
     const { templateContext: values } = options;
     return (React.createElement(Provider, { store: store },
         React.createElement(TemplateContext, { values: values },
-            React.createElement(App, null))));
+            React.createElement(ConnectedApp, null))));
 };
 export default AppReview;

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

@@ -4,7 +4,7 @@ import { SlidesState } from './slides';
 import { TokenState } from './token';
 export declare type DataState = {
     isFetching?: boolean;
-    progression?: ProgressionState;
+    progression: ProgressionState;
     skills: SkillsState;
     slides: SlidesState;
     token?: TokenState;

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

@@ -1,7 +1,7 @@
 import { ValidateSlide } from '../../actions/ui/slides';
-import { ReceivedSlide } from '../../actions/api/fetch-slide';
+import { ReceivedSlide, FetchSlide } from '../../actions/api/fetch-slide';
 import { SlideFromAPI } from '../../types/common';
-export declare type SlidesAction = ReceivedSlide | ValidateSlide;
+export declare type SlidesAction = FetchSlide | ReceivedSlide | ValidateSlide;
 export declare type SlidesState = Record<string, SlideFromAPI>;
 export declare const initialState: SlidesState;
 declare const reducer: (state: SlidesState | undefined, action: SlidesAction) => SlidesState;

package/es/reducers/data/slides.js

@@ -1,9 +1,13 @@
 import set from 'lodash/fp/set';
-import { SLIDE_FETCH_SUCCESS } from '../../actions/api/fetch-slide';
+import { SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS } from '../../actions/api/fetch-slide';
 export const initialState = {};
 // eslint-disable-next-line default-param-last
 const reducer = (state = initialState, action) => {
     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/es/reducers/data/test/progression.test.d.ts

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

package/es/reducers/data/test/progression.test.js

@@ -0,0 +1,38 @@
+import test from 'ava';
+import reducer from '../progression';
+import { POST_PROGRESSION_SUCCESS } from '../../../actions/api/post-progression';
+test('should have inital value', t => {
+    const state = reducer(undefined, {});
+    t.is(state, null);
+});
+test('should set the value of POST_PROGRESSION_SUCCESS action', t => {
+    const progression = {
+        _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/es/reducers/data/test/skills.test.d.ts

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

package/es/reducers/data/test/skills.test.js

@@ -0,0 +1,12 @@
+import test from 'ava';
+import reducer from '../skills';
+import { SKILLS_FETCH_SUCCESS } from '../../../actions/api/fetch-skills';
+test('should have inital value', t => {
+    const state = reducer(undefined, {});
+    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/es/reducers/data/test/slides.test.d.ts

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

package/es/reducers/data/test/slides.test.js

@@ -0,0 +1,20 @@
+import test from 'ava';
+import reducer 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, {});
+    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/es/reducers/data/test/token.test.d.ts

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

package/es/reducers/data/test/token.test.js

@@ -0,0 +1,11 @@
+import test from 'ava';
+import reducer from '../token';
+import { STORE_TOKEN } from '../../../actions/data/token';
+test('should have inital value', t => {
+    const state = reducer(undefined, {});
+    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/es/reducers/index.d.ts

@@ -14,7 +14,7 @@ declare const _default: import("redux").Reducer<import("redux").CombinedState<{
     ui: import("redux").CombinedState<{
         currentSlideRef: string;
         navigation: import("./ui/navigation").NavigationState;
-        slides: import("./ui/slides").UISlidesState;
+        answers: import("./ui/answers").AnswerState;
     }>;
-}>, import("../actions/ui/slides").SetCurrentSlide | import("../actions/api/post-progression").ReceiveProgression | import("../actions/api/fetch-skills").ReceivedSkills | import("./data/slides").SlidesAction | import("../actions/data/token").StoreToken | import("../actions/ui/navigation").NavigateTo | import("../actions/ui/navigation").NavigateBack>;
+}>, import("../actions/ui/slides").SetCurrentSlide | import("../actions/api/post-progression").ReceiveProgression | import("../actions/api/fetch-skills").ReceivedSkills | import("./data/slides").SlidesAction | import("../actions/data/token").StoreToken | import("../actions/ui/navigation").NavigateTo | import("../actions/ui/navigation").NavigateBack | import("../actions/ui/answers").EditBasicAction>;
 export default _default;

package/es/reducers/ui/answers.d.ts

@@ -0,0 +1,4 @@
+import { EditBasicAction } from '../../actions/ui/answers';
+export declare type AnswerState = string[];
+declare const reducer: (state: AnswerState | undefined, action: EditBasicAction) => AnswerState;
+export default reducer;

package/es/reducers/ui/answers.js

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