@camunda/e2e-test-suite 0.0.501 → 0.0.503

package/dist/utils/apiHelpers.js

@@ -303,29 +303,61 @@ async function createProcessInstance(processDefinitionKey, authToken, environmen
 }
 exports.createProcessInstance = createProcessInstance;
 async function createClusterVariableInternal(authToken, environment, variableName, variableValue, variableType, clusterType) {
+    // Retry on transient ingress / upstream errors (502/503/504) and on
+    // network-layer exceptions, which we have observed during nightly runs
+    // when the orchestration cluster gateway is in the middle of a rollout.
+    // The actual "create" semantics are idempotent because HTTP 409 is
+    // already treated as success below.
+    const maxAttempts = 5;
+    const baseDelayMs = 2000;
+    let lastErrorMessage = '';
     try {
         apiRequestContext = await getApiRequestContext();
         const url = buildZeebeApiUrl('/v2/cluster-variables/global', environment, clusterType);
-        const response = await apiRequestContext.post(url, {
-            headers: {
-                Authorization: authToken,
-            },
-            data: {
-                name: variableName,
-                value: variableValue,
-            },
-        });
-        const status = response.status();
-        if (status === 200 || status === 201 || status === 204) {
-            return;
-        }
-        // Handle "already exists" as a benign condition
-        if (status === 409) {
-            console.warn(`${variableType} cluster variable "${variableName}" already exists (HTTP 409).`);
-            return;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            let status;
+            let bodyText = '';
+            try {
+                const response = await apiRequestContext.post(url, {
+                    headers: {
+                        Authorization: authToken,
+                    },
+                    data: {
+                        name: variableName,
+                        value: variableValue,
+                    },
+                });
+                status = response.status();
+                if (status === 200 || status === 201 || status === 204) {
+                    return;
+                }
+                // Handle "already exists" as a benign condition
+                if (status === 409) {
+                    console.warn(`${variableType} cluster variable "${variableName}" already exists (HTTP 409).`);
+                    return;
+                }
+                bodyText = await response.text();
+                lastErrorMessage = `HTTP ${status} - ${bodyText.slice(0, 200)}`;
+                // Retry on transient gateway / upstream errors.
+                if (status >= 502 && status <= 504 && attempt < maxAttempts) {
+                    console.warn(`createClusterVariable "${variableName}" attempt ${attempt}/${maxAttempts} got HTTP ${status}; retrying...`);
+                    await new Promise((r) => setTimeout(r, baseDelayMs * attempt));
+                    continue;
+                }
+            }
+            catch (networkErr) {
+                // Network-layer error (e.g. ECONNRESET while the gateway is
+                // restarting). Retry a few times before giving up.
+                lastErrorMessage =
+                    networkErr instanceof Error ? networkErr.message : String(networkErr);
+                if (attempt < maxAttempts) {
+                    console.warn(`createClusterVariable "${variableName}" attempt ${attempt}/${maxAttempts} threw (${lastErrorMessage}); retrying...`);
+                    await new Promise((r) => setTimeout(r, baseDelayMs * attempt));
+                    continue;
+                }
+            }
+            throw new Error(`Failed to create ${variableType} cluster variable "${variableName}": ${lastErrorMessage}`);
         }
-        const bodyText = await response.text();
-        throw new Error(`Failed to create ${variableType} cluster variable "${variableName}": HTTP ${status} - ${bodyText}`);
     }
     catch (error) {
         if (error instanceof Error && error.message.includes('Failed to create')) {

package/dist/utils/assertionHelpers/clickLocatorWithRetry.js

@@ -23,7 +23,15 @@ const clickLocatorWithRetry = async (page, locator, options) => {
                 throw new Error('clickLocatorWithRetry: page is closed, aborting retries');
             }
             if (options?.preAction) {
-                await options?.preAction();
+                try {
+                    await options.preAction();
+                }
+                catch (preErr) {
+                    if (isPageClosedError(preErr)) {
+                        throw preErr;
+                    }
+                    console.warn(`clickLocatorWithRetry: preAction (attempt ${attempt}) threw and will be retried:`, preErr instanceof Error ? preErr.message : preErr);
+                }
             }
             await locator.waitFor({ state: 'visible', timeout: visibilityTimeout });
             await locator.scrollIntoViewIfNeeded({ timeout: visibilityTimeout });
@@ -39,7 +47,18 @@ const clickLocatorWithRetry = async (page, locator, options) => {
             }
             console.log(`Attempt ${attempt} failed for ${locator}, retrying... Error: ${err}`);
             if (options?.postAction) {
-                await options.postAction();
+                // Swallow transient errors from the recovery action (e.g.
+                // `page.reload()` throwing ERR_CONNECTION_REFUSED while the
+                // upstream is restarting). Retry the click on the next loop.
+                try {
+                    await options.postAction();
+                }
+                catch (postErr) {
+                    if (isPageClosedError(postErr)) {
+                        throw postErr;
+                    }
+                    console.warn(`clickLocatorWithRetry: postAction (attempt ${attempt}) threw and will be retried:`, postErr instanceof Error ? postErr.message : postErr);
+                }
             }
             await page.waitForTimeout(retryDelayMs);
         }

package/dist/utils/assertionHelpers/expectLocatorWithRetry.js

@@ -9,7 +9,12 @@ const expectLocatorWithRetry = async (page, item, options) => {
         attempt++;
         try {
             if (options?.preAction) {
-                await options?.preAction();
+                try {
+                    await options.preAction();
+                }
+                catch (preErr) {
+                    console.warn(`expectLocatorWithRetry: preAction (attempt ${attempt}) threw and will be retried:`, preErr instanceof Error ? preErr.message : preErr);
+                }
             }
             await page.waitForLoadState('domcontentloaded');
             await item.waitFor({
@@ -21,7 +26,17 @@ const expectLocatorWithRetry = async (page, item, options) => {
         catch (err) {
             console.log(`Attempt ${attempt} failed for ${item}, retrying...`, err instanceof Error ? err.message : err);
             if (options?.postAction) {
-                await options?.postAction();
+                // Swallow transient errors from the recovery action (e.g.
+                // `page.reload()` throwing ERR_CONNECTION_REFUSED while the
+                // upstream is restarting). The next loop iteration will retry
+                // the visibility check itself, which is what we ultimately
+                // care about.
+                try {
+                    await options.postAction();
+                }
+                catch (postErr) {
+                    console.warn(`expectLocatorWithRetry: postAction (attempt ${attempt}) threw and will be retried:`, postErr instanceof Error ? postErr.message : postErr);
+                }
             }
             await page.waitForTimeout(500);
         }

package/package.json

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