Merge remote-tracking branch 'origin/main' into beta-releases

Author: github-actions[bot]

THIRD-PARTY-NOTICES.md

@@ -1,5 +1,5 @@
 The following third-party software is used by and included in **Mongodb Compass**.
-This document was automatically generated on Sun Aug 20 2023.
+This document was automatically generated on Wed Aug 23 2023.
 
 ## List of dependencies
 

configs/mocha-config-compass/compass-plugin.js

@@ -7,6 +7,7 @@ module.exports = {
   require: [
     ...reactConfig.require,
     path.resolve(__dirname, 'register', 'electron-renderer-register.js'),
+    path.resolve(__dirname, 'register', 'compass-preferences-register.js'),
   ],
   // electron-mocha config options (ignored when run with just mocha)
   // https://github.com/jprichardson/electron-mocha

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

@@ -0,0 +1,24 @@
+let setupPreferencesPromise;
+
+module.exports = {
+  mochaHooks: {
+    async beforeAll() {
+      // Only do this setup if we are not in electron environment, electron case
+      // is handled in main-process.js
+      if (typeof process.type !== 'undefined') {
+        return;
+      }
+      // For compass-plugin test preset we want to make sure that the
+      // environment is matching compass environment, including the implicit
+      // 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 setupPreferencesPromise;
+    },
+  },
+};

package-lock.json

@@ -1 +1 @@
-module.exports = require('@mongodb-js/mocha-config-compass/react');
+module.exports = require('@mongodb-js/mocha-config-compass/compass-plugin');

packages/atlas-service/.mocharc.js

@@ -72,6 +72,7 @@
     "@mongodb-js/compass-utils": "^0.3.3",
     "@mongodb-js/devtools-connect": "^2.4.0",
     "@mongodb-js/oidc-plugin": "^0.3.0",
+    "compass-preferences-model": "^2.11.1",
     "electron": "^23.3.12",
     "keytar": "^7.9.0",
     "node-fetch": "^2.6.7",

packages/atlas-service/package.json

@@ -109,7 +109,9 @@ const AISignInModal: React.FunctionComponent<SignInModalProps> = ({
           </Button>
           <Button
             variant="primaryOutline"
-            onClick={onSignInModalClose}
+            onClick={() => {
+              onSignInModalClose?.();
+            }}
             className={cx(buttonStyles, maybeLaterButtonStyles)}
           >
             Maybe later

packages/atlas-service/src/components/ai-signin-modal.tsx

@@ -2,8 +2,9 @@ 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';
 
 const wait = promisify(setTimeout);
 
@@ -13,20 +14,6 @@ function getListenerCount(emitter: EventEmitter) {
   }, 0);
 }
 
-const atlasAIServiceTests: {
-  functionName: 'getQueryFromUserInput' | 'getAggregationFromUserInput';
-  aiEndpoint: string;
-}[] = [
-  {
-    functionName: 'getQueryFromUserInput',
-    aiEndpoint: 'mql-query',
-  },
-  {
-    functionName: 'getAggregationFromUserInput',
-    aiEndpoint: 'mql-aggregation',
-  },
-];
-
 describe('AtlasServiceMain', function () {
   const sandbox = Sinon.createSandbox();
 
@@ -52,6 +39,7 @@ describe('AtlasServiceMain', function () {
 
   const fetch = AtlasService['fetch'];
   const ipcMain = AtlasService['ipcMain'];
+  const createPlugin = AtlasService['createMongoDBOIDCPlugin'];
   const apiBaseUrl = process.env.COMPASS_ATLAS_SERVICE_BASE_URL;
   const issuer = process.env.COMPASS_OIDC_ISSUER;
   const clientId = process.env.COMPASS_CLIENT_ID;
@@ -74,6 +62,7 @@ describe('AtlasServiceMain', function () {
     AtlasService['token'] = null;
     AtlasService['initPromise'] = null;
     AtlasService['oidcPluginSyncedFromLoggerState'] = 'initial';
+    AtlasService['createMongoDBOIDCPlugin'] = createPlugin;
 
     sandbox.resetHistory();
   });
@@ -213,15 +202,46 @@ describe('AtlasServiceMain', function () {
     });
   });
 
-  for (const { functionName, aiEndpoint } of atlasAIServiceTests) {
+  const atlasAIServiceTests = [
+    {
+      functionName: 'getQueryFromUserInput',
+      aiEndpoint: 'mql-query',
+      responses: {
+        success: {
+          content: { query: { filter: "{ test: 'pineapple' }" } },
+        },
+        invalid: [
+          {},
+          { countent: {} },
+          { content: { qooery: {} } },
+          { content: { query: { filter: { foo: 1 } } } },
+        ],
+      },
+    },
+    {
+      functionName: 'getAggregationFromUserInput',
+      aiEndpoint: 'mql-aggregation',
+      responses: {
+        success: {
+          content: { aggregation: { pipeline: "[{ test: 'pineapple' }]" } },
+        },
+        invalid: [
+          {},
+          { content: { aggregation: {} } },
+          { content: { aggrogation: {} } },
+          { content: { aggregation: { pipeline: true } } },
+        ],
+      },
+    },
+  ] as const;
+
+  for (const { functionName, aiEndpoint, responses } of atlasAIServiceTests) {
     describe(functionName, function () {
       it('makes a post request with the user input to the endpoint in the environment', async function () {
         AtlasService['fetch'] = sandbox.stub().resolves({
           ok: true,
           json() {
-            return Promise.resolve({
-              content: { query: { filter: "{ test: 'pineapple' }" } },
-            });
+            return Promise.resolve(responses.success);
           },
         }) as any;
 
@@ -243,10 +263,28 @@ describe('AtlasServiceMain', function () {
         expect(args[1].body).to.eq(
           '{"userInput":"test","collectionName":"jam","databaseName":"peanut","schema":{"_id":{"types":[{"bsonType":"ObjectId"}]}},"sampleDocuments":[{"_id":1234}]}'
         );
-        expect(res).to.have.nested.property(
-          'content.query.filter',
-          "{ test: 'pineapple' }"
-        );
+        expect(res).to.deep.eq(responses.success);
+      });
+
+      it('should fail when response is not matching expected schema', async function () {
+        for (const res of responses.invalid) {
+          AtlasService['fetch'] = sandbox.stub().resolves({
+            ok: true,
+            json() {
+              return Promise.resolve(res);
+            },
+          }) as any;
+          try {
+            await AtlasService[functionName]({
+              userInput: 'test',
+              collectionName: 'test',
+              databaseName: 'peanut',
+            });
+            expect.fail(`Expected ${functionName} to throw`);
+          } catch (err) {
+            expect((err as Error).message).to.match(/Unexpected.+?response/);
+          }
+        }
       });
 
       it('uses the abort signal in the fetch request', async function () {
@@ -286,7 +324,7 @@ describe('AtlasServiceMain', function () {
         AtlasService['fetch'] = sandbox.stub().resolves({
           ok: true,
           json() {
-            return Promise.resolve({});
+            return Promise.resolve(responses.success);
           },
         }) as any;
 
@@ -353,13 +391,13 @@ describe('AtlasServiceMain', function () {
         AtlasService['fetch'] = sandbox.stub().resolves({
           ok: true,
           json() {
-            return Promise.resolve({ test: 1 });
+            return Promise.resolve(responses.success);
           },
         }) as any;
         AtlasService['oidcPluginLogger'].emit(
           'mongodb-oidc-plugin:refresh-started'
         );
-        const [query] = await Promise.all([
+        const [res] = await Promise.all([
           AtlasService[functionName]({
             userInput: 'test',
             collectionName: 'test',
@@ -375,7 +413,7 @@ describe('AtlasServiceMain', function () {
             );
           })(),
         ]);
-        expect(query).to.deep.eq({ test: 1 });
+        expect(res).to.deep.eq(responses.success);
       });
     });
   }
@@ -542,7 +580,8 @@ describe('AtlasServiceMain', function () {
           .stub()
           .rejects(new Error('Could not retrieve valid access token'));
       const createPlugin = () => mockOidcPlugin;
-      const initPromise = AtlasService.init(createPlugin);
+      AtlasService['createMongoDBOIDCPlugin'] = createPlugin;
+      const initPromise = AtlasService.init();
       expect(AtlasService).to.have.property(
         'oidcPluginSyncedFromLoggerState',
         'restoring'
@@ -558,7 +597,8 @@ describe('AtlasServiceMain', function () {
       mockOidcPlugin.mongoClientOptions.authMechanismProperties.REQUEST_TOKEN_CALLBACK =
         sandbox.stub().resolves({ accessToken: 'token' });
       const createPlugin = () => mockOidcPlugin;
-      const initPromise = AtlasService.init(createPlugin);
+      AtlasService['createMongoDBOIDCPlugin'] = createPlugin;
+      const initPromise = AtlasService.init();
       expect(AtlasService).to.have.property(
         'oidcPluginSyncedFromLoggerState',
         'restoring'
@@ -570,4 +610,68 @@ describe('AtlasServiceMain', function () {
       );
     });
   });
+
+  describe('with networkTraffic turned off', function () {
+    let networkTraffic: boolean;
+
+    before(async function () {
+      networkTraffic = preferencesAccess.getPreferences().networkTraffic;
+      await preferencesAccess.savePreferences({ networkTraffic: false });
+    });
+
+    after(async function () {
+      await preferencesAccess.savePreferences({ networkTraffic });
+    });
+
+    for (const methodName of [
+      'requestOAuthToken',
+      'signIn',
+      'getUserInfo',
+      'introspect',
+      'revoke',
+      'getAggregationFromUserInput',
+      'getQueryFromUserInput',
+    ]) {
+      it(`${methodName} should throw`, async function () {
+        try {
+          await (AtlasService as any)[methodName]({});
+          expect.fail(`Expected ${methodName} to throw`);
+        } catch (err) {
+          expect(err).to.have.property(
+            'message',
+            'Network traffic is not allowed'
+          );
+        }
+      });
+    }
+  });
+
+  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;
+    });
+  });
 });