@databiosphere/findable-ui 19.0.0 → 20.0.0

package/src/providers/googleSignInAuthentication/provider.tsx

@@ -0,0 +1,53 @@
+import React from "react";
+import { SessionController as DefaultSessionController } from "../../components/Authentication/components/SessionController/components/GoogleSessionController/SessionController";
+import { useAuthReducer } from "../../hooks/authentication/auth/useAuthReducer";
+import { useAuthenticationReducer } from "../../hooks/authentication/authentication/useAuthenticationReducer";
+import { useCredentialsReducer } from "../../hooks/authentication/credentials/useCredentialsReducer";
+import { useSessionActive } from "../../hooks/authentication/session/useSessionActive";
+import { useSessionCallbackUrl } from "../../hooks/authentication/session/useSessionCallbackUrl";
+import { useSessionIdleTimer } from "../../hooks/authentication/session/useSessionIdleTimer";
+import { useTokenReducer } from "../../hooks/authentication/token/useTokenReducer";
+import { AuthContext } from "../authentication/auth/context";
+import { AuthenticationContext } from "../authentication/authentication/context";
+import { CredentialsContext } from "../authentication/credentials/context";
+import { AUTH_STATE, AUTHENTICATION_STATE } from "./constants";
+import { useGoogleSignInService } from "./hooks/useGoogleSignInService";
+import { GoogleSignInAuthenticationProviderProps } from "./types";
+
+export function GoogleSignInAuthenticationProvider({
+  children,
+  SessionController = DefaultSessionController,
+  timeout,
+}: GoogleSignInAuthenticationProviderProps): JSX.Element {
+  const authReducer = useAuthReducer(AUTH_STATE);
+  const authenticationReducer = useAuthenticationReducer(AUTHENTICATION_STATE);
+  const credentialsReducer = useCredentialsReducer();
+  const tokenReducer = useTokenReducer(); // Reducer, local to Google Sign-In process only.
+  const service = useGoogleSignInService({
+    authReducer,
+    authenticationReducer,
+    credentialsReducer,
+    tokenReducer,
+  });
+  const { callbackUrl } = useSessionCallbackUrl();
+  const { authDispatch, authState } = authReducer;
+  const { isAuthenticated } = authState;
+  const { authenticationState } = authenticationReducer;
+  useSessionActive(authState, authenticationState);
+  useSessionIdleTimer({
+    disabled: !isAuthenticated,
+    onIdle: () => service.requestLogout({ callbackUrl }),
+    timeout,
+  });
+  return (
+    <CredentialsContext.Provider value={credentialsReducer}>
+      <AuthenticationContext.Provider value={authenticationReducer}>
+        <AuthContext.Provider value={{ authDispatch, authState, service }}>
+          <SessionController token={tokenReducer.tokenState.token}>
+            {children}
+          </SessionController>
+        </AuthContext.Provider>
+      </AuthenticationContext.Provider>
+    </CredentialsContext.Provider>
+  );
+}

package/src/providers/googleSignInAuthentication/service/constants.ts

@@ -0,0 +1,16 @@
+import { GoogleIcon } from "../../../components/common/CustomIcon/components/GoogleIcon/googleIcon";
+import { OAuthProvider } from "../../../config/entities";
+import { GoogleProfile } from "../profile/types";
+import { mapProfile } from "../profile/utils";
+
+export const GOOGLE_SIGN_IN_PROVIDER_ID = "google";
+
+export const GOOGLE_SIGN_IN_PROVIDER: Pick<
+  OAuthProvider<GoogleProfile>,
+  "icon" | "id" | "name" | "profile"
+> = {
+  icon: GoogleIcon({}),
+  id: GOOGLE_SIGN_IN_PROVIDER_ID,
+  name: "Google",
+  profile: mapProfile,
+};

package/src/providers/googleSignInAuthentication/service/service.ts

