test(e2e): Server lifecycle, startup, tray/settings, and deep linking

e2e/helpers/deeplink.ts

@@ -0,0 +1,86 @@
+// Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {expect} from '@playwright/test';
+import type {ElectronApplication, Page} from 'playwright';
+
+import {buildServerMap} from './serverMap';
+
+export function mattermostDeepLinkUrl(hostAndPath: string): string {
+    // E2E always launches the unpacked binary (electron-is-dev=true), so deep links
+    // must use mattermost-dev:// regardless of the Playwright worker's NODE_ENV.
+    return `mattermost-dev://${hostAndPath}`;
+}
+
+/** Build a channel deep link that preserves the team path from the configured server URL. */
+export function channelDeepLinkUrl(serverUrl: string, channelName: string): string {
+    const normalized = serverUrl.endsWith('/') ? serverUrl : `${serverUrl}/`;
+    const parsed = new URL(normalized);
+    const teamPath = parsed.pathname.replace(/\/$/, '');
+    const channelPath = teamPath ? `${teamPath}/channels/${channelName}` : `/channels/${channelName}`;
+    return mattermostDeepLinkUrl(`${parsed.host}${channelPath}`);
+}
+
+export async function openDeepLinkInApp(app: ElectronApplication, url: string): Promise<void> {
+    await app.evaluate((_, deepLinkUrl) => {
+        const openDeepLink = (global as any).__e2eOpenDeepLink as ((value: string) => void) | undefined;
+        if (!openDeepLink) {
+            throw new Error('__e2eOpenDeepLink not exposed (NODE_ENV must be test)');
+        }
+        openDeepLink(deepLinkUrl);
+    }, url);
+}
+
+/** Poll any tab for the server until one navigates to the expected channel. */
+export async function waitForServerChannelNavigation(
+    app: ElectronApplication,
+    serverName: string,
+    channelName: string,
+    options?: {timeout?: number},
+): Promise<void> {
+    await expect.poll(async () => {
+        try {
+            const map = await buildServerMap(app);
+            const entries = map[serverName] ?? [];
+            for (const entry of entries) {
+                const url = await entry.win.url();
+                if (url.includes(channelName)) {
+                    return true;
+                }
+            }
+            return false;
+        } catch {
+            return false;
+        }
+    }, {
+        timeout: options?.timeout ?? 15_000,
+        message: `Server view should navigate to ${channelName}`,
+    }).toBe(true);
+}
+
+/**
+ * Poll the server's primary view for a URL containing `urlSubstring`, then poll
+ * the dropdown button until it shows `serverName`. Shared by deep-link tests that
+ * assert both the navigation and the resulting active-server UI state.
+ */
+export async function waitForServerUrlAndDropdown(
+    app: ElectronApplication,
+    mainWindow: Page,
+    serverName: string,
+    urlSubstring: string,
+    options?: {urlTimeout?: number; dropdownTimeout?: number},
+): Promise<void> {
+    await expect.poll(async () => {
+        const freshMap = await buildServerMap(app);
+        const freshView = freshMap[serverName]?.[0]?.win;
+        return (await freshView?.url()) ?? '';
+    }, {
+        timeout: options?.urlTimeout ?? 30_000,
+        message: `Server view for ${serverName} should navigate to a URL containing "${urlSubstring}"`,
+    }).toContain(urlSubstring);
+
+    await expect.poll(
+        () => mainWindow.innerText('.ServerDropdownButton'),
+        {timeout: options?.dropdownTimeout ?? 15_000, message: `Server dropdown should show ${serverName}`},
+    ).toBe(serverName);
+}

e2e/helpers/electronApp.ts

@@ -42,6 +42,25 @@ export async function closeElectronAppFast(
     return closeElectronApp(app, dataDir, FAST_TEARDOWN);
 }
 
+/**
+ * Close an app that may not have launched (e.g. the launch itself threw) and may
+ * not have a userDataDir assigned yet. Uses the fast teardown when a dir is known
+ * (unique per-test dir, safe to abandon); otherwise falls back to a plain close.
+ */
+export async function closeAppSafely(
+    app: ElectronApplication | undefined,
+    dataDir?: string,
+): Promise<void> {
+    if (!app) {
+        return;
+    }
+    if (dataDir) {
+        await closeElectronAppFast(app, dataDir);
+    } else {
+        await app.close().catch(() => {});
+    }
+}
+
 function workerRegistryPath(workerPid: number = process.pid): string {
     return path.join(REGISTRY_DIR, `${REGISTRY_PREFIX}-${workerPid}.txt`);
 }

e2e/helpers/errorView.ts

