chore(atlas-service, settings): add tests for settings section and sign out (#4750)

Author: gribnoysup

configs/mocha-config-compass/register/compass-preferences-register.js

@@ -1,3 +1,5 @@
+let setupPreferencesPromise;
+
 module.exports = {
   mochaHooks: {
     async beforeAll() {
@@ -11,8 +13,12 @@ module.exports = {
       // preferences used by a lot of packages in the monorepo
       process.env.COMPASS_TEST_USE_PREFERENCES_SANDBOX =
         process.env.COMPASS_TEST_USE_PREFERENCES_SANDBOX ?? 'true';
+      // Make sure we only do this once so that --watch mode doesn't try to set
+      // up preferences again on re-run
+      setupPreferencesPromise ??=
+        require('compass-preferences-model').setupPreferences();
       // NB: Not adding this as a dep in package.json to avoid circular dependency
-      await require('compass-preferences-model').setupPreferences();
+      await setupPreferencesPromise;
     },
   },
 };

packages/atlas-service/src/main.spec.ts

@@ -2,7 +2,7 @@ import Sinon from 'sinon';
 import { expect } from 'chai';
 import { AtlasService, throwIfNotOk } from './main';
 import { promisify } from 'util';
-import type { EventEmitter } from 'events';
+import { EventEmitter } from 'events';
 import { once } from 'events';
 import preferencesAccess from 'compass-preferences-model';
 
@@ -612,9 +612,10 @@ describe('AtlasServiceMain', function () {
   });
 
   describe('with networkTraffic turned off', function () {
-    const networkTraffic = preferencesAccess.getPreferences().networkTraffic;
+    let networkTraffic: boolean;
 
     before(async function () {
+      networkTraffic = preferencesAccess.getPreferences().networkTraffic;
       await preferencesAccess.savePreferences({ networkTraffic: false });
     });
 
@@ -644,4 +645,33 @@ describe('AtlasServiceMain', function () {
       });
     }
   });
+
+  describe('signOut', function () {
+    it('should reset service state, revoke tokens, and destroy plugin', async function () {
+      const logger = new EventEmitter();
+      const plugin = {
+        destroy: sandbox.stub().resolves(),
+      };
+      AtlasService['openExternal'] = sandbox.stub().resolves();
+      AtlasService['token'] = { accessToken: '1234' };
+      AtlasService['createMongoDBOIDCPlugin'] = (() => {
+        return plugin;
+      }) as any;
+      AtlasService['fetch'] = sandbox.stub().resolves({ ok: true }) as any;
+      AtlasService['oidcPluginLogger'] = logger;
+
+      await AtlasService.init();
+      expect(getListenerCount(logger)).to.eq(25);
+
+      await AtlasService.signOut();
+      expect(getListenerCount(logger)).to.eq(0);
+      expect(logger).to.not.eq(AtlasService['oidcPluginLogger']);
+      expect(plugin.destroy).to.have.been.calledOnce;
+      expect(AtlasService['fetch']).to.have.been.calledOnceWith(
+        'http://example.com/v1/revoke?client_id=1234abcd'
+      );
+      expect(AtlasService['token']).to.eq(null);
+      expect(AtlasService['openExternal']).to.have.been.calledOnce;
+    });
+  });
 });

packages/atlas-service/src/main.ts

@@ -253,6 +253,10 @@ export class AtlasService {
     return apiBaseUrl;
   }
 
+  private static openExternal(...args: Parameters<typeof shell.openExternal>) {
+    return shell?.openExternal(...args);
+  }
+
   // We use `allowedFlows` plugin option to control whether or not plugin is
   // allowed to start sign in flow or just try refresh and fail if refresh is
   // not possible.
@@ -287,8 +291,8 @@ export class AtlasService {
 
         redirectRequestHandler(data);
       },
-      async openBrowser({ url }) {
-        await shell.openExternal(url);
+      openBrowser: async ({ url }) => {
+        await this.openExternal(url);
       },
       allowedFlows: this.getAllowedAuthFlows.bind(this),
       logger: this.oidcPluginLogger,
@@ -617,7 +621,7 @@ export class AtlasService {
     this.oidcPluginSyncedFromLoggerState = 'unauthenticated';
     this.oidcPluginLogger.emit('atlas-service-signed-out');
     // Open Atlas sign out page to end the browser session created for sign in
-    void shell.openExternal(
+    void this.openExternal(
       'https://account.mongodb.com/account/login?signedOut=true'
     );
   }

packages/atlas-service/src/store/atlas-signin-reducer.spec.ts

@@ -7,6 +7,7 @@ import {
   AttemptStateMap,
   signInWithModalPrompt,
   closeSignInModal,
+  signInWithoutPrompt,
 } from './atlas-signin-reducer';
 import { expect } from 'chai';
 import { configureStore } from './atlas-signin-store';
@@ -278,4 +279,63 @@ describe('atlasSignInReducer', function () {
       expect(store.getState()).to.have.property('state', 'canceled');
     });
   });
