@coorpacademy/app-review 0.1.15 → 0.1.16

package/lib/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/lib/actions/api/fetch-skills.js

@@ -1,13 +1,61 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import buildTask from '@coorpacademy/redux-task';
 export var SKILLS_FETCH_REQUEST = '@@skills/FETCH_REQUEST';
 export var SKILLS_FETCH_SUCCESS = '@@skills/FETCH_SUCCESS';
 export var SKILLS_FETCH_FAILURE = '@@skills/FETCH_FAILURE';
 export var fetchSkills = function (token) {
-    return buildTask({
-        types: [SKILLS_FETCH_REQUEST, SKILLS_FETCH_SUCCESS, SKILLS_FETCH_FAILURE],
-        task: function (dispatch, getState, _a) {
-            var services = _a.services;
-            return services.fetchSkills(token);
-        }
-    });
+    return function (dispatch, getState, _a) {
+        var services = _a.services;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var action;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        action = buildTask({
+                            types: [SKILLS_FETCH_REQUEST, SKILLS_FETCH_SUCCESS, SKILLS_FETCH_FAILURE],
+                            task: function () { return services.fetchSkills(token); }
+                        });
+                        return [4 /*yield*/, dispatch(action)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
 };

package/lib/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/lib/actions/api/fetch-slide.js

@@ -1,3 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import buildTask from '@coorpacademy/redux-task';
 import get from 'lodash/fp/get';
 import has from 'lodash/fp/has';
@@ -6,26 +42,40 @@ import { setCurrentSlide } from '../ui/slides';
 export var SLIDE_FETCH_REQUEST = '@@slides/FETCH_REQUEST';
 export var SLIDE_FETCH_SUCCESS = '@@slides/FETCH_SUCCESS';
 export var SLIDE_FETCH_FAILURE = '@@slides/FETCH_FAILURE';
-export var fetchSlide = function (progressionFromAPI, token) {
-    return buildTask({
-        types: [SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS, SLIDE_FETCH_FAILURE],
-        bailout: function (state) {
-            var slideRef = get('state.nextContent', progressionFromAPI).ref;
-            return has("data.slide.".concat(slideRef), state);
-        },
-        task: function (dispatch, getState, _a) {
-            var services = _a.services;
-            var slideRef = get('state.nextContent', progressionFromAPI).ref;
-            return services.fetchSlide(slideRef, token).then(function (slideFromAPI) {
-                if (!slideFromAPI)
-                    throw new Error('Slide not found');
-                var state = getState();
-                var slides = get('data.progression.state.slides', state);
-                if (isEmpty(slides)) {
-                    dispatch(setCurrentSlide(slideFromAPI));
+export var fetchSlide = function (slideRef, token) {
+    return function (dispatch, getState, _a) {
+        var services = _a.services;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var action, response, slideFromAPI, state, slides;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        action = buildTask({
+                            types: [SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS, SLIDE_FETCH_FAILURE],
+                            bailout: function (state) {
+                                return has("data.slide.".concat(slideRef), state);
+                            },
+                            task: function () {
+                                return services.fetchSlide(slideRef, token);
+                            },
+                            meta: { slideRef: slideRef }
+                        });
+                        return [4 /*yield*/, dispatch(action)];
+                    case 1:
+                        response = _b.sent();
+                        if (response.type === SLIDE_FETCH_SUCCESS) {
+                            slideFromAPI = response.payload;
+                            if (!slideFromAPI)
+                                throw new Error('Slide not found');
+                            state = getState();
+                            slides = get('data.progression.state.slides', state);
+                            if (isEmpty(slides)) {
+                                dispatch(setCurrentSlide(slideFromAPI));
+                            }
+                        }
+                        return [2 /*return*/];
                 }
-                return slideFromAPI;
             });
-        }
-    });
+        });
+    };
 };

package/lib/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/lib/actions/api/post-progression.js

@@ -1,17 +1,71 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import buildTask from '@coorpacademy/redux-task';
 import { fetchSlide } from './fetch-slide';
 export var POST_PROGRESSION_REQUEST = '@@progression/POST_REQUEST';
 export var POST_PROGRESSION_SUCCESS = '@@progression/POST_SUCCESS';
 export var POST_PROGRESSION_FAILURE = '@@progression/POST_FAILURE';
 export var postProgression = function (skillRef, token) {
-    return buildTask({
-        types: [POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS, POST_PROGRESSION_FAILURE],
-        task: function (dispatch, getState, _a) {
-            var services = _a.services;
-            return services.postProgression(skillRef, token).then(function (progression) {
-                dispatch(fetchSlide(progression, token));
-                return progression;
+    return function (dispatch, getState, _a) {
+        var services = _a.services;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var action, response, progression, slideRef;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        action = buildTask({
+                            types: [POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS, POST_PROGRESSION_FAILURE],
+                            task: function () {
+                                return services.postProgression(skillRef, token);
+                            }
+                        });
+                        return [4 /*yield*/, dispatch(action)];
+                    case 1:
+                        response = _b.sent();
+                        if (!(response.type === POST_PROGRESSION_SUCCESS)) return [3 /*break*/, 3];
+                        progression = response.payload;
+                        slideRef = progression.state.nextContent.ref;
+                        return [4 /*yield*/, dispatch(fetchSlide(slideRef, token))];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
             });
-        }
-    });
+        });
+    };
 };

