@camunda/e2e-test-suite 0.0.1252 → 0.0.1254

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.d.ts

@@ -20,6 +20,7 @@ declare class AppsPage {
     clickCluster(component: Locator, name: string): Promise<void>;
     private expandHubClusterGroup;
     private clickHubClusterApp;
+    private hubAppLink;
     isHubClusterAppPresent(clusterName: string, appName: string): Promise<boolean>;
     clickModeler(): Promise<void>;
     clickTasklist(clusterName: string): Promise<void>;

package/dist/pages/8.7/AppsPage.js

@@ -149,12 +149,31 @@ class AppsPage {
         // additional content from the design-system sidebar item, e.g. an icon
         // or badge). The five app names are distinct enough that a substring
         // match carries no ambiguity risk.
-        const appLink = this.hubSidebar.getByRole('link', {
-            name: appName,
-        });
+        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.
+        const href = await appLink.getAttribute('href');
+        if (href && (await appLink.getAttribute('target')) === '_blank') {
+            await this.page.goto(href, { waitUntil: 'domcontentloaded' });
+            return;
+        }
         await appLink.click({ timeout: 10000 });
     }
+    // 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>".
+    hubAppLink(clusterName, appName) {
+        return this.hubSidebar
+            .getByRole('link', { name: appName })
+            .or(this.page.getByRole('link', {
+            name: new RegExp(`^${escapeRegExp(appName)} in ${escapeRegExp(clusterName)}\\b`),
+        }))
+            .first();
+    }
     // Checks whether an app link is present inside the requested cluster's Hub
     // sidebar group, without clicking it. Unlike clickHubClusterApp, absence is
     // an expected, valid outcome here -- this is how callers assert per-cluster
@@ -163,7 +182,7 @@ class AppsPage {
     // rather than a disabled control -- so this never throws on a miss.
     async isHubClusterAppPresent(clusterName, appName) {
         await this.expandHubClusterGroup(clusterName);
-        const appLink = this.hubSidebar.getByRole('link', { name: appName });
+        const appLink = this.hubAppLink(clusterName, appName);
         return appLink.isVisible({ timeout: 10000 }).catch(() => false);
     }
     async clickModeler() {

package/dist/pages/8.7/ClusterDetailsPage.js

@@ -78,9 +78,15 @@ class ClusterDetailsPage {
             .locator('label')
             .filter({ hasText: /^Secrets$/ });
         this.createButton = page.getByRole('button', { name: 'Create', exact: true });
+        // The Hub shell's dialog names its close button through visually hidden
+        // text rather than an aria-label, which getByLabel does not see.
         this.closeModalButton = page
             .getByRole('dialog', { name: 'Client credentials', exact: true })
-            .getByLabel('Close');
+            .getByRole('button', { name: 'Close', exact: true })
+            .or(page
+            .getByRole('dialog', { name: 'Client credentials', exact: true })
+            .getByLabel('Close'))
+            .first();
         this.createClientButton = page.getByRole('button', {
             name: 'Create new Client',
         });
@@ -446,7 +452,13 @@ class ClusterDetailsPage {
             timeout: 20000,
         });
         await (0, test_1.expect)(this.clientCredentialsDialog.getByText('The Client Secret will not be shown again.')).toBeVisible();
-        await (0, test_1.expect)(this.clientRow(name)).toContainText('Zeebe, Tasklist, Operate, Optimize, and Secrets');
+        // The Hub shell's credentials dialog is modal and marks the page behind it
+        // aria-hidden, so the new client's row is out of the accessibility tree
+        // until it closes -- include hidden rows to check its scopes meanwhile.
+        await (0, test_1.expect)(this.page
+            .getByRole('row', { includeHidden: true })
+            .filter({ hasNotText: 'Scopes' })
+            .filter({ hasText: name })).toContainText('Zeebe, Tasklist, Operate, Optimize, and Secrets');
     }
     async clickEnvVarsButton() {
         await (0, test_1.expect)(this.envVarsTab).toBeVisible({ timeout: 40000 });

package/dist/pages/8.7/ClusterPage.js

@@ -144,6 +144,14 @@ class ClusterPage {
         }
     }
     async deleteCluster(name) {
+        // A full reload in the Hub shell bounces through /login, the identity
+        // provider and /login-callback (~35s) before the SPA pushes its returnUrl
+        // back to /clusters. Counting rows mid-bounce throws "Execution context
+        // was destroyed", so wait for the clusters page to have settled first.
+        await this.page.waitForURL((url) => /\/clusters\/?$/.test(url.pathname), {
+            timeout: 120000,
+        });
+        await (0, test_1.expect)(this.createNewClusterButton).toBeVisible({ timeout: 60000 });
         const clusterInstance = this.cluster(name).first();
         if ((await clusterInstance.count()) <= 0) {
             console.log(`No clusters found with name ${name}, skipping deletion.`);

package/dist/pages/8.7/ConnectorMarketplacePage.d.ts

@@ -8,6 +8,7 @@ declare class ConnectorMarketplacePage {
     readonly addToProjectButton: Locator;
     readonly cancelButton: Locator;
     readonly closeButton: Locator;
+    readonly browseAllMarketplaceDetailsButton: Locator;
     constructor(page: Page);
     clickSearchForConnectorTextbox(): Promise<void>;
     fillSearchForConnectorTextbox(connectorName: string): Promise<void>;

package/dist/pages/8.7/ConnectorMarketplacePage.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorMarketplacePage = void 0;
+const test_1 = require("@playwright/test");
 class ConnectorMarketplacePage {
     page;
     searchForConnectorTextbox;
@@ -10,9 +11,22 @@ class ConnectorMarketplacePage {
     addToProjectButton;
     cancelButton;
     closeButton;
+    browseAllMarketplaceDetailsButton;
     constructor(page) {
         this.page = page;
-        this.searchForConnectorTextbox = page.getByPlaceholder('Search for a connector');
+        // The legacy marketplace modal, or camunda-hub's "Browse all" dialog
+        // (2026-09-23), which lists Marketplace connectors alongside the
+        // diagram's own elements and reusable assets.
+        this.searchForConnectorTextbox = page
+            .getByPlaceholder('Search for a connector')
+            .or(page.locator('#browse-all-search'))
+            .first();
+        // A Browse all Marketplace card opens its review step ("Add to project")
+        // through this button; self-hosted connectors only link to setup docs.
+        this.browseAllMarketplaceDetailsButton = page
+            .getByRole('list', { name: 'Marketplace connectors' })
+            .getByRole('button', { name: /^View details for .+ from Marketplace$/ })
+            .first();
         this.downloadToProjectButton = page
             .getByRole('button', { name: 'Download to project' })
             .first();
@@ -42,7 +56,15 @@ class ConnectorMarketplacePage {
         await this.replaceResourceButton.click({ timeout: 60000 });
     }
     async downloadConnectorToProject() {
-        await this.clickDownloadToProjectButton();
+        await (0, test_1.expect)(this.downloadToProjectButton
+            .or(this.browseAllMarketplaceDetailsButton)
+            .first()).toBeVisible({ timeout: 60000 });
+        if (await this.downloadToProjectButton.isVisible()) {
+            await this.clickDownloadToProjectButton();
+        }
+        else {
+            await this.browseAllMarketplaceDetailsButton.click({ timeout: 30000 });
+        }
         let imported = false;
         // A fresh download shows "Add to project"; an already-present resource
         // shows "Replace resource". Pick whichever the ImportModal rendered —

package/dist/pages/8.7/ConsoleOrganizationPage.js

@@ -515,6 +515,17 @@ class ConsoleOrganizationPage {
         // to actually drop before targeting the next row: clicking a delete button
         // while its row is being removed detaches the element from the DOM and the
         // click never lands (retries against a continuously re-rendering table).
+        //
+        // The table fetches its rows after the tab renders, so sampling the count
+        // straight away read 0 while the previous run's groups were still loading
+        // -- they were left in place and re-creating them failed "name:duplicate".
+        // Give existing rows the chance to render before counting.
+        await (0, test_1.expect)(this.createGroupButton).toBeVisible({ timeout: 60000 });
+        await this.deleteButton
+            .first()
+            .waitFor({ state: 'visible', timeout: 20000 })
+            .then(() => true)
+            .catch(() => false);
         let remaining = await this.deleteButton.count();
         while (remaining > 0) {
             await this.deleteButton.first().click({ timeout: 60000 });