@camunda/e2e-test-suite 0.0.1253 → 0.0.1255

package/dist/pages/8.10/ModelerHomePage.js

@@ -8,6 +8,11 @@ const randomName_1 = require("../../utils/randomName");
 const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class ModelerHomePage {
     defaultFolderName = 'Cross Component Test Project';
+    // The default cluster test-setup.spec.ts's "Create Default Cluster" test
+    // provisions for the whole suite -- assigned to the shared workspace's
+    // Environments step so downstream specs can deploy to it without a manual
+    // assignment step first.
+    defaultClusterName = 'Test Cluster';
     // The name hub gives a project on create, before the inline rename commits.
     defaultNewProjectName = 'New project';
     page;
@@ -26,6 +31,11 @@ class ModelerHomePage {
     processApplicationName;
     modelerPageBanner;
     createNewProjectButton;
+    createWorkspaceButton;
+    workspaceWizardNameInput;
+    workspaceWizardSubmitButton;
+    workspaceWizardMembersStep;
+    workspaceWizardEnvironmentsHeading;
     projectNameInput;
     formNameInput;
     chooseBpmnTemplateButton;
@@ -61,12 +71,17 @@ class ModelerHomePage {
         // Hub's design-system shell renders the app header as a role=banner with no
         // accessible name after the Camunda Hub rebrand, so the classic
         // name-matched banner no longer resolves; the Modeler logo link inside it
-        // still carries "Camunda Modeler home". Keep the legacy named-banner branch
-        // for shells where the rename has not shipped yet.
+        // carries "Camunda Hub home" when the org has workspacesEnabled, else
+        // "Camunda Modeler home" (camunda-hub NavShellDs.common.tsx) -- match
+        // either. Keep the legacy named-banner branch for shells where the rename
+        // has not shipped yet.
         this.modelerPageBanner = page
             .getByRole('banner', {
             name: 'Camunda Modeler',
         })
+            .or(page
+            .getByRole('link', { name: 'Camunda Hub home' })
+            .and(page.locator(':not([href$="/login"])')))
             .or(page
             .getByRole('link', { name: 'Camunda Modeler home' })
             .and(page.locator(':not([href$="/login"])')))
@@ -83,6 +98,24 @@ class ModelerHomePage {
             name: 'Create project',
             exact: true,
         }));
+        // Camunda Hub, which replaced Console + Web Modeler on SaaS, tops the
+        // hierarchy with a Workspaces overview whose "Create workspace" CTA opens a
+        // wizard (General -> Members) that names the workspace up front. Same
+        // hooks as pages/SM-8.10/ModelerHomePage.ts. exact:true keeps the split
+        // button's options chevron out of the match.
+        this.createWorkspaceButton = page.getByRole('button', {
+            name: 'Create workspace',
+            exact: true,
+        });
+        this.workspaceWizardNameInput = page.locator('#workspace-name');
+        this.workspaceWizardSubmitButton = page.locator('[data-test="workspace-wizard-submit"]');
+        this.workspaceWizardMembersStep = page.locator('[data-test="step-members"]');
+        // When the org has environments enabled, an "Assign environments" step is
+        // inserted after Members -- camunda-hub's own
+        // e2e-playwright/pages/CreateWorkspacePage.ts detects it the same way.
+        this.workspaceWizardEnvironmentsHeading = page.getByRole('heading', {
+            name: 'Assign environments',
+        });
         this.projectNameInput = page.locator('[data-test="editable-input"]');
         this.formNameInput = page.locator('[data-test="editable-input"]');
         this.idpApplicationNameInput = page.getByPlaceholder('New IDP Application');
@@ -121,10 +154,13 @@ class ModelerHomePage {
         // than one project with this name — an unscoped by-title match throws a
         // strict-mode violation the moment a duplicate exists, which fails every
         // later run in that org rather than just the run that created it.
+        // On the Camunda Hub Workspaces overview the folder is a workspace tile
+        // whose "Open workspace <name>" button navigates into it.
         this.crossComponentProjectFolder = page
-            .getByTitle(this.defaultFolderName, {
+            .getByRole('button', { name: `Open workspace ${this.defaultFolderName}` })
+            .or(page.getByTitle(this.defaultFolderName, {
             exact: true,
-        })
+        }))
             .first();
         this.rows = page.getByRole('row');
         this.uploadFilesButton = page.getByRole('menuitem', { name: 'Upload files' });
@@ -582,7 +618,83 @@ class ModelerHomePage {
             .then(() => true)
             .catch(() => false);
     }
+    // Drives Camunda Hub's workspace-creation wizard. The name is entered on
+    // the General step, which enables "Next"; the same submit button then
+    // relabels itself through the remaining steps and finally reads "Create
+    // workspace" once it creates the workspace and routes the creator into its
+    // projects listing. Gate the Members-step click on that step becoming
+    // active so the shared submit button is not clicked twice while still on
+    // General.
+    async createWorkspaceViaWizard(name) {
+        await this.dismissOverlays();
+        await this.createWorkspaceButton.click({ timeout: 60000 });
+        await this.workspaceWizardNameInput.fill(name, { timeout: 60000 });
+        await this.workspaceWizardSubmitButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.workspaceWizardMembersStep).toHaveAttribute('data-state', 'active', { timeout: 30000 });
+        await this.workspaceWizardSubmitButton.click({ timeout: 60000 });
+        // When the org has environments enabled, this only advances the wizard
+        // into an "Assign environments" step instead of submitting. Assign the
+        // suite's default cluster here rather than submitting with an empty
+        // selection -- otherwise this shared workspace starts with no
+        // environments and every downstream spec that deploys to it needs its
+        // own manual assignment first. Each card's accessible name is
+        // "Select <cluster name>" before it is picked (camunda-hub's own
+        // create-workspace-environments.spec.tsx asserts the same pattern).
+        // isVisible() only samples the current state -- if the wizard's step
+        // transition hasn't rendered yet at that exact instant, this would
+        // wrongly conclude the org has no environments step and immediately
+        // wait for the post-submit URL while the wizard is actually still open
+        // (mid-transition), timing out every workspace creation. Give the step
+        // transition a bounded wait instead of an instantaneous probe.
+        if (await this.becameVisible(this.workspaceWizardEnvironmentsHeading, 5000)) {
+            // "Create Default Cluster" runs in parallel with this flow
+            // (test-setup.spec.ts's mode: 'parallel'), so the cluster this picker
+            // lists may still be provisioning -- wait for it a generous 90s rather
+            // than sampling once. If it genuinely never appears (the cluster
+            // failed rather than just being slow), don't fail the whole shared
+            // workspace's setup over it: Hub's own recovery copy for this step
+            // ("Could not load environments. You can finish creating the
+            // workspace and assign them later.") confirms submitting unassigned
+            // is a supported, recoverable path, not a broken one.
+            const clusterOption = this.page.getByRole('button', {
+                name: new RegExp(`^Select ${this.defaultClusterName}`),
+            });
+            if (await this.becameVisible(clusterOption, 90000)) {
+                await clusterOption.click({ timeout: 10000 });
+            }
+            else {
+                console.warn(`"${this.defaultClusterName}" was not selectable on the Environments step; creating the workspace without it.`);
+            }
+            await this.workspaceWizardSubmitButton.click({ timeout: 60000 });
+        }
+        await this.page.waitForURL(/\/workspaces?\/[^/]+\/projects/, {
+            timeout: 120000,
+        });
+    }
     async clickHomeBreadcrumb() {
+        // Camunda Hub has no Modeler home breadcrumb: its home is the Workspaces
+        // overview, reached through the header logo link so the SPA keeps its
+        // in-memory session (a full navigation re-runs the whole Auth0 hand-off).
+        // The link's accessible name is "Camunda Hub home" when the org has
+        // workspacesEnabled, else "Camunda Modeler home" (camunda-hub
+        // NavShellDs.common.tsx) -- match either.
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            // The authenticated header can still expose this same link with its
+            // href pointed at /login while the header is mid-update (same race
+            // modelerPageBanner already guards against) -- clicking it then sends
+            // the flow back through Auth0 and drops the session.
+            await this.page
+                .locator('header[data-slot="app-header"]')
+                .getByRole('link', { name: 'Camunda Hub home' })
+                .and(this.page.locator(':not([href$="/login"])'))
+                .or(this.page
+                .locator('header[data-slot="app-header"]')
+                .getByRole('link', { name: 'Camunda Modeler home' })
+                .and(this.page.locator(':not([href$="/login"])')))
+                .first()
+                .click({ timeout: 30000 });
+            return;
+        }
         try {
             await this.homeBreadcrumb.click();
         }
@@ -649,38 +761,112 @@ class ModelerHomePage {
             },
         });
     }
