SCM-Manager/scm-ui/ui-webapp/src/modules/auth.test.ts

import reducer, {
  FETCH_ME,
  FETCH_ME_FAILURE,
  FETCH_ME_PENDING,
  FETCH_ME_SUCCESS,
  FETCH_ME_UNAUTHORIZED,
  fetchMe,
  fetchMeSuccess,
  fetchMeUnauthenticated,
  getFetchMeFailure,
  getLoginFailure,
  getLogoutFailure,
  getMe,
  isAuthenticated,
  isFetchMePending,
  isLoginPending,
  isLogoutPending,
  isRedirecting,
  login,
  LOGIN,
  LOGIN_FAILURE,
  LOGIN_PENDING,
  LOGIN_SUCCESS,
  loginSuccess,
  logout,
  LOGOUT,
  LOGOUT_FAILURE,
  LOGOUT_PENDING,
  LOGOUT_REDIRECT,
  LOGOUT_SUCCESS,
  logoutSuccess,
  redirectAfterLogout
} from "./auth";

import configureMockStore from "redux-mock-store";
import thunk from "redux-thunk";
import fetchMock from "fetch-mock";
import {
  FETCH_INDEXRESOURCES_PENDING,
  FETCH_INDEXRESOURCES_SUCCESS
} from "./indexResource";

const me = {
  name: "tricia",
  displayName: "Tricia McMillian",
  mail: "trillian@heartofgold.universe"
};

describe("auth reducer", () => {
  it("should set me and login on successful fetch of me", () => {
    const state = reducer(undefined, fetchMeSuccess(me));
    expect(state.me).toBe(me);
  });

  it("should set authenticated to false", () => {
    const initialState = {
      me
    };
    const state = reducer(initialState, fetchMeUnauthenticated());
    expect(state.me.name).toBeUndefined();
  });

  it("should reset the state after logout", () => {
    const initialState = {
      me
    };
    const state = reducer(initialState, logoutSuccess());
    expect(state.me).toBeUndefined();
    expect(state.authenticated).toBeUndefined();
  });

  it("should keep state and set redirecting to true", () => {
    const initialState = {
      me
    };
    const state = reducer(initialState, redirectAfterLogout());
    expect(state.me).toBe(initialState.me);
    expect(state.redirecting).toBe(true);
  });

  it("should set state authenticated and me after login", () => {
    const state = reducer(undefined, loginSuccess(me));
    expect(state.me).toBe(me);
  });
});

describe("auth actions", () => {
  const mockStore = configureMockStore([thunk]);

  afterEach(() => {
    fetchMock.reset();
    fetchMock.restore();
  });

  it("should dispatch login success and dispatch fetch me", () => {
    fetchMock.postOnce("/api/v2/auth/access_token", {
      body: {
        cookie: true,
        grant_type: "password",
        username: "tricia",
        password: "secret123"
      },
      headers: {
        "content-type": "application/json"
      }
    });

    fetchMock.getOnce("/api/v2/me", {
      body: me,
      headers: {
        "content-type": "application/json"
      }
    });

    const meLink = {
      me: {
        href: "/me"
      }
    };

    fetchMock.getOnce("/api/v2/", {
      _links: meLink
    });

    const expectedActions = [
      {
        type: LOGIN_PENDING
      },
      {
        type: FETCH_INDEXRESOURCES_PENDING
      },
      {
        type: FETCH_INDEXRESOURCES_SUCCESS,
        payload: {
          _links: meLink
        }
      },
      {
        type: LOGIN_SUCCESS,
        payload: me
      }
    ];

    const store = mockStore({});

    return store
      .dispatch(login("/auth/access_token", "tricia", "secret123"))
      .then(() => {
        expect(store.getActions()).toEqual(expectedActions);
      });
  });

  it("should dispatch login failure", () => {
    fetchMock.postOnce("/api/v2/auth/access_token", {
      status: 400
    });

    const store = mockStore({});
    return store
      .dispatch(login("/auth/access_token", "tricia", "secret123"))
      .then(() => {
        const actions = store.getActions();
        expect(actions[0].type).toEqual(LOGIN_PENDING);
        expect(actions[1].type).toEqual(LOGIN_FAILURE);
        expect(actions[1].payload).toBeDefined();
      });
  });

  it("should dispatch fetch me success", () => {
    fetchMock.getOnce("/api/v2/me", {
      body: me,
      headers: {
        "content-type": "application/json"
      }
    });

    const expectedActions = [
      {
        type: FETCH_ME_PENDING
      },
      {
        type: FETCH_ME_SUCCESS,
        payload: me
      }
    ];

    const store = mockStore({});

    return store.dispatch(fetchMe("me")).then(() => {
      expect(store.getActions()).toEqual(expectedActions);
    });
  });

  it("should dispatch fetch me failure", () => {
    fetchMock.getOnce("/api/v2/me", {
      status: 500
    });

    const store = mockStore({});
    return store.dispatch(fetchMe("me")).then(() => {
      const actions = store.getActions();
      expect(actions[0].type).toEqual(FETCH_ME_PENDING);
      expect(actions[1].type).toEqual(FETCH_ME_FAILURE);
      expect(actions[1].payload).toBeDefined();
    });
  });

  it("should dispatch fetch me unauthorized", () => {
    fetchMock.getOnce("/api/v2/me", 401);

    const expectedActions = [
      {
        type: FETCH_ME_PENDING
      },
      {
        type: FETCH_ME_UNAUTHORIZED,
        resetPending: true
      }
    ];

    const store = mockStore({});

    return store.dispatch(fetchMe("me")).then(() => {
      // return of async actions
      expect(store.getActions()).toEqual(expectedActions);
    });
  });

  it("should dispatch logout success", () => {
    fetchMock.deleteOnce("/api/v2/auth/access_token", {
      status: 204
    });

    fetchMock.getOnce("/api/v2/me", {
      status: 401
    });

    fetchMock.getOnce("/api/v2/", {
      _links: {
        login: {
          login: "/login"
        }
      }
    });

    const expectedActions = [
      {
        type: LOGOUT_PENDING
      },
      {
        type: LOGOUT_SUCCESS
      },
      {
        type: FETCH_INDEXRESOURCES_PENDING
      }
    ];

    const store = mockStore({});

    return store.dispatch(logout("/auth/access_token")).then(() => {
      expect(store.getActions()).toEqual(expectedActions);
    });
  });

  it("should dispatch logout success and redirect", () => {
    fetchMock.deleteOnce("/api/v2/auth/access_token", {
      status: 200,
      body: {
        logoutRedirect: "http://example.com/cas/logout"
      }
    });

    fetchMock.getOnce("/api/v2/me", {
      status: 401
    });

    fetchMock.getOnce("/api/v2/", {
      _links: {
        login: {
          login: "/login"
        }
      }
    });

    window.location.assign = jest.fn();

    const expectedActions = [
      {
        type: LOGOUT_PENDING
      },
      {
        type: LOGOUT_REDIRECT
      }
    ];

    const store = mockStore({});

    return store.dispatch(logout("/auth/access_token")).then(() => {
      expect(window.location.assign.mock.calls[0][0]).toBe(
        "http://example.com/cas/logout"
      );
      expect(store.getActions()).toEqual(expectedActions);
    });
  });

  it("should dispatch logout failure", () => {
    fetchMock.deleteOnce("/api/v2/auth/access_token", {
      status: 500
    });

    const store = mockStore({});
    return store.dispatch(logout("/auth/access_token")).then(() => {
      const actions = store.getActions();
      expect(actions[0].type).toEqual(LOGOUT_PENDING);
      expect(actions[1].type).toEqual(LOGOUT_FAILURE);
      expect(actions[1].payload).toBeDefined();
    });
  });
});

