@camunda/e2e-test-suite 0.0.1126 → 0.0.1128

package/dist/pages/SM-8.10/ModelerCreatePage.js

@@ -187,7 +187,12 @@ class ModelerCreatePage {
         this.variableInput = page.locator('[id="variables-json"]');
         this.businessIdInput = page.locator('[id^="business-id-input"]');
         this.embedFormButton = page.getByRole('button', { name: 'Link form' });
-        this.embedButton = page.locator('[data-test="confirm-move"]');
+        // Workspaces-enabled Web Modeler renders the "Link a form" picker via
+        // LinkTargetModal, whose primary action carries data-test="link-target-confirm"
+        // instead of the legacy move dialog's "confirm-move".
+        this.embedButton = page
+            .locator('[data-test="confirm-move"]')
+            .or(page.locator('[data-test="link-target-confirm"]'));
         this.newForm = page.locator('[data-test="item-New form"]');
         this.continueToPlayButton = page.getByRole('button', { name: 'Continue' });
         this.deploySubButton = page
@@ -414,11 +419,28 @@ class ModelerCreatePage {
         await (0, test_1.expect)(this.secondElement).toBeVisible({ timeout: 30000 });
         await (0, test_1.expect)(this.thirdElement).toBeVisible({ timeout: 30000 });
     }
+    // The Carbon shell links a form via a plain list item click. Workspaces-enabled
+    // Web Modeler instead browses LinkTargetModal, whose rows are files keyed by id
+    // (not name) and merely *select* the row -- linking requires a separate confirm
+    // click (LinkTargetLevel/SelectableRow: `aria-label="Select ${name}"`, and the
+    // modal's own primary button, clicked by the caller via clickEmbedButton()).
     async clickForm(name) {
-        await this.page
+        const legacyItem = this.page
             .locator(`[data-test="item-${name}"]`)
-            .getByText(name)
-            .click({ timeout: 90000 });
+            .getByText(name);
+        const selectableRow = this.page.getByRole('button', {
+            name: `Select ${name}`,
+            exact: true,
+        });
+        await legacyItem
+            .or(selectableRow)
+            .first()
+            .waitFor({ state: 'visible', timeout: 90000 });
+        if (await selectableRow.isVisible().catch(() => false)) {
+            await selectableRow.click({ timeout: 90000 });
+            return;
+        }
+        await legacyItem.click({ timeout: 90000 });
     }
     async runProcessInstance(variables = '', tenant = '', businessId = '') {
         await this.processApplicationPage.ensureStageCluster(process.env.MODELER_CLUSTER_NAME);

package/dist/pages/SM-8.10/ModelerHomePage.d.ts

@@ -5,9 +5,22 @@ declare class ModelerHomePage {
     private processApplicationPage;
     private processApplicationUrl?;
     private processApplicationName?;
+    private workspaceProjectsUrl?;
+    private workspacesOverviewUrl?;
     readonly modelerPageBanner: Locator;
     readonly createNewProjectButton: Locator;
+    readonly createWorkspaceButton: Locator;
+    readonly workspaceOpenButton: Locator;
+    readonly noWorkspacesHeading: Locator;
+    readonly workspaceWizardHeading: Locator;
+    readonly workspaceNameInput: Locator;
+    readonly workspaceDescriptionInput: Locator;
+    readonly workspaceWizardSubmit: Locator;
+    readonly workspaceMembersHeading: Locator;
     readonly projectNameInput: Locator;
+    readonly workspaceWizardNameInput: Locator;
+    readonly workspaceWizardSubmitButton: Locator;
+    readonly workspaceWizardMembersStep: Locator;
     readonly moreActionsButton: Locator;
     readonly renameMenuItem: Locator;
     readonly renameInput: Locator;
@@ -36,9 +49,16 @@ declare class ModelerHomePage {
     constructor(page: Page);
     clickCreateNewProjectButton(): Promise<void>;
     enterNewProjectName(name: string): Promise<void>;
+    private createWorkspaceViaWizard;
     waitForModelerReady(timeoutMs?: number): Promise<void>;
     createCrossComponentProjectFolder(): Promise<void>;
     clickCrossComponentProjectFolder(): Promise<void>;
+    private ensureWorkspaceOpen;
+    private gotoWorkspacesOverview;
+    private createWorkspace;
+    private openWorkspaceTile;
+    private openOrCreateLegacyFolder;
+    private dismissModals;
     clickProcessDiagram(name: string): Promise<void>;
     clickHomeBreadcrumb(): Promise<void>;
     clickChooseBpmnTemplateButton(): Promise<void>;

package/dist/pages/SM-8.10/ModelerHomePage.js

@@ -21,9 +21,33 @@ class ModelerHomePage {
     // is how we get back. Hub's own Playwright suite does the same.
     processApplicationUrl;
     processApplicationName;
+    // Flag-on (workspaces-enabled) state. Under camunda-hub#27903 the c8-e2e
+    // "project folder" maps to a Workspace and the "process application" to a
+    // Project: `/` redirects to the `/workspaces` overview, a Workspace holds a
+    // projects listing at `/workspace/{wsId}/projects`, and a Project (the
+    // resource container) lives one level deeper. These remember the shared
+    // Workspace's projects-listing URL and the overview URL so returns don't
+    // re-walk the hierarchy from the root each time.
+    workspaceProjectsUrl;
+    workspacesOverviewUrl;
     modelerPageBanner;
     createNewProjectButton;
+    // /workspaces overview controls (flag-on). The "Create workspace" CTA is
+    // always present there (empty-state button, or the toolbar's own once a
+    // workspace exists); each existing workspace renders an "Open workspace {name}"
+    // tile. See the hub team's HomePage/CreateWorkspacePage page objects.
+    createWorkspaceButton;
+    workspaceOpenButton;
+    noWorkspacesHeading;
+    workspaceWizardHeading;
+    workspaceNameInput;
+    workspaceDescriptionInput;
+    workspaceWizardSubmit;
+    workspaceMembersHeading;
     projectNameInput;
+    workspaceWizardNameInput;
+    workspaceWizardSubmitButton;
+    workspaceWizardMembersStep;
     moreActionsButton;
     renameMenuItem;
     renameInput;
@@ -75,6 +99,14 @@ class ModelerHomePage {
             exact: true,
         }));
         this.projectNameInput = page.locator('[data-test="editable-input"]');
+        // The Design System shell no longer creates an empty project and renames it
+        // inline; "Create workspace" opens a two-step wizard (General -> Members)
+        // that names the workspace up front. The name lives on the General step, and
+        // the submit button keeps this test id across both steps ("Next" on General,
+        // "Create workspace" on Members).
+        this.workspaceWizardNameInput = page.locator('#workspace-name');
+        this.workspaceWizardSubmitButton = page.locator('[data-test="workspace-wizard-submit"]');
+        this.workspaceWizardMembersStep = page.locator('[data-test="step-members"]');
         // The rename kebab sits beside the breadcrumb in the app header. The
         // editor's action bar is a <header> too, so it also carries the banner
         // role -- getByRole('banner') alone matches three headers in the editor
@@ -127,9 +159,8 @@ class ModelerHomePage {
         this.openOrganizationsButton = page.getByLabel('Open Organizations');
         this.manageButton = page.getByRole('button', { name: 'Manage' });
         this.crossComponentProjectFolder = page
-            .getByTitle(this.defaultFolderName, {
-            exact: true,
-        })
+            .getByRole('button', { name: `Open workspace ${this.defaultFolderName}` })
+            .or(page.getByTitle(this.defaultFolderName, { exact: true }))
             .first();
         // The Design System shell drops the breadcrumb-home hook and labels the
         // same crumb "My organisation".
@@ -154,6 +185,29 @@ class ModelerHomePage {
         this.messageBanner = page.locator('[data-test="close-top-banner"]');
         this.closeButton = page.getByRole('button', { name: 'Got it - Dismiss' });
         this.modalCloseButton = page.locator('.cds--modal.is-visible .cds--modal-close');
+        // exact:true — the Workspaces overview "Create workspace" split button has a
+        // sibling options chevron whose name would otherwise substring-match.
+        this.createWorkspaceButton = page.getByRole('button', {
+            name: 'Create workspace',
+        });
+        this.workspaceOpenButton = page
+            .getByRole('button', { name: /^open workspace /i })
+            .first();
+        this.noWorkspacesHeading = page.getByRole('heading', {
+            name: /no workspaces/i,
+        });
+        // Create-workspace wizard (`/workspaces/create`). Its single primary button
+        // relabels itself "Next" -> "Create workspace" as the step changes, so it is
+        // located by the stable data-test hook rather than its changing name.
+        this.workspaceWizardHeading = page.getByRole('heading', {
+            name: 'New workspace',
+        });
+        this.workspaceNameInput = page.getByLabel('Workspace name');
+        this.workspaceDescriptionInput = page.getByLabel('Description');
+        this.workspaceWizardSubmit = page.locator('[data-test="workspace-wizard-submit"]');
+        this.workspaceMembersHeading = page.getByRole('heading', {
+            name: /workspace members/i,
+        });
     }
     async clickCreateNewProjectButton() {
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.createNewProjectButton, {
@@ -179,8 +233,16 @@ class ModelerHomePage {
     async enterNewProjectName(name) {
         await this.projectNameInput
             .or(this.moreActionsButton)
+            .or(this.workspaceWizardNameInput)
             .first()
             .waitFor({ state: 'visible', timeout: 30000 });
+        // Design System shell: "Create workspace" opens the creation wizard, which
+        // names the workspace on its first step, so there is no post-creation rename
+        // to perform. Check this before the inline branch — the wizard replaces it.
+        if (await this.workspaceWizardNameInput.isVisible()) {
+            await this.createWorkspaceViaWizard(name);
+            return;
+        }
         // Inline first: when the Carbon shell renders it, it is the whole flow.
         if (await this.projectNameInput.isVisible()) {
             await this.projectNameInput.click({ timeout: 60000 });
@@ -190,6 +252,17 @@ class ModelerHomePage {
         }
         await this.renameViaMoreActions(name);
     }
+    // Drives hub's two-step workspace-creation wizard. The name is entered on the
+    // General step, which enables "Next"; the Members step is optional and the
+    // second submit ("Create workspace") creates the workspace. Gate that second
+    // click on the Members step becoming active so the shared submit button is not
+    // clicked twice while still on General.
+    async createWorkspaceViaWizard(name) {
+        await this.workspaceWizardNameInput.fill(name);
+        await this.workspaceWizardSubmitButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.workspaceWizardMembersStep).toHaveAttribute('data-state', 'active', { timeout: 30000 });
+        await this.workspaceWizardSubmitButton.click({ timeout: 60000 });
+    }
     // Wait for the Modeler project workspace to become interactive. The caller
     // arrives here via goToModeler(), which has already loaded and authenticated
     // the app shell (banner visible). The nav banner mounts before the project
@@ -204,44 +277,83 @@ class ModelerHomePage {
     // the rest of the timeout. Transient upstream 50x is already absorbed by
     // goToModeler's gateway-error re-navigation before we get here.
     async waitForModelerReady(timeoutMs = 120000) {
-        // .first(): when the project folder already exists on the shared cluster,
-        // both the create-project button and the folder are present, so the .or()
-        // resolves to multiple elements — waitFor() requires a single match.
-        await this.createNewProjectButton
+        // Flag-on: `/` redirects to the `/workspaces` overview, which renders the
+        // "Create workspace" CTA (always present) plus an "Open workspace ..." tile
+        // per existing workspace — the legacy "Create new project" button never
+        // renders there, which is what used to time out. Gate on those overview
+        // markers as well as the legacy flag-off home markers, so the wait resolves
+        // whichever shell the deployment renders. .first(): several can be present
+        // at once (e.g. the CTA and a tile), and waitFor() requires a single match.
+        const workspaceElement = this.createWorkspaceButton
+            .or(this.workspaceOpenButton)
+            .or(this.createNewProjectButton)
             .or(this.crossComponentProjectFolder)
-            .first()
-            .waitFor({ state: 'visible', timeout: timeoutMs });
+            .first();
+        // The "New features" release modal renders lazily over the Modeler home,
+        // and under the Design System shell the project list -- the "Create new
+        // project" button and any existing folder included -- does not mount until
+        // the modal is dismissed. Gating on the workspace element alone therefore
+        // deadlocks: it never appears while the modal is up, and the dismissal in
+        // clickMessageBanner/clickCreateNewProjectButton only runs after this wait.
+        // Dismiss the modal on each poll until the workspace element mounts.
+        await (0, test_1.expect)(async () => {
+            await this.clickMessageBanner();
+            await (0, test_1.expect)(workspaceElement).toBeVisible({ timeout: 5000 });
+        }).toPass({ timeout: timeoutMs, intervals: [1000, 2000, 5000] });
     }
     async createCrossComponentProjectFolder() {
-        // After a fresh user login (e.g. lisa, bart) the Modeler pod may still be
-        // initialising or returning transient 503s. Poll until the app shell banner
-        // is visible before interacting with the project list.
+        // Kept name: opens (creating if absent) the shared Workspace this suite puts
+        // every test's Project inside, leaving the browser on the Workspace's
+        // projects listing. The flag-off era created a top-level project folder here;
+        // under flag-on that folder maps to a Workspace.
+        await this.ensureWorkspaceOpen();
+    }
+    async clickCrossComponentProjectFolder() {
+        // Kept name: callers use this to (re-)enter the shared Workspace's projects
+        // listing after leaving Modeler. Creates the Workspace if it is somehow
+        // absent (e.g. a fresh cluster where the setup spec did not run first).
+        await this.ensureWorkspaceOpen();
+    }
+    // Ensures the shared "Cross Component Test Project" Workspace is open and the
+    // browser is on its projects listing (`/workspace/{wsId}/projects`), where the
+    // per-test Project is later created. Retries the whole navigation+login on a
+    // transient web-modeler 500 rather than a bare reload, which would drop the
+    // authenticated SPA state and land on the empty login form.
+    async ensureWorkspaceOpen() {
         const maxAttempts = 3;
         const retryWaitMs = 5000;
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
             try {
+                // Go straight to the Workspaces overview rather than waiting on the
+                // post-login landing: after the OIDC callback the app briefly sits on
+                // Home (or /login-callback), which is not the workspace listing and on
+                // some builds does not auto-redirect to /workspaces. Navigating here
+                // explicitly is robust whether or not the root redirect fires.
+                await this.gotoWorkspacesOverview();
                 await this.waitForModelerReady();
                 await this.clickMessageBanner();
-                if (await this.crossComponentProjectFolder.isVisible()) {
-                    console.log('Cross Component Project folder already exists. Clicking into it');
-                    await this.clickCrossComponentProjectFolder();
+                const flagOn = await this.becameVisible(this.createWorkspaceButton.or(this.workspaceOpenButton).first(), 30000);
+                if (!flagOn) {
+                    // Legacy flag-off deployment (e.g. a pre-upgrade version in a
+                    // migration flow): /workspaces is not a route, so the app served Home
+                    // instead, where the shared folder IS the top-level project.
+                    await this.openOrCreateLegacyFolder();
                     return;
                 }
-                await this.clickCreateNewProjectButton();
-                await this.enterNewProjectName(this.defaultFolderName);
-                await (0, test_1.expect)(this.page.getByRole('heading', { name: this.defaultFolderName })).toBeVisible({ timeout: 10000 });
+                // On the flag-on overview. Remember it for clickHomeBreadcrumb().
+                this.workspacesOverviewUrl = this.page.url();
+                const workspaceExists = await this.crossComponentProjectFolder
+                    .isVisible()
+                    .catch(() => false);
+                if (!workspaceExists) {
+                    await this.createWorkspace(this.defaultFolderName);
+                }
+                await this.openWorkspaceTile();
                 return;
             }
             catch (error) {
                 if (attempt < maxAttempts - 1) {
-                    console.log(`createCrossComponentProjectFolder attempt ${attempt + 1} failed. Re-authenticating and retrying...`);
-                    // A transient web-modeler 500 on /api/internal/login right after the
-                    // OAuth callback makes the SPA log the user out, destroying the
-                    // Keycloak SSO session. A bare page.reload() then lands back on the
-                    // empty login form and never re-authenticates, so every remaining
-                    // attempt waits out its timeout on the login page. Re-run the full
-                    // navigation+login instead so a recovered backend can complete the
-                    // login on the next attempt.
+                    console.log(`ensureWorkspaceOpen attempt ${attempt + 1} failed. Re-authenticating and retrying...`);
                     try {
                         await new NavigationPage_1.NavigationPage(this.page).goToModeler();
                     }
@@ -256,51 +368,99 @@ class ModelerHomePage {
             }
         }
     }
-    async clickCrossComponentProjectFolder() {
-        let attempts = 0;
-        const maxAttempts = 3;
-        const timeout = 60000;
-        while (attempts < maxAttempts) {
-            try {
-                await this.clickMessageBanner();
-                await (0, test_1.expect)(this.crossComponentProjectFolder).toBeVisible({ timeout });
-                // The WhatsNew modal renders lazily after page load and intercepts clicks.
-                // Explicitly wait for it to appear (up to 5s), dismiss it, then click.
-                await this.closeButton
-                    .waitFor({ state: 'visible', timeout: 5000 })
-                    .then(() => this.closeButton.click())
-                    .catch(() => { });
-                await this.modalCloseButton
-                    .waitFor({ state: 'visible', timeout: 2000 })
-                    .then(() => this.modalCloseButton.click())
-                    .catch(() => { });
-                await this.crossComponentProjectFolder.click();
-                await this.clickMessageBanner();
-                return;
-            }
-            catch (error) {
-                attempts++;
-                if (attempts < maxAttempts) {
-                    console.log(`Attempt ${attempts} failed. Re-navigating to Modeler and retrying...`);
-                    // A transient web-modeler 500 on login right after the OAuth callback
-                    // logs the user out and leaves the page on the Keycloak login form. A
-                    // bare page.reload() then just reloads the login page and never
-                    // re-authenticates, so every remaining attempt waits out its timeout
-                    // on the login screen. Re-run the full navigation+login instead so a
-                    // recovered backend can complete the login on the next attempt.
-                    try {
-                        await new NavigationPage_1.NavigationPage(this.page).goToModeler();
-                    }
-                    catch (navError) {
-                        console.log(`Re-navigation to Modeler failed: ${navError}`);
-                    }
-                    await this.page.waitForLoadState('networkidle');
-                }
-                else {
-                    throw new Error('Failed to click crossComponentProjectFolder after 3 attempts.');
-                }
-            }
+    // Navigates to the Workspaces overview by resolving it against the Modeler app
+    // root in the current URL, so it works whether Modeler is served under
+    // `/modeler` (Self-Managed combined ingress) or at the app root.
+    async gotoWorkspacesOverview() {
+        const current = new URL(this.page.url());
+        const appRootMatch = current.pathname.match(/^(.*\/modeler)(?:\/|$)/);
+        const appRoot = appRootMatch ? appRootMatch[1] : '';
+        await this.page.goto(`${current.origin}${appRoot}/workspaces`, {
+            waitUntil: 'domcontentloaded',
+        });
+    }
+    // Walks the create-workspace wizard (`/workspaces/create`): fill the general
+    // step, advance to the members step, and submit with the creator only (the
+    // creator is pre-added as Workspace Admin, satisfying the "at least one admin"
+    // guard). The wizard returns to the `/workspaces` overview on success. The
+    // single primary button relabels itself "Next" -> "Create workspace" between
+    // steps; match its stable data-test hook where present and fall back to the
+    // step-appropriate accessible name (the wizard route does not render the
+    // overview's own "Create workspace" button, so the name is unambiguous here).
+    async createWorkspace(name) {
+        await (0, test_1.expect)(this.createWorkspaceButton).toBeVisible({ timeout: 60000 });
+        await this.createWorkspaceButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.workspaceWizardHeading).toBeVisible({ timeout: 60000 });
+        await this.workspaceNameInput.fill(name);
+        await this.workspaceDescriptionInput
+            .fill('Created by the cross-component E2E suite.')
+            .catch(() => { });
+        // Step 1 (General) -> members step.
+        await this.workspaceWizardSubmit
+            .or(this.page.getByRole('button', { name: 'Next', exact: true }))
+            .first()
+            .click({ timeout: 30000 });
+        await (0, test_1.expect)(this.workspaceMembersHeading).toBeVisible({ timeout: 60000 });
+        // Members step -> create.
+        await this.workspaceWizardSubmit
+            .or(this.page.getByRole('button', { name: 'Create workspace', exact: true }))
+            .first()
+            .click({ timeout: 30000 });
+        await this.page.waitForURL(/\/workspaces$/, { timeout: 120000 });
+        await this.waitForModelerReady();
+        this.workspacesOverviewUrl = this.page.url();
+    }
+    // Opens the shared Workspace's tile and waits until its projects listing has
+    // loaded, remembering that URL for later returns via clickWorkspaceBreadcrumb.
+    async openWorkspaceTile() {
+        await (0, test_1.expect)(this.crossComponentProjectFolder).toBeVisible({
+            timeout: 90000,
+        });
+        await this.dismissModals();
+        // Click the tile's "Open workspace" button specifically: the card also
+        // carries a plain title element (and a "Manage workspace" button) that the
+        // crossComponentProjectFolder .or(title) locator can resolve to first, and
+        // clicking those does not navigate to the projects listing.
+        const openButton = this.page.getByRole('button', {
+            name: `Open workspace ${this.defaultFolderName}`,
+        });
+        const target = (await openButton
+            .first()
+            .isVisible()
+            .catch(() => false))
+            ? openButton.first()
+            : this.crossComponentProjectFolder;
+        await target.click({ timeout: 60000 });
+        await this.page.waitForURL(/\/workspace\/[^/]+\/projects/, {
+            timeout: 120000,
+        });
+        this.workspaceProjectsUrl = this.page.url();
+        await this.clickMessageBanner();
+    }
+    // Legacy flag-off flow, kept for pre-upgrade UIs in migration specs: the shared
+    // folder is the top-level project, created inline via "Create new project".
+    async openOrCreateLegacyFolder() {
+        if (await this.crossComponentProjectFolder.isVisible().catch(() => false)) {
+            await this.dismissModals();
+            await this.crossComponentProjectFolder.click({ timeout: 60000 });
+            await this.clickMessageBanner();
+            return;
         }
+        await this.clickCreateNewProjectButton();
+        await this.enterNewProjectName(this.defaultFolderName);
+        await (0, test_1.expect)(this.page.getByRole('heading', { name: this.defaultFolderName })).toBeVisible({ timeout: 10000 });
+    }
+    // Dismisses the lazily-rendered "New features" / conditional-events modals that
+    // can intercept a click on the workspace tile or create controls.
+    async dismissModals() {
+        await this.closeButton
+            .waitFor({ state: 'visible', timeout: 5000 })
+            .then(() => this.closeButton.click())
+            .catch(() => { });
+        await this.modalCloseButton
+            .waitFor({ state: 'visible', timeout: 2000 })
+            .then(() => this.modalCloseButton.click())
+            .catch(() => { });
     }
     // Opens a resource where this test put it. Several specs leave Modeler
     // entirely (to Optimize, to Operate) and come back via
@@ -313,6 +473,15 @@ class ModelerHomePage {
         await process.click();
     }
     async clickHomeBreadcrumb() {
+        // Flag-on: "home" for Modeler is the `/workspaces` overview (the top of the
+        // hierarchy), remembered when the Workspace was opened.
+        if (this.workspacesOverviewUrl) {
+            await this.page.goto(this.workspacesOverviewUrl, {
+                waitUntil: 'domcontentloaded',
+            });
+            await this.waitForModelerReady();
+            return;
+        }
         try {
             await this.homeBreadcrumb.click({ timeout: 60000 });
         }
@@ -456,8 +625,18 @@ class ModelerHomePage {
     }
     // The workspace ("project") level itself, for the surfaces that genuinely
     // live there -- collaborators, IDP applications, published element
-    // templates.
+    // templates. Under flag-on this is the Workspace's projects listing.
     async clickWorkspaceBreadcrumb() {
+        if (this.workspaceProjectsUrl) {
+            await this.page.goto(this.workspaceProjectsUrl, {
+                waitUntil: 'domcontentloaded',
+            });
+            await this.processApplicationPage.createProcessApplicationButton
+                .waitFor({ state: 'visible', timeout: 90000 })
+                .catch(() => { });
+            await this.clickMessageBanner();
+            return;
+        }
         await this.workspaceBreadcrumb.click({ timeout: 60000 });
     }
     // Creates, once per test, the process application that holds this test's
@@ -484,6 +663,16 @@ class ModelerHomePage {
         await this.processApplicationPage.nameNewProcessApplication(this.processApplicationName);
         this.processApplicationUrl = this.page.url();
         this.processApplicationPage.rememberResourceContainer(this.processApplicationUrl);
+        // Under workspaces-enabled, a freshly created process application has no
+        // cluster assigned to its development stage: Deploy (and Play's "Configure
+        // environment") render a "Clusters not configured for stages" warning and
+        // stay disabled until one is. Assign it once here, right after the
+        // container is created, so every later deploy/run/play/connector/form flow
+        // in this test finds a usable cluster instead of independently reproducing
+        // this connection step (or failing on the warning). ensureStageCluster()
+        // memoizes per test, so runProcessInstance()'s own call is a no-op after
+        // this.
+        await this.processApplicationPage.ensureStageCluster(process.env.MODELER_CLUSTER_NAME);
     }
     // 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

package/dist/pages/SM-8.10/ProcessApplicationPage.js

@@ -6,22 +6,30 @@ const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModal
 // ModelerHomePage creates the container, while ModelerCreatePage later binds
 // its stage. Both page objects share the same Playwright 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.
+// Flag-on Self-Managed 8.10 (camunda-hub#27903: workspaces-enabled=true) renamed
+// the entity hierarchy: the legacy "project folder" is now a Workspace and the
+// legacy "process application" is now a Project (camunda-hub#28005). A Project is
+// the resource container -- files, folders and uploads live directly inside it,
+// there is no separate process-application level to descend into. It is created
+// from the workspace's projects listing via the "Create project" split button +
+// dialog, and the app lands on `/workspace/{wsId}/projects/{projectId}`.
+//
+// This page object owns that container's surface (creating a Project, and binding
+// its development-stage cluster). Entering and leaving it is driven from
+// ModelerHomePage so the ~150 existing spec call sites keep working unchanged.
+// Method names are kept from the flag-off era ("...ProcessApplication...") so the
+// callers do not have to change.
 class ProcessApplicationPage {
     page;
-    // Empty workspace root: a plain primary button rendered next to the "Create
-    // new" menu (hub's EmptyStateActionButtons).
+    // The workspace projects listing's "Create project" split button. exact:true
+    // because the split button has a sibling "Create project options" chevron whose
+    // accessible name substring-matches otherwise (mirrors the hub team's own
+    // WorkspaceProjectsPage.newProjectButton). Falls back to the legacy flag-off
+    // "Create process application" button so a deployment with the flag still off
+    // keeps working.
     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.
+    // Legacy flag-off fallback only: the "Create new" menu item. Not rendered under
+    // workspaces-enabled, where the split button above is the entry point.
     createProcessApplicationOption;
     creationDialog;
     nameInput;
@@ -37,45 +45,54 @@ class ProcessApplicationPage {
     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' })
+            .getByRole('button', { name: 'Create project', exact: true })
+            .or(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',
-        });
+        // The workspace-mode create-project dialog carries a "Project name" field and
+        // has no accessible dialog name; scope to it via that field. Keeps the legacy
+        // flag-off "Create a process application" dialog as a fallback.
+        this.creationDialog = page
+            .getByRole('dialog')
+            .filter({ has: page.getByLabel('Project name') })
+            .or(page.getByRole('dialog', { name: 'Create a process application' }))
+            .first();
         // 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.nameInput = this.creationDialog
+            .getByLabel('Project name')
+            .or(this.creationDialog.getByLabel('Name', { exact: true }))
+            .first();
+        this.submitButton = this.creationDialog
+            .getByRole('button', { name: 'Create project', exact: true })
+            .or(this.creationDialog.getByRole('button', { name: 'Create', exact: true }))
+            .first();
         this.cancelButton = this.creationDialog.getByRole('button', {
             name: 'Cancel',
             exact: true,
         });
-        this.breadcrumb = page.locator('[data-test="breadcrumb-process-application-menu"]');
-        // The Design System shell renames this region "Resources"; the Carbon shell
-        // calls it "Folder explorer". Both hold the resource table and its toolbar,
-        // so matching either keeps createNewDropdown below correctly scoped.
+        // Some shells expose a labelled resources region ("Resources" on the DS
+        // twin, "Folder explorer" on Carbon); the 8.10 flag-on Project detail does
+        // not, so this is only a soft readiness signal, never a required scope.
         this.folderExplorer = page
             .getByRole('region', { name: 'Folder explorer' })
             .or(page.getByRole('region', { name: 'Resources' }))
             .first();
-        // Design System proof that we are on a process application page: the
-        // Carbon-era breadcrumb hook is gone under that shell, the same way
-        // breadcrumb-project is.
+        // Proof we are on a Project (resource container) page: the flag-on Project
+        // detail renders this title-bar hook.
         this.titleBar = page.locator('[data-test="process-application-title-bar"]');
-        // 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"]')
+        // Any Project-detail marker also serves as an "inside the container" probe.
+        this.breadcrumb = this.titleBar.or(this.folderExplorer).first();
+        // The Project detail's "Create new" menu. Flag-on 8.10 renders it as
+        // [data-test="create-action-dropdown"] (aria-label "Create new"); older
+        // shells used [data-test="diagram-dropdown"]. Match either, page-wide,
+        // because the flag-on Project detail exposes no resources region to scope to.
+        this.createNewDropdown = page
+            .locator('[data-test="create-action-dropdown"]')
+            .or(page.locator('[data-test="diagram-dropdown"]'))
+            .or(page.getByRole('button', { name: 'Create new' }))
             .first();
         this.inlineNameInput = page.locator('[data-test="editable-input"]');
         this.defineStagesDialog = page
@@ -87,12 +104,13 @@ class ProcessApplicationPage {
             exact: true,
         });
     }
-    // Any one of the title bar, the resource region or the breadcrumb proves we
-    // are on the process application page. Three branches because the Design
-    // System and Carbon shells expose different subsets: only the title bar is
-    // present under both. .first() because several match once it has rendered.
+    // Any one of the title bar, the resource region or the create-new dropdown
+    // proves we are on the Project (resource container) page.
     pageReady() {
-        return this.titleBar.or(this.folderExplorer).or(this.breadcrumb).first();
+        return this.titleBar
+            .or(this.createNewDropdown)
+            .or(this.folderExplorer)
+            .first();
     }
     async waitForProcessApplication(timeout = 90000) {
         await (0, test_1.expect)(this.pageReady()).toBeVisible({ timeout });
@@ -109,10 +127,8 @@ class ProcessApplicationPage {
         });
         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.
+    // A Project is named up front in the create-project dialog. The inline path is
+    // kept as a fallback for the legacy flag-off "process application" surface.
     async nameNewProcessApplication(name) {
         const isModal = await this.creationDialog
             .waitFor({ state: 'visible', timeout: 15000 })
@@ -123,6 +139,10 @@ class ProcessApplicationPage {
             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);
+            // The app navigates to the new Project's own detail page on submit.
+            await this.page
+                .waitForURL(/\/projects\/[^/?#]+/, { timeout: 60000 })
+                .catch(() => { });
             await this.waitForProcessApplication();
             return;
         }
@@ -158,13 +178,19 @@ class ProcessApplicationPage {
             return;
         }
         const returnTo = this.page.url();
+        // Under workspaces-enabled there is no `/connected-clusters` sub-route: the
+        // "Connected clusters" card lives in the Project detail's sidebar and its
+        // "Configure" button opens the Define stages modal (see camunda-hub
+        // ConnectedClustersDs). So navigate to the Project detail itself and let
+        // openStageDefinition() click that button.
         const processApplicationUrl = container.url
             .replace(/[?#].*$/, '')
             .replace(/\/$/, '');
         await (0, test_1.expect)(async () => {
-            await this.page.goto(`${processApplicationUrl}/connected-clusters`, {
+            await this.page.goto(processApplicationUrl, {
                 waitUntil: 'domcontentloaded',
             });
+            await this.waitForProcessApplication();
             await this.openStageDefinition();
             await this.defineDevelopmentStage(clusterName);
         }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
@@ -174,34 +200,38 @@ class ProcessApplicationPage {
     }
     async openStageDefinition() {
         const opened = await this.defineStagesDialog
-            .waitFor({ state: 'visible', timeout: 15000 })
+            .waitFor({ state: 'visible', timeout: 3000 })
             .then(() => true)
             .catch(() => false);
         if (opened) {
             return;
         }
+        // The "Connected clusters" card's action is labelled "Configure"; earlier
+        // shells used "Define stages" / "Edit stages".
         const reopen = this.page
-            .getByRole('button', { name: /define stages|edit stages|configure/i })
+            .getByRole('button', { name: /^(define stages|edit stages|configure)$/i })
             .first();
         const canReopen = await reopen
-            .waitFor({ state: 'visible', timeout: 10000 })
+            .waitFor({ state: 'visible', timeout: 15000 })
             .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.');
+            throw new Error('Could not open the "Define stages" dialog: it did not open by ' +
+                'itself and no "Configure" / "Define stages" / "Edit stages" ' +
+                'control was found on the Project detail page.');
         }
         await reopen.click({ timeout: 30000 });
     }
     async openByName(name) {
-        const processApplication = this.page
-            .getByRole('row')
-            .filter({ hasText: name })
-            .getByTitle(name)
+        // Workspace-mode projects table: the whole row is the click target (see the
+        // hub team's WorkspaceProjectsPage). Fall back to the legacy title cell.
+        const projectRow = this.page
+            .getByRole('row', { name })
+            .first()
+            .or(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 (0, test_1.expect)(projectRow).toBeVisible({ timeout: 90000 });
+        await projectRow.click({ timeout: 60000 });
         await this.waitForProcessApplication();
     }
 }

package/package.json

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