@@ -0,0 +1,68 @@
+import { OAuthProvider } from "../../../config/entities";
+import { requestAuth, resetState } from "../../authentication/auth/dispatch";
+import {
+  requestAuthentication,
+  resetState as resetAuthenticationState,
+  updateAuthentication,
+} from "../../authentication/authentication/dispatch";
+import { AUTHENTICATION_STATUS } from "../../authentication/authentication/types";
+import { fetchProfile } from "../../authentication/authentication/utils";
+import { resetState as resetCredentialsState } from "../../authentication/credentials/dispatch";
+import { getAuthenticationRequestOptions } from "../../authentication/terra/hooks/common/utils";
+import {
+  resetState as resetTokenState,
+  updateToken,
+} from "../../authentication/token/dispatch";
+import { SessionDispatch } from "../common/types";
+import { GoogleProfile, TokenSetParameters } from "../profile/types";
+
+// eslint-disable-next-line  @typescript-eslint/no-explicit-any -- TODO see https://github.com/clevercanary/data-browser/issues/544.
+declare const google: any;
+
+export const service = {
+  login: (
+    provider: OAuthProvider,
+    dispatch: Pick<
+      SessionDispatch,
+      "authDispatch" | "authenticationDispatch" | "tokenDispatch"
+    >
+  ): void => {
+    const client = google.accounts.oauth2.initTokenClient({
+      callback: (response: TokenSetParameters) => {
+        const { id, profile, userinfo } = provider;
+        const { access_token: token } = response;
+        dispatch.authDispatch?.(requestAuth());
+        dispatch.authenticationDispatch?.(requestAuthentication());
+        dispatch.tokenDispatch?.(updateToken({ providerId: id, token }));
+        fetchProfile(userinfo, getAuthenticationRequestOptions(token), {
+          onError: () => {
+            dispatch.authDispatch?.(resetState());
+            dispatch.authenticationDispatch?.(
+              updateAuthentication({
+                profile: undefined,
+                status: AUTHENTICATION_STATUS.SETTLED,
+              })
+            );
+            dispatch.tokenDispatch?.(resetTokenState());
+          },
+          onSuccess: (r: GoogleProfile) =>
+            dispatch.authenticationDispatch?.(
+              updateAuthentication({
+                profile: profile(r),
+                status: AUTHENTICATION_STATUS.PENDING, // Authentication is pending until session controller is resolved.
+              })
+            ),
+        });
+      },
+      client_id: provider.clientId,
+      scope: provider.authorization.params.scope,
+    });
+    client.requestAccessToken();
+  },
+  logout: (dispatch: SessionDispatch): void => {
+    dispatch.authDispatch?.(resetState());
+    dispatch.authenticationDispatch?.(resetAuthenticationState());
+    dispatch.credentialsDispatch?.(resetCredentialsState());
+    dispatch.tokenDispatch?.(resetTokenState());
+  },
+};

package/src/providers/googleSignInAuthentication/types.ts

@@ -0,0 +1,7 @@
+import { ElementType, ReactNode } from "react";
+
+export interface GoogleSignInAuthenticationProviderProps {
+  children: ReactNode | ReactNode[];
+  SessionController?: ElementType;
+  timeout?: number;
+}

package/src/providers/nextAuthAuthentication/hooks/useNextAuthService.ts

@@ -0,0 +1,26 @@
+import { useCallback } from "react";
+import { transformRoute } from "../../../hooks/authentication/session/useSessionActive";
+import { useRouteHistory } from "../../../hooks/useRouteHistory";
+import { Service } from "../../authentication/auth/types";
+import { ProviderId } from "../../authentication/common/types";
+import { service } from "../service/service";
+
+export const useNextAuthService = (): Service => {
+  const { callbackUrl } = useRouteHistory(2);
+
+  const onLogin = useCallback(
+    (providerId: ProviderId) => {
+      service.login(providerId, { callbackUrl: callbackUrl(transformRoute) });
+    },
+    [callbackUrl]
+  );
+
+  const onLogout = useCallback(
+    (options?: { callbackUrl?: string; redirect?: boolean }) => {
+      service.logout(options);
+    },
+    []
+  );
+
+  return { requestLogin: onLogin, requestLogout: onLogout };
+};

