@camunda/e2e-test-suite 0.0.1182 → 0.0.1184

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

@@ -44,6 +44,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 dismissBlockingModal;
     clickConsoleLink(): Promise<void>;

package/dist/pages/8.8/AppsPage.js

@@ -322,6 +322,56 @@ 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: on a dead page none of the app-switcher buttons
+    // is visible, so `clickCamundaApps` below burns its three rounds probing and
+    // then throws `Failed to open app switcher after 3 attempts` -- and a caller
+    // that just re-clicks 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: the throw is caught below and turned into a re-entry.
+    //
+    // Note this is where 8.8 differs from 8.9/8.10, whose `clickCamundaApps`
+    // falls out of the same loop and returns *without* throwing. The recovery
+    // this wrapper provides is needed either way, but do not carry that
+    // description back here -- on 8.8 the failure arrives as an exception.
+    // `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++) {
+            try {
+                // Inside the try, not before it: both of these throw -- `clickOptimize`
+                // after its own retries, `clickCamundaApps` once its probes are
+                // exhausted or a click times out. 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);
         const appButtons = [

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

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

package/dist/pages/8.8/ModelerHomePage.js

@@ -49,6 +49,8 @@ class ModelerHomePage {
     createIdpApplicationButton;
     dialog;
     closeButton;
+    blockingDialog;
+    blockingDialogDismiss;
     cancelButton;
     optionsButton;
     formNameBreadcrumb;
@@ -127,6 +129,37 @@ 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 35102270880 (chromium-v2), which lost `Public Start Form`,
+        // `RBA On User Flow - No User Permission`, `- Permission for One Process`
+        // and `Form.js Integration with User Task and AI Generated Form` to exactly
+        // that.
+        //
+        // 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.
+        //
+        // `.last()`, not `.first()`: Carbon stacks modals in DOM order, so the last
+        // one is the topmost, and it is the topmost backdrop that intercepts the
+        // pointer events this whole helper exists to clear. Targeting `.first()`
+        // would click the dismiss button of a *covered* dialog and leave the
+        // blocker up -- reproducing the interception rather than fixing it. Same
+        // reasoning, and the same conclusion, as `HomePage.closeInformationDialog`.
+        // The nth here is deliberate rather than the accidental kind CLAUDE.md
+        // warns about: picking the top of a page-wide stack is the whole point, so
+        // there is no parent to scope to, and `:visible` already excludes the
+        // mounted-but-hidden containers.
+        this.blockingDialog = page.locator('[role="dialog"]:visible').last();
+        // 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,
@@ -151,17 +184,60 @@ 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() {
+        // Peel the stack from the top, re-resolving `blockingDialog` each round:
+        // closing the topmost uncovers the next, and `.last()` then points at it.
+        // Three rounds covers the two hub is known to stack (What's New plus the
+        // migration notice) and still terminates on the probe below when the stack
+        // is clear; it is not a budget to burn, so a clear page costs one 2s probe.
+        let lastClickError;
+        for (let attempt = 0; attempt < 3; 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;
+            }
+            try {
+                await this.blockingDialogDismiss.click({ timeout: 5000 });
+                lastClickError = undefined;
+            }
+            catch (error) {
+                // Held, not swallowed. A click can fail here for reasons the next round
+                // clears on its own -- a backdrop fading in over the button, a dialog
+                // re-rendering mid-animation -- so give it that round. If a dialog is
+                // still up once the rounds are spent, this error is what gets reported.
+                lastClickError = error;
+            }
+        }
+        // Still blocked after three rounds. Say so here rather than letting the
+        // caller click into the overlay and report "intercepts pointer events" from
+        // a line that has nothing to do with the dialog.
+        if (await this.blockingDialog.isVisible().catch(() => false)) {
+            throw new Error('A blocking Modeler dialog is still visible after 3 dismiss attempts.' +
+                (lastClickError === undefined
+                    ? ' Its dismiss control was clicked without closing it.'
+                    : ` Last dismiss click failed: ${lastClickError}`));
+        }
     }
     async dismissOverlays() {
         // Before the generic pass: clickMessageBanner and the loop below resolve

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

@@ -10,6 +10,8 @@ declare class Authorization {
     protected readonly createAuthorizationOwnerOption: (name: string) => Locator;
     protected readonly createAuthorizationOwnerSearchInput: Locator;
     protected readonly createAuthorizationOwnerSearchOption: (name: string) => Locator;
+    protected readonly createAuthorizationOwnerCommandInput: Locator;
+    protected readonly createAuthorizationOwnerCommandOptions: Locator;
     protected readonly createAuthorizationResourceTypeDropdown: Locator;
     protected readonly createAuthorizationResourceTypeOption: (name: string) => Locator;
     protected readonly createAuthorizationResourceIdField: Locator;

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

@@ -16,6 +16,8 @@ class Authorization {
     createAuthorizationOwnerOption;
     createAuthorizationOwnerSearchInput;
     createAuthorizationOwnerSearchOption;
+    createAuthorizationOwnerCommandInput;
+    createAuthorizationOwnerCommandOptions;
     createAuthorizationResourceTypeDropdown;
     createAuthorizationResourceTypeOption;
     createAuthorizationResourceIdField;
@@ -72,6 +74,18 @@ class Authorization {
             .locator('.cds--list-box__menu-item, [role="option"]')
             .filter({ hasText: name })
             .first();
+        // In the design-system build the closed Owner control is a combobox-role
+        // trigger that paints "Search by owner ID" as static text (no placeholder
+        // attribute), and the cmdk search box plus its result listbox only mount
+        // in a popover once the trigger is opened. That popover is portalled out
+        // of the dialog, and while it is open Radix marks the dialog aria-hidden,
+        // so both must be queried from the page root.
+        this.createAuthorizationOwnerCommandInput = this.page
+            .locator('[data-slot="command-input"]')
+            .first();
+        this.createAuthorizationOwnerCommandOptions = this.page
+            .getByRole('listbox')
+            .getByRole('option');
         this.createAuthorizationResourceTypeDropdown =
             this.createAuthorizationModal.getByRole('combobox', {
                 name: 'Resource type',
@@ -133,7 +147,10 @@ class Authorization {
             .click({ timeout: Math.min(timeout, 30000) });
     }
     // Released 8.10 alpha images still render the Carbon combobox that lists
-    // every owner, so accept whichever owner field this build shows.
+    // every owner, so accept whichever of the three owner fields this build
+    // shows: the Carbon search dropdown, the Carbon combobox that lists every
+    // owner inline, or the design-system combobox whose cmdk popover only loads
+    // results once the owner ID is typed.
     async selectAuthorizationOwner(ownerId) {
         await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput.or(this.createAuthorizationOwnerComboBox)).toBeVisible({ timeout: 30000 });
         if (await this.createAuthorizationOwnerSearchInput.isVisible()) {
@@ -151,10 +168,29 @@ class Authorization {
             return;
         }
         await this.createAuthorizationOwnerComboBox.click();
-        await (0, test_1.expect)(this.createAuthorizationOwnerOption(ownerId)).toBeVisible({
+        const commandInput = this.createAuthorizationOwnerCommandInput;
+        const inlineOwnerOption = this.createAuthorizationOwnerOption(ownerId);
+        await (0, test_1.expect)(commandInput.or(inlineOwnerOption).first()).toBeVisible({
+            timeout: 30000,
+        });
+        if (await commandInput.isVisible()) {
+            await commandInput.fill(ownerId);
+            // The result list is served by the API and debounced, and each option is
+            // labelled "<owner id> — <name>" rather than the bare ID, so narrow the
+            // search to the single row this unique owner ID resolves to instead of
+            // matching on the label text.
+            const ownerOptions = this.createAuthorizationOwnerCommandOptions;
+            await (0, test_1.expect)(ownerOptions).toHaveCount(1, { timeout: 60000 });
+            await ownerOptions.first().click({ timeout: 30000, force: true });
+            // Committing the choice closes the popover, which is what hands the
+            // dialog back to the accessibility tree for the fields that follow.
+            await (0, test_1.expect)(commandInput).toBeHidden({ timeout: 30000 });
+            return;
+        }
+        await (0, test_1.expect)(inlineOwnerOption).toBeVisible({
             timeout: 30000,
         });
-        await this.createAuthorizationOwnerOption(ownerId).click({
+        await inlineOwnerOption.click({
             timeout: 30000,
         });
     }

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

@@ -24,7 +24,7 @@ class ModelerHomePage {
     // Flag-on (workspaces-enabled) state. Under camunda-hub#27903 the c8-e2e
     // "project folder" maps to a Workspace and the "process application" to a
     // Project: `/` redirects to the `/workspaces` overview, a Workspace holds a
-    // projects listing at `/workspace/{wsId}/projects`, and a Project (the
+    // projects listing at `/workspaces/{wsId}/projects`, and a Project (the
     // resource container) lives one level deeper. These remember the shared
     // Workspace's projects-listing URL and the overview URL so returns don't
     // re-walk the hierarchy from the root each time.
@@ -324,7 +324,7 @@ class ModelerHomePage {
         await this.ensureWorkspaceOpen();
     }
     // Ensures the shared "Cross Component Test Project" Workspace is open and the
-    // browser is on its projects listing (`/workspace/{wsId}/projects`), where the
+    // browser is on its projects listing (`/workspaces/{wsId}/projects`), where the
     // per-test Project is later created. Retries the whole navigation+login on a
     // transient web-modeler 500 rather than a bare reload, which would drop the
     // authenticated SPA state and land on the empty login form.
@@ -440,7 +440,7 @@ class ModelerHomePage {
             ? openButton.first()
             : this.crossComponentProjectFolder;
         await target.click({ timeout: 60000 });
-        await this.page.waitForURL(/\/workspace\/[^/]+\/projects/, {
+        await this.page.waitForURL(/\/workspaces\/[^/]+\/projects/, {
             timeout: 120000,
         });
         this.workspaceProjectsUrl = this.page.url();

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

@@ -303,6 +303,17 @@ class OCTenantPage {
         }
     }
     async fillRoleIdSearchBox(roleId, roleIdentifier) {
+        // The option row renders the ID followed by the name, so the name is the
+        // tail of `roleIdentifier`.
+        const roleName = roleIdentifier.startsWith(roleId)
+            ? roleIdentifier.slice(roleId.length)
+            : '';
+        // The design-system row separates the two parts with an em dash
+        // ('connectors — Connectors') while the legacy Carbon row concatenates
+        // them ('connectorsConnectors'), so match both with an optional
+        // dash/whitespace run between the ID and the name.
+        const escapeForRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const rolePattern = new RegExp(`${escapeForRegExp(roleId)}[-\\s\\u2010-\\u2015]*${escapeForRegExp(roleName)}`);
         // The design-system shell portals the matches into a listbox rendered as
         // a sibling of the dialog, so they cannot be scoped to the modal. The
         // legacy Carbon list stays inside it and must remain scoped: the tenant's
@@ -311,19 +322,15 @@ class OCTenantPage {
         // the modal overlay.
         const result = this.page
             .getByRole('option')
-            .filter({ hasText: roleIdentifier })
-            .or(this.assignRoleModal.getByText(roleIdentifier))
+            .filter({ hasText: rolePattern })
+            .or(this.assignRoleModal.getByText(rolePattern))
             .first();
         // The dropdown no longer filters client-side: it queries
         // `/v2/roles/search` with `name: {$like: '*<typed>*'}`, which is
         // case-sensitive, so the role ID ('connectors') never matches the default
-        // role's name ('Connectors'). The option row renders the ID followed by
-        // the name, so the name is the tail of `roleIdentifier`: search the ID
-        // first for the shells that still match on it, then fall back to the name.
+        // role's name ('Connectors'): search the ID first for the shells that
+        // still match on it, then fall back to the name.
         const searchTerms = [roleId];
-        const roleName = roleIdentifier.startsWith(roleId)
-            ? roleIdentifier.slice(roleId.length)
-            : '';
         if (roleName !== '' && roleName !== roleId) {
             searchTerms.push(roleName);
         }

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

@@ -12,7 +12,7 @@ const resourceContainers = new WeakMap();
 // the resource container -- files, folders and uploads live directly inside it,
 // there is no separate process-application level to descend into. It is created
 // from the workspace's projects listing via the "Create project" split button +
-// dialog, and the app lands on `/workspace/{wsId}/projects/{projectId}`.
+// dialog, and the app lands on `/workspaces/{wsId}/projects/{projectId}`.
 //
 // This page object owns that container's surface (creating a Project, and binding
 // its development-stage cluster). Entering and leaving it is driven from

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

@@ -157,7 +157,33 @@ _8_8_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_8_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 no app-switcher button is visible, so
+            // clickCamundaApps() burns its rounds probing and then throws
+            // 'Failed to open app switcher after 3 attempts'. Re-clicking would just
+            // retry the same dead page until the budget ran out. openOptimizeWithRetry
+            // catches that throw and 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_8_1.test.step('Navigate to Console and Ensure Apps are Available in App Switcher', async () => {
             await appsPage.clickCamundaApps();
@@ -247,7 +273,33 @@ _8_8_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_8_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 no app-switcher button is visible, so
+            // clickCamundaApps() burns its rounds probing and then throws
+            // 'Failed to open app switcher after 3 attempts'. Re-clicking would just
+            // retry the same dead page until the budget ran out. openOptimizeWithRetry
+            // catches that throw and 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_8_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.1182",
+  "version": "0.0.1184",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",