@camunda/e2e-test-suite 0.0.1014 → 0.0.1016

package/dist/pages/8.8/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.8/UtilitiesPage.js

@@ -509,6 +509,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/dist/tests/8.8/access-user-role-management.spec.js

@@ -129,7 +129,7 @@ _8_8_1.test.describe('User Roles User Flow', () => {
             await modelerCreatePage.clickAppendEndEventButton();
             await (0, sleep_1.sleep)(20000);
             await modelerCreatePage.runProcessInstance(clusterName);
-            await (0, test_1.expect)(page.getByText('The diagram failed to deploy & run')).toBeVisible({ timeout: 60000 });
+            await (0, test_1.expect)(page.getByText(/The (diagram|application) failed to deploy & run/)).toBeVisible({ timeout: 60000 });
             await modelerCreatePage.clickCloseButton();
         });
     });
@@ -219,7 +219,7 @@ _8_8_1.test.describe('User Roles User Flow', () => {
             await modelerCreatePage.clickAppendEndEventButton();
             await (0, sleep_1.sleep)(20000);
             await modelerCreatePage.runProcessInstance(clusterName, '', {}, '', true);
-            await (0, test_1.expect)(page.getByText('The diagram failed to deploy & run')).toBeVisible({ timeout: 60000 });
+            await (0, test_1.expect)(page.getByText(/The (diagram|application) failed to deploy & run/)).toBeVisible({ timeout: 60000 });
             await modelerCreatePage.clickCloseButton();
         });
     });
@@ -314,7 +314,7 @@ _8_8_1.test.describe('User Roles User Flow', () => {
             await modelerCreatePage.clickAppendEndEventButton();
             await (0, sleep_1.sleep)(20000);
             await modelerCreatePage.runProcessInstance(clusterName);
-            await (0, test_1.expect)(page.getByText('The diagram failed to deploy & run')).not.toBeVisible({ timeout: 60000 });
+            await (0, test_1.expect)(page.getByText(/The (diagram|application) failed to deploy & run/)).not.toBeVisible({ timeout: 60000 });
             await (0, test_1.expect)(modelerCreatePage.viewProcessInstanceLink).toBeVisible({
                 timeout: 120000,
             });

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

@@ -87,7 +87,9 @@ _8_8_1.test.describe('IDP User Flow Tests', () => {
                     await modelerHomePage.clickCrossComponentProjectFolder();
                 });
                 await _8_8_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 _8_8_1.test.step('Creates a document extraction template', async () => {
@@ -159,7 +161,9 @@ _8_8_1.test.describe('IDP User Flow Tests', () => {
                     await modelerHomePage.clickCrossComponentProjectFolder();
                 });
                 await _8_8_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 _8_8_1.test.step('Creates a document extraction template', async () => {

package/package.json

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