@camunda/e2e-test-suite 0.0.1180 → 0.0.1182

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

@@ -31,7 +31,7 @@ declare class AppsPage {
     openOperateWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
     clickTasklist(clusterName: string): Promise<void>;
     openTasklistWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
-    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
+    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number, totalTimeout?: number): Promise<void>;
     clickAdmin(clusterName: string): Promise<void>;
     private doClickClusterInOperate;
     private doClickClusterInTasklist;

package/dist/pages/8.10/AppsPage.js

@@ -352,20 +352,37 @@ class AppsPage {
     // instead. Every other 8.10 spec already asserts `optimizeBanner` right
     // after `clickOptimize` for exactly this reason; only the smoke flow did
     // not.
-    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3) {
+    // `totalTimeout` is what makes the stated budget true. Retrying on a thrown
+    // hand-off (rather than escaping on the first throw) is correct, but it also
+    // multiplies the cost: a worst-case attempt here is clickCamundaApps (~188s
+    // when it has to hunt for a trigger) + clickOptimize (~456s across its own
+    // three retries) + the banner wait, so four attempts could reach ~43 min and
+    // blow the 36-minute test.slow() budget of the specs that call this. Checked
+    // between attempts, so the real ceiling is the deadline plus at most one
+    // attempt -- bounded, which "N x timeout" arithmetic alone never was.
+    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3, totalTimeout = 600000) {
+        const start = Date.now();
         for (let attempt = 0; attempt < maxRetries; attempt++) {
-            await this.clickCamundaApps();
-            await this.clickOptimize(clusterName);
             try {
+                // Inside the try, not before it: `clickOptimize` throws after its own
+                // retries, and `clickCamundaApps` can throw on a click timeout. With
+                // those calls outside, the first such throw escaped this helper before
+                // it ever reached the `page.goto('/')` below -- so in exactly the dead
+                // page case this wrapper exists for, the recovery was skipped and the
+                // remaining attempts never ran.
+                await this.clickCamundaApps();
+                await this.clickOptimize(clusterName);
                 await (0, test_1.expect)(banner).toBeVisible({ timeout });
                 return;
             }
             catch (error) {
-                if (attempt === maxRetries - 1) {
+                const elapsed = Date.now() - start;
+                if (attempt === maxRetries - 1 || elapsed >= totalTimeout) {
                     throw error;
                 }
-                console.warn(`Optimize banner not visible on attempt ${attempt + 1}; ` +
-                    're-entering through the apps menu.');
+                console.warn(`Optimize hand-off failed on attempt ${attempt + 1} ` +
+                    `(${Math.round(elapsed / 1000)}s elapsed); re-entering through ` +
+                    `the apps menu. ${error}`);
                 await this.page.goto('/', { waitUntil: 'domcontentloaded' });
             }
         }

package/dist/pages/8.10/ClusterPage.js

@@ -462,37 +462,69 @@ class ClusterPage {
             exact: true,
         });
         const start = Date.now();
-        const maxRetries = 5;
+        // The loop is bounded by `totalTimeout` alone; it used to also stop at a
+        // hardcoded `maxRetries = 5`. What that cap changed is the *reload* rate,
+        // not the budget: with `visibilityTimeout` at 120s (what
+        // createClusterIfNotExists passes) five attempts of ~123s each already
+        // consumed the full 600s, so the old loop was not giving budget back.
+        //
+        // What it did do is reload the cluster list only 5 times across those 600s.
+        // `pollTimeout` caps how long any single `waitFor` blocks, which raises that
+        // to ~33 reloads for the same wall clock. That matters because the Healthy
+        // badge is only re-read after a reload -- a `waitFor` sitting on an
+        // already-rendered page cannot observe a status that changed server-side,
+        // so the effective polling resolution is the reload interval (~123s before,
+        // ~18s now), not the `waitFor` timeout.
+        //
+        // Worth knowing if you touch this: if the cluster list ever starts
+        // live-updating its status without a reload, this change stops buying
+        // anything, because then the old loop's long `waitFor` would already notice
+        // the transition the moment it happened.
+        const pollTimeout = Math.min(visibilityTimeout, 15000);
         let attempt = 0;
-        let unhealthyConsecutive = 0;
+        // Unhealthy is confirmed by how long it persists, not by a poll count: a
+        // cluster mid-provisioning can flash through Unhealthy during the
+        // Unhealthy -> Creating -> Healthy transition. The old "2 consecutive
+        // polls" gate was poll-rate dependent -- at a `visibilityTimeout`-long
+        // interval it meant roughly 2 x visibilityTimeout of Unhealthy -- so now
+        // that we poll every 15s it has to be expressed as elapsed time, or the
+        // tolerance silently shrinks to 30s.
+        //
+        // It is derived from the caller's `visibilityTimeout` rather than fixed, so
+        // each caller keeps the tolerance it had: createClusterIfNotExists (120s)
+        // gets 4 minutes, and console-user-flows' cluster-creation check (300s,
+        // with a 25-minute total budget) keeps its ~10 minutes instead of being cut
+        // to 2. The floor matters for callers that pass a small visibilityTimeout.
+        const unhealthyConfirmMs = Math.max(2 * visibilityTimeout, 120000);
+        let unhealthySince = null;
         let lastErr;
-        while (Date.now() - start < totalTimeout && attempt < maxRetries) {
+        while (Date.now() - start < totalTimeout) {
             attempt++;
             try {
                 await this.page.reload();
                 await (0, test_1.expect)(this.clusterRow(name)).toBeVisible({ timeout: 10000 });
-                // Only treat Unhealthy as terminal if it persists across two
-                // consecutive polling attempts. A cluster mid-provisioning can flash
-                // through Unhealthy briefly during the Unhealthy → Creating → Healthy
-                // transition and we don't want a single transient reading to abort
-                // the whole helper — earlier versions gated only on `attempt > 1`
-                // which still false-positived when the transient Unhealthy showed up
-                // on attempt 2.
+                // Only treat Unhealthy as terminal once it has persisted for
+                // `unhealthyConfirmMs`. A cluster mid-provisioning can flash through
+                // Unhealthy briefly during the Unhealthy → Creating → Healthy
+                // transition and we don't want a transient reading to abort the whole
+                // helper — earlier versions gated on `attempt > 1`, then on two
+                // consecutive polls, both of which are poll-rate dependent.
                 const isUnhealthy = await unhealthy
                     .isVisible({ timeout: 2000 })
                     .catch(() => false);
                 if (isUnhealthy) {
-                    unhealthyConsecutive++;
+                    unhealthySince ??= Date.now();
+                    const unhealthyFor = Date.now() - unhealthySince;
+                    if (unhealthyFor >= unhealthyConfirmMs) {
+                        throw new Error(`Cluster "${name}" reached terminal Unhealthy state after ${Math.round((Date.now() - start) / 1000)}s (Unhealthy continuously for ${Math.round(unhealthyFor / 1000)}s); aborting Healthy poll.`);
+                    }
                 }
                 else {
-                    unhealthyConsecutive = 0;
-                }
-                if (unhealthyConsecutive >= 2) {
-                    throw new Error(`Cluster "${name}" reached terminal Unhealthy state after ${Math.round((Date.now() - start) / 1000)}s (${unhealthyConsecutive} consecutive Unhealthy polls); aborting Healthy poll.`);
+                    unhealthySince = null;
                 }
                 await this.clusterHealthiness(name).waitFor({
                     state: 'visible',
-                    timeout: visibilityTimeout,
+                    timeout: pollTimeout,
                 });
                 console.log('Cluster is healthy:', name);
                 return;
@@ -503,11 +535,17 @@ class ClusterPage {
                     throw err;
                 }
                 lastErr = err;
-                console.log(`Attempt ${attempt} failed for cluster "${name}" Healthy check, retrying...`, err instanceof Error ? err.message : err);
+                // Only log every 8th attempt now that we poll every 15s: the previous
+                // one-line-per-attempt output was 4 lines, it would otherwise be ~40
+                // identical lines per cluster and this suite creates several.
+                if (attempt === 1 || attempt % 8 === 0) {
+                    console.log(`Attempt ${attempt} failed for cluster "${name}" Healthy check ` +
+                        `(${Math.round((Date.now() - start) / 1000)}s elapsed), retrying...`, err instanceof Error ? err.message : err);
+                }
                 await this.page.waitForTimeout(500);
             }
         }
-        throw new Error(`Cluster "${name}" did not become Healthy after ${attempt} attempts. Last error: ${lastErr instanceof Error ? lastErr.message : lastErr}`);
+        throw new Error(`Cluster "${name}" did not become Healthy within ${Math.round(totalTimeout / 1000)}s (${attempt} polls). Last error: ${lastErr instanceof Error ? lastErr.message : lastErr}`);
     }
     async clickAlphaTab() {
         await this.alphaTab.click();

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

@@ -29,6 +29,8 @@ declare class ModelerHomePage {
     readonly createIdpApplicationButton: Locator;
     readonly dialog: Locator;
     readonly closeButton: Locator;
+    readonly blockingDialog: Locator;
+    readonly blockingDialogDismiss: Locator;
     readonly optionsButton: Locator;
     readonly formNameBreadcrumb: (formName: string) => Locator;
     readonly breadcrumbProjectMenu: Locator;
@@ -68,6 +70,7 @@ declare class ModelerHomePage {
     clickManageButton(retries?: number): Promise<void>;
     clickUploadFilesButton(): Promise<void>;
     dismissBlockingDialog(): Promise<void>;
+    private dismissUncataloguedDialog;
     clickMessageBanner(): Promise<void>;
     selectCluster(clusterName: string): Promise<void>;
     clickIdpApplicationTemplateOption(): Promise<void>;

package/dist/pages/8.10/ModelerHomePage.js

@@ -47,6 +47,8 @@ class ModelerHomePage {
     createIdpApplicationButton;
     dialog;
     closeButton;
+    blockingDialog;
+    blockingDialogDismiss;
     optionsButton;
     formNameBreadcrumb;
     breadcrumbProjectMenu;
@@ -132,6 +134,25 @@ class ModelerHomePage {
         this.closeButton = page
             .locator('button:visible', { hasText: /^Got it/ })
             .first();
+        // Not every modal hub stacks over the projects list carries a "Got it"
+        // control. When one does not, the `closeButton` probe above finds nothing
+        // and `dismissBlockingDialog` returns having dismissed *nothing*, so the
+        // caller clicks straight into an overlay that is still there. Run
+        // 35102164337 lost 9 tests that way: the project link resolved "visible,
+        // enabled and stable", then the click retried 116 times against a modal
+        // reported as intercepting pointer events.
+        //
+        // Anchored on the visible dialog so an announcement nobody has catalogued
+        // yet is still cleared, rather than on one more label. `:visible` matters —
+        // the Modeler home page keeps several `role="dialog"` containers mounted
+        // and hidden, which is why the label-first lookup above exists at all.
+        this.blockingDialog = page.locator('[role="dialog"]:visible').first();
+        // Only unambiguous dismissals. Deliberately NOT "Cancel": that is a form
+        // action on the dialogs specs open on purpose (cluster select, deploy), and
+        // clicking it would break a working test rather than unblock a stuck one.
+        this.blockingDialogDismiss = this.blockingDialog
+            .getByRole('button', { name: /^(Got it|Close|Dismiss)/i })
+            .first();
         this.optionsButton = page.getByRole('button', { name: 'Options' });
         this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
             hasText: formName,
@@ -585,17 +606,42 @@ class ModelerHomePage {
             .waitForLoadState('networkidle', { timeout: 15000 })
             .catch(() => false);
         for (let attempt = 0; attempt < 3; attempt++) {
-            const isOpen = await this.closeButton
-                .waitFor({ state: 'visible', timeout: 10000 })
-                .then(() => true)
-                .catch(() => false);
+            const isOpen = await this.becameVisible(this.closeButton, 10000);
+            // `break`, not `return`: a modal without a "Got it" control is exactly
+            // the case the generic pass below exists for, and returning here is what
+            // let it through.
             if (!isOpen)
-                return;
+                break;
             await this.closeButton.click({ timeout: 5000 }).catch(() => { });
             await this.closeButton
                 .waitFor({ state: 'hidden', timeout: 5000 })
                 .catch(() => false);
         }
+        await this.dismissUncataloguedDialog();
+    }
+    // Second pass for a modal the label-based probe above cannot see. Kept cheap
+    // because `dismissBlockingDialog` is called from a dozen places on the happy
+    // path: when nothing is open this costs one 2s probe, so it cannot turn into
+    // the kind of hidden budget the Optimize retry sizing did.
+    async dismissUncataloguedDialog() {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            if (!(await this.becameVisible(this.blockingDialog, 2000)))
+                return;
+            if (!(await this.becameVisible(this.blockingDialogDismiss, 2000))) {
+                // Nothing safe to click. Leave it rather than guess: pressing Escape
+                // blindly does not close a Carbon dialog (focus sits on the body after
+                // a load), and clicking an unrecognised footer button could confirm
+                // something. The caller's own assertion then reports the real blocker.
+                return;
+            }
+            await this.blockingDialogDismiss.click({ timeout: 5000 }).catch(() => { });
+            const closed = await this.blockingDialog
+                .waitFor({ state: 'hidden', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (closed)
+                return;
+        }
     }
     async clickMessageBanner() {
         try {

package/dist/pages/8.7/ModelerCreatePage.d.ts

@@ -11,6 +11,7 @@ declare class ModelerCreatePage {
     readonly userTaskOption: Locator;
     readonly appendEndEventButton: Locator;
     readonly viewProcessInstanceLink: Locator;
+    readonly autosaveIndicator: Locator;
     readonly nameInput: Locator;
     readonly diagramBreadcrumb: Locator;
     readonly renameDiagramNameButton: Locator;
@@ -135,7 +136,8 @@ declare class ModelerCreatePage {
     runProcessInstance(clusterName: string, variables?: string, formVariables?: {
         [key: string]: string;
     }, textToVisible?: string): Promise<void>;
-    retryRunProcess(maxRetries?: number): Promise<void>;
+    retryRunProcess(clusterName: string, fillDialog?: () => Promise<void>, maxRetries?: number): Promise<void>;
+    private reopenDeployAndRunDialog;
     clickViewProcessInstanceLink(): Promise<void>;
     clickNameInput(): Promise<void>;
     fillNamedInput(name: string): Promise<void>;
@@ -197,6 +199,7 @@ declare class ModelerCreatePage {
     clickIdInput(): Promise<void>;
     fillIdInput(id: string): Promise<void>;
     setAndVerifyProcessId(processId: string): Promise<void>;
+    waitForAutosaveAfterEdits(timeout?: number): Promise<void>;
     fillStartFormName(name: string): Promise<void>;
     fillStartFormDate(date: string): Promise<void>;
     checkStartFormCheckbox(): Promise<void>;

package/dist/pages/8.7/ModelerCreatePage.js

@@ -17,6 +17,7 @@ class ModelerCreatePage {
     userTaskOption;
     appendEndEventButton;
     viewProcessInstanceLink;
+    autosaveIndicator;
     nameInput;
     diagramBreadcrumb;
     renameDiagramNameButton;
@@ -150,6 +151,7 @@ class ModelerCreatePage {
             name: 'View process instance',
         });
         this.viewProcessLink = page.getByText('view process in Operate');
+        this.autosaveIndicator = page.locator('[data-test="autosave"]');
         this.nameInput = page.getByLabel('Name', { exact: true });
         this.diagramBreadcrumb = page.locator('[data-test="breadcrumb-diagram"]');
         this.renameDiagramNameButton = page.getByText('Rename');
@@ -558,35 +560,39 @@ class ModelerCreatePage {
             await this.clickDeployAndRunMainButton();
             await this.selectCluster(clusterName, 120000);
         }
-        if (variables.length > 0) {
-            await (0, test_1.expect)(this.variableInput).toBeVisible({
-                timeout: 60000,
-            });
-            await this.clickVariableInput();
-            await this.fillVariableInput(variables);
-        }
-        if (Object.keys(formVariables).length > 0) {
-            if ('formName' in formVariables && formVariables['formName']) {
-                await this.fillStartFormName(formVariables['formName']);
-            }
-            if ('checkbox' in formVariables && formVariables['checkbox'] == 'true') {
-                await this.checkStartFormCheckbox();
+        const fillDialog = async () => {
+            if (variables.length > 0) {
+                await (0, test_1.expect)(this.variableInput).toBeVisible({
+                    timeout: 60000,
+                });
+                await this.clickVariableInput();
+                await this.fillVariableInput(variables);
             }
-            if ('startDate' in formVariables && formVariables['startDate']) {
-                await this.fillStartFormDate(formVariables['startDate']);
+            if (Object.keys(formVariables).length > 0) {
+                if ('formName' in formVariables && formVariables['formName']) {
+                    await this.fillStartFormName(formVariables['formName']);
+                }
+                if ('checkbox' in formVariables &&
+                    formVariables['checkbox'] == 'true') {
+                    await this.checkStartFormCheckbox();
+                }
+                if ('startDate' in formVariables && formVariables['startDate']) {
+                    await this.fillStartFormDate(formVariables['startDate']);
+                }
+                if ('startNumber' in formVariables && formVariables['startNumber']) {
+                    await this.fillStartFormNumber(formVariables['startNumber']);
+                }
             }
-            if ('startNumber' in formVariables && formVariables['startNumber']) {
-                await this.fillStartFormNumber(formVariables['startNumber']);
+            if (textToVisible.length > 0) {
+                await (0, test_1.expect)(this.dialog.getByText(textToVisible)).toBeVisible({
+                    timeout: 30000,
+                });
             }
-        }
-        if (textToVisible.length > 0) {
-            await (0, test_1.expect)(this.dialog.getByText(textToVisible)).toBeVisible({
-                timeout: 30000,
-            });
-        }
-        await this.retryRunProcess();
+        };
+        await fillDialog();
+        await this.retryRunProcess(clusterName, fillDialog);
     }
-    async retryRunProcess(maxRetries = 3) {
+    async retryRunProcess(clusterName, fillDialog, maxRetries = 3) {
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
                 await this.clickDeployAndRunSubButton();
@@ -596,16 +602,38 @@ class ModelerCreatePage {
                 return;
             }
             catch (error) {
-                if (attempt < maxRetries - 1) {
-                    console.warn(`Attempt ${attempt + 1} failed for running process. Retrying...`);
-                }
-                else {
+                if (attempt === maxRetries - 1) {
                     console.error(error);
                     throw new Error(`Running process failed after ${maxRetries} attempts`);
                 }
+                console.warn(`Attempt ${attempt + 1} failed for running process. Retrying...`);
+                // The dialog closes on a successful deploy and switches to an error
+                // screen when the backend rejects one, so in both cases the sub button
+                // is gone and re-clicking it can only time out -- which is how a
+                // single rejected deploy burned all three attempts in the nightly.
+                // Drive the deploy from the top again whenever the button is no longer
+                // on offer, so the next attempt is a real one.
+                const stillOffered = await this.deployAndRunSubButton
+                    .isVisible()
+                    .catch(() => false);
+                if (!stillOffered) {
+                    await this.reopenDeployAndRunDialog(clusterName);
+                    await fillDialog?.();
+                }
             }
         }
     }
+    async reopenDeployAndRunDialog(clusterName) {
+        const closeButton = this.dialog
+            .getByRole('button', { name: 'Close', exact: true })
+            .first();
+        if (await closeButton.isVisible().catch(() => false)) {
+            await closeButton.click({ timeout: 30000 });
+        }
+        await (0, test_1.expect)(this.dialog).toBeHidden({ timeout: 30000 });
+        await this.clickDeployAndRunMainButton();
+        await this.selectCluster(clusterName, 120000);
+    }
     async clickViewProcessInstanceLink() {
         await this.viewProcessInstanceLink.click({ timeout: 180000 });
     }
@@ -998,6 +1026,33 @@ class ModelerCreatePage {
         }
         await (0, test_1.expect)(this.processIdInput).toHaveValue(processId, { timeout: 10000 });
     }
+    // Web Modeler persists editor edits on a debounced autosave, and
+    // "Deploy & run" deploys what the server holds for the process application,
+    // not what is on screen. The nightly trace shows the PATCH that stored the
+    // renamed process id being acknowledged 61ms before the deploy POST, so the
+    // still-stale file was deployed and the follow-up instance creation was
+    // rejected with "Command 'CREATE' rejected with code 'NOT_FOUND': Expected
+    // to find process definition with process ID '<id>', but none found". The
+    // fixed ten-second wait this replaces raced that debounce, which is itself
+    // about ten seconds. Wait for the modeler's own autosave indicator to report
+    // a save that started after the last edit instead.
+    async waitForAutosaveAfterEdits(timeout = 60000) {
+        const readIndicator = () => this.autosaveIndicator.textContent({ timeout: 10000 }).catch(() => null);
+        const beforeEdits = await readIndicator();
+        try {
+            await test_1.expect
+                .poll(readIndicator, { timeout, intervals: [1000] })
+                .not.toBe(beforeEdits);
+        }
+        catch {
+            // The window between the last edit and the baseline read is a few
+            // milliseconds, so the only way the label does not move within a wait
+            // this much longer than the debounce is that the save had already landed
+            // when the baseline was taken -- the edits are persisted either way.
+            console.warn('Autosave indicator did not change after the diagram edits; ' +
+                'treating the edits as already persisted.');
+        }
+    }
     async fillStartFormName(name) {
         await this.payloadNameInput.fill(name);
     }

package/dist/pages/8.7/UtilitiesPage.js

@@ -302,7 +302,10 @@ async function modelDiagramFromFile(page, modelerHomePage, modelerCreatePage, pr
             await modelerCreatePage.clickCanvas();
         }
     }
-    await (0, sleep_1.sleep)(10000);
+    // "Deploy & run" deploys the copy of the diagram the server holds, so the
+    // rename above has to be persisted first. A fixed ten-second sleep raced the
+    // modeler's own ten-second autosave debounce; wait for the save instead.
+    await modelerCreatePage.waitForAutosaveAfterEdits();
 }
 exports.modelDiagramFromFile = modelDiagramFromFile;
 async function disableRBA(clusterName, homePage, clusterPage, clusterDetailsPage, appsPage) {

package/dist/pages/8.9/AppsPage.d.ts

@@ -29,6 +29,7 @@ declare class AppsPage {
     private doClickClusterInOptimize;
     clickOperate(clusterName: string): Promise<void>;
     clickOptimize(clusterName: string): Promise<void>;
+    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number, totalTimeout?: number): Promise<void>;
     clickCamundaApps(maxRetries?: number): Promise<void>;
     private dismissBlockingOverlays;
     clickConsoleLink(): Promise<void>;

package/dist/pages/8.9/AppsPage.js

@@ -285,6 +285,49 @@ class AppsPage {
         }
         throw new Error(`Failed to click the optimize link after ${maxRetries} attempts.`);
     }
+    // `clickOptimize` returns once it has clicked, not once Optimize has
+    // rendered, so a hand-off that lands somewhere else (an SSO bounce to
+    // `/login`, or `/login?error`) is reported as success. Retrying the click
+    // from there does not help: `clickCamundaApps` below exits its loop without
+    // throwing when none of the app-switcher buttons is visible, which is exactly
+    // the state a dead page is in, so a caller that re-clicks just re-probes the
+    // same page until its budget runs out. Going back to `/` first is the only
+    // thing that recovers, which is what this wrapper adds.
+    // `totalTimeout` is what makes the stated budget true. Retrying on a thrown
+    // hand-off (rather than escaping on the first throw) is correct, but it also
+    // multiplies the cost: a worst-case attempt here is clickCamundaApps (~188s
+    // when it has to hunt for a trigger) + clickOptimize (~456s across its own
+    // three retries) + the banner wait, so four attempts could reach ~51 min and
+    // blow the 36-minute test.slow() budget of the specs that call this. Checked
+    // between attempts, so the real ceiling is the deadline plus at most one
+    // attempt -- bounded, which "N x timeout" arithmetic alone never was.
+    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3, totalTimeout = 600000) {
+        const start = Date.now();
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Inside the try, not before it: `clickOptimize` throws after its own
+                // retries, and `clickCamundaApps` can throw on a click timeout. With
+                // those calls outside, the first such throw escaped this helper before
+                // it ever reached the `page.goto('/')` below -- so in exactly the dead
+                // page case this wrapper exists for, the recovery was skipped and the
+                // remaining attempts never ran.
+                await this.clickCamundaApps();
+                await this.clickOptimize(clusterName);
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                const elapsed = Date.now() - start;
+                if (attempt === maxRetries - 1 || elapsed >= totalTimeout) {
+                    throw error;
+                }
+                console.warn(`Optimize hand-off failed on attempt ${attempt + 1} ` +
+                    `(${Math.round(elapsed / 1000)}s elapsed); re-entering through ` +
+                    `the apps menu. ${error}`);
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
     async clickCamundaApps(maxRetries = 3) {
         await (0, sleep_1.sleep)(2000);
         await this.dismissBlockingOverlays();

package/dist/pages/8.9/ModelerHomePage.d.ts

@@ -28,10 +28,13 @@ declare class ModelerHomePage {
     readonly createIdpApplicationButton: Locator;
     readonly dialog: Locator;
     readonly closeButton: Locator;
+    readonly blockingDialog: Locator;
+    readonly blockingDialogDismiss: Locator;
     readonly optionsButton: Locator;
     readonly formNameBreadcrumb: (formName: string) => Locator;
     constructor(page: Page);
     dismissBlockingDialog(): Promise<void>;
+    private dismissUncataloguedDialog;
     dismissOverlays(): Promise<void>;
     clickCreateNewProjectButton(): Promise<void>;
     enterNewProjectName(name: string): Promise<void>;

package/dist/pages/8.9/ModelerHomePage.js

@@ -45,6 +45,8 @@ class ModelerHomePage {
     createIdpApplicationButton;
     dialog;
     closeButton;
+    blockingDialog;
+    blockingDialogDismiss;
     optionsButton;
     formNameBreadcrumb;
     constructor(page) {
@@ -122,6 +124,26 @@ class ModelerHomePage {
         this.closeButton = page
             .locator('button:visible', { hasText: /^Got it/ })
             .first();
+        // Not every modal hub stacks over the projects list carries a "Got it"
+        // control. When one does not, the `closeButton` probe finds nothing and
+        // `dismissBlockingDialog` returns having dismissed *nothing*, so the caller
+        // clicks straight into an overlay that is still there. Observed on this
+        // version in run 35102229469, which lost `RBA On User Flow - Permission for
+        // All Processes with Full Permissions` and `- Permission for Selected
+        // Processes Only` to exactly that, with 9 "New project" click failures in
+        // the log.
+        //
+        // Anchored on the visible dialog so an announcement nobody has catalogued
+        // yet is still cleared, rather than on one more label. `:visible` matters --
+        // the Modeler home page keeps several `role="dialog"` containers mounted
+        // and hidden, which is why the label-first lookup above exists at all.
+        this.blockingDialog = page.locator('[role="dialog"]:visible').first();
+        // Only unambiguous dismissals. Deliberately NOT "Cancel": that is a form
+        // action on the dialogs specs open on purpose (cluster select, deploy), and
+        // clicking it would break a working test rather than unblock a stuck one.
+        this.blockingDialogDismiss = this.blockingDialog
+            .getByRole('button', { name: /^(Got it|Close|Dismiss)/i })
+            .first();
         this.optionsButton = page.getByRole('button', { name: 'Options' });
         this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
             hasText: formName,
@@ -143,17 +165,41 @@ class ModelerHomePage {
             .waitForLoadState('networkidle', { timeout: 15000 })
             .catch(() => false);
         for (let attempt = 0; attempt < 3; attempt++) {
-            const isOpen = await this.closeButton
-                .waitFor({ state: 'visible', timeout: 10000 })
-                .then(() => true)
-                .catch(() => false);
+            const isOpen = await this.becameVisible(this.closeButton, 10000);
+            // `break`, not `return`: a modal without a "Got it" control is exactly
+            // the case the generic pass below exists for, and returning here is what
+            // let it through.
             if (!isOpen)
-                return;
+                break;
             await this.closeButton.click({ timeout: 5000 }).catch(() => { });
             await this.closeButton
                 .waitFor({ state: 'hidden', timeout: 5000 })
                 .catch(() => false);
         }
+        await this.dismissUncataloguedDialog();
+    }
+    // Second pass for a modal the label-based probe above cannot see. Kept cheap
+    // because `dismissBlockingDialog` is called from a dozen places on the happy
+    // path: when nothing is open this costs one 2s probe.
+    async dismissUncataloguedDialog() {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            if (!(await this.becameVisible(this.blockingDialog, 2000)))
+                return;
+            if (!(await this.becameVisible(this.blockingDialogDismiss, 2000))) {
+                // Nothing safe to click. Leave it rather than guess: pressing Escape
+                // blindly does not close a Carbon dialog (focus sits on the body after
+                // a load), and clicking an unrecognised footer button could confirm
+                // something. The caller's own assertion then reports the real blocker.
+                return;
+            }
+            await this.blockingDialogDismiss.click({ timeout: 5000 }).catch(() => { });
+            const closed = await this.blockingDialog
+                .waitFor({ state: 'hidden', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (closed)
+                return;
+        }
     }
     async dismissOverlays() {
         // Before the generic pass: the loop below closes whichever overlay it finds

package/dist/tests/8.10/access-user-role-management.spec.js

@@ -154,7 +154,32 @@ _8_10_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_9,
                 password: process.env.C8_PASSWORD_TEST_9,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_10_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_10_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();
@@ -245,7 +270,32 @@ _8_10_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_10,
                 password: process.env.C8_PASSWORD_TEST_10,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_10_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_10_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();

package/dist/tests/8.9/access-user-role-management.spec.js

@@ -154,7 +154,32 @@ _8_9_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_9,
                 password: process.env.C8_PASSWORD_TEST_9,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_9_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_9_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();
@@ -245,7 +270,32 @@ _8_9_1.test.describe('User Roles User Flow', () => {
                 username: process.env.C8_USERNAME_TEST_10,
                 password: process.env.C8_PASSWORD_TEST_10,
             });
-            await (0, sleep_1.sleep)(600000); //wait for Optimize cache to refresh
+        });
+        await _8_9_1.test.step('Wait for the role change to reach Optimize', async () => {
+            // Replaces a blind `sleep(600000)`. The role change only takes effect in
+            // Optimize once its permission cache refreshes, and reaching Optimize is
+            // the single thing the rest of this test depends on -- so retry the
+            // hand-off until it succeeds rather than waiting out a fixed ten minutes.
+            // Sized against the helper's REAL per-attempt cost, not just the banner
+            // timeout: each attempt also pays clickCamundaApps() and clickOptimize()
+            // before the banner is ever asserted. Driving the real method under a
+            // virtual clock, (40000, 15) -- which looks like "15 x 40s = 600s" --
+            // actually runs 986s in the ordinary bad case and 4581s when
+            // clickCamundaApps has to hunt for its trigger, the latter alone
+            // exceeding this test's 36-minute test.slow() budget. 4 x 120s measures
+            // at 581s, which is the honest equivalent of the 600s sleep, and four
+            // attempts is ample for the page.goto('/') recovery below (the helper's
+            // own default is 3). It still rethrows once exhausted, so a cache that
+            // never refreshes fails here rather than further downstream.
+            //
+            // openOptimizeWithRetry rather than a hand-rolled poll because it carries
+            // the recovery this needs: a failed hand-off can leave the page on
+            // /login?error, where clickCamundaApps() silently returns (it exits its
+            // loop without throwing when no app-switcher button is visible), so
+            // re-clicking would retry the same dead page until the budget ran out.
+            // openOptimizeWithRetry does page.goto('/') between attempts, which is
+            // the only thing that gets back to a usable state.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName, 120000, 4);
         });
         await _8_9_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1180",
+  "version": "0.0.1182",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",