// Только самые важные импорты
import {call, put, take} from "redux-saga/effects";
export function* initApp() {
    // Инициализация хранилища и
    // получение последней сохраненной сессии
    yield put(initializeStorage());
    yield take(STORAGE_SYNC.STORAGE_INITIALIZED);
    yield put(loadSession());
    let { session } = yield take(STORAGE_SYNC.STORAGE_SESSION_LOADED);
    // Загрузка последнего проекта
    if (session) {
        yield call(loadProject, { projectId: session.lastLoadedProjectId });
    } else {
        logger.info({message: "No session available"});
    }
}

// Только самые важные импорты
import {testSaga} from "redux-saga-test-plan";
it("должно загрузить последнюю сессию и вызвать `loadProject`", () => {
    const projectId = 1;
    const mockSession = {
        lastLoadedProjectId: projectId
    };
    testSaga(initApp)
        // `next` служит командой перехода на следующую конструкцию `yield`
        // при этом мы можем передать аргумент,
        // который будет выходным результатом действующего `yield`
        // Фактически он просто запускает новую итерацию
        //(не забываем что функции-генераторы возвращают итератор)
        .next()
        .put(initializeStorage())
        .next()
        .take(STORAGE_SYNC.STORAGE_INITIALIZED)
        .next()
        .put(loadSession())
        .next()
        .take(STORAGE_SYNC.STORAGE_SESSION_LOADED)
        // Сохранение метки, чтобы иметь возможность вернуться
        .save("до развилки")
        // Передаем объект, который будет возвращен из `yield take...`
        .next({session: mockSession})
        .call(loadProject, {projectId})
        .next()
        .isDone()
        // Возвращаемся назад к метке
        .restore("до развилки")
        // Проверяем, что функция сразу завершится,
        // если последняя сессия будет отсутствовать
        .next({})
        .isDone();
});

// Только самые важные импорты
import {call, fork, put, take, takeLatest, select} from "redux-saga/effects";
// Корневая сага
export default function* sessionWatcher() {
    yield fork(initApp);
    yield takeLatest(SESSION_SYNC.SESSION_LOAD_PROJECT, loadProject);
}
export function* initApp() {
    // Инициализация хранилища и получение последней сохраненной сессии
    yield put(initializeStorage());
    yield take(STORAGE_SYNC.STORAGE_INITIALIZED);
    yield put(loadSession());
    let { session } = yield take(STORAGE_SYNC.STORAGE_SESSION_LOADED);
    // Загрузка последнего проекта
    if (session) {
        yield call(loadProject, { projectId: session.lastLoadedProjectId });
    } else {
        logger.info({message: "Нет доступной сессии"});
    }
}
export function* loadProject({ projectId }) {
    // Загрузка последнего проекта и последующая попытка его обработки
    yield put(loadProjectIntoStorage(projectId));
    const project = yield select(getProjectFromStorage);
    // Сохранение проекта, сессии с ново загрузившимся проектом и загрузка карты
    try {
        yield put({type: SESSION_ASYNC.SESSION_PROJECT_LOADED_ASYNC, project});
        yield fork(saveSession, projectId);
        yield put(loadMap());
    } catch(error) {
        yield put({type: SESSION_SYNC.SESSION_ERROR_WHILE_LOADING_PROJECT, error});
    }
}
export function getProjectFromStorage(state) {
    // Вытягивает загруженный проект из состояния системы
}
export function* saveSession(projectId) {
    // .... Вызывает внешние API
    yield call(console.log, "Вызов API...");
}

// Только самые важные импорты
import { expectSaga } from "redux-saga-test-plan";
import { select } from "redux-saga/effects";
import * as matchers from "redux-saga-test-plan/matchers";
it("должно инициализировать приложение и загрузить последний проект из предыдущей сессии", () => {
    // Стадия подготовки
    const projectId = 1;
    const anotherProjectId = 2;
    const mockedSession = {
        lastLoadedProjectId: projectId,
    };
    const mockedProject = "project";
    // Тестируем `sessionWatcher`
    // `silentRun` в конце возвращает промис с некоторыми плюшками для тестирования
    // подробнее можете почитать в официальной документации
    return (
        expectSaga(sessionWatcher)
            // Подмена генераторов эффектов
            .provide([
                // Заменить каждый генератор `select` эффекта, который использует
                // `getProjectFromStorage` и на его месте вернуть `mockedProject`
                // при этом обращать внимание как на вызываемую функцию так и на аргументы,
                // которые мы можем передать в `select`,
                // в нашем случае мы не передаем никаких
                // Пример использования стандартного генератора эффектов
                // из Redux-Saga, как фильтра
                [select(getProjectFromStorage), mockedProject],
                // Заменить каждый генератор `fork` эффекта, который вызывает `saveSession`
                // и ничего не вернуть (undefined)
                // при этом обращать внимание только на вызываемую функцию,
                // игнорирую аргументы
                // Пример использования фильтров из Redux Saga Test Plan
                [matchers.fork.fn(saveSession)],
            ])
            // Порядок не имеет значения
            // Мы упоминаем только те генераторы эффектов, которые мы хотим проверить
            // Тестирование инициализации
            .put(initializeStorage())
            .take(STORAGE_SYNC.STORAGE_INITIALIZED)
            // Генерация команды, которую в данный момент ожидает первый `take` в `initApp`
            // Генераторы команд ДОЛЖНЫ вызываться в нужном порядке
            .dispatch({ type: STORAGE_SYNC.STORAGE_INITIALIZED })
            .put(loadSession())
            .take(STORAGE_SYNC.STORAGE_SESSION_LOADED)
            .dispatch({ type: STORAGE_SYNC.STORAGE_SESSION_LOADED, session: mockedSession })
            // Тест загрузки проекта, вызванную `initApp`
            .put(loadProjectFromStorage(projectId))
            .put({ type: SESSION_ASYNC.SESSION_PROJECT_LOADED_ASYNC, project: mockedProject })
            .fork(saveSession, projectId)
            .put(loadMap())
            // Генерируем команду, которая будет перехвачена `takeLatest` в `sessionWatcher`
            // и опять протестировать загрузку проекта
            // Тест загрузки проекта, вызванную `sessionWatcher`
            .dispatch({ type: SESSION_SYNC.SESSION_LOAD_PROJECT, projectId: anotherProjectId })
            .put(loadProjectFromStorage(anotherProjectId))
            .put({ type: SESSION_ASYNC.SESSION_PROJECT_LOADED_ASYNC, project: mockedProject })
            .fork(saveSession, anotherProjectId)
            .put(loadMap())
            // Запустить тест, подавить ошибку связанную с истечением времени
            .silentRun()
    );
});