@@ -0,0 +1,175 @@
+// Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+import {expect} from '@playwright/test';
+import type {ElectronApplication} from 'playwright';
+
+import {clearCertificateErrorCallbacks} from './dialog';
+import {evaluateInMainProcessWithArg, isTransientEvaluateError} from './testRefs';
+
+type WaitForErrorViewOptions = {
+    serverName?: string;
+    timeout?: number;
+};
+
+type ServerReloadAction = 'checkRegistered' | 'reload' | 'checkLoading';
+
+/**
+ * Single main-process callback for the three server-reload polls below, so the
+ * "filter servers by name → get views → get WebContentsManager entry" traversal
+ * is written once instead of once per poll. `action` picks which step to run;
+ * this has to stay one function (rather than three) because Playwright serializes
+ * whatever function is passed to `evaluate` — helpers defined elsewhere in this
+ * module aren't reachable from inside it.
+ *
+ * NOTE: Playwright's ElectronApplication.evaluate(fn, arg) always passes the
+ * `electron` module as the FIRST argument to `fn`. The user-supplied `arg` is the
+ * SECOND argument. Hence the `(_electron, payload)` signature below.
+ */
+async function evaluateServerReloadState(
+    app: ElectronApplication,
+    action: ServerReloadAction,
+    targetServerName?: string,
+): Promise<boolean> {
+    return evaluateInMainProcessWithArg(app, (_electron, payload) => {
+        const refs = (global as any).__e2eTestRefs;
+        if (!refs) {
+            return payload.action === 'checkLoading';
+        }
+
+        const servers: Array<{id: string; name: string}> = refs.ServerManager.getAllServers();
+        const targets = payload.targetServerName ?
+            servers.filter((server) => server.name === payload.targetServerName) :
+            servers;
+
+        if (payload.action === 'checkRegistered') {
+            return targets.length > 0;
+        }
+
+        const getWebContentsEntries = () => {
+            const entries: any[] = [];
+            for (const server of targets) {
+                const views: Array<{id: string}> = refs.ViewManager.getViewsByServerId(server.id);
+                for (const view of views) {
+                    const wcEntry = refs.WebContentsManager.getView(view.id);
+                    if (wcEntry) {
+                        entries.push(wcEntry);
+                    }
+                }
+            }
+            return entries;
+        };
+
+        if (payload.action === 'reload') {
+            for (const wcEntry of getWebContentsEntries()) {
+                wcEntry.reload?.();
+            }
+            return true;
+        }
+
+        // checkLoading
+        return getWebContentsEntries().every((wcEntry) => !wcEntry.webContents?.isLoading?.());
+    }, {action, targetServerName});
+}
+
+/**
+ * Wait for the renderer to mount, then reload server views so load failures
+ * that fired before IPC listeners were registered are surfaced in ErrorView.
+ */
+export async function waitForRendererThenReload(
+    app: ElectronApplication,
+    serverName?: string,
+): Promise<void> {
+    const mainWindow = app.windows().find((window) => window.url().includes('index'));
+    if (!mainWindow) {
+        return;
+    }
+
+    await mainWindow.waitForSelector('.ServerDropdownButton', {timeout: 15_000}).catch(() => {});
+
+    if (serverName) {
+        await expect.poll(() => {
+            return !app.windows().some((window) => {
+                try {
+                    return window.url().includes('newServer');
+                } catch {
+                    return false;
+                }
+            });
+        }, {timeout: 10_000, message: 'Add server modal should close after confirm'}).toBe(true);
+
+        await expect.poll(async () => {
+            return mainWindow.innerText('.ServerDropdownButton');
+        }, {timeout: 10_000, message: `Active server should switch to ${serverName}`}).toContain(serverName);
+    }
+
+    // Wait until ServerManager knows about the target server. We intentionally do NOT
+    // require a WebContentsManager entry to exist here: on platforms where the initial
+    // load fails very fast (e.g. expired cert at startup), the view may never be added
+    // to WebContentsManager before this poll's deadline. If no view exists, the reload
+    // step below becomes a no-op and the existing load failure already surfaces in
+    // `.ErrorView`, which is what the caller is polling for.
+    await expect.poll(
+        () => evaluateServerReloadState(app, 'checkRegistered', serverName),
+        {timeout: 15_000, message: 'Target server should be registered before reload'},
+    ).toBe(true);
+
+    await clearCertificateErrorCallbacks(app).catch(() => {});
+
+    await evaluateServerReloadState(app, 'reload', serverName);
+
+    await expect.poll(
+        () => evaluateServerReloadState(app, 'checkLoading', serverName),
+        {timeout: 15_000, message: 'Server views should finish reloading after renderer is ready'},
+    ).toBe(true);
+}
+
+/**
+ * Only DOM-not-ready-yet failures (missing window, missing selector, transient
+ * evaluate errors) should be retried here. A real programming error — a bad ref,
+ * a renamed method, a typo — should fail immediately instead of being retried
+ * away for up to a minute and reported as a generic "ErrorView did not appear".
+ */
+function isRetryableErrorViewFailure(error: unknown): boolean {
+    if (isTransientEvaluateError(error)) {
+        return true;
+    }
+    if (error instanceof TypeError || error instanceof ReferenceError) {
+        return false;
+    }
+    if (error instanceof Error && error.message.startsWith('__e2eTestRefs.')) {
+        return false;
+    }
+    return true;
+}
+
+export async function waitForErrorView(
+    app: ElectronApplication,
+    options: WaitForErrorViewOptions = {},
+): Promise<void> {
+    const timeout = options.timeout ?? (process.env.CI ? 60_000 : 45_000);
+    const deadline = Date.now() + timeout;
+    let lastError: unknown;
+    while (Date.now() < deadline) {
+        try {
+            const mainWindow = app.windows().find((window) => window.url().includes('index'));
+            if (!mainWindow) {
+                throw new Error('Main index window is not available yet');
+            }
+            await waitForRendererThenReload(app, options.serverName);
+            await mainWindow.waitForSelector('.ErrorView', {
+                timeout: Math.min(10_000, deadline - Date.now()),
+            });
+            return;
+        } catch (error) {
+            if (!isRetryableErrorViewFailure(error)) {
+                throw error;
+            }
+            lastError = error;
+            await clearCertificateErrorCallbacks(app).catch(() => {});
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+    }
+
+    throw lastError instanceof Error ? lastError : new Error('ErrorView did not appear before timeout');
+}