How to use the @commercetools-frontend/constants.LOGOUT_REASONS.UNAUTHORIZED function in @commercetools-frontend/constants

export const handleActionError = (error, source) => dispatch => {
  // On production we send the errors to Sentry.
  // eslint-disable-next-line no-console
  if (window.app.env !== 'production') console.error(error, error.stack);

  // logout when unauthorized
  if (error.statusCode === STATUS_CODES.UNAUTHORIZED) {
    browserHistory.push(`/logout?reason=${LOGOUT_REASONS.UNAUTHORIZED}`);
  }

  // We need to do the return, because if not we see an error notification
  // The error is handled with the handleUnavailableResource HoC to show the PageNotFound component
  // when the api returns 404
  if (error.statusCode === STATUS_CODES.NOT_FOUND) return null;

  // All native errors that might occur within a Promise handler,
  // are caught here as well. In this case we dispatch an unexpected
  // error notification.
  if (!error.statusCode)
    return dispatch(showUnexpectedErrorNotification({ source, error }));

  const hasListOfErrors = error.body.errors && Array.isArray(error.body.errors);
  return dispatch(
    showApiErrorNotification({

return (
    dispatch: Dispatch<
      | ReturnType
      | ReturnType
    >
  ) => {
    // On production we send the errors to Sentry.
    // eslint-disable-next-line no-console
    if (window.app.env !== 'production')
      console.error(error, error instanceof Error && error.stack);

    if (!isApiError(error)) return dispatch(showUnexpectedErrorNotification());

    // logout when unauthorized
    if (error.statusCode === STATUS_CODES.UNAUTHORIZED) {
      browserHistory.push(`/logout?reason=${LOGOUT_REASONS.UNAUTHORIZED}`);
    }

    // We need to do the return, because if not we see an error notification
    // The error is handled with the handleUnavailableResource HoC to show the PageNotFound component
    // when the api returns 404
    if (error.statusCode === STATUS_CODES.NOT_FOUND) return null;

    return dispatch(
      showApiErrorNotification({
        errors: error.body.errors || [
          // Pass a fallback error so that our error components can handle it
          { message: error.body.message },
        ],
      })
    );
  };

({ graphQLErrors, networkError, operation, forward }) => {
    if (networkError && networkError.statusCode === STATUS_CODES.UNAUTHORIZED) {
      history.push(`/logout?reason=${LOGOUT_REASONS.UNAUTHORIZED}`);
    }
    // In case of graphql errors, we want to retry unauthenticated requests by
    // forcing our API to fetch a new token, using the `X-Force-Token` header.
    // https://www.apollographql.com/docs/link/links/error/#retrying-failed-requests
    // We need to do this as the `token-retry-link` only works for network errors.
    // https://www.apollographql.com/docs/link/links/retry/
    if (graphQLErrors) {
      for (const err of graphQLErrors) {
        if (err.extensions && err.extensions.code === 'UNAUTHENTICATED') {
          operation.setContext(({ headers }) => ({
            headers: {
              ...headers,
              'X-Force-Token': true,
            },
          }));
          // retry the request, returning the new observable

it('should pass queryParams', () => {
        expect(renderWrapper).toHaveProp('queryParams', {
          reason: LOGOUT_REASONS.UNAUTHORIZED,
          redirectTo: `${window.location.origin}${routerProps.location.pathname}`,
        });
      });
    });

it('should redirect to "/logout" with reason unauthorized', async () => {
    const rendered = renderApp();
    const queryParams = encode({
      reason: LOGOUT_REASONS.UNAUTHORIZED,
    });
    await wait(() => {
      expect(window.location.replace).toHaveBeenCalledWith(
        expect.stringContaining(`/logout?${queryParams}`)
      );
      expect(rendered.queryByText('OK')).not.toBeInTheDocument();
    });
  });
});

it('should redirect to the login page', () => {
      expect(history.push).toHaveBeenCalledWith(
        `/logout?reason=${LOGOUT_REASONS.UNAUTHORIZED}`
      );
    });
  });

it('redirect to /login with reason "unauthorized"', async () => {
    const rendered = renderApp(null, { route: '/foo' });
    const queryParams = encode({
      reason: LOGOUT_REASONS.UNAUTHORIZED,
      redirectTo: `${window.location.origin}/foo`,
    });
    await wait(() => {
      expect(window.location.replace).toHaveBeenCalledWith(
        `${window.location.origin}/login?${queryParams}`
      );
      expect(rendered.queryByText('OK')).not.toBeInTheDocument();
    });
  });
});

render={({ location }) => (
                  
                )}
              />

reason: (() => {
                    if (hasUnauthorizedError)
                      return LOGOUT_REASONS.UNAUTHORIZED;
                    else if (hasUserBeenDeletedError)
                      return LOGOUT_REASONS.DELETED;
                  })(),
                }}

);
        return (
          
            
          
        );
      }
      case LOGOUT_REASONS.USER:
        return (
          
            
          
        );
      case LOGOUT_REASONS.UNAUTHORIZED:
        return (
          
            
          
        );
      case LOGOUT_REASONS.INVALID:
        return (
          
            
          
        );
      default:
        return (
          
            {error.message}