// Только самые важные импорты
import {expectSaga} from "redux-saga-test-plan";
import {select} from "redux-saga/effects";
import * as matchers from "redux-saga-test-plan/matchers";
import * as providers from "redux-saga-test-plan/providers";
it("должно инициализировать приложение и обработать ошибку загрузки проекта", () => {
    const projectId = 1;
    const mockedSession = {
        lastLoadedProjectId: projectId
    };
    const mockedProject = "project";
    const mockedError = new Error("Оууу, кажется что-то пошло не так!");
    return expectSaga(sessionWatcher)
        .provide([
            [select(getProjectFromStorage), mockedProject],
            // Заменяем генератор эффекта ошибкой
            [matchers.fork.fn(saveSession), providers.throwError(mockedError)]
        ])
        // Тестирование инициализации
        .put(initializeStorage())
        .take(STORAGE_SYNC.STORAGE_INITIALIZED)
        .dispatch({type: STORAGE_SYNC.STORAGE_INITIALIZED})
        .put(loadSession())
        .take(STORAGE_SYNC.STORAGE_SESSION_LOADED)
        .dispatch({type: STORAGE_SYNC.STORAGE_SESSION_LOADED, session: mockedSession})
        // Тест загрузки проекта, вызванную `initApp`
        .put(loadProjectFromStorage(projectId))
        .put({type: SESSION_ASYNC.SESSION_PROJECT_LOADED_ASYNC, project: mockedProject})
        // Ожидаем возникновение ошибки здесь
        .fork(saveSession, projectId)
        // Тестируем, что ошибка была обработана
        .put({type: SESSION_SYNC.SESSION_ERROR_WHILE_LOADING_PROJECT, error: mockedError})
        .silentRun();
});

const defaultState = {
    loadedProject: null,
};
export function sessionReducers(state = defaultState, action) {
    if (!SESSION_ASYNC[action.type]) {
        return state;
    }
    const newState = copyObject(state);
    switch(action.type) {
        case SESSION_ASYNC.SESSION_PROJECT_LOADED_ASYNC: {
            newState.loadedProject = action.project;
        }
    }
    return newState;
}

// Только самые важные импорты
import {expectSaga} from "redux-saga-test-plan";
import {select} from "redux-saga/effects";
import * as matchers from "redux-saga-test-plan/matchers";
it("должно инициализировать приложение и загрузить последний проект из предыдущей сессии", () => {
    const projectId = 1;
    const mockedSession = {
        lastLoadedProjectId: projectId
    };
    const mockedProject = "project";
    const expectedState = {
        loadedProject: mockedProject
    };
    return expectSaga(sessionWatcher)
        // Вы можете подключить корневой модификатор, чтобы
        // динамически изменять состояние либо указать его статически с помощью `withState`
        .withReducer(sessionReducers)
        .provide([
            [select(getProjectFromStorage), mockedProject],
            [matchers.fork.fn(saveSession)]
        ])
        // Тестирование инициализации
        .put(initializeStorage())
        .take(STORAGE_SYNC.STORAGE_INITIALIZED)
        .dispatch({type: STORAGE_SYNC.STORAGE_INITIALIZED})
        .put(loadSession())
        .take(STORAGE_SYNC.STORAGE_SESSION_LOADED)
        .dispatch({type: STORAGE_SYNC.STORAGE_SESSION_LOADED, session: mockedSession})
        // Тест загрузки проекта, вызванную `initApp`
        .put(loadProjectFromStorage(projectId))
        // Теперь мы можем пропустить некоторые тесты, которые изменяют состояние,
        // так как мы его тестируем в конце
        // .put({type: SESSION_ASYNC.SESSION_PROJECT_LOADED_ASYNC, project: mockedProject})
        .fork(saveSession, projectId)
        .put(loadMap())
        // Тестирование конечного состояния
        .hasFinalState(expectedState)
        .silentRun();
});