@camunda/e2e-test-suite 0.0.1027 → 0.0.1028

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