@camunda/e2e-test-suite 0.0.1247 → 0.0.1249

package/dist/pages/8.9/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>;
     clickTasklist(clusterName: string): Promise<void>;
     clickAdmin(clusterName: string): Promise<void>;

package/dist/pages/8.9/AppsPage.js

@@ -23,9 +23,15 @@ class AppsPage {
     consoleLink;
     camundaComponentsButton;
     camundaAppsButton;
+    hubSidebar;
     constructor(page) {
         this.page = page;
         this.modelerLink = page.getByRole('link', { name: 'Modeler', exact: true });
+        // 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). Mirrors pages/8.7/AppsPage.ts.
+        this.hubSidebar = page.getByRole('navigation', { name: 'Main navigation' });
         this.appSwitcherButton = page.getByLabel('App Switcher');
         this.tasklistLink = page.getByRole('link', { name: 'Tasklist', exact: true });
         this.adminLink = page.getByRole('link', { name: /^(Admin|Identity)$/ });
@@ -75,7 +81,78 @@ class AppsPage {
         await (0, test_1.expect)(cluster).toBeVisible({ timeout: 30000 });
         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.
+    async clickHubClusterApp(clusterName, appName) {
+        // Not exact: camunda-hub's own nav-shell-ds.spec.saas.tsx asserts this same
+        // link with a substring/regex match (`{name: /Operate/}`), not an exact
+        // string -- and CI traces confirm why: even after the toggle click
+        // succeeds (no error thrown), an exact-match lookup here still times out
+        // with "element(s) not found", meaning the rendered link's accessible
+        // name is not byte-for-byte "Operate"/"Tasklist"/"Optimize" (likely
+        // additional content from the design-system sidebar item, e.g. an icon
+        // or badge). The app names are distinct enough that a substring match
+        // carries no ambiguity risk.
+        const appLink = this.hubSidebar.getByRole('link', {
+            name: appName,
+        });
+        // 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, which made this check pass while clusterName's own
+        // group stayed collapsed -- appLink.click() below then fired on the
+        // wrong cluster's link (see PR #3627 review).
+        const collapsedToggle = this.hubSidebar
+            .getByRole('button', { name: clusterName, expanded: false })
+            .first();
+        if (await collapsedToggle.isVisible({ timeout: 5000 }).catch(() => false)) {
+            // 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 collapsedToggle.click({ timeout: 10000 });
+        }
+        await (0, test_1.expect)(appLink).toBeVisible({ timeout: 30000 });
+        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 = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -106,6 +183,10 @@ class AppsPage {
         throw new Error(`Failed to click the modeler link after ${maxRetries} attempts.`);
     }
     async clickTasklist(clusterName) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.clickHubClusterApp(clusterName, 'Tasklist');
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -144,6 +225,14 @@ class AppsPage {
         throw new Error(`Failed to click the tasklist link after ${maxRetries} attempts.`);
     }
     async clickAdmin(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 {
@@ -218,6 +307,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 {
@@ -252,6 +345,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 {
@@ -329,6 +426,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);
         await this.dismissBlockingOverlays();
         const appButtons = [
@@ -357,6 +461,16 @@ class AppsPage {
         }
     }
     async clickConsoleLink() {
+        // Camunda Hub folded Console into the same persistent shell as
+        // Modeler/home: Console's Dashboard/Clusters/Organization links are
+        // just another section of the same "Main navigation" sidebar, not a
+        // separate app to switch into. Its header banner (homePage.consoleBanner,
+        // via hubHeader) is already visible from any Hub page, so there is no
+        // navigation action needed here -- mirrors the same hostname guard in
+        // clickModeler().
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {

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

@@ -3,6 +3,7 @@ import { ClientCredentialsDetailsPage } from './ClientCredentialsDetailsPage';
 import { McpCredentials } from '../../utils/mcpSecrets';
 declare class ClusterDetailsPage {
     private page;
+    private pendingClientScopeCheck;
     readonly apiTab: Locator;
     readonly createFirstClientButton: Locator;
     readonly clientNameTextbox: Locator;
@@ -54,7 +55,9 @@ declare class ClusterDetailsPage {
     readonly updateButton: Locator;
     constructor(page: Page);
     clickAPITab(): Promise<void>;
+    dismissOopsIfPresent(): Promise<void>;
     clickCreateClientButton(): Promise<void>;
+    assertAPIClientScopes(name: string): Promise<void>;
     clickClientNameTextbox(): Promise<void>;
     fillClientNameTextbox(name: string): Promise<void>;
     clickTasklistCheckbox(): Promise<void>;

package/dist/pages/8.9/ClusterDetailsPage.js

@@ -8,6 +8,9 @@ const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLoc
 const ClientCredentialsDetailsPage_1 = require("./ClientCredentialsDetailsPage");
 class ClusterDetailsPage {
     page;
+    // Name of a client whose scopes still have to be checked against the
+    // clients list — see createAPIClient() / clickCloseModalButton().
+    pendingClientScopeCheck = null;
     apiTab;
     createFirstClientButton;
     clientNameTextbox;
@@ -80,9 +83,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',
         });
@@ -113,9 +113,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')
@@ -202,8 +211,68 @@ class ClusterDetailsPage {
         await (0, test_1.expect)(this.apiTab).toBeVisible({ timeout: 60000 });
         await this.apiTab.click({ timeout: 60000 });
     }
+    async dismissOopsIfPresent() {
+        // The clients list panel sometimes lands in a Carbon "Oops ... something
+        // went wrong." state when a background ClustersService request fails on
+        // SaaS INT. The panel replaces the create-client button, so any click
+        // attempt will time out until the user clicks the inline Reload button.
+        const oopsHeading = this.page.getByRole('heading', { name: /Oops/i });
+        if (!(await oopsHeading.isVisible({ timeout: 1000 }).catch(() => false))) {
+            return;
+        }
+        const reloadButton = this.page.getByRole('button', {
+            name: 'Reload',
+            exact: true,
+        });
+        if (await reloadButton.isVisible({ timeout: 1000 }).catch(() => false)) {
+            await reloadButton.click({ timeout: 15000 });
+        }
+        else {
+            await this.page.reload();
+        }
+        await this.page.waitForLoadState('domcontentloaded');
+        // The swallowed click error above let a failed Reload look like recovery,
+        // leaving the caller to burn its own timeout against the same Oops state
+        // and report an unrelated downstream failure. Verify the panel actually
+        // recovered instead of assuming either recovery path worked.
+        await (0, test_1.expect)(oopsHeading).not.toBeVisible({ timeout: 15000 });
+    }
     async clickCreateClientButton() {
-        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.createFirstClientButton.or(this.createNewClientButton));
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.createFirstClientButton.or(this.createNewClientButton), {
+            preAction: async () => {
+                await this.dismissOopsIfPresent();
+            },
+        });
+    }
+    // Asserts the scopes an API client was created with, read from its row in
+    // the clients list. Only meaningful once the credentials modal is closed:
+    // while it is open the panel behind it can still be showing its pre-create
+    // state and lists no row for the new client at all.
+    async assertAPIClientScopes(name) {
+        const row = this.clientsList.filter({ hasText: name });
+        const scopes = /(?=.*Orchestration)(?=.*Optimize)(?=.*Secrets)/;
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                await (0, test_1.expect)(row).toContainText(scopes, { timeout: 60000 });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxAttempts) {
+                    throw error;
+                }
+                // A panel that rendered before the client existed — or that failed
+                // into the "Oops ... something went wrong." state — only picks the
+                // new client up on a refetch, which is what reloading the API tab
+                // forces. A single reload isn't always enough on a nightly cluster
+                // this suite reuses across parallel test workers, so retry more
+                // than once before failing the test.
+                console.warn(`assertAPIClientScopes: "${name}" is not listed yet (attempt ${attempt}/${maxAttempts}); reloading the API tab and retrying. ${error}`);
+                await this.dismissOopsIfPresent();
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+                await this.clickAPITab();
+            }
+        }
     }
     async clickClientNameTextbox() {
         await this.clientNameTextbox.click({ timeout: 60000 });
@@ -253,6 +322,12 @@ class ClusterDetailsPage {
     }
     async clickCloseModalButton() {
         await this.closeModalButton.click({ timeout: 60000 });
+        const pendingClient = this.pendingClientScopeCheck;
+        if (pendingClient === null) {
+            return;
+        }
+        this.pendingClientScopeCheck = null;
+        await this.assertAPIClientScopes(pendingClient);
     }
     async clickSettingsTab() {
         await this.settingsTab.click({ timeout: 60000 });
@@ -582,24 +657,16 @@ class ClusterDetailsPage {
                 await (0, test_1.expect)(this.clientCredentialsDialog
                     .getByText('The Client Secret will not be shown again.')
                     .first()).toBeVisible();
-                try {
-                    await (0, test_1.expect)(this.clientsList.filter({ hasText: attemptName })).toContainText(/(?=.*Orchestration)(?=.*Optimize)(?=.*Secrets)/, {
-                        timeout: 10000,
-                    });
-                }
-                catch (err) {
-                    // The clients list panel can land in "Oops ... something went wrong."
-                    // while the post-create modal is still open. The modal blocks pointer
-                    // events so we can't click Reload here; the modal's "Client Secret will
-                    // not be shown again" message above already proves the client exists.
-                    const oopsVisible = await this.page
-                        .getByRole('heading', { name: /Oops/i })
-                        .isVisible({ timeout: 1000 })
-                        .catch(() => false);
-                    if (!oopsVisible)
-                        throw err;
-                    console.warn(`createAPIClient: clients list panel is in Oops state; skipping row scope assertion for "${attemptName}".`);
-                }
+                // The client now exists — the modal above is proof — so the scopes it
+                // was created with are checked in clickCloseModalButton() rather than
+                // here. The clients list behind the open modal is not a reliable
+                // source for that check: it can still be rendering its pre-create
+                // state (no row for this client) or have failed into "Oops ...
+                // something went wrong.", and the modal blocks the pointer events a
+                // reload would need. Asserting it here instead sent a created client
+                // round the retry loop, which both left orphan clients behind and
+                // discarded the credentials the caller has yet to read.
+                this.pendingClientScopeCheck = attemptName;
                 return;
             }
             catch (error) {

package/dist/pages/8.9/ClusterPage.js

@@ -123,10 +123,30 @@ 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 });
+        if (await clustersPageTab.isVisible({ timeout: 5000 }).catch(() => false)) {
+            await clustersPageTab.click({ timeout: 15000 });
+        }
     }
     async deleteCluster(name) {
         await this.page.waitForTimeout(1000);
@@ -302,12 +322,33 @@ class ClusterPage {
         });
     }
     async clickConnectorSecretsTab(clusterName) {
-        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.connectorSecretsTab, {
-            postAction: async () => {
-                await this.clickClusterBanner();
-                await this.clickClusterLink(clusterName);
-            },
-        });
+        // clickLocatorWithRetry only reports whether the click itself threw --
+        // Radix's tab trigger always accepts the click, so a click that lands
+        // right before the panel re-renders (e.g. Hub's cluster-page background
+        // reauth reload) can report success while the "Connector Secrets" panel
+        // never actually activates. Verify aria-selected rather than trusting
+        // the click outcome, and redo the full navigate-and-click on a miss.
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.connectorSecretsTab, {
+                postAction: async () => {
+                    await this.clickClusterBanner();
+                    await this.clickClusterLink(clusterName);
+                },
+            });
+            const isSelected = (await this.connectorSecretsTab
+                .getAttribute('aria-selected')
+                .catch(() => null)) === 'true';
+            if (isSelected) {
+                return;
+            }
+            if (attempt === maxAttempts) {
+                throw new Error('clickConnectorSecretsTab: "Connector Secrets" tab click did not activate the tab after retries');
+            }
+            console.warn(`clickConnectorSecretsTab: click succeeded but the tab did not become active (attempt ${attempt}/${maxAttempts}); retrying`);
+            await this.clickClusterBanner();
+            await this.clickClusterLink(clusterName);
+        }
     }
     async clickLatestStableForMinorVersion() {
         const minorVersion = process.env.MINOR_VERSION;

package/dist/pages/8.9/ClusterSecretsPage.js

@@ -55,10 +55,28 @@ class ClusterSecretsPage {
         this.dialogCancelButton = this.page
             .getByRole('dialog')
             .getByRole('button', { name: 'Cancel', exact: true });
-        this.secretsSearchBox = page.getByRole('searchbox', { name: 'Filter table' });
+        // "Filter table" was Carbon's default TableToolbarSearch label. A live
+        // trace off this branch shows the panel now rendering a plain "Search"
+        // input instead (Camunda Hub's rebranded UI, not Carbon), 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',
@@ -115,6 +133,17 @@ class ClusterSecretsPage {
     async clickClusterBanner() {
         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 });
+        if (await clustersPageTab.isVisible({ timeout: 5000 }).catch(() => false)) {
+            await clustersPageTab.click({ timeout: 15000 });
+        }
     }
     async clickCluster(name) {
         await (0, test_1.expect)(this.clusterLink(name)).toBeVisible({ timeout: 30000 });
@@ -169,6 +198,22 @@ class ClusterSecretsPage {
         await (0, test_1.expect)(this.page.getByText('Creating...')).not.toBeVisible({
             timeout: 60000,
         });
+        // A live trace off this exact branch (test-setup.spec.ts, PR#3627) shows
+        // the panel taking the reload path for every one of 7 secrets created in
+        // a row, not "near-universally" -- so the 15s pre-reload probe this used
+        // to run first never once paid off and only burned 15s x N secrets.
+        // Reload unconditionally, matching the pattern createSetOfSecrets's own
+        // bulkImportSecrets() already uses after an import on this identical
+        // panel.
+        await this.page.reload({ waitUntil: 'domcontentloaded' });
+        // The reload lands back on the cluster's default Overview tab, not
+        // Connector Secrets -- a CI failure screenshot confirmed the page stuck
+        // there with the secrets panel never reached, so createNewSecretButton
+        // was never going to reappear regardless of whether the reload fixed the
+        // underlying render issue. Re-navigate to the tab before waiting for it.
+        await this.clickClusterBanner();
+        await this.clickCluster(cluster);
+        await this.clusterSecretTab.click({ timeout: 30000 });
         await (0, test_1.expect)(this.createNewSecretButton).toBeVisible({
             timeout: 60000,
         });

package/dist/pages/8.9/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;
     clickClustersWithReloadRecovery(): Promise<void>;
     clickDashboard(): Promise<void>;
     clickOrganization(): Promise<void>;

package/dist/pages/8.9/HomePage.js

@@ -16,16 +16,35 @@ class HomePage {
     appSwitcher;
     openOrganizationButton;
     consoleBanner;
+    hubHeader;
+    hubSidebar;
     modelerBanner;
     gettingStartedHeading;
     buttonSkipCustomization;
     constructor(page) {
         this.page = page;
+        // Camunda Hub replaces Console on SaaS: an app header (only carrying the
+        // user menu once authenticated) plus a sidebar whose Console section
+        // links to /org/<id>/clusters and /org/<id>/management.
+        this.hubHeader = page
+            .locator('header[data-slot="app-header"]')
+            .filter({ has: page.locator('[data-slot="user-menu-trigger"]') });
+        this.hubSidebar = page.locator('nav[data-slot="app-sidebar"]');
         this.dashboardTab = page.getByRole('link', { name: 'Dashboard' });
+        // Once an org has environmentsEnabled, camunda-hub's
+        // use-ds-sidebar-items.tsx replaces the sidebar's Clusters link with one
+        // labelled "Environments" whose href is '/environments', not
+        // '/clusters' -- accept both hrefs so this resolves either way.
         this.clusterTab = page
             .getByRole('banner')
-            .getByRole('link', { name: 'Clusters' });
-        this.organizationTab = page.getByRole('link', { name: 'Organization' });
+            .getByRole('link', { name: 'Clusters' })
+            .or(this.hubSidebar.locator('a[href$="/clusters"]'))
+            .or(this.hubSidebar.locator('a[href$="/environments"]'))
+            .first();
+        this.organizationTab = page
+            .getByRole('link', { name: 'Organization' })
+            .or(this.hubSidebar.locator('a[href$="/management"]'))
+            .first();
         this.organizationViewTitle = page.getByText('Organization Management');
         this.welcomeMessage = page.getByText('Welcome to Camunda!').first();
         this.informationDialog = page.getByRole('button', {
@@ -38,9 +57,14 @@ class HomePage {
             .or(this.camundaAppsButton)
             .or(this.appSwitcher);
         this.openOrganizationButton = page.getByLabel('Open Organizations');
-        this.consoleBanner = page.getByRole('link', {
-            name: 'Camunda logo Console',
-        });
+        // "Camunda logo Console" was the old Carbon header's logo link. Camunda
+        // Hub has no equivalent link -- its post-login landing is `hubHeader`
+        // (see above) -- so callers that assert this banner as a login/Console
+        // arrival signal need the Hub fallback too (UtilitiesPage.ts already
+        // does this ad hoc at one call site; fold it in here instead).
+        this.consoleBanner = page
+            .getByRole('link', { name: 'Camunda logo Console' })
+            .or(this.hubHeader);
         this.gettingStartedHeading = page.getByText('start by creating a project');
         this.buttonSkipCustomization = page.getByRole('button', {
             name: 'Skip customization',
@@ -52,6 +76,20 @@ class HomePage {
     async clickClusters() {
         await (0, test_1.expect)(this.clusterTab).toBeVisible({ timeout: 30000 });
         await this.clusterTab.click({ timeout: 15000 });
+        await this.clickClustersPageTabIfPresent();
+    }
+    // Landing on Hub's Environments overview (see clusterTab above) doesn't put
+    // us on the classic row-based cluster list ClusterPage.ts expects -- that
+    // page renders clusters as cards. Its own header renders a separate
+    // "Clusters" tab (camunda-hub EnvironmentsPageHeader.tsx, href /clusters)
+    // that does.
+    async clickClustersPageTabIfPresent() {
+        const clustersPageTab = this.page
+            .getByRole('navigation', { name: 'Environments views' })
+            .getByRole('link', { name: 'Clusters', exact: true });
+        if (await clustersPageTab.isVisible({ timeout: 5000 }).catch(() => false)) {
+            await clustersPageTab.click({ timeout: 15000 });
+        }
     }
     // Same navigation as clickClusters(), but recovers from a Console SPA crash
     // by remounting the app. Toggling authorizations restarts the cluster, and
@@ -70,6 +108,7 @@ class HomePage {
                 await this.page.reload();
             },
         });
+        await this.clickClustersPageTabIfPresent();
     }
     async clickDashboard() {
         await this.dashboardTab.click({ timeout: 90000 });

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

@@ -26,6 +26,7 @@ declare class LoginPage {
     clickContinueButton(): Promise<void>;
     fillPassword(password: string): Promise<void>;
     clickLoginButton(): Promise<void>;
+    private throwIfCredentialsRejected;
     login(credentials?: {
         username?: string;
         password?: string;