@camunda/e2e-test-suite 0.0.1273 → 0.0.1274

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

@@ -18,8 +18,10 @@ declare class AppsPage {
     readonly consoleLink: Locator;
     readonly camundaComponentsButton: Locator;
     readonly camundaAppsButton: Locator;
+    readonly hubSidebar: Locator;
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
+    private clickHubClusterApp;
     clickModeler(): Promise<void>;
     /**
      * Waits for the Modeler app to actually render, and recovers the one landing

package/dist/pages/8.8/AppsPage.js

@@ -23,6 +23,7 @@ class AppsPage {
     consoleLink;
     camundaComponentsButton;
     camundaAppsButton;
+    hubSidebar;
     constructor(page) {
         this.page = page;
         this.modelerLink = page.getByRole('link', { name: 'Modeler', exact: true });
@@ -34,6 +35,11 @@ class AppsPage {
         this.consoleLink = page.getByRole('link', { name: 'Console', exact: true });
         this.camundaComponentsButton = page.getByLabel('Camunda components');
         this.camundaAppsButton = page.getByLabel('Camunda apps');
+        // Camunda Hub's persistent "Main navigation" sidebar lists each cluster
+        // with its own apps (Operate/Tasklist/Optimize/Identity) as child links
+        // -- there is no per-app switcher panel to open on Hub (see
+        // clickCamundaApps below). Ported from pages/8.9/AppsPage.ts.
+        this.hubSidebar = page.getByRole('navigation', { name: 'Main navigation' });
         this.tasklistListItem = this.page
             .getByRole('listitem')
             .filter({ hasText: 'Tasklist' });
@@ -67,7 +73,83 @@ class AppsPage {
         await (0, test_1.expect)(cluster).toBeVisible({ timeout: 60000 });
         await cluster.click();
     }
+    // Camunda Hub's sidebar groups by cluster, not by app: each cluster row
+    // expands to reveal its own per-app child links (Operate/Tasklist/...).
+    // camunda-hub's own nav-shell-ds.spec.saas.tsx documents the 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 -- and
+    // the child links do not exist in the DOM at all until expanded (not just
+    // hidden), and are not 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. Ported from pages/8.9/AppsPage.ts, where
+    // this shape is already nightly-proven.
+    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
+        // cluster name and portalled OUTSIDE the "Main navigation" <nav> -- so a
+        // sidebar-scoped lookup finds nothing there. Look in that popover first;
+        // keep the sidebar-scoped lookup for the expanded-sidebar layout, where
+        // the links render inline. Not exact: the rendered accessible name
+        // carries more than the bare app name (e.g. "Operate in <cluster>
+        // (opens in a new tab)").
+        const appLink = this.page
+            .getByRole('dialog', { name: clusterName, exact: true })
+            .getByRole('link', { name: appName })
+            .or(this.hubSidebar.getByRole('link', { name: appName }))
+            .first();
+        // Decide whether to expand from clusterName's OWN toggle state, not from
+        // whether "some" appLink is already visible sidebar-wide: in a
+        // 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 });
+        }
+        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.
+        // Follow the href in the current tab instead, matching the same-tab
+        // navigation the Console app switcher gave these callers.
+        const href = await appLink.getAttribute('href');
+        if (href) {
+            await this.page.goto(new URL(href, this.page.url()).toString());
+            return;
+        }
+        await appLink.click({ timeout: 10000 });
+    }
     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
+        // check alone can't tell whether we're already there -- Hub's cluster
+        // pages are on the same hub.* hostname, and a no-op here would leave a
+        // caller that reaches clickModeler() from a cluster/API-client page
+        // stranded with the next locator running against the wrong page.
+        // 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 });
+            return;
+        }
         const maxRetries = 5;
         // If the click is already done and we are sitting on Modeler, return
         // immediately — observed in failing runs where the banner role lookup
@@ -148,6 +230,10 @@ class AppsPage {
         }
     }
     async clickTasklist(clusterName) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.clickHubClusterApp(clusterName, 'Tasklist');
+            return;
+        }
         const maxRetries = 5;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -185,6 +271,14 @@ class AppsPage {
         throw new Error(`Failed to click the tasklist link after ${maxRetries} attempts.`);
     }
     async clickIdentity(clusterName) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            // Non-anchored, matching the substring lookup clickHubClusterApp uses
+            // for Operate/Tasklist/Optimize -- an anchored pattern fails the same
+            // way an exact-string match did for those apps if the rendered link's
+            // accessible name carries any extra content (icon/badge).
+            await this.clickHubClusterApp(clusterName, /Admin|Identity/);
+            return;
+        }
         const maxRetries = 5;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -251,6 +345,10 @@ class AppsPage {
         await this.clickCluster(this.optimizeListItem, clusterName);
     }
     async clickOperate(clusterName) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.clickHubClusterApp(clusterName, 'Operate');
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -287,6 +385,10 @@ class AppsPage {
         throw new Error(`Failed to click the operate link after ${maxRetries} attempts.`);
     }
     async clickOptimize(clusterName) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.clickHubClusterApp(clusterName, 'Optimize');
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -373,6 +475,13 @@ class AppsPage {
         }
     }
     async clickCamundaApps(maxRetries = 3) {
+        // Camunda Hub's rewritten shells have no app-switcher button to open --
+        // Modeler is already Hub's home area and the other apps are reached
+        // per-cluster via the persistent sidebar, not through a global switcher
+        // panel. Mirrors the same hostname guard in clickModeler() above.
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            return;
+        }
         await (0, sleep_1.sleep)(2000);
         const appButtons = [
             this.camundaComponentsButton,
@@ -420,6 +529,19 @@ class AppsPage {
             .catch(() => { });
     }
     async clickConsoleLink() {
+        // Camunda Hub replaced Console on SaaS: there is no "Console" entry in a
+        // switcher, and the org-scoped Console area is the sidebar's
+        // Clusters/Environments section. Going there is what callers assert on
+        // (HomePage.consoleBanner resolves to Hub's authenticated header).
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            const consoleArea = this.hubSidebar
+                .locator('a[href$="/clusters"]')
+                .or(this.hubSidebar.locator('a[href$="/environments"]'))
+                .first();
+            await (0, test_1.expect)(consoleArea).toBeVisible({ timeout: 30000 });
+            await consoleArea.click({ timeout: 30000 });
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {

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

@@ -40,6 +40,7 @@ declare class ClusterDetailsPage {
     readonly orchestrationClusterCheckbox: Locator;
     readonly clientCredentialsLink: (clientCredentials: string) => Locator;
     readonly clientRow: (name: string) => Locator;
+    readonly clientRowByDom: (name: string) => Locator;
     readonly clientRowDeleteButton: (name: string) => Locator;
     readonly reviewUpdateButton: Locator;
     readonly selectTargetVersionDialog: Locator;

package/dist/pages/8.8/ClusterDetailsPage.js

@@ -46,6 +46,7 @@ class ClusterDetailsPage {
     orchestrationClusterCheckbox;
     clientCredentialsLink;
     clientRow;
+    clientRowByDom;
     clientRowDeleteButton;
     reviewUpdateButton;
     selectTargetVersionDialog;
@@ -78,9 +79,6 @@ class ClusterDetailsPage {
             .locator('label')
             .filter({ hasText: /^Administration API - Resource: Secrets$/ });
         this.createButton = page.getByRole('button', { name: 'Create', exact: true });
-        this.closeModalButton = page
-            .getByRole('dialog', { name: 'Client credentials', exact: true })
-            .getByLabel('Close');
         this.createClientButton = page.getByRole('button', {
             name: 'Create new Client',
         });
@@ -98,9 +96,18 @@ class ClusterDetailsPage {
         this.createClientCredentialsDialog = page.getByRole('dialog', {
             name: 'Create new client credentials',
         });
-        this.clientCredentialsDialog = page.getByRole('dialog', {
-            name: 'Client credentials',
-            exact: true,
+        // Use a content-based locator so the test stays robust if the dialog
+        // title is ever renamed in the Console UI.
+        this.clientCredentialsDialog = page.getByRole('dialog').filter({
+            has: page.getByText('The Client Secret will not be shown again.'),
+        });
+        // Hub's client-credentials dialog (design-system Dialog, not the old
+        // Carbon one) exposes its close affix as an accessible button named
+        // "Close" rather than via an aria-label picked up by getByLabel -- see
+        // camunda-hub's own e2e suite, ConsoleClusterDetailsPage.ts
+        // (clientCredentialsDialogCloseButton), which already uses this pattern.
+        this.closeModalButton = this.clientCredentialsDialog.getByRole('button', {
+            name: 'Close',
         });
         this.clustersLink = page
             .getByRole('banner')
@@ -154,10 +161,22 @@ class ClusterDetailsPage {
         this.orchestrationClusterCheckbox = page
             .locator('label')
             .filter({ hasText: /^Orchestration Cluster API$/ });
+        // Camunda Hub's data table renders the client name as a link-styled
+        // <button data-slot="button"> rather than an <a>. The cell also holds a
+        // pointer-events-none row-overlay button with the same accessible name,
+        // so match the visible one by its data-slot.
         this.clientCredentialsLink = (clientCredentials) => page
             .getByRole('cell', { name: clientCredentials })
-            .getByText(clientCredentials);
+            .locator('a, button[data-slot="button"]')
+            .first();
         this.clientRow = (name) => this.clientsList.filter({ hasText: name });
+        // Same row, matched through the DOM instead of the accessibility tree.
+        // Hub's client-credentials dialog is a Radix dialog: while it is open the
+        // whole app shell behind it carries aria-hidden/inert, so `getByRole`
+        // resolves nothing there and the post-create scope check below can never
+        // pass. `locator('tr')` is unaffected. The client name is unique per run,
+        // so matching page-wide cannot pick up another table's row.
+        this.clientRowByDom = (name) => page.locator('tr').filter({ hasText: name });
         this.clientRowDeleteButton = (name) => this.clientRow(name).getByRole('button', { name: 'Delete' });
         this.reviewUpdateButton = page.getByRole('button', { name: 'Review Update' });
         this.selectTargetVersionDialog = page
@@ -609,9 +628,9 @@ class ClusterDetailsPage {
         }
         await (0, test_1.expect)(this.clientCredentialsDialog.getByText('The Client Secret will not be shown again.')).toBeVisible({ timeout: 30000 });
         // The clients table behind the dialog re-fetches after the create, and
-        // renders a skeleton (no `row` roles at all) until that GET resolves — so
-        // the default 5s expect timeout can expire before the new row exists.
-        await (0, test_1.expect)(this.clientsList.filter({ hasText: name })).toContainText(/(?=.*Orchestration)(?=.*Optimize)(?=.*Secrets)/, { timeout: 60000 });
+        // renders a skeleton (no rows at all) until that GET resolves — so the
+        // default 5s expect timeout can expire before the new row exists.
+        await (0, test_1.expect)(this.clientRowByDom(name)).toContainText(/(?=.*Orchestration)(?=.*Optimize)(?=.*Secrets)/, { timeout: 60000 });
     }
     async clickEnvVarsButton() {
         await (0, test_1.expect)(this.envVarsTab).toBeVisible({ timeout: 40000 });

package/dist/pages/8.8/ClusterPage.js

@@ -124,10 +124,43 @@ class ClusterPage {
         this.clusterVersion = (clusterName, versionText) => this.cluster(clusterName).getByText(versionText);
     }
     async clickClusterBanner() {
-        await this.page
+        // Camunda Hub has no `banner` landmark; "Clusters" instead lives in its
+        // persistent "Main navigation" sidebar, and once the org has environments
+        // enabled that link is further renamed "Environments" (same rollout
+        // HomePage.clusterTab handles).
+        const clusterLink = this.page
             .getByRole('banner')
             .getByRole('link', { name: 'Clusters' })
-            .click({ timeout: 60000 });
+            .or(this.page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Clusters', exact: true }))
+            .or(this.page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Environments', exact: true }));
+        await clusterLink.click({ timeout: 60000 });
+        // Landing on Hub's Environments overview (see above) renders clusters as
+        // cards, not the getByRole('row') table this page's own locators expect
+        // -- route through the page's own "Clusters" tab to reach the classic
+        // route. Same fix as HomePage.clickClusters().
+        const clustersPageTab = this.page
+            .getByRole('navigation', { name: 'Environments views' })
+            .getByRole('link', { name: 'Clusters', exact: true });
+        // Required on Hub, not optional: this page's row-based cluster locators
+        // cannot be satisfied by the card-based Environments overview we just
+        // landed on. isVisible() does not wait, so a slow tab render used to be
+        // read as "no tab here" and the flow continued on the wrong route.
+        const onHub = new URL(this.page.url()).hostname.startsWith('hub.');
+        const tabShown = await clustersPageTab
+            .waitFor({ state: 'visible', timeout: onHub ? 30000 : 5000 })
+            .then(() => true)
+            .catch(() => false);
+        if (tabShown) {
+            await clustersPageTab.click({ timeout: 15000 });
+        }
+        else if (onHub) {
+            throw new Error('Hub Environments view did not render its "Clusters" tab; the ' +
+                'row-based cluster list this page needs is unreachable without it');
+        }
     }
     async deleteCluster(name) {
         await this.page.waitForTimeout(1000);

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

@@ -36,6 +36,7 @@ declare class ClusterSecretsPage {
         value: string;
     }[]): Promise<void>;
     reopenConnectorSecretsTab(cluster: string): Promise<void>;
+    private reselectConnectorSecretsTabIfPresent;
     assertSecretsToolbarVisible(cluster: string): Promise<void>;
     assertSecretsOrCreate(cluster: string, secrets: {
         name: string;

package/dist/pages/8.8/ClusterSecretsPage.js

@@ -50,10 +50,27 @@ class ClusterSecretsPage {
         this.dialogImportButton = this.page
             .getByRole('dialog')
             .getByRole('button', { name: 'Import', exact: true });
-        this.secretsSearchBox = page.getByRole('searchbox', { name: 'Filter table' });
+        // "Filter table" was Carbon's default TableToolbarSearch label. Camunda
+        // Hub's rebranded panel renders a plain "Search" input instead, so the
+        // old exact-name match never resolves and every lookup falls through to
+        // creating a secret that may already exist. Match either.
+        this.secretsSearchBox = page
+            .getByRole('searchbox', { name: 'Filter table' })
+            .or(page.getByRole('searchbox', { name: 'Search' }))
+            .or(page.getByPlaceholder('Search'));
+        // Camunda Hub has no `banner` landmark; "Clusters" instead lives in its
+        // persistent "Main navigation" sidebar, and once the org has environments
+        // enabled that link is further renamed "Environments" (same rollout
+        // HomePage.clusterTab handles).
         this.clusterBanner = this.page
             .getByRole('banner')
-            .getByRole('link', { name: 'Clusters' });
+            .getByRole('link', { name: 'Clusters' })
+            .or(this.page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Clusters', exact: true }))
+            .or(this.page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Environments', exact: true }));
         this.clusterLink = (name) => page.getByRole('link', { name: name });
         this.clusterSecretTab = this.page.getByRole('tab', {
             name: 'Connector Secrets',
@@ -144,6 +161,30 @@ class ClusterSecretsPage {
         await this.dismissOpenDialogIfPresent();
         await (0, test_1.expect)(this.clusterBanner).toBeVisible({ timeout: 30000 });
         await this.clusterBanner.click({ timeout: 60000 });
+        // Landing on Hub's Environments overview (see clusterBanner above) renders
+        // clusters as cards, not the getByRole('link') the clusterLink() locator
+        // below expects to find directly -- route through the page's own
+        // "Clusters" tab to reach the classic route. Same fix as
+        // HomePage.clickClusters().
+        const clustersPageTab = this.page
+            .getByRole('navigation', { name: 'Environments views' })
+            .getByRole('link', { name: 'Clusters', exact: true });
+        // Required on Hub, not optional: this page's row-based cluster locators
+        // cannot be satisfied by the card-based Environments overview we just
+        // landed on. isVisible() does not wait, so a slow tab render used to be
+        // read as "no tab here" and the flow continued on the wrong route.
+        const onHub = new URL(this.page.url()).hostname.startsWith('hub.');
+        const tabShown = await clustersPageTab
+            .waitFor({ state: 'visible', timeout: onHub ? 30000 : 5000 })
+            .then(() => true)
+            .catch(() => false);
+        if (tabShown) {
+            await clustersPageTab.click({ timeout: 15000 });
+        }
+        else if (onHub) {
+            throw new Error('Hub Environments view did not render its "Clusters" tab; the ' +
+                'row-based cluster list this page needs is unreachable without it');
+        }
     }
     async clickCluster(name) {
         await (0, test_1.expect)(this.clusterLink(name)).toBeVisible({ timeout: 30000 });
@@ -241,7 +282,25 @@ class ClusterSecretsPage {
         await (0, test_1.expect)(this.clusterSecretTab).toBeVisible({ timeout: 30000 });
         await this.clusterSecretTab.click({ timeout: 30000 });
     }
+    // Camunda Hub keeps the selected cluster tab in client-side state rather
+    // than in the URL (/org/<id>/cluster/<id> carries no tab segment), so every
+    // page.reload() in this file lands back on the cluster Overview tab, where
+    // the secrets toolbar does not exist at all. Re-selecting the tab is a
+    // client-side click that costs nothing, whereas re-entering from the
+    // Clusters list navigates to `/` and pays a full Hub OAuth hand-off -- so
+    // try the cheap route before the toolbar assertions fall through to their
+    // broken-panel recovery.
+    async reselectConnectorSecretsTabIfPresent() {
+        const onTab = await this.clusterSecretTab
+            .waitFor({ state: 'visible', timeout: 30000 })
+            .then(() => true)
+            .catch(() => false);
+        if (onTab) {
+            await this.clusterSecretTab.click({ timeout: 15000 }).catch(() => { });
+        }
+    }
     async assertSecretsToolbarVisible(cluster) {
+        await this.reselectConnectorSecretsTabIfPresent();
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.createNewSecretButton, {
             visibilityTimeout: 60000,
             totalTimeout: 300000,
@@ -272,6 +331,7 @@ class ClusterSecretsPage {
         // Same broken-panel state as assertSecretsToolbarVisible guards against:
         // when the secrets panel failed to load, Import is simply absent, and only
         // re-entering the tab brings it back.
+        await this.reselectConnectorSecretsTabIfPresent();
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.importButton, {
             visibilityTimeout: 30000,
             totalTimeout: 300000,

package/dist/pages/8.8/FormJsPage.js

@@ -5,6 +5,8 @@ const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 const sessionRecovery_1 = require("../../utils/sessionRecovery");
+const consoleApiHelpers_1 = require("../../utils/consoleApiHelpers");
+const hubDeployDialog_1 = require("../../utils/hubDeployDialog");
 class FormJsPage {
     page;
     processApplicationPage;
@@ -54,16 +56,36 @@ class FormJsPage {
         // Inside a process application hub titles this modal for the application
         // rather than for the form, so 'Deploy form' never matches and the dialog
         // reads as absent. pages/SM-8.10 filters on 'Deploy' for the same reason.
+        // Camunda Hub's design-system shell renders no Carbon markup at all: a DOM
+        // audit of a live run found zero `cds--*` classes on these pages, so the
+        // Carbon container selector matched nothing and the dialog read as absent
+        // even once it had opened. Match the dialog by role and keep the Carbon
+        // container for shells where the Ds migration has not shipped.
         this.dialog = page
+            .getByRole('dialog')
+            .filter({ hasText: 'Deploy' })
+            .or(page
             .locator('.cds--modal-container[role="dialog"]')
-            .filter({ hasText: 'Deploy' });
+            .filter({ hasText: 'Deploy' }))
+            .first();
         this.deploySubButton = this.dialog.getByRole('button', {
             name: 'Deploy',
             exact: true,
         });
+        // Same Carbon-to-design-system move as the dialog above: the success toast
+        // is a role=status/alert region on Hub rather than a `cds--toast-*` node.
+        // Hub's dialog deploys the whole PROJECT ("Deploy project"), so its
+        // confirmation is no longer the form-specific "Form deployed!" string.
+        // Match the deployment confirmation however it is worded, while still
+        // requiring a success (not an error) wording so a failed deploy cannot
+        // satisfy it.
         this.deploySuccessNotification = page
+            .getByText(/(form|project|resources?)\s+(was\s+)?deployed/i)
+            .or(page.getByText('Form deployed!'))
+            .or(page
             .locator('.cds--toast-notification--success')
-            .filter({ hasText: 'Form deployed!' });
+            .filter({ hasText: 'Form deployed!' }))
+            .first();
         this.deployErrorMessage = this.dialog.getByText('The form failed to deploy');
     }
     async generateAIForm(request = 'Create a form with the following fields: 1. A text field with the label "Full Name" 2. A number with the label "Count" 3. A date input with the label "Date of birth"4. A Checkbox with the label "Agree"') {
@@ -159,14 +181,30 @@ class FormJsPage {
             }
             return;
         }
-        const healthyRegex = new RegExp(`${clusterName}[\\s\\S]*?HealthydevManage`);
-        const cluster = this.dialog.locator(`[title="${clusterName}"]`);
+        // "HealthydevManage" was the Carbon row's chrome concatenated together.
+        // The design-system dialog renders the cluster row as
+        // "<name> ... <generation> dev <checkmark> Healthy" with no Manage link,
+        // so the old pattern could never match. Keep what the assertion is for --
+        // the chosen cluster reports Healthy -- without the stale chrome.
+        const healthyRegex = new RegExp(`${clusterName}[\\s\\S]*?Healthy`);
+        // `[title="<cluster>"]` was the Carbon toggle's own tooltip attribute; the
+        // design-system dialog renders no `title` here, so the click target is the
+        // labelled toggle itself (the same node `legacyClusterToggle` already
+        // matched to decide this branch).
+        const cluster = this.dialog
+            .locator(`[title="${clusterName}"]`)
+            .or(legacyClusterToggle.first())
+            .first();
         await (0, test_1.expect)(cluster).toBeVisible({ timeout: 30000 });
         await cluster.click();
-        await (0, test_1.expect)(this.dialog
-            .locator('label')
-            .filter({ hasText: new RegExp(`^${clusterName}`) })
-            .getByRole('switch')).toBeChecked({ timeout: 30000 });
+        // Carbon rendered the cluster choice as a toggle `switch`; the
+        // design-system dialog uses a different control (and auto-selects the
+        // single offered cluster), so a switch-only assertion timed out on a
+        // dialog that had in fact selected the cluster. Assert whichever control
+        // shape is present, and skip the check when none is -- the deploy itself,
+        // and the success notification the caller waits on, are what actually
+        // prove the right cluster was used.
+        await (0, hubDeployDialog_1.assertClusterSelectedInDialog)(this.dialog, clusterName);
         await (0, test_1.expect)(this.dialog).toHaveText(healthyRegex, {
             timeout: healthCheckTimeout,
         });
@@ -189,22 +227,7 @@ class FormJsPage {
     // silently turning it into a process-application deploy. The combobox only
     // exists inside a container, hence the boolean probe.
     async selectOnlyThisResource() {
-        const scopeSelect = this.dialog.getByRole('combobox', {
-            name: 'Resources to deploy',
-        });
-        const hasScopeSelect = await scopeSelect
-            .waitFor({ state: 'visible', timeout: 10000 })
-            .then(() => true)
-            .catch(() => false);
-        if (!hasScopeSelect) {
-            return;
-        }
-        await scopeSelect.click();
-        await this.dialog
-            .getByRole('option', { name: 'Only this resource' })
-            .or(this.dialog.getByText('Only this resource', { exact: true }))
-            .first()
-            .click({ timeout: 30000 });
+        await (0, hubDeployDialog_1.selectOnlyThisResourceInDialog)(this.page, this.dialog);
     }
     async deployForm(clusterName) {
         await this.processApplicationPage.ensureStageCluster(clusterName);
@@ -214,6 +237,14 @@ class FormJsPage {
         // retry through that propagation window instead of failing on the transient
         // rejection. Non-migration runs keep the original single-attempt behavior.
         const maxAttempts = process.env.IS_MIGRATION === 'true' ? 15 : 1;
+        // Camunda Hub's deploy modal lists the ENVIRONMENTS assigned to this
+        // workspace, not the org's clusters, so a cluster created after the
+        // workspace existed never appears and the picker comes up empty. The
+        // wizard's "Assign environments" step only covers a workspace created
+        // after its cluster, which test-setup cannot guarantee -- it creates
+        // clusters and workspaces in parallel. Ensure the link here, at the point
+        // of use, so the ordering does not matter.
+        await (0, consoleApiHelpers_1.ensureClusterLinkedToSharedWorkspace)(this.page, clusterName);
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             await this.clickDeployButton();
             await (0, test_1.expect)(this.dialog).toBeVisible({

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

@@ -12,11 +12,14 @@ declare class HomePage {
     readonly appSwitcher: Locator;
     readonly openOrganizationButton: Locator;
     readonly consoleBanner: Locator;
+    readonly hubHeader: Locator;
+    readonly hubSidebar: Locator;
     readonly modelerBanner: Locator;
     readonly gettingStartedHeading: Locator;
     readonly buttonSkipCustomization: Locator;
     constructor(page: Page);
     clickClusters(): Promise<void>;
+    private clickClustersPageTabIfPresent;
     clickDashboard(): Promise<void>;
     clickOrganization(): Promise<void>;
     closeInformationDialog(): Promise<void>;