+
+  describe('signInWithoutPrompt', function () {
+    it('should resolve when sign in flow finishes', async function () {
+      const mockAtlasService = {
+        isAuthenticated: sandbox.stub().resolves(false),
+        signIn: sandbox.stub().resolves(),
+        getUserInfo: sandbox.stub().resolves({}),
+        emit: sandbox.stub(),
+      };
+      const store = configureStore({
+        atlasService: mockAtlasService as any,
+      });
+      await store.dispatch(signInWithoutPrompt());
+      expect(store.getState()).to.have.property('state', 'success');
+    });
+
+    it('should reject if sign in fails', async function () {
+      const mockAtlasService = {
+        isAuthenticated: sandbox.stub().resolves(false),
+        signIn: sandbox.stub().rejects(new Error('Sign in failed')),
+        getUserInfo: sandbox.stub().resolves({}),
+        emit: sandbox.stub(),
+      };
+      const store = configureStore({
+        atlasService: mockAtlasService as any,
+      });
+      try {
+        await store.dispatch(signInWithoutPrompt());
+        expect.fail('Expected signInWithoutPrompt action to throw');
+      } catch (err) {
+        expect(err).to.have.property('message', 'Sign in failed');
+      }
+      expect(store.getState()).to.have.property('state', 'error');
+    });
+
+    it('should reject if provided signal was aborted', async function () {
+      const mockAtlasService = {
+        isAuthenticated: sandbox.stub().resolves(false),
+        signIn: sandbox.stub().resolves(),
+        getUserInfo: sandbox.stub().resolves({}),
+        emit: sandbox.stub(),
+      };
+      const store = configureStore({
+        atlasService: mockAtlasService as any,
+      });
+      const c = new AbortController();
+      const signInPromise = store.dispatch(
+        signInWithoutPrompt({ signal: c.signal })
+      );
+      c.abort(new Error('Aborted from outside'));
+      try {
+        await signInPromise;
+        throw new Error('Expected signInPromise to throw');
+      } catch (err) {
+        expect(err).to.have.property('message', 'Aborted from outside');
+      }
+      expect(store.getState()).to.have.property('state', 'canceled');
+    });
+  });
 });

packages/atlas-service/src/store/atlas-signin-reducer.ts

@@ -2,6 +2,7 @@ import type { AnyAction, Reducer } from 'redux';
 import type { ThunkAction } from 'redux-thunk';
 import { openToast } from '@mongodb-js/compass-components';
 import type { AtlasService } from '../renderer';
+import { throwIfAborted } from '@mongodb-js/compass-utils';
 
 export function isAction<A extends AnyAction>(
   action: AnyAction,
@@ -315,7 +316,9 @@ const startAttempt = (fn: () => void): AtlasSignInThunkAction<AttemptState> => {
         // noop for the promise created by `finally`, original promise rejection
         // should be handled by the service user
       });
-    fn();
+    setImmediate(function () {
+      fn();
+    });
     return attempt;
   };
 };
@@ -376,6 +379,7 @@ export const signIn = (): AtlasSignInThunkAction<Promise<void>> => {
     } = getAttempt(getState().currentAttemptId);
     dispatch({ type: AtlasSignInActions.Start });
     try {
+      throwIfAborted(signal);
       if ((await atlasService.isAuthenticated({ signal })) === false) {
         await atlasService.signIn({ signal });
       }

packages/compass-settings/src/components/modal.spec.tsx

@@ -1,6 +1,12 @@
 import React from 'react';
 import type { ComponentProps } from 'react';
-import { render, screen, within, waitFor } from '@testing-library/react';
+import {
+  render,
+  screen,
+  within,
+  waitFor,
+  cleanup,
+} from '@testing-library/react';
 import { spy, stub } from 'sinon';
 import type { SinonSpy } from 'sinon';
 import { expect } from 'chai';
@@ -42,6 +48,10 @@ describe('SettingsModal', function () {
     };
   });
 
+  afterEach(function () {
+    cleanup();
+  });
+
   it('renders nothing until it is open and loaded', function () {
     renderSettingsModal({ isOpen: false });