@camunda/e2e-test-suite 0.0.1273 → 0.0.1274

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.1273",
+  "version": "0.0.1274",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",