@camunda/e2e-test-suite 0.0.1027 → 0.0.1029

package/dist/pages/8.7/FormJsPage.js

@@ -194,7 +194,26 @@ class FormJsPage {
         await (0, test_1.expect)(this.dialog).toBeVisible({
             timeout: 30000,
         });
-        await this.selectCluster(clusterName);
+        // Same recovery as ModelerCreatePage.runProcessInstance: 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. This path has no surrounding retry loop, hence the one
+        // explicit second attempt.
+        try {
+            await this.selectCluster(clusterName);
+        }
+        catch (error) {
+            const rebound = await this.processApplicationPage.ensureStageCluster(clusterName);
+            if (!rebound) {
+                throw error;
+            }
+            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 });

package/dist/pages/8.7/ModelerHomePage.js

@@ -98,7 +98,10 @@ class ModelerHomePage {
         this.uploadFilesButton = page.getByRole('menuitem', { name: 'Upload files' });
         this.dialog = page.getByRole('dialog');
         this.messageBanner = page.locator('[data-test="close-top-banner"]');
-        this.closeButton = page.getByRole('button', { name: 'Got it - Dismiss' });
+        // Matched on the shared "Got it" prefix so it covers both announcement
+        // dialogs hub currently ships: the release notes one ("Got it - Dismiss")
+        // and the process-application restructure one ("Got it").
+        this.closeButton = page.getByRole('button', { name: 'Got it' });
         this.optionsButton = page.getByRole('button', { name: 'Options' });
         this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
             hasText: formName,
@@ -106,16 +109,31 @@ class ModelerHomePage {
         this.formBreadcrumbButton = page.locator('button[data-test="breadcrumb-form"]');
         this.renameFormMenuItem = page.locator('[data-test="rename-form"]');
     }
+    // The release-announcement dialog ("Check out our new release") re-mounts
+    // after the projects list re-renders, so one dismissal pass is not enough.
+    // Repeat while a pass still finds something to dismiss; a pass that finds
+    // nothing returns immediately, so the cost is unchanged when no overlay is up.
     async dismissOverlays() {
-        for (const locator of [
-            this.closeButton,
-            this.page.getByRole('button', { name: 'Close' }).first(),
-            this.messageBanner,
-        ]) {
-            await locator
-                .waitFor({ state: 'visible', timeout: 3000 })
-                .then(() => locator.click())
-                .catch(() => { });
+        for (let pass = 0; pass < 3; pass++) {
+            let dismissed = false;
+            for (const locator of [
+                this.closeButton,
+                this.page.getByRole('button', { name: 'Close' }).first(),
+                this.messageBanner,
+            ]) {
+                const visible = await locator
+                    .waitFor({ state: 'visible', timeout: 3000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (!visible) {
+                    continue;
+                }
+                await locator.click({ timeout: 10000 }).catch(() => { });
+                dismissed = true;
+            }
+            if (!dismissed) {
+                return;
+            }
         }
     }
     async clickCreateNewProjectButton() {
@@ -127,10 +145,39 @@ class ModelerHomePage {
             visibilityTimeout: 10000,
         });
     }
+    // The rename runs on a freshly created project, which is exactly when an
+    // announcement dialog mounts on top of it: it takes focus, the inline editor
+    // unmounts, and a single click on `[data-test="editable-input"]` then waits
+    // out its whole timeout on an element that never comes back — leaving the
+    // project named "New project". Dismiss overlays and re-enter the name until
+    // it commits.
+    //
+    // The committed name renders differently per page: the project page puts it
+    // in the breadcrumb menu button, and only the projects list carries a
+    // `[title="<name>"]` link. Accept either, and once the rename has been
+    // submitted treat the editor unmounting as done — hub keeps rendering the
+    // pre-rename fetch until a reload, which the caller's Home-page assertion
+    // already performs.
     async enterNewProjectName(name) {
-        await this.projectNameInput.click({ timeout: 60000 });
-        await this.projectNameInput.fill(name);
-        await this.projectNameInput.press('Enter');
+        const committedName = this.page
+            .locator('[data-test="breadcrumb-project-menu"]', { hasText: name })
+            .or(this.page.getByTitle(name, { exact: true }))
+            .first();
+        let submitted = false;
+        await (0, test_1.expect)(async () => {
+            if (await committedName.isVisible()) {
+                return;
+            }
+            if (submitted && !(await this.projectNameInput.isVisible())) {
+                return;
+            }
+            await this.dismissOverlays();
+            await this.projectNameInput.click({ timeout: 15000 });
+            await this.projectNameInput.fill(name);
+            submitted = true;
+            await this.projectNameInput.press('Enter');
+            await (0, test_1.expect)(committedName).toBeVisible({ timeout: 10000 });
+        }).toPass({ timeout: 120000 });
     }
     async enterIdpApplicationName(name) {
         await this.idpApplicationNameInput.click({ timeout: 60000 });
@@ -378,12 +425,17 @@ class ModelerHomePage {
             await this.page.getByText('Home', { exact: true }).first().click();
         }
     }
+    // An announcement dialog covering the Modeler header makes every click on the
+    // org button bounce off the modal layer ("intercepts pointer events") until
+    // the timeout, so dismiss overlays before each attempt.
     async clickOpenOrganizationsButton() {
-        await (0, sleep_1.sleep)(5000);
-        await (0, test_1.expect)(this.openOrganizationsButton).toBeVisible({
-            timeout: 10000,
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.openOrganizationsButton, {
+            preAction: async () => {
+                await this.dismissOverlays();
+            },
+            totalTimeout: 120000,
+            visibilityTimeout: 30000,
         });
-        await this.openOrganizationsButton.click({ timeout: 30000 });
     }
     async clickCrossComponentProjectFolder() {
         await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.crossComponentProjectFolder, {

package/dist/pages/8.7/ProcessApplicationPage.js

@@ -160,6 +160,19 @@ class ProcessApplicationPage {
                 .filter({ hasNotText: 'Select a development cluster' })
                 .first();
         await option.click({ timeout: 30000 });
+        // The field defaults to the first cluster alphabetically and re-mounts as
+        // the cluster list settles, so an option click can be dropped and Save
+        // then persists that default. Nothing downstream re-reads the binding --
+        // ensureStageCluster records the requested cluster as fact -- so the
+        // symptom surfaces much later, as a deploy dialog offering a cluster the
+        // test never asked for. Confirm the field carries the chosen cluster
+        // before saving; ensureStageCluster's retry re-navigates and binds again
+        // when it does not.
+        if (clusterName) {
+            await (0, test_1.expect)(this.developmentClusterSelect).toContainText(clusterName, {
+                timeout: 15000,
+            });
+        }
         await this.defineStagesSaveButton.click({ timeout: 30000 });
         await (0, test_1.expect)(this.defineStagesDialog).toBeHidden({ timeout: 60000 });
     }

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

@@ -159,7 +159,10 @@ declare class ModelerCreatePage {
     clickMarketPlaceButton(): Promise<void>;
     completeDeploymentEndpointConfiguration(): Promise<void>;
     completePlayConfiguration(): Promise<void>;
-    filterChangeElementPopup(searchTerm: string): Promise<void>;
+    revealChangeElementTemplate(option: Locator, searchTerm: string): Promise<boolean>;
+    private isVisibleWithin;
+    private openChangeElementPopup;
+    private clickChangeElementTemplateOption;
     clickWebhookMessageStartEventConnectorOption(): Promise<void>;
     clickWebhookIdInput(): Promise<void>;
     clearWebhookIdInput(): Promise<void>;

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

@@ -1128,76 +1128,93 @@ class ModelerCreatePage {
             }
         }
     }
-    // Connector templates now live in the popup's "Reusable assets" tab, not
-    // the default "BPMN" one, so they do not render until either that tab is
-    // selected or a search is active (search spans every tab and flattens the
-    // result list).
+    // Two independent paths put a connector template into the popup's queryable
+    // DOM slice, and neither is reliable alone: selecting the "Reusable assets"
+    // tab renders the template entries directly, while searching flattens the
+    // result list. Probe the option after each step and stop at the first one
+    // that worked, then keep re-issuing the filter while the popup stays open:
+    // the project's connector-template list is fetched asynchronously, so a
+    // filter typed before it lands renders "0 results found" and a single typed
+    // filter never picks the template up afterwards.
     // Use pressSequentially (not fill): the popup syncs its search state from a
     // keyup listener only, and fill() dispatches just an input event, so the
     // filter never applies and the unfiltered BPMN tab keeps rendering.
-    async filterChangeElementPopup(searchTerm) {
-        // Two independent paths put the template in the DOM, and neither is
-        // reliable alone: selecting the tab renders the template entries
-        // directly, while searching spans every tab and flattens the result
-        // list. Run 32243588212 showed the search registering (the tab strip
-        // hid) with the template still absent from .djs-popup-results, so the
-        // tab click runs first and the search backs it up.
-        const hasTabs = await this.changeElementTabStrip
-            .isVisible({ timeout: 5000 })
-            .catch(() => false);
-        if (hasTabs) {
+    async revealChangeElementTemplate(option, searchTerm) {
+        if (await this.isVisibleWithin(option, 5000)) {
+            return true;
+        }
+        if (await this.isVisibleWithin(this.changeElementTabStrip, 5000)) {
             // A failed tab click leaves the search path intact, so do not throw.
             await this.reusableAssetsTab.click({ timeout: 30000 }).catch(() => { });
+            if (await this.isVisibleWithin(option, 15000)) {
+                return true;
+            }
         }
-        const hasSearch = await this.changeElementSearchInput
-            .isVisible({ timeout: 5000 })
+        if (!(await this.isVisibleWithin(this.changeElementSearchInput, 5000))) {
+            return false;
+        }
+        const deadline = Date.now() + 90000;
+        do {
+            await this.changeElementSearchInput.click();
+            await this.changeElementSearchInput.fill('');
+            await this.changeElementSearchInput.pressSequentially(searchTerm, {
+                delay: 50,
+            });
+            if (await this.isVisibleWithin(option, 15000)) {
+                return true;
+            }
+        } while (Date.now() < deadline);
+        return false;
+    }
+    async isVisibleWithin(locator, timeout) {
+        return locator
+            .waitFor({ state: 'visible', timeout })
+            .then(() => true)
             .catch(() => false);
-        if (!hasSearch) {
+    }
+    // The specs reach the Marketplace through this popup's own empty-state link,
+    // and the import modal closes the popup behind it, so the popup is routinely
+    // gone by the time a template is clicked. Reopen it against the element being
+    // replaced first: filtering a closed popup finds no search input and the
+    // option assertion then times out against a popup that was never on screen.
+    async openChangeElementPopup(element) {
+        if (await this.isVisibleWithin(this.changeElementSearchInput, 5000)) {
             return;
         }
-        await this.changeElementSearchInput.click();
-        await this.changeElementSearchInput.fill('');
-        await this.changeElementSearchInput.pressSequentially(searchTerm, {
-            delay: 50,
-        });
-        // The popup hides its tab strip while searching. Wait on that as a
-        // readiness signal, but do not assert it: with the tab already selected
-        // the template is reachable whether or not the search registered.
-        await (0, test_1.expect)(this.changeElementTabStrip)
-            .toBeHidden({ timeout: 30000 })
-            .catch(() => { });
+        // The context pad only renders for a selected element, so "Change element"
+        // would otherwise never appear.
+        await (0, test_1.expect)(element).toBeVisible({ timeout: 60000 });
+        await element.click({ force: true, timeout: 30000 });
+        await this.changeTypeButton.click({ force: true, timeout: 30000 });
     }
-    async clickWebhookMessageStartEventConnectorOption() {
+    async clickChangeElementTemplateOption(option, element, searchTerm) {
         const maxRetries = 3;
+        let lastError;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
-                if (retries === 0) {
-                    await this.filterChangeElementPopup('Webhook Message Start Event Connector');
-                    await this.webhookMessageStartEventConnectorOption.click({
-                        timeout: 30000,
-                    });
-                }
-                else {
+                if (retries > 0) {
                     await this.page.reload();
-                    // A reload drops the selection, so re-select the start event before
-                    // reopening the popup -- the context pad only renders for a selected
-                    // element and "Change element" would otherwise never appear.
-                    await (0, test_1.expect)(this.startEventElement).toBeVisible({ timeout: 60000 });
-                    await this.startEventElement.click({ force: true, timeout: 30000 });
-                    await this.changeTypeButton.click({ force: true, timeout: 30000 });
-                    await this.filterChangeElementPopup('Webhook Message Start Event Connector');
-                    await this.webhookMessageStartEventConnectorOption.click({
-                        timeout: 90000,
-                    });
+                    // domcontentloaded is more reliable than networkidle for Modeler,
+                    // which maintains persistent background connections (SSE/WebSocket).
+                    await this.page.waitForLoadState('domcontentloaded');
                 }
+                await this.openChangeElementPopup(element);
+                if (!(await this.revealChangeElementTemplate(option, searchTerm))) {
+                    throw new Error('The connector template never appeared in the change-element popup.');
+                }
+                await option.click({ timeout: 30000 });
                 return;
             }
             catch (error) {
+                lastError = error;
                 console.error(`Click attempt ${retries + 1} failed: ${error}`);
-                await new Promise((resolve) => setTimeout(resolve, 10000));
+                await (0, sleep_1.sleep)(10000);
             }
         }
-        throw new Error(`Failed to click the button after ${maxRetries} attempts.`);
+        throw new Error(`Failed to click the connector template after ${maxRetries} attempts: ${lastError}`);
+    }
+    async clickWebhookMessageStartEventConnectorOption() {
+        await this.clickChangeElementTemplateOption(this.webhookMessageStartEventConnectorOption, this.startEventElement, 'Webhook');
     }
     async clickWebhookIdInput() {
         await this.webhookIdInput.click();
@@ -1354,33 +1371,7 @@ class ModelerCreatePage {
         await this.appendViaPopup('append-none-intermediate-throwing', ['append-events', 'append-intermediate-throw-events'], 'Intermediate throw event');
     }
     async clickIntermediateWebhookConnectorOption() {
-        const max = 3;
-        for (let i = 0; i < max; i++) {
-            try {
-                // Filter the popup to surface the webhook connector: it sits in the
-                // "Reusable assets" tab, which the popup only flattens into the result
-                // list while a search is active.
-                await this.filterChangeElementPopup('Webhook');
-                await (0, test_1.expect)(this.intermediateWebhookConnectorOption).toBeVisible({
-                    timeout: 30000,
-                });
-                await this.intermediateWebhookConnectorOption.click({ timeout: 30000 });
-                return;
-            }
-            catch (err) {
-                console.error(`clickIntermediateWebhookConnectorOption attempt ${i + 1} failed: ${err}`);
-                if (i === max - 1)
-                    throw err;
-                await this.page.reload();
-                // domcontentloaded is more reliable than networkidle for Modeler
-                // which maintains persistent background connections (SSE/WebSocket).
-                await this.page.waitForLoadState('domcontentloaded');
-                // Wait for modeler canvas to render after reload before re-selecting
-                await (0, test_1.expect)(this.secondElement).toBeVisible({ timeout: 60000 });
-                await this.secondElement.click({ force: true, timeout: 30000 });
-                await this.changeTypeButton.click({ force: true, timeout: 30000 });
-            }
-        }
+        await this.clickChangeElementTemplateOption(this.intermediateWebhookConnectorOption, this.secondElement, 'Webhook');
     }
     async clickCorrelationKeyProcessInput() {
         await this.correlationKeyProcessInput.click({ timeout: 60000 });

package/dist/tests/SM-8.10/connectors-user-flows.spec.js

@@ -98,7 +98,7 @@ SM_8_10_1.test.describe('Connectors User Flow Tests @tasklistV2', () => {
             await modelerCreatePage.clickStartEventElement();
             await modelerCreatePage.clickChangeTypeButton();
             try {
-                await modelerCreatePage.filterChangeElementPopup('Webhook Message Start Event Connector');
+                await modelerCreatePage.revealChangeElementTemplate(modelerCreatePage.webhookMessageStartEventConnectorOption, 'Webhook');
                 await (0, test_1.expect)(modelerCreatePage.webhookMessageStartEventConnectorOption).toBeVisible({
                     timeout: 15000,
                 });
@@ -212,7 +212,9 @@ SM_8_10_1.test.describe('Connectors User Flow Tests @tasklistV2', () => {
                 // Probe for the template this flow needs: an intermediate event's
                 // change-element list never offers the message start event connector,
                 // so probing for that one always fell through to the marketplace.
-                await modelerCreatePage.filterChangeElementPopup('Webhook Intermediate Event Connector');
+                // 'Webhook' is the filter both webhook flows share; the entry is then
+                // picked by its template id, so a broader term cannot mis-select.
+                await modelerCreatePage.revealChangeElementTemplate(modelerCreatePage.intermediateWebhookConnectorOption, 'Webhook');
                 await (0, test_1.expect)(modelerCreatePage.intermediateWebhookConnectorOption).toBeVisible({
                     timeout: 15000,
                 });

package/package.json

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