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

Author: github-actions[bot]

.evergreen/functions.yml

@@ -683,11 +683,8 @@ functions:
         env:
           <<: *compass-env
           DEBUG: ${debug|}
-          COMPASS_E2E_ATLAS_CLOUD_SANDBOX_CLOUD_CONFIG: 'qa'
           COMPASS_E2E_ATLAS_CLOUD_SANDBOX_USERNAME: ${e2e_tests_compass_web_atlas_username}
           COMPASS_E2E_ATLAS_CLOUD_SANDBOX_PASSWORD: ${e2e_tests_compass_web_atlas_password}
-          COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DBUSER_USERNAME: ${e2e_tests_compass_web_atlas_db_username}
-          COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DBUSER_PASSWORD: ${e2e_tests_compass_web_atlas_password}
           MCLI_PUBLIC_API_KEY: ${e2e_tests_mcli_public_api_key}
           MCLI_PRIVATE_API_KEY: ${e2e_tests_mcli_private_api_key}
           MCLI_ORG_ID: ${e2e_tests_mcli_org_id}

.evergreen/start-atlas-cloud-cluster.sh

@@ -1,10 +1,62 @@
 #!/bin/bash
 
+RUN_ID="$(date +"%s")-$(git rev-parse --short HEAD)"
+DELETE_AFTER="$(date -u -Iseconds -d '+2 hours' 2>/dev/null || date -u -Iseconds -v '+2H')"
+
+# This script helps to automatically provision Atlas cluster for running the e2e
+# tests against. In CI this will always create a new cluster and delete it when
+# the test run is finished. You can also use this script locally to run e2e
+# tests against a "logged in" Atlas Cloud experience in compass-web sandbox.
+#
+# While the provisioning of clusters is automated, you should be aware that it
+# requires some extra environmental variables to be available when you are
+# running it. If you want to be able to run these e2e tests locally, following
+# steps are required:
+#
+# - Create a test Atlas user on one of the testing environments (-dev / -qa).
+#   You can only use your work emails with a subaddress to create those (e.g,
+#   [email protected]).
+#
+# - Setup a new org and project. Save the org id and project id for later.
+#
+# - Create a new API key (Access Manager > Project Access > Create Application >
+#   API Key) for the project you created and save the public and private keys.
+#
+# - (Optional) Deploy a cluster with a required configuration through Atlas
+#   Cloud UI. If you skip the step, the script will deploy a default cluster for
+#   you.
+#
+# - Make sure that you have the following environmental variables provided to
+#   the script below:
+#
+#     MCLI_OPS_MANAGER_URL  API base url matching the environment you used to
+#                           create your user (https://cloud{-dev,-qa}.mongodb.com/)
+#     MCLI_PUBLIC_API_KEY   Public API key
+#     MCLI_PRIVATE_API_KEY  Private API key
+#     MCLI_ORG_ID           Org ID
+#     MCLI_PROJECT_ID       Project ID
+#
+#     COMPASS_E2E_ATLAS_CLOUD_SANDBOX_USERNAME         Cloud user you created
+#     COMPASS_E2E_ATLAS_CLOUD_SANDBOX_PASSWORD         Cloud user password
+#
+# - Source the script followed by running the tests to make sure that some
+#   variables exported from this script are available for the test env:
+#
+#   (ATLAS_CLOUD_TEST_CLUSTER_NAME="TestCluster" source .evergreen/start-atlas-cloud-cluster.sh \
+#     && npm run -w compass-e2e-tests test web -- --test-atlas-cloud-sandbox --test-filter="atlas-cloud/**/*")
+
+_ATLAS_CLOUD_TEST_CLUSTER_NAME=${ATLAS_CLOUD_TEST_CLUSTER_NAME:-""}
+
 # Atlas limits the naming to something like /^[\w\d-]{,23}$/ (and will auto
 # truncate if it's too long) so we're very limited in terms of how unique this
 # name can be. Hopefully the epoch + part of git hash is enough for these to not
 # overlap when tests are running
