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 Tue Jun 25 2024.
+This document was automatically generated on Wed Jun 26 2024.
 
 ## List of dependencies
 

packages/compass-aggregations/src/modules/input-documents.spec.ts

@@ -1,12 +1,22 @@
+import { expect } from 'chai';
+import { defaultPreferencesInstance } from 'compass-preferences-model';
+import sinon from 'sinon';
+
 import reducer, {
   toggleInputDocumentsCollapsed,
   updateInputDocuments,
   loadingInputDocuments,
+  refreshInputDocuments,
   ActionTypes,
 } from './input-documents';
-import { expect } from 'chai';
+import type { RootState } from '.';
+import type { DataService } from './data-service';
 
 describe('input documents module', function () {
+  afterEach(function () {
+    sinon.restore();
+  });
+
   describe('#toggleInputDocumentsCollapsed', function () {
     it('returns the ActionTypes.CollapseToggled action', function () {
       expect(toggleInputDocumentsCollapsed()).to.deep.equal({
@@ -33,6 +43,53 @@ describe('input documents module', function () {
     });
   });
 
+  describe('#refreshInputDocuments', function () {
+    it('should apply maxTimeMS to the aggregation when it is set', async function () {
+      const refreshInputDocumentsThunk = refreshInputDocuments();
+
+      const mockAggregate = sinon.stub().resolves([]);
+      const mockState: Partial<RootState> = {
+        dataService: {
+          dataService: {
+            aggregate: mockAggregate,
+          } as unknown as DataService,
+        },
+        namespace: 'test.namespace',
+        maxTimeMS: undefined,
+        settings: {
+          isExpanded: false,
+          isCommentMode: false,
+          isDirty: false,
+          limit: 10,
+          sampleSize: 10,
+        },
+      };
+
+      await refreshInputDocumentsThunk(
+        sinon.stub(),
+        () => mockState as RootState,
+        { preferences: defaultPreferencesInstance } as any
+      );
+
+      expect(mockAggregate.calledOnce).to.be.true;
+      expect(mockAggregate.firstCall.args[2]).to.deep.equal({
+        maxTimeMS: 60_000,
+      });
+
+      mockState.maxTimeMS = 1000;
+      await refreshInputDocumentsThunk(
+        sinon.stub(),
+        () => mockState as RootState,
+        { preferences: defaultPreferencesInstance } as any
+      );
+
+      expect(mockAggregate.calledTwice).to.be.true;
+      expect(mockAggregate.secondCall.args[2]).to.deep.equal({
+        maxTimeMS: 1000,
+      });
+    });
+  });
+
   describe('#reducer', function () {
     context(
       'when the action is not toggle input documents collapsed',

packages/compass-aggregations/src/modules/input-documents.ts

@@ -3,6 +3,7 @@ import { capMaxTimeMSAtPreferenceLimit } from 'compass-preferences-model/provide
 import type { PipelineBuilderThunkAction } from '.';
 import type { AnyAction } from 'redux';
 import { isAction } from '../utils/is-action';
+import { DEFAULT_MAX_TIME_MS } from '../constants';
 
 export enum ActionTypes {
   CollapseToggled = 'aggregations/input-documents/CollapseToggled',
@@ -111,9 +112,10 @@ export const refreshInputDocuments = (): PipelineBuilderThunkAction<
     }
 
     const options = {
-      maxTimeMS: capMaxTimeMSAtPreferenceLimit(preferences, maxTimeMS) as
-        | number
-        | undefined,
+      maxTimeMS: capMaxTimeMSAtPreferenceLimit(
+        preferences,
+        maxTimeMS ?? DEFAULT_MAX_TIME_MS
+      ),
     };
 
     const aggregateOptions = { ...options };

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

@@ -262,6 +262,14 @@ export function activateAggregationsPlugin(
     maxTimeMSChanged(preferences.getPreferences().maxTimeMS || null)
   );
 
+  const onCloseOrReplace = () => {
+    return !store.getState().isModified;
+  };
+
+  addCleanup(workspaces.onTabReplace?.(onCloseOrReplace));
+
+  addCleanup(workspaces.onTabClose?.(onCloseOrReplace));
+
   return {
     store,
     deactivate: cleanup,

packages/compass-connections/src/hooks/use-connection-repository.ts

@@ -43,6 +43,7 @@ function sortedAlphabetically(a: ConnectionInfo, b: ConnectionInfo): number {
 export type ConnectionRepository = {
   favoriteConnections: ConnectionInfo[];
   nonFavoriteConnections: ConnectionInfo[];
+  autoConnectInfo?: ConnectionInfo;
   saveConnection: (info: PartialConnectionInfo) => Promise<ConnectionInfo>;
   deleteConnection: (info: ConnectionInfo) => Promise<void>;
   getConnectionInfoById: (
@@ -189,6 +190,7 @@ export function useConnectionRepository(): ConnectionRepository {
     getConnectionTitleById,
     favoriteConnections,
     nonFavoriteConnections,
+    autoConnectInfo,
     saveConnection,
     deleteConnection,
   };

packages/compass-connections/src/hooks/use-connections-with-status.ts

@@ -17,11 +17,14 @@ export function useConnectionsWithStatus(): ConnectionInfoWithStatus[] {
   // when this code is refactored to use the hadron plugin interface, storage
   // should be handled through the plugin activation lifecycle
   const connectionsManager = useConnectionsManagerContext();
-  const { favoriteConnections, nonFavoriteConnections } =
+  const { favoriteConnections, nonFavoriteConnections, autoConnectInfo } =
     useConnectionRepository();
   const allConnections = useMemo(() => {
-    return [...favoriteConnections, ...nonFavoriteConnections];
-  }, [favoriteConnections, nonFavoriteConnections]);
+    return favoriteConnections.concat(
+      nonFavoriteConnections,
+      autoConnectInfo ? autoConnectInfo : []
+    );
+  }, [favoriteConnections, nonFavoriteConnections, autoConnectInfo]);
 
   const [connectionsWithStatus, setConnectionsWithStatus] = useState<
     ConnectionInfoWithStatus[]
@@ -60,7 +63,7 @@ export function useConnectionsWithStatus(): ConnectionInfoWithStatus[] {
 
   useEffect(() => {
     updateListRef.current();
-  }, [favoriteConnections, nonFavoriteConnections]);
+  }, [favoriteConnections, nonFavoriteConnections, autoConnectInfo]);
 
   useEffect(() => {
     const updateOnStatusChange = () => {

packages/compass-e2e-tests/helpers/commands/close-workspace-tabs.ts

@@ -2,7 +2,8 @@ import type { CompassBrowser } from '../compass-browser';
 import * as Selectors from '../selectors';
 
 export async function closeWorkspaceTabs(
-  browser: CompassBrowser
+  browser: CompassBrowser,
+  autoConfirmTabClose = true
 ): Promise<void> {
   const countTabs = async () => {
     return (await browser.$$(Selectors.workspaceTab(null))).length;
@@ -15,6 +16,14 @@ export async function closeWorkspaceTabs(
     await currentActiveTab.click();
     await browser.waitUntil(async () => {
       await currentActiveTab.$(Selectors.CloseWorkspaceTab).click();
+      if (autoConfirmTabClose) {
+        // Tabs in "dirty" state can't be closed without confirmation
+        if (await browser.$(Selectors.ConfirmTabCloseModal).isExisting()) {
+          await browser.clickVisible(
+            browser.$(Selectors.ConfirmTabCloseModal).$('button=Close tab')
+          );
+        }
+      }
       return (await currentActiveTab.isExisting()) === false;
     });
   }

packages/compass-e2e-tests/helpers/commands/collection-workspaces.ts

@@ -5,17 +5,21 @@ async function navigateToCollection(
   browser: CompassBrowser,
   // TODO(COMPASS-8002): take connectionName into account
   dbName: string,
-  collectionName: string
+  collectionName: string,
+
+  // Close all the workspace tabs to get rid of all the state we
+  // might have accumulated. This is the only way to get back to the zero
+  // state of Schema, and Validation tabs without re-connecting.
+  closeExistingTabs = true
 ): Promise<void> {
   const collectionSelector = Selectors.sidebarCollection(
     dbName,
     collectionName
   );
 
-  // Close all the workspace tabs to get rid of all the state we
-  // might have accumulated. This is the only way to get back to the zero
-  // state of Schema, and Validation tabs without re-connecting.
-  await browser.closeWorkspaceTabs();
+  if (closeExistingTabs) {
+    await browser.closeWorkspaceTabs();
+  }
 
   // search for the collection and wait for the collection to be there and visible
   await browser.clickVisible(Selectors.SidebarFilterInput);
@@ -39,9 +43,15 @@ export async function navigateToCollectionTab(
     | 'Aggregations'
     | 'Schema'
     | 'Indexes'
-    | 'Validation' = 'Documents'
+    | 'Validation' = 'Documents',
+  closeExistingTabs = true
 ): Promise<void> {
-  await navigateToCollection(browser, dbName, collectionName);
+  await navigateToCollection(
+    browser,
+    dbName,
+    collectionName,
+    closeExistingTabs
+  );
   await navigateWithinCurrentCollectionTabs(browser, tabName);
 }
 

packages/compass-e2e-tests/helpers/commands/index.ts

@@ -43,7 +43,7 @@ export * from './save-favorite';
 export * from './save-connection-string-as-favorite';
 export * from './select-connection';
 export * from './select-connection-menu-item';
-export * from './select-favorites-menu-item';
+export * from './select-connections-menu-item';
 export * from './open-settings-modal';
 export * from './wait-for-connection-result';
 export * from './screenshot';

packages/compass-e2e-tests/helpers/commands/select-connections-menu-item.ts

@@ -0,0 +1,32 @@
+import { TEST_MULTIPLE_CONNECTIONS } from '../compass';
+import type { CompassBrowser } from '../compass-browser';
+import * as Selectors from '../selectors';
+
+export async function selectConnectionsMenuItem(
+  browser: CompassBrowser,
+  itemSelector: string
+) {
+  const Sidebar = TEST_MULTIPLE_CONNECTIONS
+    ? Selectors.Multiple
+    : Selectors.Single;
+
+  if (!TEST_MULTIPLE_CONNECTIONS) {
+    // In the single connection world the button only appears on hover
+
+    const selector = Selectors.Single.FavoriteConnectionsHeader;
+    await browser.$(selector).waitForDisplayed();
+
+    // workaround for weirdness in the ItemActionControls menu opener icon
+    await browser.clickVisible(Selectors.Single.ConnectionsTitle);
+
+    // Hover over an arbitrary other element to ensure that the second hover will
+    // actually be a fresh one. This otherwise breaks if this function is called
+    // twice in a row.
+    await browser.hover(`*:not(${selector}, ${selector} *)`);
+    await browser.hover(selector);
+  }
+
+  await browser.clickVisible(Sidebar.ConnectionsMenuButton);
+  await browser.$(Sidebar.ConnectionsMenu).waitForDisplayed();
+  await browser.clickVisible(itemSelector);
+}