chore(web): clean-up old connection info builder code; fix unit tests COMPASS-9263 (#6949)

chore(web): clean-up old connection info builder code; fix unit tests

Author: gribnoysup

package-lock.json

@@ -119,7 +119,6 @@
     "lodash": "^4.17.21",
     "mocha": "^10.2.0",
     "mongodb": "^6.16.0",
-    "mongodb-connection-string-url": "^3.0.1",
     "mongodb-data-service": "^22.27.0",
     "mongodb-log-writer": "^2.3.4",
     "mongodb-ns": "^2.4.2",

packages/compass-web/package.json

@@ -109,13 +109,6 @@ const App = () => {
   return (
     <SandboxConnectionStorageProvider
       value={isAtlas ? null : sandboxConnectionStorage}
-      extraConnectionOptions={
-        isAtlas
-          ? // In the sandbox we're waiting for cert user to be propagated to
-            // the clusters, it can take awhile on the first connection
-            { connectTimeoutMS: 120_000, serverSelectionTimeoutMS: 120_000 }
-          : {}
-      }
     >
       <SandboxPreferencesUpdateProvider
         value={sandboxPreferencesUpdateTrigger.current}

packages/compass-web/sandbox/index.tsx

@@ -1,290 +1,10 @@
 import { expect } from 'chai';
 import { createNoopLogger } from '@mongodb-js/compass-logging/provider';
-import {
-  buildConnectionInfoFromClusterDescription,
-  AtlasCloudConnectionStorage,
-} from './connection-storage';
-import type { ClusterDescriptionWithDataProcessingRegion } from './connection-storage';
-
-const deployment = {
-  replicaSets: [
-    {
-      _id: 'replicaSet-xxx',
-      state: {
-        clusterId: '123abc',
-      },
-    },
-  ],
-  sharding: [
-    {
-      name: 'sharded-xxx',
-      state: {
-        clusterId: '123abc',
-      },
-    },
-  ],
-};
-
-type Test = [string, ClusterDescriptionWithDataProcessingRegion, string];
-
-describe('buildConnectionInfoFromClusterDescription', function () {
-  const tests: Test[] = [
-    [
-      'replicaSet',
-      {
-        '@provider': 'AWS',
-        uniqueId: '123abc',
-        groupId: 'abc',
-        name: 'Cluster0-replicaSet',
-        clusterType: 'REPLICASET',
-        srvAddress: 'replicaSet.mongodb.com',
-        state: 'IDLE',
-        deploymentItemName: 'replicaSet-xxx',
-        dataProcessingRegion: {
-          regionalUrl: 'https://example.com',
-        },
-        replicationSpecList: [
-          {
-            regionConfigs: [
-              {
-                priority: 1,
-                electableSpecs: {
-                  instanceSize: 'M0', // free tier
-                },
-              },
-            ],
-          },
-        ],
-      },
-      'mongodb+srv://replicaSet.mongodb.com/?tls=true&authMechanism=MONGODB-X509&authSource=%24external&serverMonitoringMode=poll&maxIdleTimeMS=30000&minPoolSize=0&maxPoolSize=5',
-    ],
-    [
-      'sharded',
-      {
-        '@provider': 'AWS',
-        uniqueId: '123abc',
-        groupId: 'abc',
-        name: 'Cluster0-sharded',
-        clusterType: 'SHARDED',
-        srvAddress: 'sharded.mongodb.com',
-        state: 'IDLE',
-        deploymentItemName: 'sharded-xxx',
-        dataProcessingRegion: {
-          regionalUrl: 'https://example.com',
-        },
-        geoSharding: {
-          selfManagedSharding: true,
-        },
-        replicationSpecList: [
-          {
-            regionConfigs: [
-              {
-                priority: 1,
-                electableSpecs: {
-                  instanceSize: 'M10', // dedicated
-                },
-              },
-              {
-                priority: 2,
-                electableSpecs: {
-                  instanceSize: 'M12', // dedicated
-                },
-              },
-            ],
-          },
-        ],
-      },
-      'mongodb+srv://sharded.mongodb.com/?tls=true&authMechanism=MONGODB-X509&authSource=%24external&serverMonitoringMode=poll&maxIdleTimeMS=30000&minPoolSize=0&maxPoolSize=5&srvMaxHosts=1',
-    ],
-    [
-      'serverless',
-      {
-        '@provider': 'SERVERLESS',
-        uniqueId: '123abc',
-        groupId: 'abc',
-        name: 'Cluster0-serverless',
-        clusterType: 'REPLICASET',
-        srvAddress: 'serverless.mongodb.com',
-        state: 'IDLE',
-        deploymentItemName: 'serverless-xxx',
-        dataProcessingRegion: {
-          regionalUrl: 'https://example.com',
-        },
-        replicationSpecList: [
-          {
-            regionConfigs: [
-              {
-                priority: 1,
-                electableSpecs: {
-                  instanceSize: 'SERVERLESS_V2',
-                },
-              },
-            ],
-          },
-        ],
-      },
-      'mongodb+srv://serverless.mongodb.com/?tls=true&authMechanism=MONGODB-X509&authSource=%24external&serverMonitoringMode=poll&maxIdleTimeMS=30000&minPoolSize=0&maxPoolSize=5',
-    ],
-    [
-      'flex',
-      {
-        '@provider': 'FLEX',
-        uniqueId: '123abc',
-        groupId: 'abc',
-        name: 'Cluster0-flex',
-        clusterType: 'REPLICASET',
-        srvAddress: 'flex.mongodb.com',
-        state: 'IDLE',
-        deploymentItemName: 'flex-xxx',
-        dataProcessingRegion: {
-          regionalUrl: 'https://example.com',
-        },
-        replicationSpecList: [
-          {
-            regionConfigs: [
-              {
-                priority: 1,
-                electableSpecs: {
-                  instanceSize: 'FLEX',
-                },
-              },
-            ],
-          },
-        ],
-      },
-      'mongodb+srv://flex.mongodb.com/?tls=true&authMechanism=MONGODB-X509&authSource=%24external&serverMonitoringMode=poll&maxIdleTimeMS=30000&minPoolSize=0&maxPoolSize=5',
-    ],
-  ];
-
-  for (const [type, clusterDescription, connectionString] of tests) {
-    it(`should build connection info for ${type} cluster`, function () {
-      const connectionInfo = buildConnectionInfoFromClusterDescription(
-        'ws://test',
-        '123',
-        'abc',
-        clusterDescription,
-        deployment
-      );
-
-      expect(connectionInfo).to.have.property(
-        'id',
-        clusterDescription.uniqueId
-      );
-
-      expect(connectionInfo).to.have.nested.property(
-        'connectionOptions.connectionString',
-        connectionString
-      );
-
-      expect(connectionInfo.connectionOptions.lookup?.()).to.deep.eq({
-        wsURL: 'ws://test',
-        projectId: 'abc',
-        clusterName: `Cluster0-${type}`,
-        srvAddress: `${type}.mongodb.com`,
-      });
-
-      // just assume the last regionConfig in our test data is the highest
-      // priority one
-      const expectedInstanceSize =
-        clusterDescription.replicationSpecList?.[0].regionConfigs.slice().pop()
-          ?.electableSpecs.instanceSize;
-
-      // We test these separately in another test
-      if (connectionInfo.atlasMetadata?.supports) {
-        delete (connectionInfo.atlasMetadata as { supports?: any }).supports;
-      }
-
-      expect(connectionInfo)
-        .to.have.property('atlasMetadata')
-        .deep.eq({
-          orgId: '123',
-          projectId: 'abc',
-          metricsId:
-            type === 'serverless' || type === 'flex'
-              ? `Cluster0-${type}`
-              : '123abc',
-          clusterName: `Cluster0-${type}`,
-          clusterUniqueId: '123abc',
-          metricsType: type === 'sharded' ? 'cluster' : type,
-          instanceSize: expectedInstanceSize,
-          regionalBaseUrl: null,
-          clusterType: clusterDescription.clusterType,
-          clusterState: 'IDLE',
-        });
-    });
-  }
-
-  it('should throw if deployment item is missing', function () {
-    try {
-      buildConnectionInfoFromClusterDescription(
-        'ws://test',
-        '123',
-        'abc',
-        {
-          '@provider': 'mock',
-          uniqueId: 'abc',
-          groupId: 'abc',
-          name: 'Cluster0',
-          clusterType: 'REPLICASET',
-          srvAddress: 'test',
-          state: 'test',
-          deploymentItemName: 'test',
-          dataProcessingRegion: { regionalUrl: 'test' },
-        },
-        deployment
-      );
-      expect.fail('Expected method to throw');
-    } catch (err) {
-      expect(err).to.have.property(
-        'message',
-        "Can't build metrics info when deployment item is not found"
-      );
-    }
-  });
-});
+import { AtlasCloudConnectionStorage } from './connection-storage';
 
 describe('AtlasCloudConnectionStorage', function () {
-  const testClusters: Record<
-    string,
-    Partial<ClusterDescriptionWithDataProcessingRegion>
-  > = {
-    Cluster0: {
-      '@provider': 'AWS',
-      groupId: 'abc',
-      name: 'Cluster0',
-      clusterType: 'REPLICASET',
-      srvAddress: 'test',
-      state: 'test',
-      deploymentItemName: 'replicaSet-xxx',
-      dataProcessingRegion: { regionalUrl: 'test' },
-    },
-    NoDeploymentItem: {
-      '@provider': 'AWS',
-      groupId: 'abc',
-      name: 'NoDeploymentItem',
-      clusterType: 'REPLICASET',
-      srvAddress: 'test',
-      state: 'test',
-      deploymentItemName: 'not-found',
-      dataProcessingRegion: { regionalUrl: 'test' },
-    },
-    NoSrvAddress: {
-      '@provider': 'AWS',
-      name: 'NoSrvAddress',
-    },
-    Paused: {
-      '@provider': 'AWS',
-      name: 'Paused',
-      isPaused: true,
-    },
-    WillThrowOnFetch: {
-      '@provider': 'AWS',
-      name: 'WillThrowOnFetch',
-    },
-  };
-
   describe('#loadAll', function () {
-    it('should load connection descriptions filtering out the ones that failed to fetch', async function () {
+    it('should load connection descriptions filtering out the ones that are in the unsupported state', async function () {
       const atlasService = {
         cloudEndpoint(path: string) {
           return path;
@@ -293,25 +13,30 @@ describe('AtlasCloudConnectionStorage', function () {
           return path;
         },
         authenticatedFetch(path: string) {
-          let payload: any;
-          if (path === '/deployment/abc') {
-            payload = deployment;
-          }
-          if (path === '/nds/clusters/abc') {
-            payload = Array.from(Object.values(testClusters));
-          }
-          const { groups } =
-            /^\/nds\/clusters\/abc\/(?<clusterName>.+?)\/.+?$/.exec(path) ?? {
-              groups: undefined,
-            };
-          if (groups?.clusterName) {
-            if (groups?.clusterName === 'WillThrowOnFetch') {
-              return Promise.reject(
-                new Error('Failed to fetch cluster description')
-              );
-            }
-            payload = testClusters[groups.clusterName];
+          if (!path.endsWith('/clusters/connectionInfo')) {
+            throw new Error('Unsupported URL');
           }
+          const payload = [
+            {
+              id: 'foo',
+              connectionOptions: {},
+              atlasMetadata: { clusterName: 'Cluster0', clusterState: 'IDLE' },
+            },
+            // No metadata, will filter this out
+            {
+              id: 'bar',
+              connectionOptions: {},
+            },
+            // Cluster state not supported
+            {
+              id: 'buz',
+              connectionOptions: {},
+              atlasMetadata: {
+                clusterName: 'Cluster2',
+                clusterState: 'WEIRD_ONE',
+              },
+            },
+          ];
           return Promise.resolve({
             json() {
               return payload;
@@ -339,7 +64,10 @@ describe('AtlasCloudConnectionStorage', function () {
       // We expect all other clusters to be filtered out for one reason or
       // another
       expect(connections).to.have.lengthOf(1);
-      expect(connections[0]).to.have.property('id', 'Cluster0');
+      expect(connections[0]).to.have.nested.property(
+        'atlasMetadata.clusterName',
+        'Cluster0'
+      );
     });
   });
 });