chore(e2e): refactor resize into its own method; use compass default instead of os max screen size (#7545)

* chore(e2e): refactor resize into its own method; use compass default instead of os max screen size

* fix(e2e): allow slight deviations when resizing window

* fix(e2e): skip expected height check on macos

* fix(e2e): account for old compass in smokes not returning from maximize handler

* fix(e2e): more smoke workarounds

* debugging smokes is not fun

Author: gribnoysup

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

@@ -66,3 +66,4 @@ export * from './read-first-document-content';
 export * from './read-stage-operators';
 export * from './click-confirmation-action';
 export * from './get-input-by-label';
+export * from './resize-window';

packages/compass-e2e-tests/helpers/commands/resize-window.ts

@@ -0,0 +1,64 @@
+import { inspect } from 'util';
+import type { CompassBrowser } from '../compass-browser';
+import { isTestingDesktop } from '../test-runner-context';
+
+type WindowSize = Awaited<ReturnType<CompassBrowser['getWindowSize']>>;
+
+function isEqualWithMargin(a: number, b: number, margin = 30) {
+  return Math.abs(a - b) <= margin;
+}
+
+export async function resizeWindow(
+  browser: CompassBrowser,
+  width: number,
+  height: number,
+  dangerouslySkipWaitFor?: boolean
+): Promise<WindowSize> {
+  let newSize: WindowSize | undefined | void;
+  // On macOS you can only change height as much as the system allows, so when
+  // on macOS, skip checking for the height matching what we requested. That's
+  // not great that we can't be sure that we got what we requested, but there's
+  // little we can do and generally speaking we usually mostly care about the
+  // width being big enough when resizing
+  const skipHeightCheck = process.platform === 'darwin';
+  try {
+    await browser.waitUntil(async () => {
+      // Electron doesn't support setWindowSize / getWindowSize, so we use a
+      // custom ipc handler
+      if (isTestingDesktop()) {
+        newSize = await browser.execute(
+          async (_width: number, _height: number) => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            return await require('electron').ipcRenderer.invoke(
+              'compass:maximize',
+              _width,
+              _height
+            );
+          },
+          width,
+          height
+        );
+        newSize ??= { width: 0, height: 0 }; // in older compass versions 'compass:maximize' doesn't return anything
+      } else {
+        await browser.setWindowSize(width, height);
+        newSize = await browser.getWindowSize();
+      }
+      return (
+        dangerouslySkipWaitFor ||
+        (newSize &&
+          isEqualWithMargin(newSize.width, width) &&
+          (skipHeightCheck || isEqualWithMargin(newSize.height, height)))
+      );
+    });
+  } catch (err) {
+    throw new Error(
+      `Failed to update window size: expected ${inspect({
+        width,
+        height,
+      })}, but got ${inspect(newSize)}. Original error:\n\n${
+        (err as Error).message
+      }`
+    );
+  }
+  return newSize!;
+}

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

@@ -1147,30 +1147,17 @@ export async function init(
     opts.dangerouslySkipSharedConfigWaitFor
   );
 
-  if (TEST_COMPASS_WEB) {
-    // larger window for more consistent results
-    const [width, height] = await browser.execute(() => {
-      // in case setWindowSize() below doesn't work
-      // eslint-disable-next-line no-restricted-globals
-      window.resizeTo(window.screen.availWidth, window.screen.availHeight);
-      // eslint-disable-next-line no-restricted-globals
-      return [window.screen.availWidth, window.screen.availHeight];
-    });
-    // getting available width=1512, height=944 in electron on mac which is arbitrary
-    debug(`available width=${width}, height=${height}`);
-    try {
-      // window.resizeTo() doesn't work on firefox
-      await browser.setWindowSize(width, height);
-    } catch (err) {
-      console.error(err instanceof Error ? err.stack : err);
-    }
-  } else {
-    await browser.execute(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { ipcRenderer } = require('electron');
-      void ipcRenderer.invoke('compass:maximize');
-    });
-  }
+  // Matches Compass desktop defaults
+  const defaultWindowWidth = 1432;
+  const defaultWindowHeight = 840;
+
+  const { width: newWidth, height: newHeight } = await browser.resizeWindow(
+    defaultWindowWidth,
+    defaultWindowHeight,
+    opts.dangerouslySkipSharedConfigWaitFor
+  );
+
+  debug(`resized window to ${newWidth}x${newHeight}`);
 
   if (compass.needsCloseWelcomeModal) {
     try {

packages/compass/src/main/window-manager.ts

@@ -394,10 +394,19 @@ class CompassWindowManager {
     // To resize an electron window you have to do it from the main process.
     // This is here so that the e2e tests can resize the window from the
     // renderer process.
-    ipcMain?.handle('compass:maximize', () => {
-      const first = BrowserWindow.getAllWindows()[0];
-      first.maximize();
-    });
+    ipcMain?.handle(
+      'compass:maximize',
+      (evt, width: number, height: number) => {
+        const window = BrowserWindow.fromWebContents(evt.sender);
+        if (width && height) {
+          window?.setSize(width, height);
+        } else {
+          window?.maximize();
+        }
+        const [newWidth, newHeight] = window?.getSize() ?? [];
+        return window ? { width: newWidth, height: newHeight } : null;
+      }
+    );
 
     await electronApp.whenReady();
     await onAppReady();