package/src/providers/nextAuthAuthentication/provider.tsx

@@ -0,0 +1,42 @@
+import { SessionProvider } from "next-auth/react";
+import React from "react";
+import { SessionController } from "../../components/Authentication/components/SessionController/components/NextSessionController/SessionController";
+import { useAuthReducer } from "../../hooks/authentication/auth/useAuthReducer";
+import { useAuthenticationReducer } from "../../hooks/authentication/authentication/useAuthenticationReducer";
+import { useSessionCallbackUrl } from "../../hooks/authentication/session/useSessionCallbackUrl";
+import { useSessionIdleTimer } from "../../hooks/authentication/session/useSessionIdleTimer";
+import { AuthContext } from "../authentication/auth/context";
+import { AuthenticationContext } from "../authentication/authentication/context";
+import { useNextAuthService } from "./hooks/useNextAuthService";
+import { NextAuthAuthenticationProviderProps } from "./types";
+
+export function NextAuthAuthenticationProvider({
+  children,
+  refetchInterval = 0,
+  session,
+  timeout,
+}: NextAuthAuthenticationProviderProps): JSX.Element {
+  const authReducer = useAuthReducer();
+  const authenticationReducer = useAuthenticationReducer();
+  const service = useNextAuthService();
+  const { authDispatch, authState } = authReducer;
+  const { isAuthenticated } = authState;
+  const { callbackUrl } = useSessionCallbackUrl();
+  useSessionIdleTimer({
+    crossTab: true,
+    disabled: !isAuthenticated,
+    onIdle: () => {
+      service.requestLogout({ callbackUrl, redirect: true });
+    },
+    timeout,
+  });
+  return (
+    <SessionProvider session={session} refetchInterval={refetchInterval / 1000}>
+      <AuthenticationContext.Provider value={authenticationReducer}>
+        <AuthContext.Provider value={{ authDispatch, authState, service }}>
+          <SessionController>{children}</SessionController>
+        </AuthContext.Provider>
+      </AuthenticationContext.Provider>
+    </SessionProvider>
+  );
+}

package/src/providers/nextAuthAuthentication/service/service.ts

@@ -0,0 +1,14 @@
+import { signIn, SignInOptions, signOut, SignOutParams } from "next-auth/react";
+import { ProviderId } from "../../authentication/common/types";
+
+export const service = {
+  login: (providerId: ProviderId, options?: SignInOptions): void => {
+    signIn(providerId, options).catch((e) => console.error(e));
+  },
+  logout: (options?: SignOutParams<boolean>): void => {
+    signOut({
+      callbackUrl: options?.callbackUrl,
+      redirect: options?.redirect || false,
+    }).catch((e) => console.error(e));
+  },
+};

package/src/providers/nextAuthAuthentication/types.ts

@@ -0,0 +1,9 @@
+import { Session } from "next-auth";
+import { ReactNode } from "react";
+
+export interface NextAuthAuthenticationProviderProps {
+  children: ReactNode | ReactNode[];
+  refetchInterval?: number;
+  session?: Session | null;
+  timeout?: number;
+}

package/src/routes/constants.ts

@@ -0,0 +1,3 @@
+export const ROUTE = {
+  LOGIN: "/login",
+};

package/src/styles/common/mui/button.ts

@@ -0,0 +1,20 @@
+import { ButtonProps } from "@mui/material";
+
+export const COLOR: Record<string, ButtonProps["color"]> = {
+  ERROR: "error",
+  INFO: "info",
+  INHERIT: "inherit",
+  PRIMARY: "primary",
+  SECONDARY: "secondary",
+  SUCCESS: "success",
+  WARNING: "warning",
+};
+
+export const VARIANT: Record<string, ButtonProps["variant"]> = {
+  ACTIVE_NAV: "activeNav",
+  BACK_NAV: "backNav",
+  CONTAINED: "contained",
+  NAV: "nav",
+  OUTLINED: "outlined",
+  TEXT: "text",
+};

