@camunda/e2e-test-suite 0.0.1275 → 0.0.1277

package/dist/pages/8.10/ClusterPage.js

@@ -280,7 +280,14 @@ class ClusterPage {
         await this.clickClusterNameInput();
         await this.fillClusterNameInput(name);
         await this.clickClusterType();
-        await this.page.getByRole('tab', { name: region }).click();
+        // Same design-system role="radio" fallback as the choice()-wrapped
+        // locators above -- `region` is a runtime parameter ('GCP'/'AWS') so
+        // this can't reuse a named locator directly. Ported from
+        // pages/8.9/ClusterPage.ts.
+        await this.page
+            .getByRole('tab', { name: region })
+            .or(this.page.getByRole('radio', { name: region, exact: true }))
+            .click();
         await this.selectSubRegion(region);
         await this.clickClusterOption();
         await this.determineTasklistAPI(tasklistV1Api);

package/dist/pages/8.10/ConsoleOrganizationPage.js

@@ -118,9 +118,16 @@ class ConsoleOrganizationPage {
             name: 'danger',
         })
             .last();
-        this.filterTableSearchbox = page.getByRole('searchbox', {
-            name: 'Filter table',
-        });
+        // Camunda Hub's design-system Organization Management page renamed the
+        // Carbon TableToolbarSearch's default "Filter table" label to plain
+        // "Search" (same rename already ported elsewhere for the secrets
+        // panels). Confirmed against camunda-hub's own
+        // e2e-playwright/pages/Console/ConsoleOrgManagementPage.ts, which already
+        // uses `getByRole('searchbox', {name: 'Search'})` for this exact users
+        // list. Match either.
+        this.filterTableSearchbox = page
+            .getByRole('searchbox', { name: 'Filter table' })
+            .or(page.getByRole('searchbox', { name: 'Search' }));
     }
     async filterTable(names) {
         for (const name of names) {

package/dist/pages/8.10/ProcessApplicationPage.js

@@ -48,21 +48,49 @@ class ProcessApplicationPage {
         // .first() defensively only: hub renders exactly one of these today, in the
         // workspace-root empty state. A future second placement should not turn
         // every PA-creating test into a strict-mode violation.
+        //
+        // hubTerm('project') (utils/hub-terminology.ts) renames "process
+        // application" to "project" in copy once an org has workspacesEnabled --
+        // confirmed from a nightly trace screenshot on hub.ultrawombat.com: the
+        // workspace-root empty state renders "Create project" (not "Create
+        // process application"), and EmptyStateActionButtons.tsx's source
+        // confirms the button text is `Create {hubTerm('project')}`. Accept both
+        // so this keeps working on orgs at either rollout stage.
+        // exact:true on both -- without it, "Create project" substring-matches
+        // the split button's own "Create project options" chevron too, and
+        // .first() then picks whichever the DOM happens to order first. Same
+        // pattern already fixed for the same chevron in
+        // ModelerHomePage.ts's createNewProjectButton/createWorkspaceButton.
         this.createProcessApplicationButton = page
-            .getByRole('button', { name: 'Create process application' })
+            .getByRole('button', { name: 'Create process application', exact: true })
+            .or(page.getByRole('button', { name: 'Create project', exact: true }))
             .first();
         this.createProcessApplicationOption = page.locator('[data-test="create-process-application"]');
-        this.creationDialog = page.getByRole('dialog', {
-            name: 'Create a process application',
-        });
+        // Same hubTerm('project') rename as the button above --
+        // CreationModalDs.common.tsx's dialog title is `Create a
+        // {hubTerm('project')}`. A confirmed nightly trace showed a THIRD shape,
+        // live on this SaaS org: `app/pages/workspace-projects/features/
+        // create-project/CreateProjectModal.tsx` -- a newer, unrelated component
+        // (built on `api/projects`' useCreateProject, not processApplicationStore)
+        // titled plainly "Create project" (no "a"), with its field labelled
+        // "Project name" (not "Name") and its submit button reading "Create
+        // project" (not "Create"). Accept all three shapes.
+        this.creationDialog = page
+            .getByRole('dialog', { name: 'Create a process application' })
+            .or(page.getByRole('dialog', { name: 'Create a project' }))
+            .or(page.getByRole('dialog', { name: 'Create project', exact: true }));
         // Deliberately scoped to the dialog: ModelerCreatePage owns an unscoped
         // getByLabel('Name', {exact: true}) for the properties panel, which would
         // resolve to two elements while the creation modal is open.
-        this.nameInput = this.creationDialog.getByLabel('Name', { exact: true });
-        this.submitButton = this.creationDialog.getByRole('button', {
-            name: 'Create',
+        this.nameInput = this.creationDialog
+            .getByLabel('Name', { exact: true })
+            .or(this.creationDialog.getByLabel('Project name', { exact: true }));
+        this.submitButton = this.creationDialog
+            .getByRole('button', { name: 'Create', exact: true })
+            .or(this.creationDialog.getByRole('button', {
+            name: 'Create project',
             exact: true,
-        });
+        }));
         this.cancelButton = this.creationDialog.getByRole('button', {
             name: 'Cancel',
             exact: true,

package/dist/pages/8.10/SettingsPage.js

@@ -7,8 +7,18 @@ class SettingsPage {
     logoutButton;
     constructor(page) {
         this.page = page;
-        this.openSettingsButton = page.getByLabel('Open Settings');
-        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+        // Camunda Hub's design-system shell renders a `UserMenu` button named
+        // "User menu, <full name>" in place of the legacy Carbon "Open Settings"
+        // icon button, and its logout control is a menuitem inside that menu
+        // rather than a plain button. Both shells still ship -- match either.
+        // Ported from camunda-hub's own e2e-playwright/pages/Console/ConsoleBasePage.ts
+        // (settingsButton / dsLogoutMenuItem / carbonLogoutButton).
+        this.openSettingsButton = page
+            .getByRole('button', { name: /^User menu,/ })
+            .or(page.getByLabel('Open Settings'));
+        this.logoutButton = page
+            .getByRole('menuitem', { name: 'Log out', exact: true })
+            .or(page.getByRole('button', { name: 'Log out' }));
     }
     async clickOpenSettingsButton(retries = 3) {
         for (let i = 0; i < retries; i++) {

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

@@ -21,8 +21,13 @@ declare class AppsPage {
     readonly hubSidebar: Locator;
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
+    private expandHubClusterGroup;
+    private expandHubSidebar;
+    private showAllWorkspaces;
     private clickHubClusterApp;
+    private isOnHub;
     clickModeler(): Promise<void>;
+    private clickHubModelerHome;
     /**
      * Waits for the Modeler app to actually render, and recovers the one landing
      * state a hostname check cannot see: Modeler's OAuth `/login-callback`

package/dist/pages/8.8/AppsPage.js

@@ -4,6 +4,9 @@ exports.AppsPage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const UtilitiesPage_1 = require("../8.8/UtilitiesPage");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 class AppsPage {
     page;
     modelerLink;
@@ -85,6 +88,187 @@ class AppsPage {
     // up the app link sidebar-wide rather than scoped to a "group" container
     // that doesn't reliably exist. Ported from pages/8.9/AppsPage.ts, where
     // this shape is already nightly-proven.
+    async expandHubClusterGroup(clusterName) {
+        const toggle = this.hubSidebar
+            .getByRole('button', { name: clusterName })
+            .first();
+        // The diagram editor (and other full-screen views reached from it, e.g.
+        // right after runProcessInstance/deployDiagram) has no "Main navigation"
+        // sidebar at all -- confirmed from a nightly trace's DOM snapshot: the
+        // page's only <nav> is aria-label="Context navigation" (the breadcrumb),
+        // and neither "Operate"/"Tasklist"/"Optimize" nor any app-switcher text
+        // appears anywhere on it. clickCamundaApps() is a no-op on Hub (there is
+        // no switcher panel to open), so a caller reaching clickOperate/
+        // clickTasklist/clickOptimize straight from a diagram was left on a page
+        // this sidebar could never resolve on, no matter how the toggle itself
+        // is matched. Navigate home first, the same way clickModeler() does,
+        // whenever the sidebar isn't already there.
+        //
+        // A freshly re-authenticated page can also land on a workspace-agnostic
+        // route (e.g. bare /workspaces right after loginWithTestUser(), which
+        // clickCamundaApps() does nothing to fix -- it is a no-op on Hub) whose
+        // sidebar renders but has not resolved this cluster's own group yet.
+        // Confirmed from a nightly trace: both the getAttribute and click below
+        // timed out (10s each) against this exact toggle while the URL sat on
+        // /workspaces, right after a mid-test re-login. Route through the same
+        // clickModeler() recovery whenever the toggle itself hasn't shown up
+        // either, not only when the whole sidebar is missing.
+        // Before deciding whether the group is reachable: a collapsed rail hides
+        // every cluster trigger, so the probe below would report "not ready" and
+        // the recovery would then wait out its own timeout on the same hidden
+        // element.
+        await this.expandHubSidebar();
+        const sidebarReady = (await this.hubSidebar.isVisible({ timeout: 5000 }).catch(() => false)) &&
+            (await toggle
+                .waitFor({ state: 'visible', timeout: 10000 })
+                .then(() => true)
+                .catch(() => false));
+        if (!sidebarReady) {
+            await this.clickModeler();
+            await (0, test_1.expect)(this.hubSidebar).toBeVisible({ timeout: 30000 });
+            // Since camunda-hub #28956 the Workspaces overview defaults to "My
+            // workspaces" -- only the ones the current user is an EXPLICIT member
+            // of -- and resets to it on every load. The shared workspace is created
+            // by whichever setup user won the race, so a role-flow user lands on
+            // "No workspaces match this filter / You don't have explicit membership
+            // in any workspace in this organization" (confirmed live) and the
+            // sidebar never renders this cluster's group. Widening the scope is
+            // what makes it appear; without it the wait below can only time out.
+            // ModelerHomePage.showAllWorkspaces() covers the project-folder paths,
+            // but nothing covered the app-switcher path until here.
+            await this.showAllWorkspaces(5000);
+            await this.expandHubSidebar();
+            await (0, test_1.expect)(toggle).toBeVisible({ timeout: 30000 });
+        }
+        // camunda-hub's own nav-shell-ds.spec.saas.tsx documents the actual
+        // shape: "the design system splits the group row into a label control
+        // and a chevron control, both labelled by the cluster name; either one
+        // opens it" -- there is no separate "Toggle <name>" control, and the
+        // child links do not exist in the DOM at all until expanded (not merely
+        // hidden), nor are they nested under any container matchable by cluster
+        // name once expanded. So: find the toggle by the cluster's own name
+        // (`.first()` because both controls share that name), click it, then
+        // look up the app link sidebar-wide rather than scoped to a "group"
+        // container that doesn't reliably exist.
+        // Check THIS cluster's own toggle state, not "is any app link with this
+        // name visible anywhere in the sidebar" -- with more than one cluster in
+        // the org, a DIFFERENT cluster's group can already be expanded (left over
+        // from an earlier action on the same page), and that cluster's own
+        // Operate/Tasklist/Optimize link would satisfy an unscoped visibility
+        // check, skipping expansion of the requested cluster entirely and then
+        // clicking the wrong cluster's link. The child links are not nested under
+        // any container matchable by cluster name once expanded (confirmed
+        // against camunda-hub's own nav-shell-ds.spec.saas.tsx), so the toggle's
+        // own aria-expanded is the only reliable per-cluster signal available.
+        // Not exact: the same suite asserts this row with a substring/regex
+        // match (`{name: /Production/}`), not an exact string -- and nightly
+        // traces confirm why: the rendered toggle's accessible name is not
+        // byte-for-byte the bare cluster name (it carries additional content,
+        // e.g. a trailing tag summary), so an exact-match lookup here finds
+        // nothing and the click below times out waiting on a locator that can
+        // never resolve.
+        const alreadyExpanded = (await toggle.getAttribute('aria-expanded').catch(() => null)) === 'true';
+        if (!alreadyExpanded) {
+            // This is the only expansion action in the Hub path -- swallowing its
+            // failure made a broken expansion look successful and left the caller
+            // to burn the full 30s below waiting on an app link that could never
+            // appear, hiding the actionable error (e.g. a toggle that doesn't
+            // exist or isn't clickable) behind an unrelated timeout.
+            await toggle.click({ timeout: 10000 });
+        }
+        // An app link resolved after this is sidebar-wide (see callers below), so
+        // if an EARLIER call in the same test left a different cluster's group
+        // expanded too, two "Operate" (say) links now exist and that becomes a
+        // strict-mode violation. Collapse every other expanded group before
+        // resolving it -- there is no container to scope the link to instead,
+        // since the child links aren't nested under anything matchable by
+        // cluster name once expanded.
+        // hasNotText filters DOM text content, not the accessible name -- the
+        // expanded chevron can be labelled via aria-label with no text content
+        // of its own, in which case hasNotText would fail to exclude the toggle
+        // we just expanded and this loop would immediately collapse it again.
+        // Match by accessible name (same algorithm getByRole's own name option
+        // uses) instead, excluding any name CONTAINING clusterName -- not just
+        // one exactly equal to it, since (per the toggle locator above) the
+        // current cluster's own toggle name is not exactly clusterName either,
+        // and an exact-equality exclusion would wrongly treat it as "other" and
+        // immediately re-collapse the group this method just expanded.
+        const otherExpandedToggles = this.hubSidebar.getByRole('button', {
+            expanded: true,
+            name: new RegExp(`^(?!.*${escapeRegExp(clusterName)}).+$`),
+        });
+        for (let i = 0; i < 5 && (await otherExpandedToggles.count()) > 0; i++) {
+            // Let a failed collapse throw rather than swallowing it: the app link
+            // is intentionally sidebar-wide, so a group left expanded here produces
+            // a strict-mode violation (or the wrong cluster's link) below anyway --
+            // failing at the actual cause is more useful than at that symptom.
+            await otherExpandedToggles.first().click({ timeout: 10000 });
+        }
+    }
+    // Widens Hub's Workspaces scope filter to "All workspaces". Duplicated from
+    // ModelerHomePage.showAllWorkspaces() rather than imported: ModelerHomePage
+    // constructs page objects of its own, and pulling it in here would make the
+    // Apps -> Modeler navigation path circular. The control is absent outside
+    // Hub and for non-elevated users, where a membership-scoped list is already
+    // correct, so a missing control is a no-op.
+    // Opens Hub's collapsed left rail. While collapsed it shows only the
+    // top-level nav icons: the per-cluster group triggers are in the DOM
+    // (data-slot="app-sidebar-group-trigger", aria-label="<cluster>") but never
+    // visible, so a toBeVisible() wait on one can only time out. A failing run's
+    // trace carries "Expand sidebar" seven times and "Collapse sidebar" not
+    // once, i.e. the rail stayed shut for its whole duration. A no-op when the
+    // rail is already open, since the toggle is then labelled "Collapse sidebar".
+    async expandHubSidebar() {
+        const expandToggle = this.page
+            .getByRole('button', { name: 'Expand sidebar' })
+            .or(this.page
+            .locator('[data-slot="app-sidebar-collapse-toggle"]')
+            .and(this.page.getByLabel('Expand sidebar')))
+            .first();
+        if (!(await expandToggle.isVisible().catch(() => false))) {
+            return;
+        }
+        await expandToggle.click({ timeout: 10000 });
+        await (0, test_1.expect)(expandToggle).toBeHidden({ timeout: 10000 });
+    }
+    async showAllWorkspaces(probeTimeout) {
+        // The empty state offers an explicit "Switch to All workspaces" button
+        // next to "You don't have explicit membership in any workspace in this
+        // organization" -- prefer it. Driving the combobox alone was not enough:
+        // when its accessible name does not match, the probe below simply
+        // returns and the caller waits out its whole timeout on a page that is
+        // still scoped to "My workspaces" (observed live, twice).
+        const switchButton = this.page.getByRole('button', {
+            name: 'Switch to All workspaces',
+        });
+        const scopeFilter = this.page.getByRole('combobox', {
+            name: 'Filter workspaces',
+        });
+        const appeared = await switchButton
+            .or(scopeFilter)
+            .first()
+            .waitFor({ state: 'visible', timeout: probeTimeout })
+            .then(() => true)
+            .catch(() => false);
+        if (!appeared) {
+            return;
+        }
+        if (await switchButton.isVisible().catch(() => false)) {
+            await switchButton.click({ timeout: 10000 });
+            await (0, test_1.expect)(switchButton).toBeHidden({ timeout: 10000 });
+            return;
+        }
+        if ((await scopeFilter.innerText()).includes('All workspaces')) {
+            return;
+        }
+        await scopeFilter.click({ timeout: 10000 });
+        await this.page
+            .getByRole('option', { name: 'All workspaces' })
+            .click({ timeout: 10000 });
+        await (0, test_1.expect)(scopeFilter).toContainText('All workspaces', {
+            timeout: 10000,
+        });
+    }
     async clickHubClusterApp(clusterName, appName) {
         // When the sidebar is collapsed (the default on a fresh session), the
         // group toggle opens a Radix popover -- a role="dialog" labelled with the
@@ -104,12 +288,12 @@ class AppsPage {
         // multi-cluster org another cluster's group can already be expanded with
         // the same app name, and the click would then fire on the wrong
         // cluster's link.
-        const collapsedToggle = this.hubSidebar
-            .getByRole('button', { name: clusterName, expanded: false })
-            .first();
-        if (await collapsedToggle.isVisible({ timeout: 5000 }).catch(() => false)) {
-            await collapsedToggle.click({ timeout: 10000 });
-        }
+        // Expansion, sidebar recovery and collapsing every OTHER expanded group
+        // all live in the ported helper: with more than one cluster in the org
+        // (this suite creates Test Cluster and AWS Cluster), a sidebar-wide app
+        // link can otherwise resolve to a different cluster's row, or become a
+        // strict-mode violation once two groups are open.
+        await this.expandHubClusterGroup(clusterName);
         await (0, test_1.expect)(appLink).toBeVisible({ timeout: 30000 });
         // Hub's cluster-app links carry target="_blank", so clicking them opens
         // the app in a new tab while every caller keeps asserting on this.page.
@@ -122,6 +306,11 @@ class AppsPage {
         }
         await appLink.click({ timeout: 10000 });
     }
+    // True once the tab is on a Camunda Hub host, where Modeler home is Hub's
+    // own home rather than a modeler.* hostname.
+    isOnHub() {
+        return new URL(this.page.url()).hostname.startsWith('hub.');
+    }
     async clickModeler() {
         // Camunda Hub (hub.*) replaced Console + Web Modeler on SaaS and has no
         // app switcher. Its home is the Modeler/Workspaces home, but a hostname
@@ -132,22 +321,7 @@ class AppsPage {
         // Navigate home through the header logo link instead, same as
         // ModelerHomePage.clickHomeBreadcrumb -- clicking it when already on the
         // Modeler home is a harmless in-SPA no-op.
-        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
-            const header = this.page.locator('header[data-slot="app-header"]');
-            // The href stays literally "/login" until the client's auth state
-            // catches up just after login (camunda-hub NavShellDs.common.tsx) --
-            // clicking it in that window would log the test out instead of
-            // navigating home, so exclude that href and wait for the authenticated
-            // one rather than racing it.
-            const homeLink = header
-                .getByRole('link', { name: 'Camunda Modeler home' })
-                .and(this.page.locator(':not([href$="/login"])'))
-                .or(header
-                .getByRole('link', { name: 'Camunda Hub home' })
-                .and(this.page.locator(':not([href$="/login"])')))
-                .first();
-            await (0, test_1.expect)(homeLink).toBeVisible({ timeout: 30000 });
-            await homeLink.click({ timeout: 30000 });
+        if (await this.clickHubModelerHome()) {
             return;
         }
         const maxRetries = 5;
@@ -160,6 +334,17 @@ class AppsPage {
         }
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
+                // Re-checked every iteration, not once before the loop. A caller can
+                // reach here from a cluster app (Operate/Tasklist/Identity), which is
+                // NOT a hub.* host, so the pre-loop check above takes the legacy
+                // branch -- but the reload in the catch below lands back on Hub, and
+                // the loop's own success signal (a modeler.* hostname) can never come
+                // true there. A nightly trace shows exactly that: every retry
+                // snapshot sits on hub.ultrawombat.com/workspaces, which IS Modeler
+                // home, while the loop kept failing until it ran out of attempts.
+                if (await this.clickHubModelerHome()) {
+                    return;
+                }
                 await this.clickCamundaApps();
                 await (0, test_1.expect)(this.modelerLink).toBeVisible({ timeout: 30000 });
                 await this.modelerLink.click({ timeout: 30000 });
@@ -194,6 +379,30 @@ class AppsPage {
         }
         throw new Error(`Failed to click the modeler link after ${maxRetries} attempts.`);
     }
+    // Navigates to Hub's Modeler home through the header logo link. Returns
+    // false when this tab is not on a Hub host, so the caller falls through to
+    // the legacy Console app-switcher flow.
+    async clickHubModelerHome() {
+        if (!this.isOnHub()) {
+            return false;
+        }
+        const header = this.page.locator('header[data-slot="app-header"]');
+        // The href stays literally "/login" until the client's auth state
+        // catches up just after login (camunda-hub NavShellDs.common.tsx) --
+        // clicking it in that window would log the test out instead of
+        // navigating home, so exclude that href and wait for the authenticated
+        // one rather than racing it.
+        const homeLink = header
+            .getByRole('link', { name: 'Camunda Modeler home' })
+            .and(this.page.locator(':not([href$="/login"])'))
+            .or(header
+            .getByRole('link', { name: 'Camunda Hub home' })
+            .and(this.page.locator(':not([href$="/login"])')))
+            .first();
+        await (0, test_1.expect)(homeLink).toBeVisible({ timeout: 30000 });
+        await homeLink.click({ timeout: 30000 });
+        return true;
+    }
     /**
      * Waits for the Modeler app to actually render, and recovers the one landing
      * state a hostname check cannot see: Modeler's OAuth `/login-callback`

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

@@ -22,8 +22,13 @@ declare class ClusterDetailsPage {
     readonly clientCredentialsDialog: Locator;
     readonly clustersLink: Locator;
     readonly alertsTab: Locator;
+    readonly alertsPanel: Locator;
     readonly activeTabPanel: Locator;
     readonly alertsList: Locator;
+    readonly alertExpandRowButtons: Locator;
+    readonly alertRowActionsButtons: Locator;
+    readonly deleteAlertMenuItem: Locator;
+    readonly deleteAlertConfirmButton: Locator;
     readonly createFirstAlertButton: Locator;
     readonly createNewAlertButton: Locator;
     readonly emailRadioButton: Locator;
@@ -37,6 +42,7 @@ declare class ClusterDetailsPage {
     readonly expandButton: Locator;
     readonly rbaEnabledMessage: Locator;
     readonly authorizationsHeading: Locator;
+    readonly authorizationsSwitch: Locator;
     readonly orchestrationClusterCheckbox: Locator;
     readonly clientCredentialsLink: (clientCredentials: string) => Locator;
     readonly clientRow: (name: string) => Locator;
@@ -64,6 +70,7 @@ declare class ClusterDetailsPage {
     clickCloseModalButton(): Promise<void>;
     clickSettingsTab(): Promise<void>;
     private waitForAuthorizationsSection;
+    private setAuthorizationsViaSwitch;
     enableAuthorizations(): Promise<void>;
     disableAuthorizations(): Promise<void>;
     searchAndClickClientCredentialsLink(name: string): Promise<ClientCredentialsDetailsPage>;
@@ -76,6 +83,8 @@ declare class ClusterDetailsPage {
     selectEmailRadioButton(): Promise<void>;
     clickCreateAlertButton(): Promise<void>;
     deleteAlerts(): Promise<void>;
+    ensureAlertsTabSelected(): Promise<void>;
+    expandAlerts(): Promise<void>;
     private confirmDelete;
     private dismissDeleteDialog;
     private doDelete;