@camunda/e2e-test-suite 0.0.944 → 0.0.945

package/dist/pages/8.10/OperateProcessesPage.d.ts

@@ -21,6 +21,7 @@ declare class OperateProcessesPage {
     clickProcessIncidentsCheckbox(): Promise<void>;
     clickRunningProcessInstancesCheckbox(): Promise<void>;
     clickFinishedProcessInstancesCheckbox(): Promise<void>;
+    private returnToProcessesList;
     clickProcessInstanceLink(processName: string): Promise<void>;
     applyMoreFilters(filter: string, value: string): Promise<void>;
 }

package/dist/pages/8.10/OperateProcessesPage.js

@@ -78,19 +78,55 @@ class OperateProcessesPage {
     async clickFinishedProcessInstancesCheckbox() {
         await this.processFinishedInstancesCheckbox.click();
     }
+    // Puts the tab back on the processes list before the next attempt of
+    // `clickProcessInstanceLink`. A click that DID navigate to the instance page
+    // but whose "Instance History" panel was slow to render leaves the tab on
+    // `/processes/<key>`, and the instance row the loop looks for can never
+    // appear there: reloading that page spent every remaining attempt waiting
+    // 60s for a row that is not on it, which is what reported "Failed to click
+    // the link after 5 attempts" while the instance was perfectly fine.
+    // Re-opening the list URL also restores the filters the caller applied
+    // (they live in the query string), which a `goBack()` would not guarantee.
+    //
+    // Navigation errors are logged and retried rather than thrown: a reload that
+    // races the click's still-in-flight navigation fails with
+    // `net::ERR_ABORTED; maybe frame was detached?` and a DNS blip with
+    // `net::ERR_NAME_NOT_RESOLVED`. Both used to escape this loop's catch block
+    // and fail the test outright instead of being retried like every other
+    // recovery step here.
+    async returnToProcessesList(listUrl) {
+        try {
+            if (this.page.url() === listUrl) {
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+                return;
+            }
+            await this.page.goto(listUrl, { waitUntil: 'domcontentloaded' });
+        }
+        catch (error) {
+            console.warn(`Could not return to the processes list: ${error}`);
+        }
+    }
     async clickProcessInstanceLink(processName) {
         // Increased from 3 to 5 retries: process-instance indexing in Operate can take
         // longer than 3 × (60 s visible + 10 s reload) on busy SaaS environments,
         // causing intermittent failures in the webhook connector nightly tests.
         const maxRetries = 5;
+        // Captured before the first click so a retry can re-open the list with the
+        // caller's filters instead of reloading whatever page the click landed on.
+        const listUrl = this.page.url();
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
                 await (0, test_1.expect)(this.processInstanceLink(processName)).toBeVisible({
                     timeout: 60000,
                 });
                 await this.processInstanceLink(processName).click({ timeout: 60000 });
+                // The instance page is rendered from the same Zeebe -> Operate import
+                // this list was filtered on, so on a busy cluster the panel regularly
+                // needs longer than 10s to paint. That short budget turned a slow
+                // render into a full re-attempt — and every re-attempt then looked for
+                // the row on the instance page it had just opened.
                 await (0, test_1.expect)(this.page.getByText('Instance History').first()).toBeVisible({
-                    timeout: 10000,
+                    timeout: 60000,
                 });
                 if (await this.whatsNewPopUp.isVisible()) {
                     await this.gotItButton.click();
@@ -99,7 +135,7 @@ class OperateProcessesPage {
             }
             catch (error) {
                 console.error(`Click attempt ${retries + 1} failed: ${error}`);
-                await this.page.reload();
+                await this.returnToProcessesList(listUrl);
                 await (0, sleep_1.sleep)(10000);
             }
         }

package/dist/pages/8.10/OptimizeHomePage.d.ts

@@ -6,7 +6,12 @@ declare class OptimizeHomePage {
     readonly modalCloseButton: Locator;
     readonly optimizeBanner: Locator;
     readonly noPermissionsMessage: Locator;
+    readonly filterTableInput: Locator;
     constructor(page: Page);
+    private waitForOptimizeToRender;
+    private filterTableToProcess;
+    closeModalIfVisible(): Promise<void>;
+    assertProcessImportedWithRetry(processName: string, timeout: number, maxRetries?: number): Promise<void>;
     clickCollectionsLink(): Promise<void>;
     clickDashboardLink(): Promise<void>;
 }

package/dist/pages/8.10/OptimizeHomePage.js

@@ -3,6 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OptimizeHomePage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
+// Optimize's SSO hand-off can fail on the way into the app and leave the tab on
+// `/login?error`, which is not an Optimize page at all: nothing on it ever
+// renders a process definition, and `page.reload()` only re-requests the very
+// same static error page. A polling loop that reloads is therefore stuck there
+// for its whole budget -- that is what reported "Assertion of process <name> in
+// Optimize failed after 1200000ms of polling
+// (url=<region>.optimize.ultrawombat.com/login?error)". Re-entering the app
+// root instead restarts the hand-off, so the poll can get back onto the app.
+const OPTIMIZE_LOGIN_PATH = /^\/login\/?$/;
+function isOptimizeLoginPage(rawUrl) {
+    try {
+        return OPTIMIZE_LOGIN_PATH.test(new URL(rawUrl).pathname);
+    }
+    catch {
+        // Not a parsable URL yet (e.g. a tab still on about:blank).
+        return false;
+    }
+}
 class OptimizeHomePage {
     page;
     collectionsLink;
@@ -10,8 +28,10 @@ class OptimizeHomePage {
     modalCloseButton;
     optimizeBanner;
     noPermissionsMessage;
+    filterTableInput;
     constructor(page) {
         this.page = page;
+        this.filterTableInput = page.getByPlaceholder('Filter table');
         this.collectionsLink = page
             .getByRole('banner')
             .getByRole('link', { name: 'Collections' });
@@ -22,6 +42,124 @@ class OptimizeHomePage {
         });
         this.noPermissionsMessage = page.getByText('default backend - 404');
     }
+    // The Optimize process overview renders a bounded slice of the definition
+    // table, so on an org that already holds the definitions every sibling spec
+    // deployed that night a freshly imported one can sit outside the rendered
+    // rows entirely: `getByRole('link', {name})` then never becomes visible no
+    // matter how long the loop below waits, which is exactly what reported
+    // "Assertion of process <name> in Optimize failed after 1200000ms of
+    // polling" from the app root — a full 20 minutes of reload-polling for a
+    // definition that had long since been imported. Narrowing the table to the
+    // name being waited for is what `OptimizeDashboardPage.processLinkAssertion`
+    // already does before this identical link assertion.
+    // Best effort by design: when the input is not rendered (the app is still
+    // coming up, or a round landed on a page without the table) the round falls
+    // through and asserts against the unfiltered table exactly as before.
+    // Every probe a polling round makes runs immediately after that round's
+    // `reload()` + `waitForLoadState('domcontentloaded')`, which returns while
+    // the Optimize SPA is still mounting and the document is effectively empty.
+    // `isVisible()` answers instantly, so both probes below — the onboarding
+    // modal and the table filter — answered "not there" on essentially every
+    // round: the modal was never dismissed and the table was never narrowed, and
+    // the round then spent its whole slice asserting against a list that had not
+    // rendered. Waiting for the app shell first is what makes the rest of the
+    // round mean anything. It costs nothing once Optimize is up (the wait
+    // resolves in milliseconds) and is bounded, so a round that lands on a page
+    // which never renders Optimize still falls through and reloads as before.
+    async waitForOptimizeToRender(timeout) {
+        await this.filterTableInput
+            .or(this.optimizeBanner)
+            .first()
+            .waitFor({ state: 'visible', timeout })
+            .catch(() => { });
+    }
+    async filterTableToProcess(processName) {
+        const hasFilter = await this.filterTableInput
+            .isVisible()
+            .catch(() => false);
+        if (!hasFilter) {
+            return;
+        }
+        try {
+            await this.filterTableInput.fill(processName, { timeout: 15000 });
+            await this.filterTableInput.press('Enter');
+        }
+        catch (error) {
+            console.warn(`Could not filter the Optimize process table: ${error}`);
+        }
+    }
+    async closeModalIfVisible() {
+        if (await this.modalCloseButton.isVisible()) {
+            await this.modalCloseButton.click({ timeout: 60000 });
+        }
+    }
+    // Optimize pulls process definitions on its own import cycle, so the only
+    // lever is patience — but the patience has to be spent re-asking, not idling.
+    // This list does not live-update: a definition that lands mid-wait is only
+    // rendered by the next reload, so a long `toBeVisible` per round just sits on
+    // a page that already answered. `timeout` x `maxRetries` is kept as the total
+    // budget and spent in short slices that each reload, which turns 10 re-asks
+    // over 20 minutes into one every ~20s. That is the same "re-ask instead of
+    // idling" change already made for the Operate import waits, and it is what
+    // ran out as "Assertion of process <name> in Optimize failed after 10
+    // attempts" whenever the import lagged behind the exporter.
+    // Each round also dismisses the onboarding modal Optimize shows on this
+    // page — it is re-rendered by every reload and covers the process list, so
+    // without closing it the remaining rounds all assert against a modal.
+    async assertProcessImportedWithRetry(processName, timeout, maxRetries = 8) {
+        const processLink = this.page.getByRole('link', { name: processName });
+        const deadline = Date.now() + timeout * maxRetries;
+        // Short enough that a definition imported mid-wait is picked up by the next
+        // reload within seconds, long enough to keep the reload rate modest.
+        const checkSlice = 20000;
+        let lastError;
+        while (Date.now() < deadline) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                break;
+            }
+            try {
+                await this.waitForOptimizeToRender(Math.min(checkSlice, remaining));
+                await this.closeModalIfVisible();
+                await this.filterTableToProcess(processName);
+                await (0, test_1.expect)(processLink).toBeVisible({
+                    timeout: Math.min(checkSlice, remaining),
+                });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+            if (Date.now() >= deadline) {
+                break;
+            }
+            // A reload that races an in-flight navigation fails with
+            // `net::ERR_ABORTED; maybe frame was detached?`, a DNS blip with
+            // `net::ERR_NAME_NOT_RESOLVED`. Both used to escape this polling loop
+            // and fail the test outright instead of being retried on the next round;
+            // an import that genuinely never lands still fails below.
+            try {
+                if (isOptimizeLoginPage(this.page.url())) {
+                    // Off the app entirely (see the note above the class): re-enter the
+                    // app root so the SSO hand-off is retried. Reloading the login page
+                    // can only ever render the login page again.
+                    await this.page.goto(new URL('/', this.page.url()).toString(), {
+                        waitUntil: 'domcontentloaded',
+                    });
+                }
+                else {
+                    await this.page.reload();
+                    await this.page.waitForLoadState('domcontentloaded');
+                }
+            }
+            catch (error) {
+                console.warn(`Could not reload the Optimize process list: ${error}`);
+            }
+        }
+        throw new Error(`Assertion of process ${processName} in Optimize failed after ` +
+            `${timeout * maxRetries}ms of polling (url=${this.page.url()}): ` +
+            `${lastError}`);
+    }
     async clickCollectionsLink() {
         if (await this.modalCloseButton.isVisible({ timeout: 60000 })) {
             await this.modalCloseButton.click();

package/dist/pages/8.10/OptimizeReportPage.d.ts

@@ -40,6 +40,7 @@ declare class OptimizeReportPage {
     clearReportName(): Promise<void>;
     fillReportName(name: string): Promise<void>;
     clickSaveButton(): Promise<void>;
+    assertUserTaskInstanceCountWithRetry(expectedCount: number, tab: Page, maxRetries?: number, timeout?: number): Promise<void>;
     waitUntilLocatorIsVisible(locator: Locator, tab: Page): Promise<void>;
     waitUntilProcessIsVisible(locator: Locator, tab: Page): Promise<void>;
     clickBlankReportButton(): Promise<void>;

package/dist/pages/8.10/OptimizeReportPage.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OptimizeReportPage = void 0;
+const test_1 = require("@playwright/test");
 class OptimizeReportPage {
     page;
     processSelectionButton;
@@ -117,6 +118,30 @@ class OptimizeReportPage {
     async clickSaveButton() {
         await this.saveButton.click();
     }
+    // Optimize imports user-task *instance* data on a later cycle than the
+    // process definition, so a report saved right after the definition lands can
+    // render with a table that is still empty or only partly filled. Poll the
+    // expected row count across reloads instead of probing visibility once and
+    // then asserting the count against whatever the first render contained --
+    // that ordering reports `toHaveCount` received 0 while the import is simply
+    // still in flight.
+    async assertUserTaskInstanceCountWithRetry(expectedCount, tab, maxRetries = 4, timeout = 60000) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(this.oneUserTaskInstance).toHaveCount(expectedCount, {
+                    timeout: timeout,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                await tab.reload();
+                await tab.waitForLoadState('domcontentloaded');
+            }
+        }
+    }
     async waitUntilLocatorIsVisible(locator, tab) {
         let elapsedTime = 0;
         const maxWaitTimeSeconds = 120000;

package/dist/pages/8.10/TaskPanelPage.d.ts

@@ -10,7 +10,8 @@ declare class TaskPanelPage {
     readonly expandButton: Locator;
     readonly processesInfoText: Locator;
     constructor(page: Page);
-    openTask(name: string): Promise<void>;
+    taskInList(name: string): Locator;
+    openTask(name: string, totalTimeout?: number): Promise<void>;
     filterBy(option: 'All open' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
     taskCount(name: string): Promise<number>;
     clickTasksTab(): Promise<void>;

package/dist/pages/8.10/TaskPanelPage.js

@@ -30,24 +30,52 @@ class TaskPanelPage {
         });
         this.processesInfoText = page.getByText('Browse and run processes published by your organization');
     }
-    async openTask(name) {
-        let attempts = 0;
-        const maxAttempts = 3;
-        while (attempts < maxAttempts) {
+    // Tasklist's importer can lag well behind Zeebe under heavy concurrent load
+    // from the sibling chromium-v1/chromium-v2 projects sharing one cluster --
+    // trace evidence from failing runs showed a smoke-test user task still
+    // absent from "Available tasks" more than 5 minutes after the instance was
+    // already ACTIVE in Operate. The budget is therefore generous, but it is a
+    // *total* deadline rather than a fixed attempt count: an attempt count
+    // multiplies with any outer retry loop (`completeTaskWithRetry` re-enters
+    // this method 3 times), which gave one step a worst case larger than the
+    // whole test timeout, so a lagging importer killed the test on the harness
+    // clock instead of failing here with a usable error.
+    // The row for a named task inside the task list. Exposed so callers that
+    // assert on the details panel can re-select the row when a click did not
+    // take effect, rather than re-deriving the locator.
+    taskInList(name) {
+        return this.availableTasks.getByText(name, { exact: true }).first();
+    }
+    async openTask(name, totalTimeout = 1200000) {
+        const deadline = Date.now() + totalTimeout;
+        let lastError;
+        while (Date.now() < deadline) {
             try {
-                const task = this.availableTasks.getByText(name, { exact: true }).first();
-                await task.waitFor({ state: 'visible', timeout: 120000 });
+                const task = this.taskInList(name);
+                await task.waitFor({
+                    state: 'visible',
+                    // Clamped away from 0: Playwright reads `timeout: 0` as "no timeout".
+                    timeout: Math.max(1000, Math.min(120000, deadline - Date.now())),
+                });
                 await task.click({ timeout: 120000 });
                 return;
             }
             catch (error) {
-                attempts++;
-                if (attempts >= maxAttempts) {
-                    throw error;
+                lastError = error;
+                if (Date.now() >= deadline) {
+                    break;
                 }
                 await this.page.reload();
+                // Tasklist polls continuously for new tasks, so `networkidle` never
+                // fires and the wait times out at 60s -- burning the retry budget
+                // without ever re-attempting the task click. `domcontentloaded`
+                // resolves once the reloaded HTML has parsed, which is the actual
+                // signal we need before trying to find the task again.
+                await this.page.waitForLoadState('domcontentloaded', { timeout: 60000 });
             }
         }
+        throw new Error(`Task ${name} did not open from "Available tasks" within ` +
+            `${totalTimeout}ms: ${lastError}`);
     }
     async filterBy(option) {
         try {

package/dist/pages/8.10/UtilitiesPage.d.ts

@@ -24,8 +24,9 @@ export declare function modelRestConnector(modelerCreatePage: ModelerCreatePage,
     password: string;
 }): Promise<void>;
 export declare function assertLocatorVisibleWithRetry(page: Page | OperateProcessInstancePage | ModelerHomePage, locator: Locator, text: string, timeout?: number, notVisible?: boolean, maxRetries?: number, clickLocator?: Locator): Promise<void>;
+export declare function openAppTabWithRetry(page: Page, link: Locator, timeout?: number, maxRetries?: number, clickTimeout?: number): Promise<Page>;
 export declare function assertPageTextWithRetry(page: Page, text: string, notVisible?: boolean, timeout?: number, maxRetries?: number): Promise<void>;
-export declare function completeTaskWithRetry(taskPanelPage: TaskPanelPage, taskDetailsPage: TaskDetailsPage, taskName: string, taskPriority: string, maxRetries?: number): Promise<void>;
+export declare function completeTaskWithRetry(taskPanelPage: TaskPanelPage, taskDetailsPage: TaskDetailsPage, taskName: string, taskPriority: string, maxRetries?: number, totalTimeout?: number): Promise<void>;
 export declare function runProcess(clusterName: string, page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, processName: string, processId?: string, uploadFromFile?: string): Promise<void>;
 export declare function runMultipleProcesses(clusterName: string, page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, options?: {
     numberOfProcesses?: number;

package/dist/pages/8.10/UtilitiesPage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForLoadingToFinish = exports.assertTestUsesCorrectOrganizationFromModeler = exports.expectCountToBeOneOf = exports.createAPIClient = exports.modelAndRunConnectorsTimerEventDiagram = exports.modelAndRunConnectorsDocHandlingDiagram = exports.deleteCluster = exports.deleteAllUserGroups = exports.assertTestUsesCorrectOrganization = exports.assertLatestAlertEmail = exports.clickInvitationLinkInEmail = exports.enableAuthorizations = exports.disableRBA = exports.runMultipleProcesses = exports.runProcess = exports.completeTaskWithRetry = exports.assertPageTextWithRetry = exports.assertLocatorVisibleWithRetry = exports.modelRestConnector = exports.modelDiagramFromFile = exports.loginWithRetry = void 0;
+exports.waitForLoadingToFinish = exports.assertTestUsesCorrectOrganizationFromModeler = exports.expectCountToBeOneOf = exports.createAPIClient = exports.modelAndRunConnectorsTimerEventDiagram = exports.modelAndRunConnectorsDocHandlingDiagram = exports.deleteCluster = exports.deleteAllUserGroups = exports.assertTestUsesCorrectOrganization = exports.assertLatestAlertEmail = exports.clickInvitationLinkInEmail = exports.enableAuthorizations = exports.disableRBA = exports.runMultipleProcesses = exports.runProcess = exports.completeTaskWithRetry = exports.assertPageTextWithRetry = exports.openAppTabWithRetry = exports.assertLocatorVisibleWithRetry = exports.modelRestConnector = exports.modelDiagramFromFile = exports.loginWithRetry = void 0;
 const test_1 = require("@playwright/test");
 const ModelerHomePage_1 = require("./ModelerHomePage");
 const HomePage_1 = require("./HomePage");
@@ -8,6 +8,85 @@ const sleep_1 = require("../../utils/sleep");
 const randomSleep_1 = require("../../utils/randomSleep");
 const fileUpload_1 = require("../../utils/fileUpload");
 const mailSlurpClient_1 = require("../../utils/mailSlurpClient");
+async function clearWebStorage(page) {
+    await page
+        .evaluate(() => {
+        try {
+            localStorage.clear();
+        }
+        catch (_) {
+            // ignore — storage may be unavailable in some contexts
+        }
+        try {
+            sessionStorage.clear();
+        }
+        catch (_) {
+            // ignore — storage may be unavailable in some contexts
+        }
+    })
+        .catch(() => { });
+}
+// Waits for the auth0 login form, re-asking Console for the auth redirect
+// between checks instead of idling on whatever page the browser landed on.
+//
+// A single passive `expect.poll` cannot recover the two ways this hand-off
+// fails: Console swallowing the redirect (the tab stays on a page that will
+// never render a login form), or a session that outlived the cookie wipe (the
+// authenticated shell renders instead). In both cases nothing changes on its
+// own, so the poll burns its whole budget and the login attempt is lost --
+// three of those in a row is exactly the reported "Login failed after 3
+// attempts: ... Timeout 60000ms exceeded while waiting on the predicate".
+// Re-navigating to '/' re-triggers the redirect, and dropping cookies +
+// storage first evicts a surviving session, so the hand-off self-heals inside
+// the attempt rather than costing one.
+async function waitForLoginForm(page, loginPage, totalTimeout = 90000, roundTimeout = 20000) {
+    const deadline = Date.now() + totalTimeout;
+    const homePage = new HomePage_1.HomePage(page);
+    let lastState = 'no login form';
+    while (Date.now() < deadline) {
+        const round = Math.min(roundTimeout, deadline - Date.now());
+        try {
+            // Confirm we reached the login page before filling credentials.
+            // Without this check the locator for 'Email address' can match a hidden
+            // invite-user input on the Console page when the logout redirect has not
+            // yet completed, causing a 200 s wait before failing.
+            await test_1.expect
+                .poll(async () => {
+                const [loginMessageVisible, passwordHeadingVisible, usernameVisible, passwordVisible,] = await Promise.all([
+                    loginPage.loginMessage.isVisible().catch(() => false),
+                    loginPage.passwordHeading.isVisible().catch(() => false),
+                    loginPage.usernameInput.locator.isVisible().catch(() => false),
+                    loginPage.passwordInput.isVisible().catch(() => false),
+                ]);
+                return (loginMessageVisible ||
+                    passwordHeadingVisible ||
+                    usernameVisible ||
+                    passwordVisible);
+            }, { timeout: round })
+                .toBe(true);
+            return;
+        }
+        catch {
+            // No login form this round — establish why, then re-ask for the redirect.
+            lastState = `no login form on ${page.url()}`;
+        }
+        const authenticated = await homePage.camundaComponentsButton
+            .isVisible()
+            .catch(() => false);
+        if (authenticated) {
+            lastState = 'an authenticated Console shell — no auth0 hand-off happened';
+            // The session survived the cookie wipe done before this wait; drop it
+            // again so the navigation below has to go through auth0.
+            await page.context().clearCookies();
+            await clearWebStorage(page);
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        await page.goto('/', { waitUntil: 'domcontentloaded', timeout: 60000 });
+    }
+    throw new Error(`Auth0 login form did not render within ${totalTimeout}ms: ${lastState}`);
+}
 async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 3) {
     let lastError;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
@@ -59,24 +138,7 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 3
                 .waitForLoadState('networkidle', { timeout: 30000 })
                 .catch(() => { });
             await (0, sleep_1.sleep)(timeout);
-            // Confirm we reached the login page before filling credentials.
-            // Without this check the locator for 'Email address' can match a hidden
-            // invite-user input on the Console page when the logout redirect has not
-            // yet completed, causing a 200 s wait before failing.
-            await test_1.expect
-                .poll(async () => {
-                const [loginMessageVisible, passwordHeadingVisible, usernameVisible, passwordVisible,] = await Promise.all([
-                    loginPage.loginMessage.isVisible().catch(() => false),
-                    loginPage.passwordHeading.isVisible().catch(() => false),
-                    loginPage.usernameInput.locator.isVisible().catch(() => false),
-                    loginPage.passwordInput.isVisible().catch(() => false),
-                ]);
-                return (loginMessageVisible ||
-                    passwordHeadingVisible ||
-                    usernameVisible ||
-                    passwordVisible);
-            }, { timeout: 60000 })
-                .toBe(true);
+            await waitForLoginForm(page, loginPage);
             await loginPage.loginWithTestUser(testUser);
             return;
         }
@@ -125,8 +187,14 @@ async function modelRestConnector(modelerCreatePage, connectorSettingsPage, proc
     username: '',
     password: '',
 }) {
+    // Same gate as `modelJobWorkerDiagram` (120s) and
+    // `modelCamundaUserTaskDiagram` (180s): the properties panel renders once the
+    // new BPMN template has finished opening. 15s was the outlier here, and a
+    // slow template load failed with
+    // `locator('[data-group-id="group-general"]') ... element(s) not found`
+    // before any modelling had started.
     await (0, test_1.expect)(modelerCreatePage.generalPanel).toBeVisible({
-        timeout: 15000,
+        timeout: 120000,
     });
     await modelerCreatePage.enterDiagramName(processName);
     await (0, sleep_1.sleep)(10000);
@@ -209,7 +277,16 @@ async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 6000
         catch (error) {
             if (attempt < maxRetries - 1) {
                 console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
-                await page.reload();
+                // The reload is only the recovery step: when it races an in-flight
+                // navigation (`net::ERR_ABORTED; maybe frame was detached?`) or hits a
+                // DNS blip (`net::ERR_NAME_NOT_RESOLVED`) it used to escape this catch
+                // and fail the test instead of letting the next attempt re-assert.
+                try {
+                    await page.reload();
+                }
+                catch (reloadError) {
+                    console.warn(`Could not reload while asserting ${text}: ${reloadError}`);
+                }
                 await (0, sleep_1.sleep)(10000);
             }
             else {
@@ -219,6 +296,53 @@ async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 6000
     }
 }
 exports.assertLocatorVisibleWithRetry = assertLocatorVisibleWithRetry;
+// Clicks a link/button that opens another Camunda app in a new tab and returns
+// that tab, retrying the click when no tab appears.
+//
+// The wait is registered BEFORE each click because Playwright only reports
+// events raised after it is called and the tab opens while the click is still
+// resolving. That alone is not enough though: the "View process instance"
+// control lives in Modeler's post-deployment notification, and a click that
+// lands while that notification is being torn down resolves without ever
+// running its handler — no tab is opened, and the wait then sits out its full
+// budget on a click that silently did nothing ("page.waitForEvent: Timeout
+// 60000ms exceeded while waiting for event \"popup\""). Re-clicking recovers
+// that, so long as the control is still on screen; when it is gone the loop
+// stops immediately rather than burning another click timeout on it.
+async function openAppTabWithRetry(page, link, timeout = 60000, maxRetries = 3, clickTimeout = 180000) {
+    const context = page.context();
+    const knownPages = new Set(context.pages());
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        if (attempt > 1 && !(await link.isVisible().catch(() => false))) {
+            break;
+        }
+        const appTabPromise = page.waitForEvent('popup', { timeout });
+        let clickError;
+        try {
+            await link.click({ timeout: clickTimeout });
+        }
+        catch (error) {
+            clickError = error;
+        }
+        try {
+            // Always awaited, even when the click threw, so the wait can never
+            // reject unobserved.
+            return await appTabPromise;
+        }
+        catch (error) {
+            lastError = clickError ?? error;
+            // The click may still have opened the tab without the wait observing it.
+            const opened = context.pages().find((tab) => !knownPages.has(tab));
+            if (opened !== undefined) {
+                return opened;
+            }
+            console.warn(`Attempt ${attempt} to open the app tab failed: ${error}`);
+        }
+    }
+    throw new Error(`Failed to open the app tab after ${maxRetries} attempts: ${lastError}`);
+}
+exports.openAppTabWithRetry = openAppTabWithRetry;
 async function assertPageTextWithRetry(page, text, notVisible = false, timeout = 60000, maxRetries = 10) {
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
@@ -248,14 +372,22 @@ async function assertPageTextWithRetry(page, text, notVisible = false, timeout =
     }
 }
 exports.assertPageTextWithRetry = assertPageTextWithRetry;
-async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, taskPriority, maxRetries = 3) {
+// `totalTimeout` bounds the whole "complete this task" hop, including the wait
+// for Tasklist to import the task. It is shared across the attempts below
+// rather than granted to each of them: `openTask` polls for minutes on its
+// own, so a per-attempt budget multiplied out to a worst case longer than the
+// test timeout and the harness killed the test mid-wait, with no assertion
+// error to diagnose. One deadline keeps the retries (which recover a lost
+// click or a stale assign button) without inflating the ceiling.
+async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, taskPriority, maxRetries = 3, totalTimeout = 1200000) {
+    const deadline = Date.now() + totalTimeout;
     const openTask = taskPanelPage.availableTasks
         .getByText(taskName, { exact: true })
         .first();
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         let completionRequested = false;
         try {
-            await taskPanelPage.openTask(taskName);
+            await taskPanelPage.openTask(taskName, Math.max(30000, deadline - Date.now()));
             await (0, test_1.expect)(taskDetailsPage.detailsInfo.getByText(taskName, { exact: true })).toBeVisible();
             if (!(await taskDetailsPage.assignedToMeText.isVisible())) {
                 await taskDetailsPage.clickAssignToMeButton();

package/dist/pages/SM-8.10/KeycloakAdminPage.js

@@ -36,7 +36,7 @@ class KeycloakAdminPage {
         await (0, test_1.expect)(realmResult).toBeVisible({ timeout: 30000 });
         await realmResult.click();
         const mainLocator = this.page.locator('#kc-main-content-page-container');
-        await (0, test_1.expect)(mainLocator).toBeVisible();
+        await (0, test_1.expect)(mainLocator).toBeVisible({ timeout: 60000 });
     }
     async clickUsersTab() {
         await this.page.click('a[id="nav-item-users"]');

package/dist/pages/SM-8.10/KeycloakLoginPage.d.ts

@@ -6,6 +6,7 @@ declare class KeycloakLoginPage {
     toBeVisible(): Promise<void>;
     fillUsername(username: string): Promise<void>;
     fillPassword(password: string): Promise<void>;
+    clearSession(): Promise<void>;
     clickLogin(): Promise<void>;
 }
 export { KeycloakLoginPage };

package/dist/pages/SM-8.10/KeycloakLoginPage.js

@@ -18,8 +18,15 @@ class KeycloakLoginPage {
     async fillPassword(password) {
         await this.page.fill('#password', password);
     }
+    async clearSession() {
+        await this.page.context().clearCookies();
+    }
     async clickLogin() {
-        await this.page.click('button[type="submit"]');
+        // Submitting the Keycloak form starts a redirect chain that page.click
+        // implicitly waits on ("waiting for scheduled navigations to finish"), so
+        // the action inherits the 10s actionTimeout to cover a navigation. Give it
+        // the navigation budget the rest of the suite uses instead.
+        await this.page.click('button[type="submit"]', { timeout: 60000 });
     }
 }
 exports.KeycloakLoginPage = KeycloakLoginPage;