package/lib/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/lib/actions/api/test/create-test-store.js

@@ -0,0 +1,18 @@
+import constant from 'lodash/fp/constant';
+import { applyMiddleware, compose, createStore } from 'redux';
+import thunk from 'redux-thunk';
+import rootReducer from '../../../reducers';
+var assertActionsMiddleware = function (t, ACTIONS) {
+    return constant(function (next) { return function (action) {
+        var expectedAction = ACTIONS.shift();
+        if (!expectedAction)
+            throw new Error("Missing {type: \"".concat(action.type, "\"} action"));
+        t.deepEqual(action, expectedAction);
+        return next(action);
+    }; });
+};
+export var createTestStore = function (t, initialState, services, actions) {
+    var thunkMiddleware = thunk.withExtraArgument({ services: services });
+    var enhancer = compose(applyMiddleware(thunkMiddleware, assertActionsMiddleware(t, actions)));
+    return createStore(rootReducer, initialState, enhancer);
+};

package/lib/actions/api/test/fetch-skills.test.d.ts

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

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

@@ -0,0 +1,113 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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';
+var 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', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var services, expectedActions, dispatch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                services = __assign(__assign({}, mockedServices), { fetchSkills: function (token) {
+                        t.is(token, '1234');
+                        return Promise.resolve([]);
+                    } });
+                expectedActions = [
+                    { type: SKILLS_FETCH_REQUEST },
+                    {
+                        type: SKILLS_FETCH_SUCCESS,
+                        payload: []
+                    }
+                ];
+                dispatch = createTestStore(t, initialState, services, expectedActions).dispatch;
+                return [4 /*yield*/, dispatch(fetchSkills('1234'))];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('should dispatch SKILLS_FETCH_FAILURE action when fetchSkills fails', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var services, expectedActions, dispatch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                services = __assign(__assign({}, mockedServices), { fetchSkills: function (token) {
+                        t.is(token, '1234');
+                        return Promise.reject(new Error('unexpected'));
+                    } });
+                expectedActions = [
+                    { type: SKILLS_FETCH_REQUEST },
+                    {
+                        type: SKILLS_FETCH_FAILURE,
+                        payload: new Error('unexpected'),
+                        error: true
+                    }
+                ];
+                dispatch = createTestStore(t, initialState, services, expectedActions).dispatch;
+                return [4 /*yield*/, dispatch(fetchSkills('1234'))];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });

package/lib/actions/api/test/fetch-slide.test.d.ts

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

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

@@ -0,0 +1,120 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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';
+var 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', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var services, expectedActions, dispatch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                services = __assign(__assign({}, mockedServices), { fetchSlide: function (slideRef, token) {
+                        t.is(token, '1234');
+                        t.is(slideRef, 'sli_VJYjJnJhg');
+                        return Promise.resolve(freeTextSlide);
+                    } });
+                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 }
+                ];
+                dispatch = createTestStore(t, initialState, services, expectedActions).dispatch;
+                return [4 /*yield*/, dispatch(fetchSlide('sli_VJYjJnJhg', '1234'))];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('should dispatch SLIDE_FETCH_FAILURE action when fetchSlide fails', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var services, expectedActions, dispatch;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                services = __assign(__assign({}, mockedServices), { fetchSlide: function (slideRef, token) {
+                        t.is(token, '1234');
+                        t.is(slideRef, 'slide_ref');
+                        return Promise.reject(new Error('error'));
+                    } });
+                expectedActions = [
+                    { type: SLIDE_FETCH_REQUEST, meta: { slideRef: 'slide_ref' } },
+                    {
+                        type: SLIDE_FETCH_FAILURE,
+                        meta: { slideRef: 'slide_ref' },
+                        payload: new Error('error'),
+                        error: true
+                    }
+                ];
+                dispatch = createTestStore(t, initialState, services, expectedActions).dispatch;
+                return [4 /*yield*/, dispatch(fetchSlide('slide_ref', '1234'))];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });

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

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