package/src/styles/common/mui/paper.ts

@@ -0,0 +1,11 @@
+import { PaperProps } from "@mui/material";
+
+export const VARIANT: Record<string, PaperProps["variant"]> = {
+  ELEVATION: "elevation",
+  FOOTER: "footer",
+  MENU: "menu",
+  OUTLINED: "outlined",
+  PANEL: "panel",
+  SEARCH_BAR: "searchbar",
+  TABLE: "table",
+};

package/src/styles/common/mui/popover.ts

@@ -0,0 +1,19 @@
+import { PopoverOrigin } from "@mui/material";
+
+export const POPOVER_ORIGIN_HORIZONTAL: Record<
+  string,
+  PopoverOrigin["horizontal"]
+> = {
+  CENTER: "center",
+  LEFT: "left",
+  RIGHT: "right",
+};
+
+export const POPOVER_ORIGIN_VERTICAL: Record<
+  string,
+  PopoverOrigin["vertical"]
+> = {
+  BOTTOM: "bottom",
+  CENTER: "center",
+  TOP: "top",
+};

package/src/theme/common/entities.ts

@@ -0,0 +1,7 @@
+export interface BaseComponentProps {
+  className?: string;
+}
+
+export interface TrackingComponentProps {
+  trackingId?: string;
+}

package/src/views/LoginView/loginView.tsx

@@ -1,18 +1,24 @@
+import { ClientSafeProvider } from "next-auth/react";
 import React from "react";
 import { Login } from "../../components/Login/login";
-import { useAuthenticationConfig } from "../../hooks/useAuthenticationConfig";
+import { useAuthenticationConfig } from "../../hooks/authentication/config/useAuthenticationConfig";
 
