import uuidV1 from 'uuid/v1';

import {

  isAuthenticated,

  currentUser,

  currentGroup,

  token,

  clientId,

  login,

  register,

  groups,

  createGroup,

} from '../authReducer';

import asyncRequest from '../../constants/asyncRequest';

import * as types from '../../constants/ActionTypes'

import UserRecord from '../../store/userRecord';

import GroupRecord from '../../store/groupRecord';

describe('auth reducer isAuthenticated', () => {

  it('should return the initial state', () => {

    expect(

      isAuthenticated(undefined, {})

    ).toEqual(false)

  });

  it("Handle AUTH_DEAUTHENTICATE true", () => {

    expect(

      isAuthenticated(true, {

        type: types.AUTH_DEAUTHENTICATE

      })

    ).toEqual(false)

  });

  it("Handle AUTH_DEAUTHENTICATE false", () => {

    expect(

      isAuthenticated(false, {

        type: types.AUTH_DEAUTHENTICATE

      })

    ).toEqual(false)

  });

  it("Handle AUTH_LOGOUT true", () => {

    expect(

      isAuthenticated(true, {

        type: types.AUTH_LOGOUT

      })

    ).toEqual(false)

  });

  it("Handle AUTH_LOGOUT false", () => {

    expect(

      isAuthenticated(false, {

        type: types.AUTH_LOGOUT

      })

    ).toEqual(false)

  });

  it("Handle AUTH_LOGIN_SUCCESS false", () => {

    expect(

      isAuthenticated(false, {

        type: types.AUTH_LOGIN_SUCCESS

      })

    ).toEqual(true)

  });

  it("Handle AUTH_LOGIN_SUCCESS true", () => {

    expect(

      isAuthenticated(true, {

        type: types.AUTH_LOGIN_SUCCESS

      })

    ).toEqual(true)

  });

});

describe('auth reducer currentUser', () => {

  it('should return the initial state', () => {

    expect(

      currentUser(undefined, {})

    ).toEqual(null)

  });

  it('Handle AUTH_DEAUTHENTICATE', () => {

    const initalState = new UserRecord({ first_name: 'John', last_name: 'Doe'});

    expect(

      currentUser(initalState, {

        type: types.AUTH_DEAUTHENTICATE

      })

    ).toEqual(null)

  });

  it('Handle AUTH_LOGOUT', () => {

    const initalState = new UserRecord({ first_name: 'John', last_name: 'Doe'});

    expect(

      currentUser(initalState, {

        type: types.AUTH_LOGOUT

      })

    ).toEqual(null)

  });

  it('Handle AUTH_LOGIN_SUCCESS', () => {

    const initalState = null;

    expect(

      currentUser(initalState, {

        type: types.AUTH_LOGIN_SUCCESS,

        user: { first_name: 'John', last_name: 'Doe'}

      })

    ).toEqual(new UserRecord({ first_name: 'John', last_name: 'Doe'}))

  });

  it('Handle USER_UPDATE_SETTINGS', () => {

    const initalState = new UserRecord({ first_name: 'John', last_name: 'Doe'});

    expect(

      currentUser(initalState, {

        type: types.USER_UPDATE_SETTINGS,

        firstname: 'Jane',

        lastname: 'Orwell'

      })

    ).toEqual(new UserRecord({ first_name: 'Jane', last_name: 'Orwell'}))

  });

});

describe('auth reducer currentGroup', () => {

  it('should return the initial state', () => {

    expect(

      currentGroup(undefined, {})

    ).toEqual(null)

  });

  it('Handle AUTH_DEAUTHENTICATE', () => {

    expect(

      currentGroup('group1', {

        type: types.AUTH_DEAUTHENTICATE

      })

    ).toEqual(null);

  });

  it('Handle AUTH_LOGOUT', () => {

    expect(

      currentGroup('group1', {

        type: types.AUTH_LOGOUT

      })

    ).toEqual(null);

  });

  it('Handle AUTH_LOGIN_SUCCESS', () => {

    expect(

      currentGroup(null, {

        type: types.AUTH_LOGIN_SUCCESS,

        user: { first_name: 'John', last_name: 'Doe', default_group: 'group1' }

      })

    ).toEqual('group1');

  });

  it('Handle GROUP_CREATE_SUCCESS', () => {

    expect(

      currentGroup('group1', {

        type: types.GROUP_CREATE_SUCCESS,

        group: { name: 'group2' }

      })

    ).toEqual('group2');

  });

  it('Handle GROUP_SET_GROUP', () => {

    expect(

      currentGroup('group1', {

        type: types.GROUP_SET_GROUP,

        group: 'group2'

      })

    ).toEqual('group2');

  });

});

