@camunda/e2e-test-suite 0.0.1015 → 0.0.1016

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

@@ -1,6 +1,7 @@
 import { Page, Locator } from '@playwright/test';
 declare class FormJsPage {
     private page;
+    private processApplicationPage;
     readonly aiFormGeneratorButton: Locator;
     readonly formRequestInput: Locator;
     readonly generateFormButton: Locator;
@@ -31,6 +32,7 @@ declare class FormJsPage {
     selectCluster(clusterName: string): Promise<void>;
     clickDeployButton(): Promise<void>;
     clickDeploySubButton(): Promise<void>;
+    selectOnlyThisResource(): Promise<void>;
     deployForm(clusterName: string): Promise<void>;
 }
 export { FormJsPage };

package/dist/pages/8.7/FormJsPage.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormJsPage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class FormJsPage {
     page;
+    processApplicationPage;
     aiFormGeneratorButton;
     formRequestInput;
     generateFormButton;
@@ -23,6 +25,7 @@ class FormJsPage {
     deploySuccessNotification;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.aiFormGeneratorButton = page.getByRole('button', {
             name: 'AI Form Generator',
         });
@@ -44,9 +47,12 @@ class FormJsPage {
         this.deployButton = page
             .locator('[data-test="action-bar"]')
             .getByRole('button', { name: 'Deploy', exact: true });
+        // Inside a process application hub titles this modal for the application
+        // rather than for the form, so 'Deploy form' never matches and the dialog
+        // reads as absent. pages/SM-8.10 filters on 'Deploy' for the same reason.
         this.dialog = page
             .locator('.cds--modal-container[role="dialog"]')
-            .filter({ hasText: 'Deploy form' });
+            .filter({ hasText: 'Deploy' });
         this.deploySubButton = this.dialog.getByRole('button', {
             name: 'Deploy',
             exact: true,
@@ -99,6 +105,46 @@ class FormJsPage {
     async selectCluster(clusterName) {
         await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 30000 });
         const healthCheckTimeout = 30000;
+        // Inside a process application the deploy dialog renders
+        // ProcessAppClusterSelection, not the per-deploy ClusterSelection toggle
+        // list: it shows only clusters assigned to one of the application's stages
+        // and auto-selects the first, so there is no label to click. Confirm the
+        // intended cluster is the one on offer instead.
+        //
+        // The unconfigured case is called out explicitly: without this the symptom
+        // is the cluster toggle never appearing, retried until the test times out,
+        // which says nothing about the actual cause.
+        const notConfigured = this.dialog.getByText('Clusters not configured for stages');
+        if (await notConfigured.isVisible().catch(() => false)) {
+            throw new Error(`Process application has no cluster assigned to any stage, so "${clusterName}" cannot be deployed to. ` +
+                'ProcessApplicationPage.ensureStageCluster() should have bound it before the deploy dialog was opened.');
+        }
+        const legacyClusterToggle = this.dialog.locator('label').filter({
+            hasText: new RegExp(`^${clusterName}`),
+        });
+        const isLegacyDialog = await legacyClusterToggle
+            .first()
+            .isVisible()
+            .catch(() => false);
+        if (!isLegacyDialog) {
+            const offered = await this.dialog
+                .getByText(clusterName, { exact: false })
+                .first()
+                .waitFor({ state: 'visible', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!offered) {
+                // Forget the binding before failing. The dialog lists exactly the
+                // clusters this application's stages point at, so a missing cluster
+                // means the binding did not take -- and no amount of reopening the
+                // dialog will make it appear. Clearing the record lets the caller's
+                // next attempt rebind instead of re-checking an unchanged dialog.
+                this.processApplicationPage.forgetStageCluster();
+                throw new Error(`The deploy dialog does not offer "${clusterName}": its stage ` +
+                    'binding did not take. It will be rebound on the next attempt.');
+            }
+            return;
+        }
         const healthyRegex = new RegExp(`${clusterName}[\\s\\S]*?HealthydevManage`);
         const cluster = this.dialog.locator(`[title="${clusterName}"]`);
         await (0, test_1.expect)(cluster).toBeVisible({ timeout: 30000 });
@@ -117,12 +163,39 @@ class FormJsPage {
     async clickDeploySubButton() {
         await this.deploySubButton.click({ timeout: 60000 });
     }
+    // Since camunda/camunda-hub#25831 a form lives inside a process application,
+    // and Hub then scopes Deploy to the WHOLE application by default -- it calls
+    // deployProcessApplication, not deployFile, so the "Form deployed!" toast
+    // never fires (hub's own form-deploy-action.spec.sm.tsx asserts exactly that
+    // default). Narrowing the scope keeps this a form-deploy test instead of
+    // silently turning it into a process-application deploy. The combobox only
+    // exists inside a container, hence the boolean probe.
+    async selectOnlyThisResource() {
+        const scopeSelect = this.dialog.getByRole('combobox', {
+            name: 'Resources to deploy',
+        });
+        const hasScopeSelect = await scopeSelect
+            .waitFor({ state: 'visible', timeout: 10000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!hasScopeSelect) {
+            return;
+        }
+        await scopeSelect.click();
+        await this.dialog
+            .getByRole('option', { name: 'Only this resource' })
+            .or(this.dialog.getByText('Only this resource', { exact: true }))
+            .first()
+            .click({ timeout: 30000 });
+    }
     async deployForm(clusterName) {
+        await this.processApplicationPage.ensureStageCluster(clusterName);
         await this.clickDeployButton();
         await (0, test_1.expect)(this.dialog).toBeVisible({
             timeout: 30000,
         });
         await this.selectCluster(clusterName);
+        await this.selectOnlyThisResource();
         await this.clickDeploySubButton();
         await (0, test_1.expect)(this.deploySuccessNotification).toBeVisible({ timeout: 30000 });
         await (0, test_1.expect)(this.deploySuccessNotification).not.toBeVisible({

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

@@ -1,6 +1,7 @@
 import { Page, Locator } from '@playwright/test';
 declare class ModelerCreatePage {
     private page;
+    private processApplicationPage;
     readonly generalPanel: Locator;
     private deployDiagramDialog;
     readonly processIdInput: Locator;
@@ -216,7 +217,7 @@ declare class ModelerCreatePage {
     private suppressTestModeAnnouncement;
     switchToPlay(): Promise<void>;
     completePlayConfiguration(clusterName: string): Promise<void>;
-    selectCluster(clusterName: string): Promise<void>;
+    selectCluster(clusterName: string, healthCheckTimeout?: number): Promise<void>;
     embedForm(formName: string): Promise<void>;
     fillStartEventVariablesForDocHandling(zeebeUrl: string, zeebeClientId: string, zeebeClientSecret: string): Promise<void>;
     fillZeebeClientId(clientId: string): Promise<void>;

package/dist/pages/8.7/ModelerCreatePage.js

@@ -4,8 +4,10 @@ exports.ModelerCreatePage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const ConnectorMarketplacePage_1 = require("./ConnectorMarketplacePage");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class ModelerCreatePage {
     page;
+    processApplicationPage;
     generalPanel;
     deployDiagramDialog;
     processIdInput;
@@ -109,6 +111,7 @@ class ModelerCreatePage {
     diagramNameBreadcrumb;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.generalPanel = page.locator('[data-group-id="group-general"]');
         this.processIdInput = page.getByLabel('ID', { exact: true });
         this.startEventElement = page.locator('.djs-hit').first();
@@ -220,8 +223,12 @@ class ModelerCreatePage {
         this.rbaEnabledDeployedDialog = page.getByRole('dialog', {
             name: 'Process successfully deployed',
         });
+        // Since camunda/camunda-hub#25831 a diagram deploys as part of its process
+        // application and hub titles the modal for the application, not for the
+        // single resource, so an exact 'Deploy diagram' name no longer matches.
+        // Match on the verb -- pages/SM-8.10 already leaves this unfiltered.
         this.deployDiagramDialog = page.getByRole('dialog', {
-            name: 'Deploy diagram',
+            name: /^Deploy/,
         });
         this.appendGatewayButton = page.getByRole('button', {
             name: 'Append gateway',
@@ -472,6 +479,7 @@ class ModelerCreatePage {
         await this.deployMenuItem.click({ timeout: 60000 });
     }
     async deployDiagram(clusterName) {
+        await this.processApplicationPage.ensureStageCluster(clusterName);
         await this.clickDeployButtonWithRetry();
         await (0, test_1.expect)(this.deployDiagramDialog).toBeVisible({
             timeout: 30000,
@@ -521,24 +529,29 @@ class ModelerCreatePage {
         await this.deployAndRunSubButton.click({ timeout: 30000 });
     }
     async runProcessInstance(clusterName, variables = '', formVariables = {}, textToVisible = '') {
+        await this.processApplicationPage.ensureStageCluster(clusterName);
         await this.clickDeployAndRunMainButton();
-        await (0, test_1.expect)(this.dialog).toBeVisible({
-            timeout: 30000,
-        });
-        //Select the correct cluster if multiple exist
-        const clusterLabel = this.dialog
-            .locator('label')
-            .filter({ hasText: new RegExp(`^${clusterName}`) });
-        await (0, test_1.expect)(clusterLabel).toBeVisible({ timeout: 30000 });
-        await clusterLabel.click();
-        await (0, test_1.expect)(clusterLabel.getByRole('switch')).toBeChecked({
-            timeout: 30000,
-        });
-        //Check healthy status of the selected cluster
-        const regex = new RegExp(`${clusterName}.*?HealthydevManage`);
-        await (0, test_1.expect)(this.dialog).toHaveText(regex, {
-            timeout: 120000,
-        });
+        // Routed through selectCluster so this path gets the same
+        // legacy-toggle-vs-ProcessAppClusterSelection branch as every other deploy:
+        // inside a process application there is no cluster toggle to click. Keeps
+        // this path's own 120s health wait rather than selectCluster's 30s default.
+        try {
+            await this.selectCluster(clusterName, 120000);
+        }
+        catch (error) {
+            // selectCluster clears the stage binding when the dialog does not offer
+            // the cluster, so ensureStageCluster rebinds here and reports that it
+            // navigated. Any other failure leaves the binding in place, it returns
+            // false, and the original error stands -- there is nothing to redo.
+            // Unlike the 8.8+ flows this one has no surrounding retry loop, hence
+            // the one explicit second attempt.
+            const rebound = await this.processApplicationPage.ensureStageCluster(clusterName);
+            if (!rebound) {
+                throw error;
+            }
+            await this.clickDeployAndRunMainButton();
+            await this.selectCluster(clusterName, 120000);
+        }
         if (variables.length > 0) {
             await (0, test_1.expect)(this.variableInput).toBeVisible({
                 timeout: 60000,
@@ -633,8 +646,45 @@ class ModelerCreatePage {
             }
         }
     }
+    // Opening the breadcrumb menu leaves the pointer on the breadcrumb button,
+    // and hub renders that button's truncated-name tooltip on top of the menu,
+    // where it swallows the click on "Rename" -- playwright reports
+    // `<div role="tooltip">…</div> intercepts pointer events`. Since
+    // camunda/camunda-hub#25831 the breadcrumb carries an extra
+    // process-application crumb, so the name truncates, and the tooltip renders,
+    // as the rule rather than the exception. Park the pointer away from the
+    // breadcrumb and let the tooltip unmount before clicking; reopen the menu if
+    // a previous attempt closed it.
     async clickEditDiagramNameButton() {
-        await this.renameDiagramNameButton.click({ timeout: 60000 });
+        const openTooltip = this.page.locator('[role="tooltip"][aria-hidden="false"]');
+        await (0, test_1.expect)(async () => {
+            const menuOpen = await this.renameDiagramNameButton
+                .isVisible()
+                .catch(() => false);
+            if (!menuOpen) {
+                await this.clickDiagramBreadcrumb();
+            }
+            // Park the pointer so the breadcrumb's own tooltip gets a chance to
+            // unmount -- best effort, because it is not reliably hover-driven, and
+            // requiring it to go turned an interceptable click into a hard failure.
+            await this.page.mouse.move(0, 0);
+            await openTooltip
+                .first()
+                .waitFor({ state: 'hidden', timeout: 2000 })
+                .catch(() => false);
+            try {
+                await this.renameDiagramNameButton.click({ timeout: 10000 });
+            }
+            catch {
+                // The tooltip renders over the menu and swallows the click (playwright
+                // reports `<div role="tooltip">…</div> intercepts pointer events`).
+                // Dispatching on the element bypasses hit-testing, which no amount of
+                // waiting achieves when the tooltip never unmounts. Not a swallowed
+                // failure: the assertion below is what decides whether this worked.
+                await this.renameDiagramNameButton.dispatchEvent('click');
+            }
+            await (0, test_1.expect)(this.diagramNameInput).toBeVisible({ timeout: 10000 });
+        }).toPass({ timeout: 60000, intervals: [1000, 2000, 5000] });
     }
     async enterDiagramName(name) {
         // The inline name field stays in the DOM after the rename action closes,
@@ -1137,6 +1187,16 @@ class ModelerCreatePage {
         await this.playTab.click();
     }
     async completePlayConfiguration(clusterName) {
+        // Play is a tab on the diagram page, not its own URL, so the stage-cluster
+        // detour's goto() lands back on the Modeler tab and every Play locator
+        // below would then look for a panel that is no longer rendered. Re-enter
+        // Play when the detour actually navigated. Binding cannot simply move
+        // before switchToPlay(): this is the first point in the flow that knows
+        // which cluster the test plays on.
+        const reboundStageCluster = await this.processApplicationPage.ensureStageCluster(clusterName);
+        if (reboundStageCluster) {
+            await this.switchToPlay();
+        }
         const timeout = 30000;
         // New flow (8.10+): "Setup environment" panel with three steps:
         //   1. Connect cluster → "Configure environment" modal → select cluster → Save
@@ -1160,17 +1220,37 @@ class ModelerCreatePage {
             name: /^Configure (test case|scenario)$/,
         }))
             .first();
-        // Wait up to 15s for EITHER the new-flow setup panel OR the legacy Continue
-        // button to appear.
-        const setupOrContinue = setupDeployButton.or(this.continueToPlayButton);
-        const panelAppeared = await setupOrContinue
-            .first()
-            .isVisible({ timeout: 15000 })
-            .catch(() => false);
-        if (!panelAppeared) {
+        // Play settles into exactly ONE of three states, and which one is not
+        // knowable up front, so race them instead of timing out on each in turn:
+        // the setup overlay, the legacy Continue button, or the configure-test
+        // panel (meaning setup is already done for this diagram).
+        //
+        // Waiting only for the first two and reading "neither" as "already ready"
+        // was wrong once the diagram moved inside a process application.
+        // ConfigurationOverlay renders null until isDeploymentStateValidated, and
+        // it sets that flag synchronously ONLY when processApplicationId is
+        // undefined -- exactly what a project-root diagram used to give it. With
+        // the diagram in a process application the id is defined, so the overlay
+        // must first await checkExistingDeployment(). The old 15s probe raced that
+        // async call, concluded "already ready" and returned while the overlay was
+        // still about to appear. ConfigureTestPanel returns null for as long as the
+        // overlay is up, so the Start button never existed and
+        // clickStartInstanceButton burned its entire retry budget looking for it.
+        const configurationOverlay = this.page.locator('[data-test="play-configuration-overlay"]');
+        const configureTestPanel = this.page.getByTestId('configure-test-panel');
+        await (0, test_1.expect)(configurationOverlay
+            .or(this.continueToPlayButton)
+            .or(configureTestPanel)
+            .first()).toBeVisible({ timeout: 90000 });
+        if (await configureTestPanel.isVisible()) {
+            // Already past setup for this diagram -- nothing to drive.
             return;
         }
-        const isNewFlow = await setupDeployButton.isVisible().catch(() => false);
+        // Keyed on the overlay itself, not on its Deploy button: when
+        // checkExistingDeployment finds a deployment the overlay opens with the
+        // deploy step already complete, so there is no Deploy button to see and
+        // keying on it would fall through to the legacy Continue flow.
+        const isNewFlow = await configurationOverlay.isVisible();
         if (isNewFlow) {
             // Step 1: connect cluster if not yet connected (modal with cluster dropdown)
             const connectClusterButton = this.page.getByRole('button', {
@@ -1209,13 +1289,33 @@ class ModelerCreatePage {
                     .getByRole('button', { name: 'Save' })
                     .click({ timeout });
             }
-            // Step 2: deploy — wait for enabled; button stays disabled until the cluster
-            // connection is confirmed by the backend after the Save in step 1.
-            await (0, test_1.expect)(setupDeployButton).toBeEnabled({ timeout: 60000 });
-            await setupDeployButton.click({ timeout });
-            await (0, test_1.expect)(this.page.getByText('Process has been successfully deployed')).toBeVisible({ timeout: 90000 });
-            // Step 3: configure scenario
-            await configureScenarioButton.click({ timeout });
+            // Step 2: deploy, unless the overlay already opened with the
+            // deploy step complete. checkExistingDeployment only runs when
+            // processApplicationId is defined, which it now is, so re-entering
+            // Play on an already-deployed process application legitimately
+            // has nothing to deploy and renders no Deploy button at all.
+            const alreadyDeployed = await configureScenarioButton
+                .isVisible({ timeout: 3000 })
+                .catch(() => false);
+            if (!alreadyDeployed) {
+                // Step 2: deploy — wait for enabled; button stays disabled until the cluster
+                // connection is confirmed by the backend after the Save in step 1.
+                await (0, test_1.expect)(setupDeployButton).toBeEnabled({ timeout: 60000 });
+                await setupDeployButton.click({ timeout });
+                await (0, test_1.expect)(this.page.getByText('Process has been successfully deployed')).toBeVisible({ timeout: 90000 });
+            }
+            // Step 3: leave the overlay, and confirm we actually left it. The
+            // button only calls hideConfigurationOverlay(); the overlay's own
+            // cluster-change effect can then fire resetDeployment and bring it
+            // straight back, and ConfigureTestPanel stays null while it is up.
+            // Assert the panel really rendered, and re-drive the click if the
+            // overlay returned.
+            await (0, test_1.expect)(async () => {
+                if (await configurationOverlay.isVisible()) {
+                    await configureScenarioButton.click({ timeout });
+                }
+                await (0, test_1.expect)(configureTestPanel).toBeVisible({ timeout: 15000 });
+            }).toPass({ timeout: 90000 });
             return;
         }
         // Legacy flow: select cluster via dialog, then click Continue.
@@ -1238,9 +1338,48 @@ class ModelerCreatePage {
             }
         }
     }
-    async selectCluster(clusterName) {
+    async selectCluster(clusterName, healthCheckTimeout = 30000) {
         await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 30000 });
-        const healthCheckTimeout = 30000;
+        // Inside a process application the deploy dialog renders
+        // ProcessAppClusterSelection, not the per-deploy ClusterSelection toggle
+        // list: it shows only clusters assigned to one of the application's stages
+        // and auto-selects the first, so there is no label to click. Confirm the
+        // intended cluster is the one on offer instead.
+        //
+        // The unconfigured case is called out explicitly: without this the symptom
+        // is the cluster toggle never appearing, retried until the test times out,
+        // which says nothing about the actual cause.
+        const notConfigured = this.dialog.getByText('Clusters not configured for stages');
+        if (await notConfigured.isVisible().catch(() => false)) {
+            throw new Error(`Process application has no cluster assigned to any stage, so "${clusterName}" cannot be deployed to. ` +
+                'ProcessApplicationPage.ensureStageCluster() should have bound it before the deploy dialog was opened.');
+        }
+        const legacyClusterToggle = this.dialog.locator('label').filter({
+            hasText: new RegExp(`^${clusterName}`),
+        });
+        const isLegacyDialog = await legacyClusterToggle
+            .first()
+            .isVisible()
+            .catch(() => false);
+        if (!isLegacyDialog) {
+            const offered = await this.dialog
+                .getByText(clusterName, { exact: false })
+                .first()
+                .waitFor({ state: 'visible', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!offered) {
+                // Forget the binding before failing. The dialog lists exactly the
+                // clusters this application's stages point at, so a missing cluster
+                // means the binding did not take -- and no amount of reopening the
+                // dialog will make it appear. Clearing the record lets the caller's
+                // next attempt rebind instead of re-checking an unchanged dialog.
+                this.processApplicationPage.forgetStageCluster();
+                throw new Error(`The deploy dialog does not offer "${clusterName}": its stage ` +
+                    'binding did not take. It will be rebound on the next attempt.');
+            }
+            return;
+        }
         const healthyRegex = new RegExp(`${clusterName}.*?HealthydevManage`);
         const clusterLabel = this.dialog
             .locator('label')

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

@@ -3,6 +3,9 @@ import { LoginPage } from './LoginPage';
 declare class ModelerHomePage {
     private defaultFolderName;
     private page;
+    private processApplicationPage;
+    private processApplicationUrl?;
+    private processApplicationName?;
     readonly modelerPageBanner: Locator;
     readonly createNewProjectButton: Locator;
     readonly projectNameInput: Locator;
@@ -15,6 +18,7 @@ declare class ModelerHomePage {
     readonly idpApplicationNameInput: Locator;
     readonly createIdpApplicationButton: Locator;
     readonly projectBreadcrumb: Locator;
+    readonly workspaceBreadcrumb: Locator;
     readonly openOrganizationsButton: Locator;
     readonly optionsButton: Locator;
     readonly manageButton: Locator;
@@ -41,12 +45,20 @@ declare class ModelerHomePage {
     getProjectNames(name: string): Promise<string[]>;
     clickProcessDiagram(name: string): Promise<void>;
     clickDiagramTypeDropdown(): Promise<void>;
+    clickWorkspaceDiagramTypeDropdown(): Promise<void>;
     clickBpmnTemplateOption(): Promise<void>;
     clickIdpApplicationTemplateOption(): Promise<void>;
     clickFormOption(): Promise<void>;
     enterFormName(name: string): Promise<void>;
     openFormRenameEditor(): Promise<void>;
     clickProjectBreadcrumb(): Promise<void>;
+    clickWorkspaceBreadcrumb(): Promise<void>;
+    enterResourceContainer(name?: string): Promise<void>;
+    private clickCreateProcessApplication;
+    private ensureInResourceContainer;
+    returnToResourceContainer(): Promise<void>;
+    startBlankBpmnDiagram(): Promise<void>;
+    private becameVisible;
     clickHomeBreadcrumb(): Promise<void>;
     clickOpenOrganizationsButton(): Promise<void>;
     clickCrossComponentProjectFolder(): Promise<void>;

package/dist/pages/8.7/ModelerHomePage.js

@@ -4,10 +4,25 @@ exports.ModelerHomePage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+const randomName_1 = require("../../utils/randomName");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
 class ModelerHomePage {
     defaultFolderName = 'Cross Component Test Project';
     page;
+    // Since camunda/camunda-hub#25831 files and folders cannot sit at a
+    // workspace ("project" in today's UI) root -- only process applications and
+    // IDP applications can. The container is therefore entered lazily, at the
+    // point a resource is created, and remembered for the lifetime of this page
+    // object (one instance per test, see fixtures/8.7.ts). Specs that only
+    // need the workspace itself -- collaborators, IDP applications -- never
+    // trigger the hop.
+    processApplicationPage;
+    // Load-bearing: hub renders no process-application breadcrumb on a diagram
+    // page at container root, so the remembered URL -- not a breadcrumb click --
+    // is how we get back. Hub's own Playwright suite does the same.
+    processApplicationUrl;
+    processApplicationName;
     modelerPageBanner;
     createNewProjectButton;
     projectNameInput;
@@ -20,6 +35,7 @@ class ModelerHomePage {
     idpApplicationNameInput;
     createIdpApplicationButton;
     projectBreadcrumb;
+    workspaceBreadcrumb;
     openOrganizationsButton;
     optionsButton;
     manageButton;
@@ -35,6 +51,7 @@ class ModelerHomePage {
     renameFormMenuItem;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.modelerPageBanner = page.getByRole('banner', {
             name: 'Camunda Modeler',
         });
@@ -52,16 +69,23 @@ class ModelerHomePage {
             name: 'Choose BPMN template',
         });
         this.diagramTypeDropdown = page.locator('[data-test="diagram-dropdown"]');
-        this.bpmnTemplateOption = page
-            .locator('[data-test="create-bpmn-diagram"]')
-            .getByText('BPMN Diagram');
-        this.formTemplateOption = page
-            .locator('[data-test="create-form"]')
-            .getByText('Form');
+        // Matched on the test id alone: hub's design-system variant of the create
+        // menu renders "BPMN diagram" (lowercase d), so a text filter breaks the
+        // day that variant ships.
+        this.bpmnTemplateOption = page.locator('[data-test="create-bpmn-diagram"]');
+        this.formTemplateOption = page.locator('[data-test="create-form"]');
         this.idpTemplateOption = page
             .locator('[data-test="create-idp-application"]')
             .getByText('IDP Application');
         this.projectBreadcrumb = page.locator('[data-test="breadcrumb-project"]');
+        // Kept separate from projectBreadcrumb, which now means "the container my
+        // resources live in". When hub's workspaces terminology flag flips,
+        // breadcrumb-project comes to denote the process application, so the
+        // workspace level needs its own name from the start.
+        this.workspaceBreadcrumb = page
+            .locator('[data-test="breadcrumb-project"]')
+            .or(page.locator('[data-test="breadcrumb-workspace"]'))
+            .first();
         this.homeBreadcrumb = page.locator('[data-test="breadcrumb-home"]');
         this.openOrganizationsButton = page.getByLabel('Open Organizations');
         this.manageButton = page.getByRole('menuitem', { name: 'Manage' });
@@ -154,12 +178,32 @@ class ModelerHomePage {
             .map((el) => el.textContent || '')
             .filter((text) => text !== ''));
     }
+    // Opens a resource where this test put it. Several specs leave Modeler
+    // entirely (to Operate, to Optimize) and come back via
+    // clickCrossComponentProjectFolder(), which lands at workspace root -- the
+    // resource is one level down, so re-enter the container first.
     async clickProcessDiagram(name) {
+        await this.ensureInResourceContainer();
         const process = this.rows.filter({ hasText: name }).getByTitle(name).first();
         await (0, test_1.expect)(process).toBeVisible({ timeout: 90000 });
         await process.click();
     }
+    // Opens the create menu inside this test's process application. The menu at
+    // workspace root no longer offers BPMN, Form or Upload -- those resources
+    // cannot live there -- so the container is entered first. Callers are
+    // unchanged, which is why the existing spec call sites need no edit.
     async clickDiagramTypeDropdown() {
+        await this.enterResourceContainer();
+        const dropdown = this.processApplicationPage.createNewDropdown;
+        await (0, test_1.expect)(dropdown).toBeVisible({
+            timeout: 60000,
+        });
+        await dropdown.click({ timeout: 120000 });
+    }
+    // Opens the create menu at workspace root, which is the only place process
+    // applications and IDP applications can be created. Everything else has to
+    // go through clickDiagramTypeDropdown().
+    async clickWorkspaceDiagramTypeDropdown() {
         await (0, test_1.expect)(this.diagramTypeDropdown).toBeVisible({
             timeout: 60000,
         });
@@ -222,8 +266,109 @@ class ModelerHomePage {
         await this.formBreadcrumbButton.click({ timeout: 60000 });
         await this.renameFormMenuItem.click({ timeout: 30000 });
     }
+    // Kept under its original name because it is what the existing call sites
+    // already mean: "go back to where my resources live". That is now the
+    // process application, not the workspace root.
     async clickProjectBreadcrumb() {
-        await this.projectBreadcrumb.click({ timeout: 60000 });
+        await this.returnToResourceContainer();
+    }
+    // The workspace ("project") level itself, for the surfaces that genuinely
+    // live there -- collaborators, IDP applications, published element
+    // templates.
+    async clickWorkspaceBreadcrumb() {
+        await this.workspaceBreadcrumb.click({ timeout: 60000 });
+    }
+    // Creates, once per test, the process application that holds this test's
+    // resources, and leaves the browser inside it. Idempotent: called again while
+    // already in the container it is a no-op, so a spec that creates several
+    // resources in a row pays for the container once.
+    //
+    // One container per test rather than one shared with the seeded workspace:
+    // deploying is process-application-wide, so a shared container would let one
+    // spec's deploy pick up every other spec's half-modelled diagram.
+    async enterResourceContainer(name) {
+        if (this.processApplicationUrl) {
+            const stillInside = await this.becameVisible(this.processApplicationPage.breadcrumb, 5000);
+            if (!stillInside) {
+                await this.returnToResourceContainer();
+            }
+            return;
+        }
+        this.processApplicationName =
+            name ??
+                (await (0, randomName_1.randomNameAgregator)('Cross Component Process Application'));
+        console.log(`Creating process application ${this.processApplicationName} inside ${this.defaultFolderName}`);
+        await this.clickCreateProcessApplication();
+        await this.processApplicationPage.nameNewProcessApplication(this.processApplicationName);
+        this.processApplicationUrl = this.page.url();
+        // Remember the container; its stage cluster is bound on the first deploy,
+        // by ProcessApplicationPage.ensureStageCluster, which -- unlike this point
+        // in the flow -- knows which cluster the test is going to deploy to.
+        this.processApplicationPage.rememberResourceContainer(this.processApplicationUrl);
+    }
+    // Which control creates a process application depends on the hub version
+    // under test. Since camunda/camunda-hub#25831 it is a plain primary button on
+    // the workspace root, and the "Create new" menu explicitly hides the item
+    // (hideProcessApplication) because a process application is no longer just
+    // another resource. Before that change the menu item was the only way in.
+    // Race both entry points so neither version pays a full timeout, then use
+    // whichever one rendered.
+    async clickCreateProcessApplication() {
+        const button = this.processApplicationPage.createProcessApplicationButton;
+        const rootLoaded = await this.becameVisible(button.or(this.diagramTypeDropdown).first(), 60000);
+        if (!rootLoaded) {
+            await this.page.reload();
+        }
+        // Short: the joint probe above already settled which branch rendered, and
+        // hub renders exactly one of them (EntityTable renders the toolbar's create
+        // menu OR the empty state, never both), so this only confirms which.
+        if (await this.becameVisible(button, 5000)) {
+            await this.processApplicationPage.clickCreateProcessApplicationButton();
+            return;
+        }
+        await this.clickWorkspaceDiagramTypeDropdown();
+        await this.processApplicationPage.clickCreateProcessApplicationOption();
+    }
+    // Re-enters this test's container if it already has one, without creating
+    // one: opening an existing resource must not have the side effect of
+    // creating a container for a spec that never asked for it.
+    async ensureInResourceContainer() {
+        if (!this.processApplicationUrl) {
+            return;
+        }
+        await this.enterResourceContainer();
+    }
+    // Navigates back to this test's process application by the remembered URL
+    // rather than by a breadcrumb click: hub renders no process-application
+    // breadcrumb on a diagram page at container root, and the breadcrumb that
+    // does exist on the container page doubles as its rename control. Hub's own
+    // Playwright suite navigates back the same way.
+    async returnToResourceContainer() {
+        if (!this.processApplicationUrl) {
+            await this.clickWorkspaceBreadcrumb();
+            return;
+        }
+        await this.page.goto(this.processApplicationUrl, {
+            waitUntil: 'domcontentloaded',
+        });
+        await this.processApplicationPage.waitForProcessApplication();
+        await this.dismissOverlays();
+    }
+    // Single seam for "give me an empty BPMN diagram in this test's container".
+    // A process application always ships an auto-created main process; this adds
+    // a new diagram rather than adopting that one, so every existing modelling
+    // assertion keeps its current subject.
+    async startBlankBpmnDiagram() {
+        await this.clickDiagramTypeDropdown();
+        await this.clickBpmnTemplateOption();
+    }
+    // Boolean visibility probe. waitFor rather than isVisible, which resolves
+    // immediately and would report a false negative on a still-rendering page.
+    async becameVisible(locator, timeout) {
+        return locator
+            .waitFor({ state: 'visible', timeout })
+            .then(() => true)
+            .catch(() => false);
     }
     async clickHomeBreadcrumb() {
         try {

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

@@ -0,0 +1,30 @@
+import { Locator, Page } from '@playwright/test';
+declare class ProcessApplicationPage {
+    private page;
+    readonly createProcessApplicationButton: Locator;
+    readonly createProcessApplicationOption: Locator;
+    readonly creationDialog: Locator;
+    readonly nameInput: Locator;
+    readonly submitButton: Locator;
+    readonly cancelButton: Locator;
+    readonly breadcrumb: Locator;
+    readonly folderExplorer: Locator;
+    readonly createNewDropdown: Locator;
+    readonly inlineNameInput: Locator;
+    readonly defineStagesDialog: Locator;
+    readonly developmentClusterSelect: Locator;
+    readonly defineStagesSaveButton: Locator;
+    constructor(page: Page);
+    private pageReady;
+    waitForProcessApplication(timeout?: number): Promise<void>;
+    clickCreateProcessApplicationButton(): Promise<void>;
+    clickCreateProcessApplicationOption(): Promise<void>;
+    nameNewProcessApplication(name: string): Promise<void>;
+    defineDevelopmentStage(clusterName?: string): Promise<void>;
+    rememberResourceContainer(url: string): void;
+    forgetStageCluster(): void;
+    ensureStageCluster(clusterName: string): Promise<boolean>;
+    private openStageDefinition;
+    openByName(name: string): Promise<void>;
+}
+export { ProcessApplicationPage };

package/dist/pages/8.7/ProcessApplicationPage.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessApplicationPage = void 0;
+const test_1 = require("@playwright/test");
+const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
+// Which process application holds the current test's resources, and which
+// cluster its development stage currently points at. Keyed by the Playwright
+// Page because the object that creates the container (ModelerHomePage) and the
+// objects that later need a specific cluster inside it (ModelerCreatePage,
+// FormJsPage) hold separate ProcessApplicationPage instances but share one page.
+const resourceContainers = new WeakMap();
+// Since camunda/camunda-hub#25831 a process application is a first-class
+// container rather than a folder, and a workspace root ("project" in today's
+// UI) holds nothing but process applications and IDP applications. Every file
+// and folder this suite creates therefore has to live inside a process
+// application. This page object owns that container's surface only; entering
+// and leaving it is driven from ModelerHomePage so the ~150 existing spec call
+// sites keep working unchanged.
+class ProcessApplicationPage {
+    page;
+    // Empty workspace root: a plain primary button rendered next to the "Create
+    // new" menu (hub's EmptyStateActionButtons).
+    createProcessApplicationButton;
+    // Non-empty root: the item inside the "Create new" menu. Hub passes
+    // hideProcessApplication at workspace level, so this is the fallback rather
+    // than the primary path -- its own unit test asserts the item is absent
+    // there. Kept because the Hub PR is still moving this surface.
+    createProcessApplicationOption;
+    creationDialog;
+    nameInput;
+    submitButton;
+    cancelButton;
+    breadcrumb;
+    folderExplorer;
+    createNewDropdown;
+    inlineNameInput;
+    // "Define stages" dialog, reached from the process application's "Connected
+    // clusters" card (or its /connected-clusters deep link). Assigning a cluster
+    // to a stage here is what makes it deployable: DeployModal renders
+    // ProcessAppClusterSelection for a process application, and that filters the
+    // cluster list through getProcessAppClustersByStage -- so a process
+    // application with no stage assigned offers no cluster at all.
+    defineStagesDialog;
+    developmentClusterSelect;
+    defineStagesSaveButton;
+    constructor(page) {
+        this.page = page;
+        // .first() defensively only: hub renders exactly one of these today, in the
+        // workspace-root empty state. A future second placement should not turn
+        // every PA-creating test into a strict-mode violation.
+        this.createProcessApplicationButton = page
+            .getByRole('button', { name: 'Create process application' })
+            .first();
+        this.createProcessApplicationOption = page.locator('[data-test="create-process-application"]');
+        this.creationDialog = page.getByRole('dialog', {
+            name: 'Create a process application',
+        });
+        // Deliberately scoped to the dialog: ModelerCreatePage owns an unscoped
+        // getByLabel('Name', {exact: true}) for the properties panel, which would
+        // resolve to two elements while the creation modal is open.
+        this.nameInput = this.creationDialog.getByLabel('Name', { exact: true });
+        this.submitButton = this.creationDialog.getByRole('button', {
+            name: 'Create',
+            exact: true,
+        });
+        this.cancelButton = this.creationDialog.getByRole('button', {
+            name: 'Cancel',
+            exact: true,
+        });
+        this.breadcrumb = page.locator('[data-test="breadcrumb-process-application-menu"]');
+        this.folderExplorer = page.getByRole('region', { name: 'Folder explorer' });
+        // The process application page renders more than one diagram-dropdown
+        // (hub's own unit tests reach for it with getAllByTestId), so the dropdown
+        // has to be resolved inside the folder explorer rather than page-wide.
+        this.createNewDropdown = this.folderExplorer
+            .locator('[data-test="diagram-dropdown"]')
+            .first();
+        this.inlineNameInput = page.locator('[data-test="editable-input"]');
+        this.defineStagesDialog = page
+            .getByRole('dialog')
+            .filter({ hasText: 'Define stages' });
+        // Carbon Dropdown / design-system Select both keep this id.
+        this.developmentClusterSelect = this.defineStagesDialog.locator('#dropdown-development-cluster');
+        this.defineStagesSaveButton = this.defineStagesDialog.getByRole('button', {
+            name: 'Save',
+            exact: true,
+        });
+    }
+    // Either the folder explorer or the breadcrumb proves we are on the process
+    // application page; .first() because both are present once it has rendered.
+    pageReady() {
+        return this.folderExplorer.or(this.breadcrumb).first();
+    }
+    async waitForProcessApplication(timeout = 90000) {
+        await (0, test_1.expect)(this.pageReady()).toBeVisible({ timeout });
+    }
+    async clickCreateProcessApplicationButton() {
+        await (0, test_1.expect)(this.createProcessApplicationButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.createProcessApplicationButton.click({ timeout: 60000 });
+    }
+    async clickCreateProcessApplicationOption() {
+        await (0, test_1.expect)(this.createProcessApplicationOption).toBeVisible({
+            timeout: 60000,
+        });
+        await this.createProcessApplicationOption.click({ timeout: 60000 });
+    }
+    // Hub creates a process application through a modal today. It used an inline
+    // editable title before, and #27593 is still moving this surface, so the
+    // inline path is kept as a fallback — this is the one method that has to
+    // change if naming moves back inline.
+    async nameNewProcessApplication(name) {
+        const isModal = await this.creationDialog
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (isModal) {
+            await this.nameInput.click({ timeout: 30000 });
+            await this.nameInput.fill(name);
+            await (0, test_1.expect)(this.nameInput).toHaveValue(name, { timeout: 10000 });
+            await (0, submitModalWithRetry_1.submitModalWithRetry)(this.submitButton, this.creationDialog);
+            await this.waitForProcessApplication();
+            return;
+        }
+        await (0, test_1.expect)(this.inlineNameInput).toBeVisible({ timeout: 30000 });
+        await this.inlineNameInput.click({ timeout: 60000 });
+        await this.inlineNameInput.fill(name);
+        await this.inlineNameInput.press('Enter');
+        await this.waitForProcessApplication();
+    }
+    // Assigns a cluster to this process application's development stage.
+    //
+    // Deploying from inside a process application goes through
+    // ProcessAppClusterSelection, which only lists clusters the application has
+    // assigned to a stage, and does not auto-select anything when that list is
+    // empty. A freshly created process application has no stages, so the deploy
+    // dialog shows "Clusters not configured for stages" and offers nothing to
+    // pick -- which is why the old per-deploy cluster toggle was nowhere to be
+    // found. Assign the stage once, at creation, and the deploy dialog then
+    // auto-selects it.
+    //
+    // clusterName is matched as a prefix because the dropdown renders each
+    // cluster as "<name> <generation>". Without it, the first real cluster is
+    // taken -- callers that care assert the name in the deploy dialog anyway.
+    async defineDevelopmentStage(clusterName) {
+        await (0, test_1.expect)(this.defineStagesDialog).toBeVisible({ timeout: 60000 });
+        await this.developmentClusterSelect.click({ timeout: 30000 });
+        // Escape before interpolating: a cluster name can carry regex
+        // metacharacters -- "Test Cluster (v2)" is the common case -- which would
+        // otherwise mis-match or throw. Same treatment as
+        // utils/modelerCluster.selectModelerCluster.
+        const escapedClusterName = clusterName?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const option = clusterName
+            ? this.defineStagesDialog
+                .getByRole('option', { name: new RegExp(`^${escapedClusterName}`) })
+                .first()
+            : this.defineStagesDialog
+                .getByRole('option')
+                .filter({ hasNotText: 'Select a development cluster' })
+                .first();
+        await option.click({ timeout: 30000 });
+        await this.defineStagesSaveButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.defineStagesDialog).toBeHidden({ timeout: 60000 });
+    }
+    rememberResourceContainer(url) {
+        resourceContainers.set(this.page, { url });
+    }
+    // Drops the recorded development-stage binding so the next ensureStageCluster
+    // call binds again. Called when the deploy dialog turns out not to offer the
+    // cluster we believe we bound: the dialog offers exactly what the
+    // application's stages point at, so if the cluster is missing the binding
+    // did not take, and reopening the dialog can never change that. Without
+    // this, a caller's retries all re-check a state nothing is changing.
+    forgetStageCluster() {
+        const container = resourceContainers.get(this.page);
+        if (container) {
+            container.developmentCluster = undefined;
+        }
+    }
+    // A process application deploys to the clusters bound to its stages, and
+    // nothing else: inside a container DeployModal renders
+    // ProcessAppClusterSelection, which lists only those and auto-selects the
+    // first. Which cluster a test wants is known only once a deploy flow names
+    // it, so the binding happens here, on demand -- leave the diagram, bind the
+    // cluster to the development stage, come back. Repeat calls for the same
+    // cluster cost nothing, and a test deploying to a second cluster rebinds.
+    // Returns whether it navigated: the caller may have been on a view that a
+    // reload does not restore -- Play is a tab click, not a URL -- and has to
+    // re-enter it.
+    async ensureStageCluster(clusterName) {
+        const container = resourceContainers.get(this.page);
+        if (!container || container.developmentCluster === clusterName) {
+            return false;
+        }
+        const returnTo = this.page.url();
+        const paUrl = container.url.replace(/[?#].*$/, '').replace(/\/$/, '');
+        // Retried as a whole, re-entering the page on every attempt. This binding
+        // is a one-shot precondition for every deploy the test goes on to make,
+        // and unlike the deploy itself it sits outside runProcessInstance's retry
+        // loop -- so a single transient miss (the session bounced to /login, the
+        // cluster list not yet arrived when the dropdown opened) failed the test
+        // outright instead of being absorbed the way every other modal in this
+        // 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.
+        await (0, test_1.expect)(async () => {
+            await this.page.goto(`${paUrl}/connected-clusters`, {
+                waitUntil: 'domcontentloaded',
+            });
+            await this.openStageDefinition();
+            await this.defineDevelopmentStage(clusterName);
+        }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
+        container.developmentCluster = clusterName;
+        await this.page.goto(returnTo, { waitUntil: 'domcontentloaded' });
+        return true;
+    }
+    // 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
+    // the affordances hub offers before failing with exactly what was looked for.
+    // Worth the noise: an unbound cluster otherwise surfaces as a deploy dialog
+    // that silently offers nothing, which says nothing about its own cause.
+    async openStageDefinition() {
+        const opened = await this.defineStagesDialog
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (opened) {
+            return;
+        }
+        // Page-scoped .first(): hub renders one such control on this page, and a
+        // second placement must not turn every rebinding test into a strict-mode
+        // violation.
+        const reopen = this.page
+            .getByRole('button', { name: /define stages|edit stages|configure/i })
+            .first();
+        const canReopen = await reopen
+            .waitFor({ state: 'visible', timeout: 10000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!canReopen) {
+            throw new Error('Could not open the "Define stages" dialog on /connected-clusters: it ' +
+                'did not open by itself and no "Define stages" / "Edit stages" / ' +
+                '"Configure" control was found.');
+        }
+        await reopen.click({ timeout: 30000 });
+    }
+    async openByName(name) {
+        const processApplication = this.page
+            .getByRole('row')
+            .filter({ hasText: name })
+            .getByTitle(name)
+            .first();
+        await (0, test_1.expect)(processApplication).toBeVisible({ timeout: 90000 });
+        await processApplication.click({ timeout: 60000 });
+        await this.waitForProcessApplication();
+    }
+}
+exports.ProcessApplicationPage = ProcessApplicationPage;

package/dist/pages/8.7/UtilitiesPage.js

@@ -449,6 +449,14 @@ async function modelAndRunConnectorsTimerEventDiagram(modelerCreatePage, modeler
         timeout: 60000,
     });
     await connectorMarketplacePage.downloadConnectorToProject();
+    // Both lookups are container-relative: clickProjectBreadcrumb() returns to
+    // this test's process application, which is where the uploaded diagram
+    // lives. The downloaded element template is the open question -- hub
+    // publishes element templates to the workspace, but the marketplace download
+    // is initiated from inside the container, so it should land there. If a
+    // trace shows the template at workspace root instead, this call becomes
+    // clickWorkspaceBreadcrumb() followed by returnToResourceContainer() before
+    // the diagram is reopened.
     await modelerHomePage.clickProjectBreadcrumb();
     await modelerHomePage.clickProcessDiagram('REST Outbound Connector');
     await connectorTemplatePage.publishConnector();

package/dist/tests/8.7/idp-user-flows.spec.js

@@ -98,7 +98,9 @@ _8_7_1.test.describe('IDP User Flow Tests', () => {
             await modelerHomePage.clickCrossComponentProjectFolder();
         });
         await _8_7_1.test.step('Add an IDP application to the project', async () => {
-            await modelerHomePage.clickDiagramTypeDropdown();
+            // Workspace-level menu: an IDP application can only be created at
+            // workspace root, never inside a process application.
+            await modelerHomePage.clickWorkspaceDiagramTypeDropdown();
             await modelerHomePage.clickIdpApplicationTemplateOption();
             await modelerHomePage.enterIdpApplicationName(idpApplicationName);
             await modelerHomePage.selectCluster(clusterName);

package/package.json

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