Merge

Author: Ghost-in-a-Jar

src/auth/auth.ts

@@ -9,9 +9,12 @@ import {
   OidcUser,
 } from 'src/auth/oidc-broker';
 import { cookiesAcceptedKey } from 'src/components/CookieWarning';
-import { Ajax } from 'src/libs/ajax';
 import { fetchOk } from 'src/libs/ajax/ajax-common';
-import { SamUserAttributes } from 'src/libs/ajax/User';
+import { ExternalCredentials } from 'src/libs/ajax/ExternalCredentials';
+import { Groups } from 'src/libs/ajax/Groups';
+import { Metrics } from 'src/libs/ajax/Metrics';
+import { TermsOfService } from 'src/libs/ajax/TermsOfService';
+import { SamUserAttributes, User } from 'src/libs/ajax/User';
 import { withErrorIgnoring, withErrorReporting } from 'src/libs/error';
 import Events, { captureAppcuesEvent, MetricsEventName } from 'src/libs/events';
 import * as Nav from 'src/libs/nav';
@@ -50,7 +53,7 @@ export const getAuthTokenFromLocalStorage = async (): Promise<string | undefined
 };
 
 export const sendRetryMetric = () => {
-  Ajax().Metrics.captureEvent(Events.user.authToken.load.retry, {});
+  Metrics().captureEvent(Events.user.authToken.load.retry, {});
 };
 
 export const signIn = async (includeBillingScope = false): Promise<OidcUser> => {
@@ -71,13 +74,13 @@ export const signIn = async (includeBillingScope = false): Promise<OidcUser> =>
       sessionId,
       sessionStartTime,
     }));
-    Ajax().Metrics.captureEvent(Events.user.login.success, {
+    Metrics().captureEvent(Events.user.login.success, {
       sessionStartTime: Utils.makeCompleteDate(sessionStartTime),
     });
     return authTokenState.oidcUser;
   }
   if (authTokenState.status === 'error') {
-    Ajax().Metrics.captureEvent(Events.user.login.error, {});
+    Metrics().captureEvent(Events.user.login.error, {});
   }
   throw new Error('Auth token failed to load when signing in');
 };
@@ -170,7 +173,7 @@ export const loadAuthToken = async (
     }));
     const { refreshTokenMetadata: currentRefreshTokenMetadata } = metricStore.get();
 
