import {reducer} from './reducer';
import {actionCreators} from './action';

describe('Container State', () => {
    let initState: {
        TEST: Object
    };
    let KEY = 'TEST';

    beforeEach(() => {
        initState = {
            TEST: {}
        };
    });

    it('setData', () => {
        let updateAction = actionCreators.setData({
            name: 'datepicker',
            value: '2017-12-20'
        }, KEY);
        let state = reducer(initState, updateAction);

        expect(state[KEY]).toEqual({
            datepicker: '2017-12-20'
        });
    });

    it('multiSetData return difference model', () => {
        let oneUpdate = actionCreators.setData({
            name: 'str',
            value: 'a'
        }, KEY);

        let twoUpdate = actionCreators.setData({
            name: 'str',
            value: 'b'
        }, KEY);

        let state = reducer(initState, oneUpdate);
        expect(initState[KEY] === state).toBe(false);
        expect(reducer(state, twoUpdate) === state).toBe(false);
    });

    it('setDataWithRepeat', () => {
        let updateAction = actionCreators.setData({
            name: 'datepicker',
            value: '2017-12-20'
        }, KEY);
        let repeatAction = actionCreators.setData({
            name: 'datepicker',
            value: '2018-01-01'
        }, KEY);
        let state = reducer(initState, updateAction);
        state = reducer(state, repeatAction);
        expect(state[KEY]).toEqual({
            datepicker: '2018-01-01'
        });
    });

    it('setData with invalid model', () => {
        let updateAction = actionCreators.setData({
            name: 'datepicker',
            value: '2017-12-20'
        }, 'UNKNOWN');
        let state = reducer(initState, updateAction);

        expect(state).toEqual(state);
    });

    it('setData nameGroup', () => {
        let updateAction = actionCreators.setData({
            name: 'datepicker.startTime.timestamp',
            value: '2017-12-20'
        }, KEY);
        let repeateAction = actionCreators.setData({
            name: 'datepicker.startTime.timestamp',
            value: '2018-01-01'
        }, KEY);

        let state = reducer(initState, updateAction);
        state = reducer(state, repeateAction);

        expect(state[KEY]).toEqual({
            datepicker: {
                startTime: {
                    timestamp: '2018-01-01'
                }
            }
        });
    });

    it('setDataList', () => {
        let updateAction = actionCreators.setDataList([{
            name: 'datepicker.startTime.timestamp',
            value: '2017-12-20'
        }, {
            name: 'searchbox',
            value: 'andycall'
        }, {
            name: 'datepicker.startTime.timestamp',
            value: '2018-01-10',
        }, {
            name: 'datepicker.startTime.endTime',
            value: '2019-01-01'
        }], KEY);
        let state = reducer(initState, updateAction);

        expect(state[KEY]).toEqual({
            datepicker: {
                startTime: {
                    timestamp: '2018-01-10',
                    endTime: '2019-01-01'
                }
            },
            searchbox: 'andycall'
        });
    });

    it('setDataList with invalid model', () => {
        let updateAction = actionCreators.setDataList([{
            name: 'datepicker.startTime.timestamp',
            value: '2017-12-20'
        }, {
            name: 'searchbox',
            value: 'andycall'
        }], 'UNKNOWN');
        let state = reducer(initState, updateAction);

        expect(state).toEqual(state);
    });

    it('asyncLoadProgress', () => {
        let updateAction = actionCreators.asyncLoadDataProgress({
            model: KEY
        });
        let state = reducer(initState, updateAction);
        expect(state[KEY]).toEqual({$loading: true});
    });

    it('asyncLoadFail', () => {
        let updateAction = actionCreators.asyncLoadDataFail({
            model: KEY,
            error: 'you got an error'
        });
        let state = reducer(initState, updateAction);
        expect(state[KEY]).toEqual({
            $loading: false,
            $error: 'you got an error'
        });
    });

    it('asynLoadDataSuccess', () => {
        let updateAction = actionCreators.asyncLoadDataSuccess({
            model: KEY,
            data: {
                name: 1
            }
        });
        let state = reducer(initState, updateAction);
        expect(state[KEY]).toEqual({
            name: 1,
            $loading: false
        });
    });

    it('syncLoadSuccess', () => {
        let updateAction = actionCreators.syncLoadDataSuccess({
            model: KEY,
            data: {
                name: 1
            }
        });
        let state = reducer(initState, updateAction);
        expect(state[KEY]).toEqual({
            name: 1
        });
    });

    it('syncLoadFail', () => {
        let updateAction = actionCreators.syncLoadDataFail({
            model: KEY,
            error: 'you got an error'
        });
        let state = reducer(initState, updateAction);
        expect(state[KEY]).toEqual({
            $error: 'you got an error'
        });
    });

    it('dataCustomerPass', () => {
        let updateAction = actionCreators.dataCustomerPass({
            model: KEY,
            data: {
                name: 1
            }
        });
        let state = reducer(initState, updateAction);
        expect(state[KEY]).toEqual({
            name: 1
        });
    });

    it('removeData', () => {
        let addAction = actionCreators.setData({
            name: 'name',
            value: 1
        }, KEY);
        let updateAction = actionCreators.clearData({
            model: KEY
        });
        let state = reducer(initState, addAction);
        state = reducer(state, updateAction);
        expect(state[KEY]).toEqual(undefined);
    });

    it('clearData', () => {
        let addAction = actionCreators.setData({
            name: 'name',
            value: 1
        }, KEY);
        let updateAction = actionCreators.clearData({
            model: KEY
        });
        let state = reducer(initState, addAction);
        state = reducer(state, updateAction);
        expect(state).toEqual({});
    });
});