-ATLAS_CLOUD_TEST_CLUSTER_NAME="e2e-$(date +"%s")-$(git rev-parse HEAD)"
+DEFAULT_ATLAS_CLOUD_TEST_CLUSTER_NAME="e2e-$RUN_ID"
+
+ATLAS_CLUSTER_NAME="${_ATLAS_CLOUD_TEST_CLUSTER_NAME:-$DEFAULT_ATLAS_CLOUD_TEST_CLUSTER_NAME}"
+
+ATLAS_TEST_DB_USERNAME="testuser-$RUN_ID"
+ATLAS_TEST_DB_PASSWORD="$(head -c 32 /dev/urandom | base64 | tr -dc 'a-zA-Z0-9')"
 
 function atlascli() {
   docker run \
@@ -17,23 +69,59 @@ function atlascli() {
 }
 
 cleanup() {
-  echo "Scheduling Atlas deployment \`$ATLAS_CLOUD_TEST_CLUSTER_NAME\` for deletion..."
-  atlascli clusters delete $ATLAS_CLOUD_TEST_CLUSTER_NAME --force
+  # Assuming that we want to preserve the cluster if the name was provided
+  # outside of script. Helpful when trying to run the tests locally, you can
+  # automatically create a cluster with a custom name for the first time, but
+  # then re-use it when running the tests again. Don't forget to clean it up
+  # after you're done!
+  if [ -z "$_ATLAS_CLOUD_TEST_CLUSTER_NAME" ]; then
+    echo "Scheduling Atlas deployment \`$ATLAS_CLUSTER_NAME\` for deletion..."
+    atlascli clusters delete $ATLAS_CLUSTER_NAME --force
+  else
+    echo "Custom cluster name provided ($_ATLAS_CLOUD_TEST_CLUSTER_NAME), skipping cluster cleanup"
+  fi
+  echo "Deleting Atlas db user \`$ATLAS_TEST_DB_USERNAME\`..."
+  atlascli dbusers delete $ATLAS_TEST_DB_USERNAME --force
 }
 
 trap cleanup EXIT
 
-echo "Creating Atlas deployment \`$ATLAS_CLOUD_TEST_CLUSTER_NAME\` to test against..."
-atlascli clusters create $ATLAS_CLOUD_TEST_CLUSTER_NAME \
+echo "Allowing access from current ip..."
+atlascli accessList create \
+  --currentIp \
+  --deleteAfter "$DELETE_AFTER"
+
+echo "Creating Atlas db user \`$ATLAS_TEST_DB_USERNAME\`..."
+atlascli dbusers create atlasAdmin \
+  --username "$ATLAS_TEST_DB_USERNAME" \
+  --password "$ATLAS_TEST_DB_PASSWORD" \
+  --deleteAfter "$DELETE_AFTER" # so that it's autoremoved if cleaning up failed for some reason
+
+export COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DBUSER_USERNAME="$ATLAS_TEST_DB_USERNAME"
+export COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DBUSER_PASSWORD="$ATLAS_TEST_DB_PASSWORD"
+
+echo "Creating Atlas deployment \`$ATLAS_CLUSTER_NAME\` to test against..."
+atlascli clusters create $ATLAS_CLUSTER_NAME \
   --provider AWS \
   --region US_EAST_1 \
   --tier M10
 
 echo "Waiting for the deployment to be provisioned..."
-atlascli clusters watch "$ATLAS_CLOUD_TEST_CLUSTER_NAME"
+atlascli clusters watch $ATLAS_CLUSTER_NAME
 
 echo "Getting connection string for provisioned cluster..."
-ATLAS_CLOUD_TEST_CLUSTER_CONNECTION_STRING_JSON="$(atlascli clusters connectionStrings describe $ATLAS_CLOUD_TEST_CLUSTER_NAME -o json)"
+CONNECTION_STRINGS_JSON="$(atlascli clusters connectionStrings describe $ATLAS_CLUSTER_NAME -o json)"
+
+export COMPASS_E2E_ATLAS_CLOUD_SANDBOX_CLOUD_CONFIG=$(
+  if [[ "$MCLI_OPS_MANAGER_URL" =~ "-dev" ]]; then
+    echo "dev"
+  elif [[ "$MCLI_OPS_MANAGER_URL" =~ "-qa" ]]; then
+    echo "qa"
+  else
+    echo "prod"
+  fi
+)
+echo "Cloud config: $COMPASS_E2E_ATLAS_CLOUD_SANDBOX_CLOUD_CONFIG"
 
-export COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DEFAULT_CONNECTIONS="{\"$ATLAS_CLOUD_TEST_CLUSTER_NAME\": $ATLAS_CLOUD_TEST_CLUSTER_CONNECTION_STRING_JSON}"
+export COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DEFAULT_CONNECTIONS="{\"$ATLAS_CLUSTER_NAME\": $CONNECTION_STRINGS_JSON}"
 echo "Cluster connections: $COMPASS_E2E_ATLAS_CLOUD_SANDBOX_DEFAULT_CONNECTIONS"

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 Tue Oct 29 2024.
+This document was automatically generated on Sun Nov 03 2024.
 
 ## List of dependencies
 

docs/tracking-plan.md

@@ -1,7 +1,7 @@
 
 # Compass Tracking Plan
 
-Generated on Tue, Oct 29, 2024 at 05:29 PM
+Generated on Sun, Nov 3, 2024 at 03:17 AM
 
 ## Table of Contents
 
@@ -148,6 +148,7 @@ Generated on Tue, Oct 29, 2024 at 05:29 PM
 
 ### Schema
 - [Schema Analyzed](#event--SchemaAnalyzedEvent)
+- [Schema Exported](#event--SchemaExportedEvent)
 
 ### Schema Validation
 - [Schema Validation Added](#event--SchemaValidationAddedEvent)
@@ -1801,6 +1802,25 @@ This event is fired when user analyzes the schema.
 - **connection_id** (optional): `string | undefined`
   - The id of the connection associated to this event.
 
+<a name="event--SchemaExportedEvent"></a>
+
+### Schema Exported
+
+This event is fired when user shares the schema.
+
+**Properties**:
+
+- **has_schema** (required): `boolean`
+  - Indicates whether the schema was analyzed before sharing.
+- **schema_width** (required): `number`
+  - The number of fields at the top level.
+- **schema_depth** (required): `number`
+  - The number of nested levels.
+- **geo_data** (required): `boolean`
+  - Indicates whether the schema contains geospatial data.
+- **connection_id** (optional): `string | undefined`
+  - The id of the connection associated to this event.
+
 
 ## Schema Validation
 

packages/compass-e2e-tests/helpers/compass-web-sandbox.ts

@@ -132,7 +132,44 @@ export async function spawnCompassWebSandboxAndSignInToAtlas(
 
   debug('Waiting for the auth to finish ...');
 
-  const res = await authenticatePromise;
+  let authenticatedPromiseSettled = false;
+
+  // Atlas Cloud will periodically remind user to enable MFA (which we can't
+  // enable in e2e CI environment), so to account for that, in parallel to
+  // waiting for auth to finish, we'll wait for the MFA screen to show up and
+  // skip it if it appears
+  const [, settledRes] = await Promise.allSettled([
+    (async () => {
+      const remindMeLaterButton = 'button*=Remind me later';
+
+      await electronProxyRemote.waitUntil(
+        async () => {
+          return (
+            authenticatedPromiseSettled ||
+            (await electronProxyRemote.$(remindMeLaterButton).isDisplayed())
+          );
+        },
+        // Takes awhile for the redirect to land on this reminder page when it
+        // happens, so no need to bombard the browser with displayed checks
+        { interval: 2000 }
+      );
+
+      if (authenticatedPromiseSettled) {
+        return;
+      }
+
+      await electronProxyRemote.$(remindMeLaterButton).click();
+    })(),
+    authenticatePromise.finally(() => {
+      authenticatedPromiseSettled = true;
+    }),
+  ]);
+
+  if (settledRes.status === 'rejected') {
+    throw settledRes.reason;
+  }
+
+  const res = settledRes.value;
 
   if (res.ok === false || !(await res.json()).projectId) {
     throw new Error(

packages/compass-e2e-tests/helpers/test-runner-context.ts

@@ -4,7 +4,7 @@ import {
 } from '@mongodb-js/connection-info';
 import type { MongoClusterOptions } from 'mongodb-runner';
 import yargs from 'yargs';
-import type { Argv } from 'yargs';
+import type { Argv, CamelCase } from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import Debug from 'debug';
 import fs from 'fs';
@@ -106,15 +106,17 @@ function buildDesktopArgs(yargs: Argv) {
  * make sure that the tests in mms are also updated to account for that
  */
 const atlasCloudExternalArgs = [
-  'test-atlas-cloud-external',
   'atlas-cloud-external-url',
   'atlas-cloud-external-project-id',
   'atlas-cloud-external-cookies-file',
   'atlas-cloud-external-default-connections-file',
 ] as const;
 
+type AtlasCloudExternalArgs =
+  | typeof atlasCloudExternalArgs[number]
+  | CamelCase<typeof atlasCloudExternalArgs[number]>;
+
 const atlasCloudSandboxArgs = [
-  'test-atlas-cloud-sandbox',
   'atlas-cloud-sandbox-cloud-config',
   'atlas-cloud-sandbox-username',
   'atlas-cloud-sandbox-password',
@@ -123,6 +125,10 @@ const atlasCloudSandboxArgs = [
   'atlas-cloud-sandbox-default-connections',
 ] as const;
 
+type AtlasCloudSandboxArgs =
+  | typeof atlasCloudSandboxArgs[number]
+  | CamelCase<typeof atlasCloudSandboxArgs[number]>;
+
 let testEnv: 'desktop' | 'web' | undefined;
 
 function buildWebArgs(yargs: Argv) {
@@ -191,13 +197,9 @@ function buildWebArgs(yargs: Argv) {
         description:
           'Stringified JSON with connections that are expected to be available in the Atlas project',
       })
-      .implies(
-        Object.fromEntries(
-          atlasCloudSandboxArgs.map((arg) => {
-            return [arg, atlasCloudSandboxArgs];
-          })
-        )
-      )
+      .implies({
+        'test-atlas-cloud-sandbox': atlasCloudSandboxArgs,
+      })
       .option('test-atlas-cloud-external', {
         type: 'boolean',
         description:
@@ -221,13 +223,9 @@ function buildWebArgs(yargs: Argv) {
         description:
           'File with JSON array of connections (following ConnectionInfo schema) that are expected to be available in the Atlas project',
       })
-      .implies(
-        Object.fromEntries(
-          atlasCloudExternalArgs.map((arg) => {
-            return [arg, atlasCloudExternalArgs];
-          })
-        )
-      )
+      .implies({
+        'test-atlas-cloud-external': atlasCloudExternalArgs,
+      })
       .conflicts({
         'test-atlas-cloud-external': 'test-atlas-cloud-sandbox',
         'test-atlas-cloud-sandbox': 'test-atlas-cloud-external',
@@ -310,42 +308,23 @@ export function assertTestingWeb(ctx = context): asserts ctx is WebParsedArgs {
 export function isTestingAtlasCloudExternal(
   ctx = context
 ): ctx is WebParsedArgs & {
-  [K in
-    | 'testAtlasCloudExternal'
-    | 'atlasCloudExternalUrl'
-    | 'atlasCloudExternalProjectId'
-    | 'atlasCloudExternalCookiesFile'
-    | 'atlasCloudExternalDefaultConnectionsFile']: NonNullable<
-    WebParsedArgs[K]
-  >;
+  [K in AtlasCloudExternalArgs]: NonNullable<WebParsedArgs[K]>;
 } {
   return isTestingWeb(ctx) && !!ctx.testAtlasCloudExternal;
 }
 
 export function isTestingAtlasCloudSandbox(
   ctx = context
 ): ctx is WebParsedArgs & {
-  [K in
-    | 'testAtlasCloudSandbox'
-    | 'atlasCloudSandboxUsername'
-    | 'atlasCloudSandboxPassword'
-    | 'atlasCloudSandboxDbuserUsername'
-    | 'atlasCloudSandboxDbuserPassword'
-    | 'atlasCloudSandboxDefaultConnections']: NonNullable<WebParsedArgs[K]>;
+  [K in AtlasCloudSandboxArgs]: NonNullable<WebParsedArgs[K]>;
 } {
   return isTestingWeb(ctx) && !!ctx.testAtlasCloudSandbox;
 }
 
 export function assertTestingAtlasCloudSandbox(
   ctx = context
 ): asserts ctx is WebParsedArgs & {
-  [K in
-    | 'testAtlasCloudSandbox'
-    | 'atlasCloudSandboxUsername'
-    | 'atlasCloudSandboxPassword'
-    | 'atlasCloudSandboxDbuserUsername'
-    | 'atlasCloudSandboxDbuserPassword'
-    | 'atlasCloudSandboxDefaultConnections']: NonNullable<WebParsedArgs[K]>;
+  [K in AtlasCloudSandboxArgs]: NonNullable<WebParsedArgs[K]>;
 } {
   if (!isTestingAtlasCloudSandbox(ctx)) {
     throw new Error(`Expected tested runtime to be web w/ Atlas Cloud account`);

packages/compass-schema/src/stores/store.ts

@@ -87,6 +87,8 @@ export type SchemaStore = StoreWithStateMixin<SchemaState> & {
   dataService: DataService;
 
   handleSchemaShare(): void;
+  _trackSchemaShared(hasSchema: boolean): void;
+
   onSchemaSampled(): void;
   geoLayerAdded(
     field: string,
@@ -162,6 +164,7 @@ export function activateSchemaPlugin(
         JSON.stringify(this.state.schema, null, '  ')
       );
       const hasSchema = this.state.schema !== null;
+      this._trackSchemaShared(hasSchema);
       openToast(
         'share-schema',
         hasSchema
@@ -181,6 +184,21 @@ export function activateSchemaPlugin(
       );
     },
 
+    _trackSchemaShared(this: SchemaStore, hasSchema: boolean) {
+      const { schema } = this.state;
+      // Use a function here to a) ensure that the calculations here
+      // are only made when telemetry is enabled and b) that errors from
+      // those calculations are caught and logged rather than displayed to
+      // users as errors from the core schema sharing logic.
+      const trackEvent = () => ({
+        has_schema: hasSchema,
+        schema_width: schema?.fields?.length ?? 0,
+        schema_depth: schema ? calculateSchemaDepth(schema) : 0,
+        geo_data: schema ? schemaContainsGeoData(schema) : false,
+      });
+      track('Schema Exported', trackEvent, connectionInfoRef.current);
+    },
+
     /**
      * Initialize the schema store.
      *