@camunda/e2e-test-suite 0.0.944 → 0.0.945

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

@@ -16,6 +16,6 @@ declare class LoginPage {
     clickUsername(): Promise<void>;
     fillPassword(password: string): Promise<void>;
     clickLoginButton(): Promise<void>;
-    login(username: string, password: string): Promise<void>;
+    login(username: string, password: string): Promise<boolean>;
 }
 export { LoginPage };

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

@@ -79,7 +79,11 @@ class LoginPage {
     }
     async clickLoginButton() {
         if (await this.page.locator('button[type="submit"]').isVisible()) {
-            await this.page.click('button[type="submit"]');
+            // The Keycloak submit path was the only click here without an explicit
+            // timeout, so it inherited the 10s actionTimeout while page.click waits
+            // out the OAuth redirect chain it triggers. Match the 60s budget the
+            // sibling branches already use.
+            await this.page.click('button[type="submit"]', { timeout: 60000 });
         }
         else {
             await (this.useCore
@@ -87,17 +91,22 @@ class LoginPage {
                 : this.loginButton.click({ timeout: 60000 }));
         }
     }
+    // Resolves to whether credentials were actually submitted. A missing form is
+    // not an error -- the caller may already hold a session, in which case there
+    // is nothing to fill -- but the caller has to be able to tell that apart from
+    // a submitted form, because only the latter leaves a page transition pending.
     async login(username, password) {
         try {
             await this.detectLoginForm();
         }
         catch (error) {
-            return;
+            return false;
         }
         await this.clickUsername();
         await this.fillUsername(username);
         await this.fillPassword(password);
         await this.clickLoginButton();
+        return true;
     }
 }
 exports.LoginPage = LoginPage;

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