-    Ajax().Metrics.captureEvent(Events.user.authToken.load.success, {
+    Metrics().captureEvent(Events.user.authToken.load.success, {
       authProvider: oidcUser.profile.idp,
       ...getOldAuthTokenLabels(oldAuthTokenMetadata),
       authTokenCreatedAt: getTimestampMetricLabel(authTokenCreatedAt),
@@ -182,7 +185,7 @@ export const loadAuthToken = async (
       jwtExpiresAt: getTimestampMetricLabel(jwtExpiresAt),
     });
   } else if (loadedAuthTokenState.status === 'error') {
-    Ajax().Metrics.captureEvent(Events.user.authToken.load.error, {
+    Metrics().captureEvent(Events.user.authToken.load.error, {
       // we could potentially log the reason, but I don't know if that data is safe to log
       ...getOldAuthTokenLabels(oldAuthTokenMetadata),
       refreshTokenId: oldRefreshTokenMetadata.id,
@@ -460,27 +463,27 @@ authStore.subscribe((state: AuthState) => {
 authStore.subscribe(
   withErrorReporting('Error checking groups for timeout status')(async (state: AuthState, oldState: AuthState) => {
     if (userCanNowUseTerra(oldState, state)) {
-      const isTimeoutEnabled = _.some({ groupName: 'session_timeout' }, await Ajax().Groups.list());
+      const isTimeoutEnabled = _.some({ groupName: 'session_timeout' }, await Groups().list());
       authStore.update((state) => ({ ...state, isTimeoutEnabled }));
     }
   })
 );
 
 export const refreshTerraProfile = async () => {
-  const profile: TerraUserProfile = await Ajax().User.profile.get();
+  const profile: TerraUserProfile = await User().profile.get();
   userStore.update((state: TerraUserState) => ({ ...state, profile }));
 };
 
 export const refreshSamUserAttributes = async (): Promise<void> => {
-  const terraUserAttributes: SamUserAttributes = await Ajax().User.getUserAttributes();
+  const terraUserAttributes: SamUserAttributes = await User().getUserAttributes();
   userStore.update((state: TerraUserState) => ({ ...state, terraUserAttributes }));
 };
 
 export const loadTerraUser = async (): Promise<void> => {
   try {
     const signInStatus = 'userLoaded';
-    const getProfile = Ajax().User.profile.get();
-    const getCombinedState = Ajax().User.getSamUserCombinedState();
+    const getProfile = User().profile.get();
+    const getCombinedState = User().getSamUserCombinedState();
     const [profile, terraUserCombinedState] = await Promise.all([getProfile, getCombinedState]);
     const { terraUserAttributes, enterpriseFeatures, samUser, terraUserAllowances, termsOfService } =
       terraUserCombinedState;
@@ -534,7 +537,7 @@ authStore.subscribe(
 authStore.subscribe(
   withErrorReporting('Error loading NIH account link status')(async (state: AuthState, oldState: AuthState) => {
     if (userCanNowUseTerra(oldState, state)) {
-      const nihStatus = await Ajax().User.getNihStatus();
+      const nihStatus = await User().getNihStatus();
       authStore.update((state: AuthState) => ({ ...state, nihStatus, nihStatusLoaded: true }));
     }
   })
@@ -543,7 +546,7 @@ authStore.subscribe(
 authStore.subscribe(
   withErrorIgnoring(async (state: AuthState, oldState: AuthState) => {
     if (userCanNowUseTerra(oldState, state)) {
-      await Ajax().Metrics.syncProfile();
+      await Metrics().syncProfile();
     }
   })
 );
@@ -553,7 +556,7 @@ authStore.subscribe(
     if (userCanNowUseTerra(oldState, state)) {
       const { anonymousId } = metricStore.get();
       if (anonymousId) {
-        return await Ajax().Metrics.identify(anonymousId);
+        return await Metrics().identify(anonymousId);
       }
     }
   })
@@ -564,7 +567,7 @@ authStore.subscribe(
     if (userCanNowUseTerra(oldState, state)) {
       await Promise.all(
         _.map(async (provider) => {
-          const status = await Ajax().ExternalCredentials(provider).getAccountLinkStatus();
+          const status = await ExternalCredentials()(provider).getAccountLinkStatus();
           authStore.update(_.set(['oAuth2AccountStatus', provider.key], status));
         }, allOAuth2Providers)
       );

src/auth/login.test.ts

@@ -2,16 +2,16 @@ import { DeepPartial } from '@terra-ui-packages/core-utils';
 import { asMockedFn } from '@terra-ui-packages/test-utils';
 import { act } from '@testing-library/react';
 import { loadTerraUser } from 'src/auth/auth';
-import { Ajax } from 'src/libs/ajax';
-import { GroupRole } from 'src/libs/ajax/Groups';
-import { SamUserTermsOfServiceDetails } from 'src/libs/ajax/TermsOfService';
-import { SamUserCombinedStateResponse, SamUserResponse } from 'src/libs/ajax/User';
-import { userStore } from 'src/libs/state';
+import { Groups, GroupsContract } from 'src/libs/ajax/Groups';
+import { Metrics, MetricsContract } from 'src/libs/ajax/Metrics';
+import { SamUserTermsOfServiceDetails, TermsOfService, TermsOfServiceContract } from 'src/libs/ajax/TermsOfService';
+import { SamUserResponse, User, UserContract } from 'src/libs/ajax/User';
+import { oidcStore, TerraUserState, userStore } from 'src/libs/state';
 
-jest.mock('src/libs/ajax');
-
-type AjaxExports = typeof import('src/libs/ajax');
-type AjaxContract = ReturnType<AjaxExports['Ajax']>;
+jest.mock('src/libs/ajax/TermsOfService');
+jest.mock('src/libs/ajax/User');
+jest.mock('src/libs/ajax/Groups');
+jest.mock('src/libs/ajax/Metrics');
 
 jest.mock('react-notifications-component', () => {
   return {
@@ -22,6 +22,12 @@ jest.mock('react-notifications-component', () => {
   };
 });
 
+jest.spyOn(oidcStore, 'get').mockImplementation(
+  jest.fn().mockReturnValue({
+    userManager: { getUser: jest.fn() },
+  })
+);
+
 const samUserDate = new Date('1970-01-01');
 
 const mockSamUserResponse: SamUserResponse = {
@@ -86,43 +92,50 @@ const mockOrchestrationNihStatusResponse = {
   linkExpireTime: 1234,
 };
 
-const mockCurrentUserGroupMembership = {
-  groupEmail: 'testGroupEmail',
-  groupName: 'testGroupName',
-  role: 'member' as GroupRole,
-};
-
 // TODO centralize Ajax mock setup so it can be reused across tests
 describe('a request to load a terra user', () => {
-  // reset userStore state before each test
+  // Arrange (shared between tests for the success case)
+  const getUserAllowancesFunction = jest.fn().mockResolvedValue(testSamUserAllowances);
+  const getUserAttributesFunction = jest.fn().mockResolvedValue({ marketingConsent: false });
+  const getUserTermsOfServiceDetailsFunction = jest.fn().mockResolvedValue(mockSamUserTermsOfServiceDetails);
+  const getEnterpriseFeaturesFunction = jest.fn().mockResolvedValue([]);
+  const getSamUserResponseFunction = jest.fn().mockResolvedValue(mockSamUserResponse);
+  const getNihStatusFunction = jest.fn().mockResolvedValue(mockOrchestrationNihStatusResponse);
+  const getFenceStatusFunction = jest.fn().mockResolvedValue({});
+  const getSamUserCombinedStateMock = jest.fn().mockResolvedValue(mockSamUserCombinedState);
+
   beforeEach(() => {
-    userStore.reset;
+    userStore.reset();
+  });
+
+  // reset userStore state before each test
+  beforeAll(() => {
+    asMockedFn(Metrics).mockReturnValue({
+      captureEvent: jest.fn(),
+    } as Partial<MetricsContract> as MetricsContract);
+    asMockedFn(User).mockReturnValue({
+      getSamUserCombinedState: getSamUserCombinedStateMock,
+      getUserAllowances: getUserAllowancesFunction,
+      getUserAttributes: getUserAttributesFunction,
+      getUserTermsOfServiceDetails: getUserTermsOfServiceDetailsFunction,
+      getEnterpriseFeatures: getEnterpriseFeaturesFunction,
+      getSamUserResponse: getSamUserResponseFunction,
+      getNihStatus: getNihStatusFunction,
+      getFenceStatus: getFenceStatusFunction,
+      profile: {
+        get: jest.fn().mockReturnValue(mockTerraUserProfile),
+      },
+    } as DeepPartial<UserContract> as UserContract);
+
+    asMockedFn(Groups).mockReturnValue({
+      list: jest.fn(),
+    } as Partial<GroupsContract> as GroupsContract);
+
+    asMockedFn(TermsOfService).mockReturnValue({
+      getUserTermsOfServiceDetails: jest.fn().mockReturnValue({}),
+    } as Partial<TermsOfServiceContract> as TermsOfServiceContract);
   });
   describe('when successful', () => {
-    // Arrange (shared between tests for the success case)
-    const getSamUserCombinedStateMock = jest.fn().mockResolvedValue(mockSamUserCombinedState);
-    const getNihStatusMock = jest.fn().mockResolvedValue(mockOrchestrationNihStatusResponse);
-    const getFenceStatusMock = jest.fn().mockResolvedValue({});
-
-    asMockedFn(Ajax).mockImplementation(
-      () =>
-        ({
-          User: {
-            getSamUserCombinedState: getSamUserCombinedStateMock,
-            getNihStatus: getNihStatusMock,
-            getFenceStatus: getFenceStatusMock,
-            profile: {
-              get: jest.fn().mockReturnValue(mockTerraUserProfile),
-            },
-          },
-          TermsOfService: {
-            getUserTermsOfServiceDetails: jest.fn().mockReturnValue({}),
-          },
-          Groups: {
-            list: jest.fn().mockReturnValue([mockCurrentUserGroupMembership]),
-          },
-        } as DeepPartial<AjaxContract> as AjaxContract)
-    );
     it('should include a samUserResponse', async () => {
       // Act
       await act(() => loadTerraUser());
@@ -144,20 +157,20 @@ describe('a request to load a terra user', () => {
         // mock a failure to get samUserResponse
         const getSamUserCombinedStateMockFailure = jest.fn().mockRejectedValue(new Error('unknown'));
 
-        asMockedFn(Ajax).mockImplementation(
-          () =>
-            ({
-              User: {
-                getSamUserCombinedState: getSamUserCombinedStateMockFailure,
-                profile: {
-                  get: jest.fn().mockReturnValue(mockTerraUserProfile),
-                },
-              },
-              TermsOfService: {
-                getUserTermsOfServiceDetails: jest.fn().mockReturnValue({}),
-              },
-            } as DeepPartial<AjaxContract> as AjaxContract)
-        );
+        asMockedFn(User).mockReturnValue({
+          getUserAllowances: getUserAllowancesFunction,
+          getUserAttributes: getUserAttributesFunction,
+          getUserTermsOfServiceDetails: getUserTermsOfServiceDetailsFunction,
+          getEnterpriseFeatures: getEnterpriseFeaturesFunction,
+          getSamUserResponse: getSamUserResponseFunction,
+          getSamUserCombinedState: getSamUserCombinedStateMockFailure,
+
+          profile: {
+            get: jest.fn().mockReturnValue(mockTerraUserProfile),
+          },
+          getNihStatus: getNihStatusFunction,
+        } as DeepPartial<UserContract> as UserContract);
+
         // Act, Assert
         // this expect.assertions is here to prevent the test from passing if the error is not thrown
         expect.assertions(1);

src/registration/terms-of-service/TermsOfServicePage.test.ts

@@ -2,12 +2,18 @@ import { DeepPartial } from '@terra-ui-packages/core-utils';
 import { act, fireEvent, screen } from '@testing-library/react';
 import { h } from 'react-hyperscript-helpers';
 import { Ajax } from 'src/libs/ajax';
-import { SamUserTermsOfServiceDetails } from 'src/libs/ajax/TermsOfService';
-import { SamUserAllowances, SamUserCombinedStateResponse, SamUserResponse } from 'src/libs/ajax/User';
+import { Groups, GroupsContract } from 'src/libs/ajax/Groups';
+import { Metrics, MetricsContract } from 'src/libs/ajax/Metrics';
+import { SamUserTermsOfServiceDetails, TermsOfService, TermsOfServiceContract } from 'src/libs/ajax/TermsOfService';
+import { SamUserAllowances, SamUserResponse, User, UserContract } from 'src/libs/ajax/User';
 import { AuthState, authStore } from 'src/libs/state';
 import { TermsOfServicePage } from 'src/registration/terms-of-service/TermsOfServicePage';
 import { asMockedFn, renderWithAppContexts as render } from 'src/testing/test-utils';
 
+jest.mock('src/libs/ajax/Metrics');
+jest.mock('src/libs/ajax/TermsOfService');
+jest.mock('src/libs/ajax/User');
+jest.mock('src/libs/ajax/Groups');
 jest.mock('src/libs/ajax');
 jest.mock('react-notifications-component', () => {
   return {
@@ -27,8 +33,6 @@ jest.mock(
   })
 );
 
-type AuthExports = typeof import('src/auth/auth');
-
 type SignOutExports = typeof import('src/auth/signout/sign-out');
 jest.mock(
   'src/auth/signout/sign-out',
@@ -38,13 +42,6 @@ jest.mock(
   })
 );
 
-jest.mock(
-  'src/auth/auth',
-  (): AuthExports => ({
-    ...jest.requireActual<AuthExports>('src/auth/auth'),
-  })
-);
-
 interface TermsOfServiceSetupResult {
   getTosFn: jest.Mock;
   getTermsOfServiceComplianceStatusFn: jest.Mock;
@@ -92,31 +89,41 @@ const setupMockAjax = async (
   asMockedFn(Ajax).mockImplementation(
     () =>
       ({
-        Metrics: {
-          captureEvent: jest.fn(),
-        },
-        User: {
-          getSamUserCombinedState: jest.fn().mockResolvedValue(mockSamUserCombinedState),
-          profile: {
-            get: jest.fn().mockResolvedValue({ keyValuePairs: [] }),
-            update: jest.fn().mockResolvedValue({ keyValuePairs: [] }),
-            setPreferences: jest.fn().mockResolvedValue({}),
-            preferLegacyFirecloud: jest.fn().mockResolvedValue({}),
-          },
-          getNihStatus,
-        },
         TermsOfService: {
-          getUserTermsOfServiceDetails,
           acceptTermsOfService,
           rejectTermsOfService,
           getTermsOfServiceText,
         },
-        Groups: {
-          list: jest.fn(),
-        },
       } as DeepPartial<AjaxContract> as AjaxContract)
   );
 
+  asMockedFn(Metrics).mockReturnValue({
+    captureEvent: jest.fn(),
+  } as Partial<MetricsContract> as MetricsContract);
+
+  asMockedFn(User).mockReturnValue({
+    getSamUserCombinedState: jest.fn().mockResolvedValue(mockSamUserCombinedState),
+    getUserAttributes: jest.fn().mockResolvedValue({ marketingConsent: true }),
+    getUserAllowances: jest.fn().mockResolvedValue(terraUserAllowances),
+    getEnterpriseFeatures: jest.fn().mockResolvedValue([]),
+    getSamUserResponse: jest.fn().mockResolvedValue(mockSamUserResponse),
+    profile: {
+      get: jest.fn().mockResolvedValue({ keyValuePairs: [] }),
+      update: jest.fn().mockResolvedValue({ keyValuePairs: [] }),
+      setPreferences: jest.fn().mockResolvedValue({}),
+      preferLegacyFirecloud: jest.fn().mockResolvedValue({}),
+    },
+    getNihStatus,
+  } as Partial<UserContract> as UserContract);
+
+  asMockedFn(Groups).mockReturnValue({
+    list: jest.fn(),
+  } as Partial<GroupsContract> as GroupsContract);
+
+  asMockedFn(TermsOfService).mockReturnValue({
+    getUserTermsOfServiceDetails,
+  } as Partial<TermsOfServiceContract> as TermsOfServiceContract);
+
   await act(async () => {
     authStore.update((state: AuthState) => ({ ...state, termsOfService, signInStatus, terraUserAllowances }));
   });