describe("auth selectors", () => {
  const error = new Error("yo it failed");

  it("should return true if me exist and login Link does not exist", () => {
    expect(
      isAuthenticated({
        auth: {
          me
        },
        indexResources: {
          links: {}
        }
      })
    ).toBe(true);
  });

  it("should return false if me exist and login Link does exist", () => {
    expect(
      isAuthenticated({
        auth: {
          me
        },
        indexResources: {
          links: {
            login: {
              href: "login.href"
            }
          }
        }
      })
    ).toBe(false);
  });

  it("should return me", () => {
    expect(
      getMe({
        auth: {
          me
        }
      })
    ).toBe(me);
  });

  it("should return undefined, if me is not set", () => {
    expect(getMe({})).toBeUndefined();
  });

  it("should return true, if FETCH_ME is pending", () => {
    expect(
      isFetchMePending({
        pending: {
          [FETCH_ME]: true
        }
      })
    ).toBe(true);
  });

  it("should return false, if FETCH_ME is not in pending state", () => {
    expect(
      isFetchMePending({
        pending: {}
      })
    ).toBe(false);
  });

  it("should return true, if LOGIN is pending", () => {
    expect(
      isLoginPending({
        pending: {
          [LOGIN]: true
        }
      })
    ).toBe(true);
  });

  it("should return false, if LOGIN is not in pending state", () => {
    expect(
      isLoginPending({
        pending: {}
      })
    ).toBe(false);
  });

  it("should return true, if LOGOUT is pending", () => {
    expect(
      isLogoutPending({
        pending: {
          [LOGOUT]: true
        }
      })
    ).toBe(true);
  });

  it("should return false, if LOGOUT is not in pending state", () => {
    expect(
      isLogoutPending({
        pending: {}
      })
    ).toBe(false);
  });

  it("should return the error, if failure state is set for FETCH_ME", () => {
    expect(
      getFetchMeFailure({
        failure: {
          [FETCH_ME]: error
        }
      })
    ).toBe(error);
  });

  it("should return unknown, if failure state is not set for FETCH_ME", () => {
    expect(getFetchMeFailure({})).toBeUndefined();
  });

  it("should return the error, if failure state is set for LOGIN", () => {
    expect(
      getLoginFailure({
        failure: {
          [LOGIN]: error
        }
      })
    ).toBe(error);
  });

  it("should return unknown, if failure state is not set for LOGIN", () => {
    expect(getLoginFailure({})).toBeUndefined();
  });

  it("should return the error, if failure state is set for LOGOUT", () => {
    expect(
      getLogoutFailure({
        failure: {
          [LOGOUT]: error
        }
      })
    ).toBe(error);
  });

  it("should return unknown, if failure state is not set for LOGOUT", () => {
    expect(getLogoutFailure({})).toBeUndefined();
  });

  it("should return false, if redirecting is not set", () => {
    expect(isRedirecting({})).toBe(false);
  });

  it("should return false, if redirecting is false", () => {
    expect(
      isRedirecting({
        auth: {
          redirecting: false
        }
      })
    ).toBe(false);
  });

  it("should return true, if redirecting is true", () => {
    expect(
      isRedirecting({
        auth: {
          redirecting: true
        }
      })
    ).toBe(true);
  });
});