-export const LoginView = (): JSX.Element => {
-  const { googleGISAuthConfig, termsOfService, text, title, warning } =
-    useAuthenticationConfig();
+export interface LoginViewProps {
+  providers?: ClientSafeProvider[];
+}
 
+export const LoginView = ({
+  providers,
+}: LoginViewProps): JSX.Element | null => {
+  const authConfig = useAuthenticationConfig();
+  if (!authConfig) return null;
   return (
     <Login
-      isGoogle={!!googleGISAuthConfig}
-      termsOfService={termsOfService}
-      text={text}
-      title={title}
-      warning={warning}
+      providers={providers || authConfig.providers}
+      termsOfService={authConfig.termsOfService}
+      text={authConfig.text}
+      title={authConfig.title}
+      warning={authConfig.warning}
     />
   );
 };

package/tests/getProfileStatus.test.ts

@@ -0,0 +1,290 @@
+import {
+  LoginStatus,
+  REQUEST_STATUS,
+} from "../src/providers/authentication/terra/hooks/common/entities";
+import { TerraNIHResponse } from "../src/providers/authentication/terra/hooks/useFetchTerraNIHProfile";
+import { TerraResponse } from "../src/providers/authentication/terra/hooks/useFetchTerraProfile";
+import { TerraTermsOfServiceResponse } from "../src/providers/authentication/terra/hooks/useFetchTerraTermsOfService";
+import { TERRA_PROFILE_STATUS } from "../src/providers/authentication/terra/types";
+import { getProfileStatus } from "../src/providers/authentication/terra/utils";
+
+const LOGIN_STATUS_NIH_COMPLETED: LoginStatus<TerraNIHResponse> = {
+  isSuccess: true,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.COMPLETED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_COMPLETED: LoginStatus<TerraResponse> = {
+  isSuccess: true,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.COMPLETED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_COMPLETED: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: true,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.COMPLETED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_COMPLETED_UNSUCCESSFUL: LoginStatus<TerraTermsOfServiceResponse> =
+  {
+    isSuccess: false,
+    isSupported: true,
+    requestStatus: REQUEST_STATUS.COMPLETED,
+    response: undefined,
+  };
+
+const LOGIN_STATUS_NIH_NOT_STARTED: LoginStatus<TerraNIHResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_NOT_STARTED: LoginStatus<TerraResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_NOT_STARTED: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_NIH_PENDING: LoginStatus<TerraNIHResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_PENDING: LoginStatus<TerraResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_PENDING: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: false,
+  isSupported: true,
+  requestStatus: REQUEST_STATUS.PENDING,
+  response: undefined,
+};
+
+const LOGIN_STATUS_NIH_UNSUPPORTED: LoginStatus<TerraNIHResponse> = {
+  isSuccess: false,
+  isSupported: false,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TERRA_UNSUPPORTED: LoginStatus<TerraResponse> = {
+  isSuccess: false,
+  isSupported: false,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+const LOGIN_STATUS_TOS_UNSUPPORTED: LoginStatus<TerraTermsOfServiceResponse> = {
+  isSuccess: false,
+  isSupported: false,
+  requestStatus: REQUEST_STATUS.NOT_STARTED,
+  response: undefined,
+};
+
+describe("getProfileStatus", () => {
+  test("not authenticated, services not started", () => {
+    expect(
+      getProfileStatus(
+        false,
+        LOGIN_STATUS_NIH_NOT_STARTED,
+        LOGIN_STATUS_TERRA_NOT_STARTED,
+        LOGIN_STATUS_TOS_NOT_STARTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("not authenticated, services unsupported", () => {
+    expect(
+      getProfileStatus(
+        false,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_UNSUPPORTED,
+        LOGIN_STATUS_TOS_UNSUPPORTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("not authenticated, services completed", () => {
+    expect(
+      getProfileStatus(
+        false,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, services not started", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_NOT_STARTED,
+        LOGIN_STATUS_TERRA_NOT_STARTED,
+        LOGIN_STATUS_TOS_NOT_STARTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, services pending", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_PENDING,
+        LOGIN_STATUS_TERRA_PENDING,
+        LOGIN_STATUS_TOS_PENDING
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih pending, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_PENDING,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, terra pending, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_PENDING,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, tos pending, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_PENDING
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih completed, terra pending, tos not started", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_PENDING,
+        LOGIN_STATUS_TOS_NOT_STARTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih not started, terra completed, tos pending", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_NOT_STARTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_PENDING
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, nih pending, terra not started, tos completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_PENDING,
+        LOGIN_STATUS_TERRA_NOT_STARTED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.PENDING);
+  });
+
+  test("authenticated, services unsupported", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_UNSUPPORTED,
+        LOGIN_STATUS_TOS_UNSUPPORTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.AUTHENTICATED);
+  });
+
+  test("authenticated, services completed, tos unsuccessful", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED_UNSUCCESSFUL
+      )
+    ).toBe(TERRA_PROFILE_STATUS.UNAUTHENTICATED);
+  });
+
+  test("authenticated, nih unsupported, terra completed, tos completed unsuccessfully", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED_UNSUCCESSFUL
+      )
+    ).toBe(TERRA_PROFILE_STATUS.UNAUTHENTICATED);
+  });
+
+  test("authenticated, nih unsupported, other services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.AUTHENTICATED);
+  });
+
+  test("authenticated, terra completed, other services unsupported", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_UNSUPPORTED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_UNSUPPORTED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.UNAUTHENTICATED);
+  });
+
+  test("authenticated, services completed", () => {
+    expect(
+      getProfileStatus(
+        true,
+        LOGIN_STATUS_NIH_COMPLETED,
+        LOGIN_STATUS_TERRA_COMPLETED,
+        LOGIN_STATUS_TOS_COMPLETED
+      )
+    ).toBe(TERRA_PROFILE_STATUS.AUTHENTICATED);
+  });
+});