-    async createCrossComponentProjectFolder() {
-        await this.dismissOverlays();
-        // The projects list renders asynchronously, so an instantaneous
-        // isVisible() reports "missing" whenever the list is still loading — and
-        // this method then creates a SECOND project with the same name. Those
-        // duplicates are permanent and break every subsequent run for that user,
-        // so wait for the folder to actually show up before concluding it is
-        // absent (this also replaces the blind 15s sleep the check relied on).
-        const folderExists = await this.crossComponentProjectFolder
-            .waitFor({ state: 'visible', timeout: 60000 })
-            .then(() => true)
-            .catch(() => false);
-        if (folderExists) {
-            console.log('Cross Component Project folder already exists. Clicking into it');
-            await this.clickCrossComponentProjectFolder();
-            return;
+    // Hub's "Create workspace" CTA is a persistent toolbar button, rendered
+    // regardless of whether the existing-workspaces list has finished loading
+    // -- so a single slow or failed list fetch must not be read as "no
+    // workspace exists yet". Retry the wait once after a reload before
+    // concluding the folder is genuinely absent, since creating one when it
+    // already exists (just hadn't rendered) leaves a permanent duplicate that
+    // breaks every later run for that user.
+    async waitForCrossComponentProjectFolder() {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const found = await this.crossComponentProjectFolder
+                .waitFor({ state: 'visible', timeout: 60000 })
+                .then(() => true)
+                .catch(() => false);
+            if (found)
+                return true;
+            if (attempt === 0) {
+                await this.page.reload();
+                await this.page.waitForLoadState('networkidle').catch(() => { });
+            }
         }
-        await this.clickCreateNewProjectButton();
-        await this.enterNewProjectName(this.defaultFolderName);
-        // Both branches must leave the browser inside the workspace: the callers
-        // go straight on to clickDiagramTypeDropdown(), whose create control only
-        // exists there. Creating normally navigates into the new project, but when
-        // hub leaves the browser on the projects list the rename happens in the row
-        // and no navigation follows.
-        //
-        // Keyed on "New project", which hub renders only on the projects list and
-        // never inside an open project, so it answers which view we are on
-        // directly. The folder tile is the wrong signal: on a slow list render it
-        // is still absent, which would read as "already inside" and skip a hop
-        // that was needed.
-        if (await this.becameVisible(this.createNewProjectButton, 5000)) {
-            await this.clickCrossComponentProjectFolder();
+        return false;
+    }
+    // Retries the whole detect-or-create sequence, not just its individual
+    // steps. Up to 27 test-user workers race to create/open this one shared
+    // workspace concurrently, and a losing worker can land on a workspace-root
+    // page that never finishes rendering (neither the folder tile nor a create
+    // control ever becomes visible) for reasons the per-step probes/reloads
+    // below cannot resolve on their own -- each step bounds itself, but their
+    // sum does not bound the whole method, and a single unlucky pass used to
+    // run long enough to hit the 12-minute test timeout outright (run
+    // 36110457453 lost 6 "Create Project Folder" tests this way, pending
+    // inside a reload with no error of its own -- the test timeout fired
+    // first). Mirrors the 8.9 sibling's outer retry loop, which this method
+    // lost when it grew its own per-step reload-retries in place of it.
+    async createCrossComponentProjectFolder() {
+        const maxAttempts = 3;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            await this.dismissOverlays();
+            // The projects list renders asynchronously, so an instantaneous
+            // isVisible() reports "missing" whenever the list is still loading — and
+            // this method then creates a SECOND project with the same name. Those
+            // duplicates are permanent and break every subsequent run for that user,
+            // so wait for the folder to actually show up before concluding it is
+            // absent (this also replaces the blind 15s sleep the check relied on).
+            // Re-checked on every attempt: a sibling worker may finish creating the
+            // folder while this one is retrying.
+            const folderExists = await this.waitForCrossComponentProjectFolder();
+            if (folderExists) {
+                console.log('Cross Component Project folder already exists. Clicking into it');
+                await this.clickCrossComponentProjectFolder();
+                return;
+            }
+            try {
+                // Same joint-probe pattern as clickCreateProcessApplication above: a
+                // single ORed probe with a generous timeout settles which shell
+                // actually rendered (Hub's "Create workspace" empty state vs. the
+                // legacy "New project" / "Create project" button) before a short
+                // confirmation decides the branch. A live CI trace showed probing
+                // createWorkspaceButton alone for 5s racing Hub's slower loads under
+                // worker contention: the probe reported "absent" on a workspaces
+                // overview that was merely still loading, sending the flow down the
+                // legacy branch -- which that overview never renders.
+                const rootLoaded = await this.becameVisible(this.createWorkspaceButton.or(this.createNewProjectButton).first(), 60000);
+                if (!rootLoaded) {
+                    // Mirrors clickCreateProcessApplication's own reload-retry: a reload
+                    // gives one more 60s window in case the root was still loading
+                    // rather than genuinely absent, instead of committing to the wrong
+                    // branch.
+                    await this.page.reload();
+                    await this.page.waitForLoadState('domcontentloaded');
+                    await this.becameVisible(this.createWorkspaceButton.or(this.createNewProjectButton).first(), 60000);
+                }
+                if (await this.becameVisible(this.createWorkspaceButton, 5000)) {
+                    await this.createWorkspaceViaWizard(this.defaultFolderName);
+                    return;
+                }
+                await this.clickCreateNewProjectButton();
+                await this.enterNewProjectName(this.defaultFolderName);
+                // Both branches must leave the browser inside the workspace: the
+                // callers go straight on to clickDiagramTypeDropdown(), whose create
+                // control only exists there. Creating normally navigates into the new
+                // project, but when hub leaves the browser on the projects list the
+                // rename happens in the row and no navigation follows.
+                //
+                // Keyed on "New project", which hub renders only on the projects list
+                // and never inside an open project, so it answers which view we are
+                // on directly. The folder tile is the wrong signal: on a slow list
+                // render it is still absent, which would read as "already inside" and
+                // skip a hop that was needed.
+                if (await this.becameVisible(this.createNewProjectButton, 5000)) {
+                    await this.clickCrossComponentProjectFolder();
+                }
+                return;
+            }
+            catch (error) {
+                if (attempt >= maxAttempts - 1) {
+                    throw error;
+                }
+                // The stuck-root case above, or a wizard/rename step that threw, can
+                // leave the browser on a half-loaded or errored page that retrying
+                // in place cannot recover from. Return Home so the next attempt's
+                // existence check starts clean, instead of retrying against the same
+                // stuck page.
+                await this.clickHomeBreadcrumb().catch(() => { });
+                console.log(`createCrossComponentProjectFolder attempt ${attempt + 1} failed; retrying...`);
+            }
         }
     }
     async clickManageButton(retries = 3) {

package/dist/pages/8.10/UtilitiesPage.js

@@ -10,6 +10,7 @@ const authErrorClassification_1 = require("../../utils/authErrorClassification")
 const LoginPage_1 = require("./LoginPage");
 const fileUpload_1 = require("../../utils/fileUpload");
 const mailSlurpClient_1 = require("../../utils/mailSlurpClient");
+const consoleApiHelpers_1 = require("../../utils/consoleApiHelpers");
 async function clearWebStorage(page) {
     await page
         .evaluate(() => {
@@ -101,6 +102,27 @@ async function waitForLoginForm(page, loginPage, totalTimeout = 90000, roundTime
 // stagger sleep below, so a worker only pays it once per process lifetime
 // rather than on every call -- see the comment at the call site.
 const staggeredWorkerTimeouts = new Set();
+const onboardingTourSuppressed = new WeakSet();
+// Mirrors camunda-hub@452978f: pre-seed the onboarding tour's "seen" localStorage flag
+// (SEEN_KEY_PREFIX in .../tour-dialog/use-onboarding-seen.ts) so it never auto-opens. The
+// "Welcome to Camunda Hub" tour mounts app-wide -- Console included, not just Modeler -- and
+// hides the post-login shell from the accessibility tree until dismissed, which times out
+// assertTestUsesCorrectOrganization's banner check. addInitScript runs before any page
+// script on every navigation/reload, so there's no login-response race to lose; the flag is
+// matched by prefix since the user id isn't known ahead of login.
+async function suppressOnboardingTour(page) {
+    if (onboardingTourSuppressed.has(page)) {
+        return;
+    }
+    onboardingTourSuppressed.add(page);
+    await page.addInitScript((prefixPattern) => {
+        const pattern = new RegExp(prefixPattern);
+        const originalGetItem = Storage.prototype.getItem;
+        Storage.prototype.getItem = function (key) {
+            return pattern.test(key) ? 'true' : originalGetItem.call(this, key);
+        };
+    }, '^hub\\.onboarding\\..*\\.seen\\.');
+}
 async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5) {
     // A blank credential is not something retrying can fix, and from inside the
     // browser it does not look like a credential problem at all: the form takes
@@ -131,6 +153,7 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
             '"Skip output ... since it may contain secret" warning on the ' +
             'matching C8_*_PASSWORD output.');
     }
+    await suppressOnboardingTour(page);
     let lastError;
     // `timeout` is a stable per-worker identifier (derived from workerIndex),
     // and a worker is a long-lived process across every test/repeat it runs, so
@@ -142,6 +165,11 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
             await page.context().clearCookies();
+            // The Hub bearer-token cache in consoleApiHelpers.ts is keyed by Page
+            // for the tab's whole lifetime; without clearing it here alongside
+            // cookies/storage, a flow that logs a different user into the same
+            // page could have getUserToken() return the PREVIOUS user's token.
+            (0, consoleApiHelpers_1.resetHubBearerToken)(page);
             await page.goto('about:blank');
             await page
                 .evaluate(() => {
@@ -196,6 +224,17 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
         }
         catch (error) {
             lastError = error;
+            // A rejected password or a blocked account is a credential/
+            // provisioning-level failure, not a transient one: every attempt
+            // resubmits the same env-supplied credentials, so retrying just
+            // reproduces the same rejection up to maxRetries times (observed:
+            // ~6 minutes burned across 5 identical "Wrong email or password"
+            // cycles for one seeded user). Fail on the first rejection instead.
+            if (String(error).includes(authErrorClassification_1.AUTH0_INVALID_CREDENTIALS) ||
+                String(error).includes(authErrorClassification_1.AUTH0_ACCOUNT_BLOCKED)) {
+                console.error(lastError);
+                throw lastError;
+            }
             if (attempt < maxRetries - 1) {
                 const rateLimited = String(error).includes(authErrorClassification_1.AUTH0_RATE_LIMIT);
                 console.warn(`Attempt ${attempt + 1} failed for logging in. Retrying with clean session...`, error);
@@ -731,8 +770,12 @@ async function assertTestUsesCorrectOrganization(page) {
     const homePage = new HomePage_1.HomePage(page);
     if (page.url().includes('?code=') || page.url().includes('&state=')) {
         console.log('OAuth callback detected, waiting for redirect...');
+        // Camunda Hub (which replaced Console on SaaS) only exchanges the code
+        // once its SPA has booted, and on CI runners that boot alone was measured
+        // at ~45s past /login-callback -- a 30s wait aborted the exchange on every
+        // attempt.
         await page.waitForURL((url) => !url.toString().includes('?code='), {
-            timeout: 30000,
+            timeout: 120000,
         });
         await (0, sleep_1.sleep)(5000);
     }
@@ -742,7 +785,20 @@ async function assertTestUsesCorrectOrganization(page) {
         await (0, test_1.expect)(homePage.modelerBanner).toBeVisible({ timeout: 30000 });
     }
     else {
-        await (0, test_1.expect)(homePage.consoleBanner).toBeVisible({ timeout: 60000 });
+        await (0, test_1.expect)(homePage.consoleBanner.or(homePage.hubHeader)).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    // Camunda Hub replaces Console on SaaS (8.10 release notes), and the Hub
+    // shell has neither the "Camunda logo Console" link nor the "Open
+    // Organizations" switcher, and lands on /workspaces without the org id in
+    // the URL. Its sidebar scopes the Clusters/Organization links to the active
+    // org, so assert the expected org id there instead.
+    if (await homePage.hubHeader.isVisible()) {
+        await (0, test_1.expect)(homePage.hubSidebar
+            .locator(`a[href*="/org/${process.env.ORG_ID}/"]`)
+            .first()).toBeVisible({ timeout: 180000 });
+        return;
     }
     await (0, test_1.expect)(homePage.openOrganizationButton).toBeVisible({ timeout: 180000 });
     try {

package/dist/pages/8.7/AppsPage.js

@@ -81,6 +81,40 @@ class AppsPage {
     // (see clickHubClusterApp and isHubClusterAppPresent below) gets at most
     // one match, scoped to this cluster.
     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.
+        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 });
+            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
@@ -101,9 +135,13 @@ class AppsPage {
         // 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.
-        const toggle = this.hubSidebar
-            .getByRole('button', { name: clusterName, exact: true })
-            .first();
+        // 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
@@ -125,10 +163,14 @@ class AppsPage {
         // 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 an exact match on clusterName.
+        // 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)}$).+$`),
+            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
@@ -151,12 +193,15 @@ class AppsPage {
         // match carries no ambiguity risk.
         const appLink = this.hubAppLink(clusterName, appName);
         await (0, test_1.expect)(appLink).toBeVisible({ timeout: 30000 });
-        // With Hub environments enabled the sidebar lists environments, whose
-        // app links open in a new tab ("Operate in <env> (opens in a new tab)").
-        // Callers assert the app on this page, so follow the link here instead.
+        // 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 appLink.getAttribute('target')) === '_blank') {
-            await this.page.goto(href, { waitUntil: 'domcontentloaded' });
+            await this.page.goto(new URL(href, this.page.url()).toString(), {
+                waitUntil: 'domcontentloaded',
+            });
             return;
         }
         await appLink.click({ timeout: 10000 });
@@ -164,11 +209,18 @@ class AppsPage {
     // Inline (expanded rail) the app link carries the app's name. The rail can
     // also start collapsed (camunda-hub seeds SidebarProvider's defaultExpanded
     // from whether its items had loaded at first render); the group toggle then
-    // opens a flyout portalled outside "Main navigation", whose links -- like
-    // environment rows' -- are named "<app> in <cluster>".
+    // opens a Radix popover -- a role="dialog" labelled with the cluster name
+    // and portalled OUTSIDE "Main navigation" -- whose links are plainly named.
+    // With Hub's Environments feature on, the sidebar instead lists
+    // environments whose app links render inline but are named
+    // "<app> in <cluster>" (opens in a new tab). Try the expanded-sidebar
+    // layout first, then each of these fallbacks.
     hubAppLink(clusterName, appName) {
         return this.hubSidebar
             .getByRole('link', { name: appName })
+            .or(this.page
+            .getByRole('dialog', { name: clusterName, exact: true })
+            .getByRole('link', { name: appName }))
             .or(this.page.getByRole('link', {
             name: new RegExp(`^${escapeRegExp(appName)} in ${escapeRegExp(clusterName)}\\b`),
         }))
@@ -182,6 +234,8 @@ class AppsPage {
     // rather than a disabled control -- so this never throws on a miss.
     async isHubClusterAppPresent(clusterName, appName) {
         await this.expandHubClusterGroup(clusterName);
+        // Same collapsed-sidebar popover / environment-row fallbacks as
+        // clickHubClusterApp -- see hubAppLink.
         const appLink = this.hubAppLink(clusterName, appName);
         return appLink.isVisible({ timeout: 10000 }).catch(() => false);
     }

package/dist/pages/8.7/ClusterPage.js

@@ -79,28 +79,27 @@ class ClusterPage {
             exact: true,
         });
         this.generationSearchInput = page.getByPlaceholder('Search generations');
-        this.g3DevClusterType = page.locator('label').filter({
-            hasText: this.defaultClusterType,
-        });
-        this.alphaTab = page.getByRole('tab', { name: 'Alpha' });
-        this.devTab = page.getByRole('tab', { name: 'Internal Dev' });
-        this.stableTab = page.getByRole('tab', { name: 'Stable' });
-        this.qaGenerationsTab = page.getByRole('tab', { name: 'QA Generations' });
-        this.gcpRegion = page.getByRole('tab', {
-            name: 'GCP',
-        });
-        this.belgiumRegion = page.locator('label').filter({
+        // Camunda Hub's create-cluster form replaced the Carbon tiles (a <label>
+        // per option) and tabs with design-system choice cards and toggle
+        // groups, all exposed as role="radio" named by their title. Each locator
+        // below accepts either shape via this helper.
+        const choice = (legacy, name) => legacy.or(page.getByRole('radio', { name, exact: true }));
+        this.g3DevClusterType = choice(page.locator('label').filter({ hasText: this.defaultClusterType }), this.defaultClusterType);
+        this.alphaTab = choice(page.getByRole('tab', { name: 'Alpha' }), 'Alpha');
+        this.devTab = choice(page.getByRole('tab', { name: 'Internal Dev' }), 'Internal Dev');
+        this.stableTab = choice(page.getByRole('tab', { name: 'Stable' }), 'Stable');
+        this.qaGenerationsTab = choice(page.getByRole('tab', { name: 'QA Generations' }), 'QA Generations');
+        this.gcpRegion = choice(page.getByRole('tab', { name: 'GCP' }), 'GCP');
+        this.belgiumRegion = choice(page.locator('label').filter({
             hasText: 'Chaos, Belgium, Europe (europe-west1)',
-        });
-        this.finlandRegion = page.locator('label').filter({
+        }), 'Chaos, Belgium, Europe (europe-west1)');
+        this.finlandRegion = choice(page.locator('label').filter({
             hasText: 'Finland, Europe (europe-north1)',
-        });
-        this.londonRegion = page.locator('label').filter({
-            hasText: 'London, Europe (europe-west2)',
-        });
-        this.ohioRegion = page.locator('label').filter({
+        }), 'Finland, Europe (europe-north1)');
+        this.londonRegion = choice(page.locator('label').filter({ hasText: 'London, Europe (europe-west2)' }), 'London, Europe (europe-west2)');
+        this.ohioRegion = choice(page.locator('label').filter({
             hasText: 'Ohio, North America (us-east-2)',
-        });
+        }), 'Ohio, North America (us-east-2)');
         this.clustersList = page
             .getByRole('row')
             .filter({ hasNotText: 'Generation' }); //Filter out header row
@@ -239,7 +238,10 @@ class ClusterPage {
         await this.clickClusterNameInput();
         await this.fillClusterNameInput(name);
         await this.clickClusterType();
-        await this.page.getByRole('tab', { name: region }).click();
+        await this.page
+            .getByRole('tab', { name: region })
+            .or(this.page.getByRole('radio', { name: region, exact: true }))
+            .click();
         await this.selectSubRegion(region);
         await this.clickClusterOption(process.env.CLUSTER_VERSION);
         await this.clickCreateClusterButton();