use reflow to migrate from flow to typescript

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

@@ -0,0 +1,487 @@
+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);
+  });
+});