describe('auth reducer token', () => {

  it('should return the initial state', () => {

    expect(

      token(undefined, {})

    ).toEqual(null)

  });

  it('Handle AUTH_DEAUTHENTICATE', () => {

    expect(

      token('token1', {

        type: types.AUTH_DEAUTHENTICATE

      })

    ).toEqual(null);

  });

  it('Handle AUTH_LOGOUT', () => {

    expect(

      token('token1', {

        type: types.AUTH_LOGOUT

      })

    ).toEqual(null);

  });

  it('Handle AUTH_STORE_TOKEN', () => {

    expect(

      token(null, {

        type: types.AUTH_STORE_TOKEN,

        token: 'token1'

      })

    ).toEqual('token1');

  });

});

describe('auth reducer clientId', () => {

  it('should return the initial state', () => {

    expect(

      clientId(undefined, {})

    ).toEqual(null)

  });

  it('Handle AUTH_DEAUTHENTICATE', () => {

    expect(

      clientId(uuidV1(), {

        type: types.AUTH_DEAUTHENTICATE

      })

    ).toEqual(null);

  });

  it('Handle AUTH_LOGOUT', () => {

    expect(

      clientId(uuidV1(), {

        type: types.AUTH_LOGOUT

      })

    ).toEqual(null);

  });

  it('Handle AUTH_LOGIN_SUCCESS', () => {

    expect(

      clientId(uuidV1(), {

        type: types.AUTH_LOGIN_SUCCESS

      })

    ).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);

  });

});

describe('auth reducer login', () => {

  it('should return the initial state', () => {

    expect(

      login(undefined, {})

    ).toEqual(asyncRequest)

  });

  it('Handle AUTH_LOGIN_REQUEST', () => {

    expect(

      login(asyncRequest, {

        type: types.AUTH_LOGIN_REQUEST,

      })

    ).toEqual({

      loading: true,

      success: false,

      error: false,

    });

  });

  it('Handle AUTH_LOGIN_SUCCESS', () => {

    expect(

      login(asyncRequest, {

        type: types.AUTH_LOGIN_SUCCESS,

      })

    ).toEqual({

      loading: false,

      success: true,

      error: false,

      errorMessages: {},

    });

  });

  it('Handle AUTH_LOGIN_ERROR', () => {

    expect(

      login(asyncRequest, {

        type: types.AUTH_LOGIN_ERROR,

        error: {

          msg: "Bad credential"

        }

      })

    ).toEqual({

      loading: false,

      success: false,

      error: true,

      errorMessages: { msg: "Bad credential" },

    });

  });

});

describe('auth reducer register', () => {

  it('should return the initial state', () => {

    expect(

      register(undefined, {})

    ).toEqual(asyncRequest)

  });

  it('Handle AUTH_REGISTER_REQUEST', () => {

    expect(

      register(asyncRequest, {

        type: types.AUTH_REGISTER_REQUEST,

      })

    ).toEqual({

      loading: true,

      success: false,

      error: false,

    });

  });

  it('Handle AUTH_LOGIN_SUCCESS', () => {

    expect(

      register(asyncRequest, {

        type: types.AUTH_LOGIN_SUCCESS,

      })

    ).toEqual({

      loading: false,

      success: true,

      error: false,

      errorMessages: {}

    });

  });

  it('Handle AUTH_REGISTER_ERROR', () => {

    expect(

      register(asyncRequest, {

        type: types.AUTH_REGISTER_ERROR,

        error: {

          msg: 'error when registering'

        }

      })

    ).toEqual({

      loading: false,

      success: false,

      error: true,

      errorMessages: { msg: 'error when registering' }

    });

  });

});

describe('auth reducer groups', () => {

  it('should return the initial state', () => {

    expect(

      groups(undefined, {})

    ).toEqual([])

  });

  it('Handle GROUP_LOAD_SUCCESS', () => {

    expect(

      groups([], {

        type: types.GROUP_LOAD_SUCCESS,

        groups: [

          { name: 'group1', is_personal: false },

          { name: 'jdoe', is_personal: true }

        ]

      })

    ).toEqual([

      GroupRecord({ name: 'group1', isPersonal: false }),

      GroupRecord({ name: 'jdoe', isPersonal: true })

    ])

  });

  it('Handle GROUP_CREATE_SUCCESS', () => {

    expect(

      groups([

        GroupRecord({ name: 'group1', isPersonal: false }),

        GroupRecord({ name: 'jdoe', isPersonal: true })

      ], {

        type: types.GROUP_CREATE_SUCCESS,

        group: { name: 'newGroup', is_personal: false },

      })

    ).toEqual([

      GroupRecord({ name: 'group1', isPersonal: false }),

      GroupRecord({ name: 'jdoe', isPersonal: true }),

      GroupRecord({ name: 'newGroup', isPersonal: false }),

    ])

  });