@camunda/e2e-test-suite 0.0.1272 → 0.0.1274

package/dist/pages/8.9/ProcessApplicationPage.js

@@ -266,7 +266,19 @@ class ProcessApplicationPage {
         // suite is. Re-navigating is the recovery; waiting longer on a page that
         // has already gone wrong is not, which is why the inner timeouts stay
         // short. A genuinely unbindable cluster still fails, with the same error.
+        //
+        // Under Hub workspaces (/workspaces/<ws>/projects/<id>) there is no
+        // /connected-clusters route -- it renders "No match for the current
+        // location". With Hub's Environments feature on (camunda-hub#29210),
+        // WorkspaceProjectDetail hides the Connected clusters card altogether and
+        // the deploy dialog offers the environments assigned to the parent
+        // workspace instead, so the binding is made there.
+        const workspaceId = paUrl.match(/\/workspaces\/([^/]+)\/projects\//)?.[1];
         await (0, test_1.expect)(async () => {
+            if (workspaceId) {
+                await this.ensureWorkspaceEnvironment(paUrl, workspaceId, clusterName);
+                return;
+            }
             await this.page.goto(`${paUrl}/connected-clusters`, {
                 waitUntil: 'domcontentloaded',
             });
@@ -277,6 +289,90 @@ class ProcessApplicationPage {
         await this.page.goto(returnTo, { waitUntil: 'domcontentloaded' });
         return true;
     }
+    // Assigns the Environment backed by clusterName to the workspace, from
+    // workspace management's Environments tab (camunda-hub
+    // WorkspaceEnvironmentsTab). Without the Environments feature the project
+    // page still carries the Connected clusters card, whose "Configure" button
+    // opens the Define stages dialog -- that path is taken instead.
+    //
+    // Save replaces the workspace's whole assignment with the picker's
+    // selection, and parallel workers share this workspace, so only this
+    // cluster's toggle is touched and the result re-read afterwards. A
+    // concurrent save that drops it anyway surfaces as a deploy dialog without
+    // the cluster, which forgets the binding and comes back here (see
+    // forgetStageCluster).
+    async ensureWorkspaceEnvironment(paUrl, workspaceId, clusterName) {
+        await this.page.goto(paUrl, { waitUntil: 'domcontentloaded' });
+        await this.waitForProcessApplication();
+        const configure = this.page.getByRole('button', {
+            name: 'Configure',
+            exact: true,
+        });
+        // isVisible() is a point-in-time check: the Connected clusters card can
+        // still be mounting right after waitForProcessApplication resolves, so an
+        // instant read here races the card and can wrongly fall through to the
+        // (possibly unavailable) Environments tab below. Give it the same short
+        // wait the analogous hasEnvironmentRow checks elsewhere in this PR use.
+        const configureAppeared = await configure
+            .waitFor({ state: 'visible', timeout: 10000 })
+            .then(() => true)
+            .catch(() => false);
+        if (configureAppeared) {
+            await configure.click({ timeout: 30000 });
+            await this.defineDevelopmentStage(clusterName);
+            return;
+        }
+        const manageUrl = `${new URL(paUrl).origin}/workspaces/${workspaceId}/manage?tab=environments`;
+        await this.page.goto(manageUrl, { waitUntil: 'domcontentloaded' });
+        const heading = this.page.locator('[data-test="manage-environments-heading"]');
+        if (!(await heading
+            .waitFor({ state: 'visible', timeout: 60000 })
+            .then(() => true)
+            .catch(() => false))) {
+            throw new Error(`Could not bind "${clusterName}" as a deploy target: the project page ` +
+                'has no Connected clusters "Configure" control, and the workspace ' +
+                `Environments tab did not render at ${manageUrl}.`);
+        }
+        const editButton = this.page.locator('[data-test="edit-environments-button"]');
+        await (0, test_1.expect)(editButton).toBeEnabled({ timeout: 60000 });
+        await editButton.click({ timeout: 30000 });
+        const editor = this.page.getByRole('group', {
+            name: 'Edit assigned environments',
+        });
+        await (0, test_1.expect)(editor).toBeVisible({ timeout: 30000 });
+        const search = editor.locator('[data-test="picker-search"]');
+        if (await search.isVisible().catch(() => false)) {
+            await search.fill(clusterName);
+        }
+        // Picker card toggles are named "Select <environment> (<cluster>)" and
+        // flip to "Selected ..." with aria-pressed once picked.
+        const escapedClusterName = clusterName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const toggle = editor
+            .locator('[data-test="picker-environment"]')
+            .getByRole('button', {
+            name: new RegExp(`^Select(ed)? .*\\(${escapedClusterName}\\)$`),
+        })
+            .first();
+        await (0, test_1.expect)(toggle).toBeVisible({ timeout: 60000 });
+        if ((await toggle.getAttribute('aria-pressed')) === 'true') {
+            await this.page
+                .getByRole('button', { name: 'Cancel', exact: true })
+                .click({ timeout: 30000 });
+            await (0, test_1.expect)(editor).toBeHidden({ timeout: 30000 });
+            return;
+        }
+        await toggle.click({ timeout: 30000 });
+        await (0, test_1.expect)(toggle).toHaveAttribute('aria-pressed', 'true');
+        await this.page
+            .getByRole('button', { name: 'Save', exact: true })
+            .click({ timeout: 30000 });
+        await (0, test_1.expect)(editor).toBeHidden({ timeout: 60000 });
+        await (0, test_1.expect)(this.page
+            .getByRole('list', { name: 'Assigned environments' })
+            .getByRole('listitem')
+            .filter({ hasText: clusterName })
+            .first()).toBeVisible({ timeout: 60000 });
+    }
     // The /connected-clusters deep link opens the Define stages dialog by itself
     // while the application has no stage bound. Once one is bound -- a test that
     // deploys to a second cluster -- it has to be reopened from the page, so try

package/dist/pages/8.9/SettingsPage.js

@@ -7,8 +7,18 @@ class SettingsPage {
     logoutButton;
     constructor(page) {
         this.page = page;
-        this.openSettingsButton = page.getByLabel('Open Settings');
-        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+        // The Camunda Hub shell replaces Console's "Open Settings" header button
+        // with the design system's UserMenu, whose trigger carries
+        // data-slot="user-menu-trigger" and whose logout entry is a "Log out"
+        // menuitem (camunda-hub NavShellDs.common.tsx, nav-shell-ds.spec.saas.tsx).
+        this.openSettingsButton = page
+            .getByLabel('Open Settings')
+            .or(page.locator('[data-slot="user-menu-trigger"]'))
+            .first();
+        this.logoutButton = page
+            .getByRole('button', { name: 'Log out' })
+            .or(page.getByRole('menuitem', { name: 'Log out', exact: true }))
+            .first();
     }
     async clickOpenSettingsButton(retries = 3) {
         for (let i = 0; i < retries; i++) {

package/dist/tests/8.8/test-setup.spec.js

@@ -18,7 +18,8 @@ _8_8_1.test.describe('Cluster Setup Tests', () => {
         await (0, _setup_1.captureScreenshot)(page, testInfo);
         await (0, _setup_1.captureFailureVideo)(page, testInfo);
     });
-    (0, _8_8_1.test)('Enable Alpha Features', async ({ page, loginPage, consoleOrganizationsPage, homePage, }, testInfo) => {
+    // Skipped due to bug #29346: https://github.com/camunda/camunda-hub/issues/29346
+    _8_8_1.test.skip('Enable Alpha Features', async ({ page, loginPage, consoleOrganizationsPage, homePage, }, testInfo) => {
         _8_8_1.test.skip(process.env.IS_PROD === 'true', 'Skipping test because not required on PROD test org');
         _8_8_1.test.skip(process.env.IS_AG === 'true', 'Skipping test because not required when IS_AG is true');
         await (0, UtilitiesPage_1.loginWithRetry)(page, loginPage, users_1.testUsers.mainUser, (testInfo.workerIndex + 1) * 1000);
@@ -45,6 +46,14 @@ _8_8_1.test.describe('Cluster Setup Tests', () => {
             await (0, consoleApiHelpers_1.waitForClusterHealthyViaApi)(page, clusterUuid);
             await homePage.clickClusters();
         }
+        // Whichever way the cluster was just created -- through the UI above or via
+        // the API in the else branch -- link it to the suite's shared Hub
+        // workspace: Hub gates deployment on the ENVIRONMENTS assigned to a
+        // workspace, so a cluster the workspace does not list is invisible in every
+        // deploy dialog. A no-op when the workspace does not exist yet (this test
+        // races the workspace-creating ones), which the deploy-time ensure-link
+        // then covers.
+        await (0, consoleApiHelpers_1.linkClusterToSharedWorkspaceViaApi)(page, clusterName);
         await clusterPage.clickClusterLink(clusterName);
         await clusterDetailsPage.assertComponentsHealth();
         // API-client creation is needed whenever this run will also exercise the
@@ -94,6 +103,14 @@ _8_8_1.test.describe('Cluster Setup Tests', () => {
             await (0, consoleApiHelpers_1.waitForClusterHealthyViaApi)(page, clusterUuid, 1500000);
             await homePage.clickClusters();
         }
+        // Whichever way the cluster was just created -- through the UI above or via
+        // the API in the else branch -- link it to the suite's shared Hub
+        // workspace: Hub gates deployment on the ENVIRONMENTS assigned to a
+        // workspace, so a cluster the workspace does not list is invisible in every
+        // deploy dialog. A no-op when the workspace does not exist yet (this test
+        // races the workspace-creating ones), which the deploy-time ensure-link
+        // then covers.
+        await (0, consoleApiHelpers_1.linkClusterToSharedWorkspaceViaApi)(page, clusterName);
         await clusterPage.clickClusterLink(clusterName);
         await clusterDetailsPage.assertComponentsHealth();
         if (process.env.IS_AG !== 'true') {
@@ -107,11 +124,17 @@ _8_8_1.test.describe('Cluster Setup Tests', () => {
                 await (0, UtilitiesPage_1.loginWithRetry)(page, loginPage, user, (testInfo.workerIndex + 1) * 1000);
             });
             await _8_8_1.test.step('Navigate to Web Modeler', async () => {
-                await (0, test_1.expect)(homePage.camundaComponentsButton).toBeVisible({
+                // Camunda Hub replaced Console + Web Modeler on SaaS: it lands on the
+                // Modeler home directly and has no app switcher to wait for.
+                await (0, test_1.expect)(homePage.camundaComponentsButton.or(homePage.hubHeader)).toBeVisible({
                     timeout: 120000,
                 });
-                await appsPage.clickCamundaApps();
-                await appsPage.clickModeler();
+                // Camunda Hub (hub.*) replaced Console + Web Modeler on SaaS and has no
+                // app switcher: its home already is the Modeler home.
+                if (!new URL(page.url()).hostname.startsWith('hub.')) {
+                    await appsPage.clickCamundaApps();
+                    await appsPage.clickModeler();
+                }
                 await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
                     timeout: 180000,
                 });
@@ -120,6 +143,8 @@ _8_8_1.test.describe('Cluster Setup Tests', () => {
                 await homePage.clickSkipCustomization();
                 await modelerHomePage.createCrossComponentProjectFolder();
                 await modelerHomePage.clickHomeBreadcrumb();
+                // Hub resets the overview to "My workspaces" on every load.
+                await modelerHomePage.showAllWorkspaces(10000);
                 // The project-rename PATCH commits on the backend, but navigating to
                 // Home right after can render the SPA's stale (pre-rename) project
                 // list without refetching, so the folder never appears under a plain

package/dist/tests/8.9/console-user-flows.spec.js

@@ -106,6 +106,7 @@ _8_9_1.test.describe('Console User Flow Tests @tasklistV2', () => {
         await _8_9_1.test.step('Create First Email Alert', async () => {
             await clusterDetailsPage.createAlert(true);
             await (0, test_1.expect)(async () => {
+                await clusterDetailsPage.expandAlerts();
                 (0, test_1.expect)(await clusterDetailsPage.alertsList.count()).toBeGreaterThan(1);
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.nth(0)).toContainText(`Email`);
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.nth(1)).toContainText(testUser.username);
@@ -157,6 +158,7 @@ _8_9_1.test.describe('Console User Flow Tests @tasklistV2', () => {
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.first()).toBeVisible({
                     timeout: 20000,
                 });
+                await clusterDetailsPage.expandAlerts();
                 (0, test_1.expect)(await clusterDetailsPage.alertsList.count()).toBeGreaterThan(1);
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.nth(0)).toContainText(`Email`);
                 await clusterDetailsPage.assertAlertText('Amount triggered1');
@@ -196,6 +198,7 @@ _8_9_1.test.describe('Console User Flow Tests @tasklistV2', () => {
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.first()).toBeVisible({
                     timeout: 20000,
                 });
+                await clusterDetailsPage.expandAlerts();
                 (0, test_1.expect)(await clusterDetailsPage.alertsList.count()).toBeGreaterThan(1);
             }).toPass({ timeout: 60000 });
             await clusterDetailsPage.assertAlertText('Amount triggered3');

package/dist/utils/consoleApiHelpers.d.ts

@@ -9,3 +9,8 @@ export declare function waitForClusterHealthyViaApi(page: Page, clusterUuid: str
 export declare function waitForClusterRestartHealthyViaApi(page: Page, clusterUuid: string, timeoutMs?: number): Promise<void>;
 export declare function areAiFeaturesEnabledViaApi(page: Page): Promise<boolean>;
 export declare function waitForAiFeaturesEnabledViaApi(page: Page, timeoutMs?: number): Promise<void>;
+export declare function linkClusterToWorkspaceViaApi(page: Page, workspaceId: string, clusterName: string): Promise<void>;
+export declare function rememberHubWorkspaceId(page: Page, workspaceId: string): void;
+export declare function getHubWorkspaceId(page: Page): string | undefined;
+export declare function linkClusterToSharedWorkspaceViaApi(page: Page, clusterName: string): Promise<void>;
+export declare function ensureClusterLinkedToSharedWorkspace(page: Page, clusterName: string): Promise<void>;

package/dist/utils/consoleApiHelpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForAiFeaturesEnabledViaApi = exports.areAiFeaturesEnabledViaApi = exports.waitForClusterRestartHealthyViaApi = exports.waitForClusterHealthyViaApi = exports.ensureClientAuditLoggingViaApi = exports.ensureTasklistV2Enabled = exports.ensureClusterViaApi = exports.createClusterViaApi = exports.deleteClusterViaApi = exports.resetHubBearerToken = void 0;
+exports.ensureClusterLinkedToSharedWorkspace = exports.linkClusterToSharedWorkspaceViaApi = exports.getHubWorkspaceId = exports.rememberHubWorkspaceId = exports.linkClusterToWorkspaceViaApi = exports.waitForAiFeaturesEnabledViaApi = exports.areAiFeaturesEnabledViaApi = exports.waitForClusterRestartHealthyViaApi = exports.waitForClusterHealthyViaApi = exports.ensureClientAuditLoggingViaApi = exports.ensureTasklistV2Enabled = exports.ensureClusterViaApi = exports.createClusterViaApi = exports.deleteClusterViaApi = exports.resetHubBearerToken = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("./sleep");
 const PLAN_TYPE_ID = '574cde5f-54ae-43c1-851a-e6fb4f03423a';
@@ -169,7 +169,7 @@ const API_WRITE_TIMEOUT_MS = 45000;
 // POST is the only non-idempotent verb used here: repeating it creates a second
 // cluster under the same name. Let its timeout surface instead, so the caller
 // can recover by looking the cluster up by name (see createClusterViaApi).
-const TIMEOUT_RETRYABLE_METHODS = ['GET', 'PATCH', 'DELETE'];
+const TIMEOUT_RETRYABLE_METHODS = ['GET', 'PUT', 'PATCH', 'DELETE'];
 async function clusterApiRequest(page, method, url, data) {
     let response;
     for (let attempt = 1; attempt <= API_MAX_ATTEMPTS; attempt++) {
@@ -751,3 +751,178 @@ async function waitForAiFeaturesEnabledViaApi(page, timeoutMs = 180000) {
         .toBe(true);
 }
 exports.waitForAiFeaturesEnabledViaApi = waitForAiFeaturesEnabledViaApi;
+// Camunda Hub gates deployment on ENVIRONMENTS assigned to the workspace, not
+// on the org's clusters: with the feature on, the deploy modal lists only the
+// workspace's assigned environments, so a cluster created after the workspace
+// exists is invisible there and the picker comes up empty. The wizard's
+// "Assign environments" step only covers a workspace created AFTER its
+// cluster, which the nightly cannot guarantee -- test-setup creates clusters
+// and workspaces in parallel.
+//
+// Endpoints and semantics mirror camunda-hub's own
+// e2e-playwright/api/modeler/EnvironmentsApiClient.ts.
+async function hubApiOrigin(page) {
+    return new URL(page.url()).origin;
+}
+// Every `/api/internal/v2/**` body is wrapped by Hub's
+// `ResponseBodyWrapperAdvice` as `{data, errors}`, so the array lives under
+// `data` -- reading the body directly yielded an object and every array
+// operation on it threw. Mirrors camunda-hub's own `toEnvironments`.
+function toHubEnvironments(body) {
+    const payload = body && typeof body === 'object' && 'data' in body
+        ? body.data
+        : body;
+    const list = Array.isArray(payload) ? payload : [];
+    return list
+        .map((item) => (item ?? {}))
+        .filter((item) => typeof item.id === 'string')
+        .map((item) => ({
+        id: item.id,
+        name: typeof item.name === 'string' ? item.name : '',
+        clusterName: typeof item.clusterName === 'string' ? item.clusterName : '',
+        discoveryState: typeof item.discoveryState === 'string' ? item.discoveryState : '',
+    }));
+}
+async function listOrganizationEnvironments(page) {
+    const origin = await hubApiOrigin(page);
+    const response = await clusterApiRequest(page, 'GET', `${origin}/api/internal/v2/organizations/${encodeURIComponent(process.env.ORG_ID)}/environments`);
+    // 404 means the environments feature is off for this org: there is nothing
+    // to assign and deployment is not gated on it, so callers no-op.
+    if (response.status() === 404) {
+        return null;
+    }
+    return toHubEnvironments(await response.json());
+}
+async function listWorkspaceEnvironments(page, workspaceId) {
+    const origin = await hubApiOrigin(page);
+    const response = await clusterApiRequest(page, 'GET', `${origin}/api/internal/v2/workspaces/${encodeURIComponent(workspaceId)}/environments`);
+    if (!response.ok()) {
+        // NOT an empty list: the caller feeds this into a full-set replace, so
+        // reporting "nothing assigned" for a 401/5xx would unassign every
+        // environment the workspace already had.
+        throw new Error(`Failed to read environments for workspace ${workspaceId}: ` +
+            `${response.status()} ${response.statusText()}`);
+    }
+    return toHubEnvironments(await response.json());
+}
+// Assigns the environment backing `clusterName` to `workspaceId`, keeping the
+// workspace's existing assignments: the PUT is a full-set REPLACE, so sending
+// only the new id would silently unassign every other cluster the suite had
+// already linked (the AWS cluster, a sibling Tasklist-mode project's default).
+async function linkClusterToWorkspaceViaApi(page, workspaceId, clusterName) {
+    const environments = await listOrganizationEnvironments(page);
+    if (environments === null) {
+        console.log('Environments feature is off for this org; leaving the workspace unlinked');
+        return;
+    }
+    const matches = environments.filter((environment) => environment.clusterName === clusterName);
+    // Prefer an ACTIVE environment over a stale NOT_REPORTED duplicate left by
+    // an earlier cluster of the same name.
+    const match = matches.find((environment) => environment.discoveryState === 'ACTIVE') ??
+        matches[0];
+    if (!match) {
+        throw new Error(`No environment backs cluster "${clusterName}"; available: ` +
+            (environments
+                .map((e) => `${e.name}@${e.clusterName} (${e.discoveryState})`)
+                .join(', ') || '<none>'));
+    }
+    const assigned = await listWorkspaceEnvironments(page, workspaceId);
+    if (assigned.some((environment) => environment.id === match.id)) {
+        // Logged rather than returning silently: a quiet no-op here is
+        // indistinguishable from the helper never having run at all, which is
+        // exactly the ambiguity that hid an earlier bug.
+        console.log(`Cluster "${clusterName}" is already linked to workspace ${workspaceId}`);
+        return;
+    }
+    const origin = await hubApiOrigin(page);
+    const url = `${origin}/api/internal/v2/workspaces/${encodeURIComponent(workspaceId)}/environments`;
+    // Read-modify-write against a full-set replace, and test-setup runs its
+    // cluster tests in parallel: two workers can read the same assignment list
+    // and the second PUT then drops the first one's environment. Re-read after
+    // writing and retry when our own id is missing, so a lost update heals
+    // instead of silently removing a cluster from every later deploy dialog.
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        const current = attempt === 1
+            ? assigned
+            : await listWorkspaceEnvironments(page, workspaceId);
+        if (attempt > 1 && current.some((e) => e.id === match.id)) {
+            return;
+        }
+        const ids = [...new Set([...current.map((e) => e.id), match.id])];
+        const response = await clusterApiRequest(page, 'PUT', url, {
+            environmentIds: ids,
+        });
+        if (!response.ok()) {
+            // clusterApiRequest returns non-2xx for non-transient statuses rather
+            // than throwing, so an unchecked call would log success and let the
+            // deploy fail much later with an unrelated-looking empty picker.
+            throw new Error(`Failed to link cluster "${clusterName}" to workspace ${workspaceId}: ` +
+                `${response.status()} ${response.statusText()}`);
+        }
+        const after = await listWorkspaceEnvironments(page, workspaceId);
+        if (after.some((e) => e.id === match.id)) {
+            console.log(`Linked cluster "${clusterName}" (environment ${match.id}) to workspace ${workspaceId}`);
+            return;
+        }
+    }
+    throw new Error(`Cluster "${clusterName}" did not stay linked to workspace ${workspaceId} ` +
+        'after 3 attempts; a concurrent environment replace keeps dropping it');
+}
+exports.linkClusterToWorkspaceViaApi = linkClusterToWorkspaceViaApi;
+// The Hub workspace the suite's shared project lives in. Remembered while the
+// flow is on a /workspaces/<id> path so later steps -- the deploy dialog runs
+// from the form editor, whose path has no workspace segment -- can still
+// address it.
+const hubWorkspaceIds = new WeakMap();
+function rememberHubWorkspaceId(page, workspaceId) {
+    hubWorkspaceIds.set(page, workspaceId);
+}
+exports.rememberHubWorkspaceId = rememberHubWorkspaceId;
+function getHubWorkspaceId(page) {
+    return hubWorkspaceIds.get(page);
+}
+exports.getHubWorkspaceId = getHubWorkspaceId;
+// Resolves the suite's shared Hub workspace by NAME. Needed at cluster-creation
+// time, where there is no /workspaces/<id> page URL to read the id from.
+// Endpoint and payload shape from camunda-hub's own
+// e2e-playwright/api/modeler/WorkspacesApiClient.ts: the list is nested as
+// `{data: {items: [...]}}`, not the bare array the environments routes return.
+const SHARED_HUB_WORKSPACE_NAME = 'Cross Component Test Project';
+async function findHubWorkspaceIdByName(page, name) {
+    const origin = await hubApiOrigin(page);
+    const response = await clusterApiRequest(page, 'GET', `${origin}/api/internal/v2/organizations/${encodeURIComponent(process.env.ORG_ID)}/workspaces?sort=name,asc&offset=0&limit=100`);
+    if (!response.ok()) {
+        return undefined;
+    }
+    const body = (await response.json());
+    const data = (body.data ?? body);
+    const items = Array.isArray(data.items) ? data.items : [];
+    const match = items
+        .map((item) => (item ?? {}))
+        .find((item) => item.name === name && typeof item.id === 'string');
+    return match?.id;
+}
+// Links a just-created cluster to the suite's shared workspace. Safe to call
+// right after creating a cluster by API or through the UI: when the workspace
+// does not exist yet -- test-setup creates clusters and workspaces in parallel,
+// so either order happens -- this logs and returns, and the ensure-link at
+// deploy time covers that case instead.
+async function linkClusterToSharedWorkspaceViaApi(page, clusterName) {
+    const workspaceId = getHubWorkspaceId(page) ??
+        (await findHubWorkspaceIdByName(page, SHARED_HUB_WORKSPACE_NAME));
+    if (!workspaceId) {
+        console.log(`Shared workspace "${SHARED_HUB_WORKSPACE_NAME}" does not exist yet; ` +
+            `"${clusterName}" will be linked when a deploy first needs it`);
+        return;
+    }
+    rememberHubWorkspaceId(page, workspaceId);
+    await linkClusterToWorkspaceViaApi(page, workspaceId, clusterName);
+}
+exports.linkClusterToSharedWorkspaceViaApi = linkClusterToSharedWorkspaceViaApi;
+// Ensure-link at the point a deploy dialog is about to be opened. Resolves the
+// workspace from the id remembered while the flow was on it, else by name.
+// Cheap and idempotent: it returns early once the environment is assigned.
+async function ensureClusterLinkedToSharedWorkspace(page, clusterName) {
+    await linkClusterToSharedWorkspaceViaApi(page, clusterName);
+}
+exports.ensureClusterLinkedToSharedWorkspace = ensureClusterLinkedToSharedWorkspace;

package/dist/utils/hubDeployDialog.d.ts

@@ -0,0 +1,3 @@
+import { Locator, Page } from '@playwright/test';
+export declare function selectOnlyThisResourceInDialog(page: Page, dialog: Locator): Promise<void>;
+export declare function assertClusterSelectedInDialog(dialog: Locator, clusterName: string): Promise<void>;

package/dist/utils/hubDeployDialog.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertClusterSelectedInDialog = exports.selectOnlyThisResourceInDialog = void 0;
+const test_1 = require("@playwright/test");
+// Hub's deploy / "Deploy & run" dialog scopes a deployment through a
+// design-system select. The trigger carries no aria-labelledby, so its
+// accessible name is its own VALUE ("All resources") rather than the
+// "Resources to deploy" label beside it -- a name-based lookup silently
+// matched nothing and left every deployment scoped to the whole project.
+// Address it by id instead.
+//
+// Shared by the form deploy dialog and the diagram deploy-and-run dialog so
+// the two cannot drift apart.
+async function selectOnlyThisResourceInDialog(page, dialog) {
+    const scopeSelect = dialog
+        .locator('#deployment-scope-selection')
+        .or(dialog.getByRole('combobox', { name: 'Resources to deploy' }))
+        .first();
+    const hasScopeSelect = await scopeSelect
+        .waitFor({ state: 'visible', timeout: 10000 })
+        .then(() => true)
+        .catch(() => false);
+    if (!hasScopeSelect) {
+        // On Hub the default scope is the WHOLE PROJECT, so quietly accepting a
+        // missing trigger turns a resource deployment into a project deployment
+        // -- and the deployment confirmation is worded broadly enough that the
+        // test would still pass. Fail there; only the pre-Hub shells, which have
+        // no scope selector at all, may continue.
+        if (new URL(page.url()).hostname.startsWith('hub.')) {
+            throw new Error('Hub deploy dialog exposed no deployment-scope select ' +
+                '(#deployment-scope-selection); refusing to fall back to deploying ' +
+                'the whole project');
+        }
+        return;
+    }
+    if ((await scopeSelect.innerText()).includes('Only this resource')) {
+        return;
+    }
+    await scopeSelect.click();
+    // Page-scoped: the select renders its options in a portal attached to
+    // <body>, outside the dialog element.
+    await page
+        .getByRole('option', { name: 'Only this resource' })
+        .or(page.getByRole('menuitem', { name: 'Only this resource' }))
+        .or(page.getByText('Only this resource', { exact: true }))
+        .first()
+        .click({ timeout: 30000 });
+    await (0, test_1.expect)(scopeSelect).toContainText('Only this resource', {
+        timeout: 10000,
+    });
+}
+exports.selectOnlyThisResourceInDialog = selectOnlyThisResourceInDialog;
+// Confirms the chosen cluster is selected in a deploy dialog.
+//
+// Carbon nested a toggle `switch` inside the cluster's <label>; Hub's
+// design-system dialog renders the control as a sibling radio next to the
+// cluster name (auto-selected when a single cluster is offered), so a
+// label-scoped lookup finds nothing at all. Search the DIALOG for a control
+// named after the cluster, and keep the label-scoped shapes for the older
+// shells.
+async function assertClusterSelectedInDialog(dialog, clusterName) {
+    const byName = new RegExp(`^${clusterName}`);
+    const labelRow = dialog.locator('label').filter({ hasText: byName }).first();
+    const control = dialog
+        .getByRole('radio', { name: byName })
+        .or(dialog.getByRole('switch', { name: byName }))
+        .or(dialog.getByRole('checkbox', { name: byName }))
+        .or(labelRow.getByRole('switch'))
+        .or(labelRow.getByRole('radio'))
+        .or(labelRow.getByRole('checkbox'))
+        .first();
+    await (0, test_1.expect)(control).toBeChecked({ timeout: 30000 });
+}
+exports.assertClusterSelectedInDialog = assertClusterSelectedInDialog;

package/dist/utils/hubResourceRename.d.ts

@@ -0,0 +1,4 @@
+import { Page, Locator } from '@playwright/test';
+export declare function hubBreadcrumbs(page: Page): Locator;
+export declare function hubRenameInput(page: Page): Locator;
+export declare function renameHubResource(page: Page, currentName: string, newName: string): Promise<void>;

package/dist/utils/hubResourceRename.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameHubResource = exports.hubRenameInput = exports.hubBreadcrumbs = void 0;
+const test_1 = require("@playwright/test");
+// Camunda Hub no longer exposes a resource's title as a directly editable
+// field: the rename happens in a shared dialog (`rename-input` /
+// `rename-submit`) opened from the CURRENT breadcrumb crumb's actions menu.
+//
+// Ported from camunda-hub's own e2e-playwright/pages/BasePage.ts
+// (`renameCurrentEntityViaBreadcrumb`) rather than invented, including two
+// hazards documented there:
+//   * the trigger must be scoped to the breadcrumbs and taken as `.last()` --
+//     an unscoped `/ actions$/` match can resolve to the PARENT's crumb
+//     mid-navigation and rename the parent instead;
+//   * NavProvider keeps the previous page's settled crumbs while the new
+//     route's are still pending, so gate positively on the trigger naming the
+//     entity we mean to rename before opening its menu.
+function hubBreadcrumbs(page) {
+    return page
+        .locator('[data-test="breadcrumbs"]')
+        .or(page.getByRole('navigation', { name: 'Context navigation' }))
+        .or(page.getByRole('navigation', { name: 'Breadcrumb', exact: true }));
+}
+exports.hubBreadcrumbs = hubBreadcrumbs;
+function hubRenameInput(page) {
+    return page
+        .locator('[data-test="rename-input"]')
+        .or(page.locator('[data-test="editable-input"]'))
+        .first();
+}
+exports.hubRenameInput = hubRenameInput;
+function breadcrumbActionsButton(page) {
+    return hubBreadcrumbs(page)
+        .getByRole('button', { name: / actions$/ })
+        .last();
+}
+// `currentName` is the server default the resource still carries (e.g.
+// "New form", "New BPMN diagram"); it is what the gate matches on.
+async function renameHubResource(page, currentName, newName) {
+    const breadcrumbs = hubBreadcrumbs(page);
+    const trigger = breadcrumbActionsButton(page);
+    const renameInput = page.locator('[data-test="rename-input"]');
+    const renameSubmit = page.locator('[data-test="rename-submit"]');
+    const hasBreadcrumbRename = await trigger
+        .waitFor({ state: 'visible', timeout: 30000 })
+        .then(() => true)
+        .catch(() => false);
+    if (!hasBreadcrumbRename) {
+        // A shell that still renames through the inline editable title: fill it
+        // directly, the way this flow always used to.
+        const inline = hubRenameInput(page);
+        await (0, test_1.expect)(inline).toBeVisible({ timeout: 60000 });
+        await inline.fill(newName, { timeout: 60000 });
+        await inline.press('Enter');
+        return;
+    }
+    await (0, test_1.expect)(trigger).toHaveAccessibleName(`${currentName} actions`, {
+        timeout: 30000,
+    });
+    await (0, test_1.expect)(async () => {
+        if (await breadcrumbs.getByText(newName).isVisible())
+            return;
+        await trigger.click({ timeout: 15000 });
+        await page.getByRole('menuitem', { name: 'Rename' }).click({ timeout: 15000 });
+        await (0, test_1.expect)(renameInput).toBeVisible({ timeout: 15000 });
+        await renameInput.fill(newName);
+        await (0, test_1.expect)(renameInput).toHaveValue(newName, { timeout: 15000 });
+        await renameSubmit.click({ timeout: 15000 });
+        await (0, test_1.expect)(breadcrumbs.getByText(newName)).toBeVisible({
+            timeout: 15000,
+        });
+    }).toPass({ timeout: 120000 });
+}
+exports.renameHubResource = renameHubResource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1272",
+  "version": "0.0.1274",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",