@@ -10,6 +10,7 @@ declare class NavigationPage {
     readonly managementIdentityPageBanner: Locator;
     constructor(page: Page);
     private isGatewayErrorPage;
+    private waitForBanner;
     goTo(url: string, banner: Locator, sleepTimeout?: number, { username, password, }?: {
         username?: string;
         password?: string;

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

@@ -58,6 +58,52 @@ class NavigationPage {
             .isVisible()
             .catch(() => false);
     }
+    // Waits for the app shell's banner, but treats the two states that cannot
+    // resolve on their own as a reason to act rather than to keep waiting.
+    //
+    // The passive `expect(banner).toBeVisible({timeout: 60000})` this replaces
+    // could not tell a shell that is merely slow (worth waiting for) from one
+    // where nothing is coming at all: `login` swallowed a missing form and
+    // submitted nothing, so no transition is pending, or the ingress served a
+    // 50x page for the OAuth callback, which never becomes the app shell. Both
+    // spend the whole 60s and lose the attempt, and the only surviving evidence
+    // is "toBeVisible ... <element(s) not found>" -- repeated once per attempt,
+    // that is exactly the reported "Login (/modeler) failed after 8 attempts".
+    // The 60s budget is unchanged: a genuinely slow shell still gets all of it,
+    // and a sustained outage still fails.
+    async waitForBanner(url, banner, submitted) {
+        const totalTimeout = constants_1._1_SECOND_IN_MS * 60;
+        const deadline = Date.now() + totalTimeout;
+        let lastState = 'no banner';
+        while (Date.now() < deadline) {
+            const round = Math.min(constants_1._1_SECOND_IN_MS * 20, deadline - Date.now());
+            try {
+                await (0, test_1.expect)(banner).toBeVisible({ timeout: round });
+                return;
+            }
+            catch {
+                lastState = `no banner on ${this.page.url()}`;
+            }
+            if (!submitted) {
+                // Nothing was submitted and no banner rendered, so there is no pending
+                // transition for the rest of the budget to wait on. Hand back to the
+                // caller's retry loop now — it re-navigates and logs in again, which
+                // is the only thing that can change this state.
+                throw new Error(`${url} rendered no banner and no credentials were submitted: ${lastState}`);
+            }
+            if (await this.isGatewayErrorPage()) {
+                lastState = `a 50x gateway page on ${this.page.url()}`;
+                if (Date.now() >= deadline) {
+                    break;
+                }
+                await this.page.goto(url, {
+                    timeout: 60000,
+                    waitUntil: 'domcontentloaded',
+                });
+            }
+        }
+        throw new Error(`${url} did not render its banner within ${totalTimeout}ms: ${lastState}`);
+    }
     async goTo(url, banner, sleepTimeout, { username = IDENTITY_FIRSTUSER_USERNAME, password = IDENTITY_FIRSTUSER_PASSWORD, } = {}, maxRetries = 8) {
         const startTime = Date.now();
         let timeout = constants_1._1_SECOND_IN_MS * 10;
@@ -77,8 +123,15 @@ class NavigationPage {
                 // serves an nginx 50x gateway page in place of the app. Reload with a
                 // bounded budget so a short blip self-heals; a sustained outage
                 // exhausts the budget and still surfaces as a failed navigation.
+                // The bound is wall clock as well as count: 8 reloads that each wait
+                // out the 60s goto budget are ~520s of the 720s test timeout inside a
+                // single attempt, which starves the retry loop below of the attempts
+                // it needs to ride the outage out.
+                const gatewayDeadline = Date.now() + constants_1._1_SECOND_IN_MS * 60;
                 let gatewayReloads = 0;
-                while (gatewayReloads < 8 && (await this.isGatewayErrorPage())) {
+                while (gatewayReloads < 8 &&
+                    Date.now() < gatewayDeadline &&
+                    (await this.isGatewayErrorPage())) {
                     await (0, sleep_1.sleep)(constants_1._1_SECOND_IN_MS * 5);
                     await this.page.goto(url, {
                         timeout: 60000,
@@ -100,17 +153,27 @@ class NavigationPage {
                 // authenticated — wait for the real login form to appear.
                 const currentUrl = this.page.url();
                 const onLoginPath = currentUrl.includes('/login') || currentUrl.includes('/auth/');
+                let submitted = false;
                 if (isBannerVisible && !onLoginPath) {
-                    const loginVisible = await loginPage.usernameInput.isVisible();
+                    // Probe with the same #username signal detectLoginForm uses: the
+                    // KC26 default theme does not expose the 'Username or email' label,
+                    // so the old locator reported "no form" on a rendered Keycloak login
+                    // page and left the attempt unauthenticated.
+                    const loginVisible = await this.page
+                        .locator('#username')
+                        .or(loginPage.usernameInput)
+                        .first()
+                        .isVisible()
+                        .catch(() => false);
                     if (loginVisible) {
-                        await loginPage.login(username, password);
+                        submitted = await loginPage.login(username, password);
                     }
                     // If login selector not visible, banner is real - navigation succeeded
                 }
                 else {
-                    await loginPage.login(username, password);
+                    submitted = await loginPage.login(username, password);
                 }
-                await (0, test_1.expect)(banner).toBeVisible({ timeout: 60000 });
+                await this.waitForBanner(url, banner, submitted);
                 return;
             }
             catch (error) {
@@ -142,8 +205,16 @@ class NavigationPage {
                     }
                 }
                 else {
-                    console.error(`[${now.toISOString()}] (+${elapsed}ms) [NavigationPage] Login (${url}) failed after ${maxRetries} attempts`);
-                    throw new Error(`Login (${url}) failed after ${maxRetries} attempts`);
+                    console.error(`[${now.toISOString()}] (+${elapsed}ms) [NavigationPage] Login (${url}) failed after ${maxRetries} attempts: ${error}`);
+                    // Carry the final attempt's error into the thrown message. Without
+                    // it the only surviving signal is the attempt count, which says
+                    // nothing about WHY all 8 attempts failed -- a Keycloak 5xx, a
+                    // gateway page, a missing banner and a closed page all collapse to
+                    // the same string, so triage of this signature has to guess. Every
+                    // sibling helper already does this (goToKeycloak below rethrows
+                    // lastError; KeycloakUtils and pages/8.10/UtilitiesPage interpolate
+                    // the cause).
+                    throw new Error(`Login (${url}) failed after ${maxRetries} attempts: ${error}`);
                 }
             }
         }
@@ -204,7 +275,14 @@ class NavigationPage {
             : new Error(`goToKeycloak failed after ${maxRetries} attempts`);
     }
     async goToOCAdmin(sleepTimeout, credentials, maxRetries) {
-        await this.goTo(`${NORMALIZED_ORCHESTRATION_CONTEXT_PATH}/admin`, this.identityPageBanner, sleepTimeout, credentials, maxRetries ?? (env_1.isOpenSearch ? 10 : 5));
+        await this.goTo(`${NORMALIZED_ORCHESTRATION_CONTEXT_PATH}/admin`, this.identityPageBanner, sleepTimeout, credentials, 
+        // 8, not 5, to match goTo's own default: the comment there records that
+        // ~20s of backoff (all 5 attempts buy) was not consistently enough to
+        // outlast Keycloak's warm-up, and /admin additionally serves a
+        // forbidden redirect while the user's admin authorization propagates.
+        // Call sites that wrap goToOCAdmin in their own toPass loop still pass
+        // maxRetries explicitly (see document-handling-user-flows).
+        maxRetries ?? (env_1.isOpenSearch ? 10 : 8));
     }
     async goToClusters(sleepTimeout, credentials) {
         await this.goTo(`${MODELER_CONTEXT_PATH}/clusters`, this.modelerPageBanner, sleepTimeout, credentials);

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

@@ -67,8 +67,18 @@ class OCIdentityHomePage {
         await this.authorizationsTab.click();
     }
     async clickRolesTab() {
-        await (0, test_1.expect)(this.rolesTab).toBeVisible({ timeout: 30000 });
-        await this.rolesTab.click();
+        // Reload between attempts: the Admin shell can render its branding link
+        // (which is all goToOCAdmin waits for) before the nav hydrates, and /admin
+        // serves a no-permission view while the user's admin authorization is
+        // still propagating. A flat wait on the same DOM can recover from neither.
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.rolesTab, {
+            visibilityTimeout: 30000,
+            totalTimeout: 120000,
+            postAction: async () => {
+                await this.page.reload();
+            },
+        });
+        await this.rolesTab.click({ timeout: 30000 });
     }
     async clickGroupsTab() {
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.groupsTab);

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

@@ -21,6 +21,7 @@ declare class OCIdentityRolesPage {
     readonly deleteRoleModalCancelButton: Locator;
     readonly deleteRoleModalDeleteButton: Locator;
     readonly adminRole: Locator;
+    readonly rolesNavTab: Locator;
     readonly assignUserButton: Locator;
     readonly usernameTextBox: Locator;
     readonly assignUserSubButton: Locator;
@@ -40,6 +41,8 @@ declare class OCIdentityRolesPage {
     deleteRole(name: string, options?: {
         throwError?: boolean;
     }): Promise<void>;
+    private isRolesListOpen;
+    private openRolesList;
     clickAdminRole(): Promise<void>;
     assignUserToRole(userId: string): Promise<void>;
     clickAssignUserButton(): Promise<void>;

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

@@ -4,6 +4,7 @@ exports.OCIdentityRolesPage = void 0;
 const test_1 = require("@playwright/test");
 const UtilitiesPage_1 = require("../SM-8.10/UtilitiesPage");
 const expectLocatorWithPagination_1 = require("../../utils/assertionHelpers/expectLocatorWithPagination");
+const findLocatorWithPagination_1 = require("../../utils/assertionHelpers/findLocatorWithPagination");
 const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
 const sleep_1 = require("../../utils/sleep");
 class OCIdentityRolesPage {
@@ -28,6 +29,7 @@ class OCIdentityRolesPage {
     deleteRoleModalCancelButton;
     deleteRoleModalDeleteButton;
     adminRole;
+    rolesNavTab;
     assignUserButton;
     usernameTextBox;
     assignUserSubButton;
@@ -84,6 +86,11 @@ class OCIdentityRolesPage {
             name: /delete role/i,
         });
         this.adminRole = page.getByRole('cell', { name: 'admin', exact: true });
+        this.rolesNavTab = page
+            .getByRole('banner')
+            .locator('a')
+            .filter({ hasText: /^Roles$/ })
+            .first();
         this.assignUserButton = page.getByRole('button', { name: 'Assign user' });
         this.usernameTextBox = page.getByRole('textbox', { name: 'Username' });
         this.assignUserSubButton = page
@@ -181,8 +188,97 @@ class OCIdentityRolesPage {
             }
         }
     }
+    async isRolesListOpen(timeout) {
+        return this.createRoleButton
+            .first()
+            .waitFor({ state: 'visible', timeout })
+            .then(() => true)
+            .catch(() => false);
+    }
+    // Re-enters the roles list through the in-app nav rather than reloading.
+    // `page.reload()` re-runs the OIDC round-trip and its post-login redirect
+    // drops the deep path, so a reload-based retry re-ran against whatever the
+    // Admin root rendered: a view with no table at all, or the wrong table.
+    // Clicking the banner's Roles link is a client-side route change, so it
+    // cannot lose the session; the reload is kept only for the case where the
+    // app shell itself is gone.
+    async openRolesList(timeout) {
+        if (await this.isRolesListOpen(Math.min(timeout, 15000))) {
+            return;
+        }
+        const shellVisible = await this.rolesNavTab
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!shellVisible) {
+            await this.page.reload({ waitUntil: 'domcontentloaded' });
+            await (0, test_1.expect)(this.rolesNavTab).toBeVisible({ timeout });
+        }
+        await this.rolesNavTab.click({ timeout });
+        await (0, test_1.expect)(this.createRoleButton.first()).toBeVisible({ timeout });
+    }
     async clickAdminRole() {
-        await this.adminRole.click();
+        // The roles table is fetched after the Roles tab click, and other specs in
+        // the nightly add roles that can push `admin` onto a later page, so a bare
+        // click had only the 10s actionTimeout to cover both the load and the
+        // lookup. Use the same pagination-aware lookup createRole/clickRole use.
+        //
+        // Bounded overall: this runs in the smoke suite's beforeEach, whose time is
+        // charged to the test, and three attempts of the previous per-step budgets
+        // could occupy 540s of the 720s test timeout on their own — which is why a
+        // stuck recovery here surfaced as a timeout in the test body rather than as
+        // this method's own error.
+        const deadline = Date.now() + 300000;
+        const budget = (max) => Math.max(5000, Math.min(max, deadline - Date.now()));
+        const adminCell = this.adminRole.first();
+        const maxRetries = 3;
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries && Date.now() < deadline; attempt++) {
+            try {
+                // Every attempt starts from a confirmed roles list, so a swallowed nav
+                // click or a redirect back to the Admin root is recovered instead of
+                // being scanned again.
+                await this.openRolesList(budget(60000));
+                // Wait for the admin row itself before scanning: the scan gives each
+                // page only 5s, so against a table that is still fetching it reports
+                // the row missing and — with no next page to walk to — gives up in 5s.
+                // That is the shape of the run log's 52 "No more pages available after
+                // page 1" against 600 finds on page 1.
+                const onCurrentPage = await adminCell
+                    .waitFor({ state: 'visible', timeout: budget(30000) })
+                    .then(() => true)
+                    .catch(() => false);
+                if (!onCurrentPage) {
+                    // Scanned directly rather than through expectLocatorWithPagination:
+                    // that wrapper hard-codes the scan to 30s (it forwards no options),
+                    // which is ~5 pages, and the roles table reached 5 pages in the same
+                    // run. Its retry also reloads, which is the recovery openRolesList
+                    // exists to avoid.
+                    const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, adminCell, {
+                        timeout: budget(90000),
+                    });
+                    if (!found) {
+                        throw new Error('admin role row not found on any page of the roles table');
+                    }
+                }
+                await adminCell.click({ timeout: budget(30000) });
+                // The row click is the only thing that navigates to the role detail
+                // page, and nothing confirmed it landed — a click the table swallowed
+                // mid-render left the caller waiting out assignUserButton's whole
+                // budget on a page that never had one.
+                await (0, test_1.expect)(this.assignUserButton).toBeVisible({
+                    timeout: budget(30000),
+                });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1}: admin role detail page did not open, retrying...`);
+                }
+            }
+        }
+        throw new Error(`Admin role detail page did not open after ${maxRetries} attempts: ${String(lastError)}`);
     }
     async assignUserToRole(userId) {
         await this.clickAssignUserButton();
@@ -191,16 +287,26 @@ class OCIdentityRolesPage {
         await this.clickAssignUserSubButton();
     }
     async clickAssignUserButton() {
-        await this.assignUserButton.click();
+        // Rendered only once the role detail page has loaded its users tab, which
+        // outlasts the 10s actionTimeout a bare click inherits. Same budget the
+        // SaaS 8.10 doAssignUserToRole already gives this button.
+        await (0, test_1.expect)(this.assignUserButton).toBeVisible({ timeout: 60000 });
+        await this.assignUserButton.click({ timeout: 60000 });
     }
     async clickUsernameTextbox() {
-        await this.usernameTextBox.click();
+        // Waiting for the textbox is what confirms the modal finished opening.
+        await (0, test_1.expect)(this.usernameTextBox).toBeVisible({ timeout: 60000 });
+        await this.usernameTextBox.click({ timeout: 60000 });
     }
     async fillUsernameTextbox(userId) {
         await this.usernameTextBox.fill(userId);
     }
     async clickAssignUserSubButton() {
-        await this.assignUserSubButton.click();
+        // The modal's submit button stays disabled until the username field
+        // validates, so wait for it to be actionable rather than racing the 10s
+        // actionTimeout.
+        await (0, test_1.expect)(this.assignUserSubButton).toBeEnabled({ timeout: 60000 });
+        await this.assignUserSubButton.click({ timeout: 60000 });
     }
     async clickClientsTab() {
         await this.clientsTab.click();

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

@@ -49,10 +49,22 @@ class OperateHomePage {
             .getByLabel('Open');
     }
     async clickProcessesTab() {
+        // Called right after navigating into Operate, a Vite SPA whose nav bar can
+        // take longer than clickLocatorWithRetry's default 10s visibilityTimeout to
+        // render on a loaded cluster — so all 3 attempts could burn inside 30s and
+        // throw while the link was still on its way. Give each attempt the 30s the
+        // callers that pre-wait this same link already assume.
         await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.processesTab, {
-            totalTimeout: 60000,
+            totalTimeout: 120000,
+            visibilityTimeout: 30000,
         });
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.processPageHeading, {
+            // Defaults (10s per attempt, 60s total) gave the Processes panel less
+            // budget than the tab click above already assumes it needs on a loaded
+            // cluster, so all three attempts could expire while the view was still
+            // rendering. Match the 30s/120s the click uses.
+            visibilityTimeout: 30000,
+            totalTimeout: 120000,
             preAction: async () => {
                 await (0, test_1.expect)(this.processesTab).toBeVisible({
                     timeout: constants_1._1_SECOND_IN_MS * 4,

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

@@ -23,6 +23,7 @@ declare class OperateProcessesPage {
     private toggleActiveCheckboxOn;
     private toggleCompletedCheckbox;
     private applyProcessStateFilter;
+    private dismissWhatsNewPopUp;
     private checkTableForProcess;
     clickProcessActiveCheckbox(): Promise<void>;
     clickProcessCompletedCheckbox(): Promise<void>;

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

@@ -98,7 +98,10 @@ class OperateProcessesPage {
     }
     async toggleActiveCheckboxOn() {
         await this.uncheckCompletedCheckbox();
-        await this.clickProcessIncidentsCheckbox();
+        // Set — never toggle — the Incidents filter: applyProcessStateFilter is
+        // re-applied after every reload in clickProcessInstanceLink, so a blind
+        // flip oscillates the filter between passes and the lookup never converges.
+        await this.checkCheckbox(this.processIncidentsCheckbox);
         await this.processActiveCheckbox.waitFor({
             state: 'attached',
             timeout: constants_1._1_SECOND_IN_MS * 10,
@@ -114,7 +117,7 @@ class OperateProcessesPage {
     }
     async toggleCompletedCheckbox() {
         await this.uncheckActiveCheckbox();
-        await this.clickProcessIncidentsCheckbox();
+        await this.checkCheckbox(this.processIncidentsCheckbox);
         await this.processCompletedCheckbox.waitFor({
             state: 'attached',
             timeout: constants_1._1_SECOND_IN_MS * 10,
@@ -137,6 +140,31 @@ class OperateProcessesPage {
             await this.toggleCompletedCheckbox();
         }
     }
+    // Operate raises the "Here's what moved in Operate" modal on a first page
+    // load, and every test here logs in as a freshly created user, so it is up on
+    // the Processes view. Its Carbon overlay swallows clicks on the Processes tab
+    // link and on the filter checkbox labels, which is why a reload-recovery pass
+    // could make no progress at all. Dismiss it before interacting with the view,
+    // not only after an instance page has opened.
+    async dismissWhatsNewPopUp() {
+        // isVisible() returns immediately — Playwright ignores its `timeout`
+        // option — so this probe got none of the 2s grace it reads as having. Right
+        // after a reload Operate has usually not mounted the modal yet, the probe
+        // reported "not open", and the Carbon overlay then intercepted every click
+        // in the recovery loop below until the 720s test timeout. waitFor spends
+        // the 2s the probe was written to spend.
+        const isOpen = await this.whatsNewPopUp
+            .waitFor({ state: 'visible', timeout: constants_1._1_SECOND_IN_MS * 2 })
+            .then(() => true)
+            .catch(() => false);
+        if (!isOpen) {
+            return;
+        }
+        await this.gotItButton.click({ timeout: constants_1._1_SECOND_IN_MS * 10 });
+        await (0, test_1.expect)(this.whatsNewPopUp).toBeHidden({
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+    }
     async checkTableForProcess(processName) {
         try {
             const processTable = this.page.locator('[aria-label="Process Instances Panel"]');
@@ -149,9 +177,7 @@ class OperateProcessesPage {
             await link.scrollIntoViewIfNeeded();
             await link.click({ timeout: constants_1._1_SECOND_IN_MS * 2 });
             await (0, test_1.expect)(this.page.getByText('Instance History').first()).toBeVisible({ timeout: constants_1._1_SECOND_IN_MS * 10 });
-            if (await this.whatsNewPopUp.isVisible()) {
-                await this.gotItButton.click();
-            }
+            await this.dismissWhatsNewPopUp();
             return true;
         }
         catch (err) {
@@ -190,19 +216,7 @@ class OperateProcessesPage {
             timeout: constants_1._1_SECOND_IN_MS * 10,
         });
         const wasChecked = await this.processIncidentsCheckbox.isChecked();
-        if (wasChecked) {
-            await this.processIncidentsCheckbox.uncheck({
-                force: true,
-                timeout: 90000,
-            });
-        }
-        else {
-            await this.processIncidentsCheckbox.check({ force: true, timeout: 90000 });
-        }
-        await (0, test_1.expect)(this.processIncidentsCheckbox).toBeChecked({
-            checked: !wasChecked,
-            timeout: constants_1._1_SECOND_IN_MS * 5,
-        });
+        await this.setCheckboxState(this.processIncidentsCheckbox, !wasChecked);
     }
     async clickRunningProcessInstancesCheckbox() {
         await this.processRunningInstancesCheckbox.waitFor({
@@ -240,6 +254,7 @@ class OperateProcessesPage {
         });
     }
     async clickProcessInstanceLink(processName, type = 'active') {
+        await this.dismissWhatsNewPopUp();
         await this.applyProcessStateFilter(type);
         if (await this.checkTableForProcess(processName)) {
             return;
@@ -278,6 +293,10 @@ class OperateProcessesPage {
                         .waitForLoadState('networkidle', { timeout: 30000 })
                         .catch(() => console.log('waitForLoadState after Operate navigation timed out, continuing...'));
                 }
+                // The reload re-raises the what's-new modal, and its overlay would
+                // otherwise intercept both the Processes tab click and the checkbox
+                // labels below, so no attempt in this loop could ever converge.
+                await this.dismissWhatsNewPopUp();
                 // Operate may land on the Dashboard after reload even when the captured
                 // URL pointed at the Processes view.  The filter checkboxes only exist on
                 // the Processes tab, so navigate there explicitly before applying filters.

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

@@ -67,7 +67,27 @@ class OptimizeReportPage {
         await this.processSelectionButton.click({ timeout: 180000 });
     }
     async clickUserTaskProcess(processName) {
-        await this.page.getByText(processName, { exact: true }).first().click();
+        const processOption = this.page
+            .getByText(processName, { exact: true })
+            .first();
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            await (0, test_1.expect)(processOption).toBeVisible({ timeout: 30000 });
+            await processOption.click();
+            // Optimize keeps refetching the definition list while the modal is open.
+            // A refetch that lands right after the click remounts the version
+            // list-box and drops the selection with it, so Version stays disabled and
+            // the caller's toBeEnabled assertion times out. Confirm the selection
+            // committed and re-pick when a remount swallowed it. Deliberately no
+            // throw here: the caller's assertion stays the gate on this state.
+            try {
+                await (0, test_1.expect)(this.versionSelection).toBeEnabled({ timeout: 15000 });
+                return;
+            }
+            catch (error) {
+                console.warn(`Attempt ${attempt} to select process ${processName} left the version selection disabled, retrying...`, error instanceof Error ? error.message : error);
+            }
+        }
     }
     async clickVersionSelection() {
         await this.versionSelection.click();

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

@@ -105,6 +105,13 @@ class TaskDetailsPage {
         await (0, test_1.expect)(this.assignToMeButton).toBeVisible({ timeout: 60000 });
         await this.assignToMeButton.click({ timeout: 60000 });
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.assignedToMeText, {
+            // Assignment is a round-trip through the Zeebe user-task backend, which
+            // on a loaded cluster outlasts the default 10s per attempt. Every failure
+            // here aborts the caller's whole task-completion attempt, so it retries
+            // the search, the click and the panel load as well — the run log shows
+            // that churn repeating up to attempt 7.
+            visibilityTimeout: 30000,
+            totalTimeout: 60000,
             postAction: async () => {
                 await this.page.reload();
             },

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

@@ -82,7 +82,12 @@ async function completeTaskWithRetry(page, taskPanelPage, taskDetailsPage, taskN
     }
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            await page.waitForLoadState('networkidle');
+            // Tasklist keeps polling for task updates, so 'networkidle' never
+            // settles here. This wait carried no timeout, so it consumed whatever
+            // was left of the 12-minute test budget and the run died inside
+            // waitForLoadState. The task panel rendering is the precondition this
+            // step actually needs, so wait for that instead.
+            await (0, test_1.expect)(taskPanelPage.availableTasks).toBeVisible({ timeout: 60000 });
             const taskLocator = taskPanelPage.availableTasks
                 .getByText(taskName, { exact: true })
                 .first();
@@ -150,7 +155,8 @@ async function completeTaskWithRetry(page, taskPanelPage, taskDetailsPage, taskN
                 catch {
                     await page.reload();
                 }
-                await page.waitForLoadState('networkidle');
+                // No settle wait here either — the goto already waited for
+                // domcontentloaded and the next attempt waits for the task panel.
             }
             else {
                 console.error(`All ${maxRetries} attempts failed for task ${taskName}`);
@@ -343,7 +349,12 @@ async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 3000
                 console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
             }
             else {
-                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                // Keep the cause. Callers branch on the original error to tell a real
+                // failure apart from the test timeout aborting an in-flight wait (see
+                // assertReportWithRefreshes), and a bare attempt count told them
+                // nothing — so they retried into an already-dead test budget and
+                // reported their own generic "after N attempts" instead.
+                throw new Error(`Assertion failed after ${maxRetries} attempts: ${String(error)}`);
             }
         }
     }
@@ -371,7 +382,7 @@ async function assertPageTextWithRetry(page, text, notVisible, timeout = 30000,
                 console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
             }
             else {
-                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                throw new Error(`Assertion failed after ${maxRetries} attempts: ${String(error)}`);
             }
         }
     }