@camunda/e2e-test-suite 0.0.502 → 0.0.504

package/dist/pages/SM-8.8/KeycloakAdminPage.js

@@ -48,7 +48,11 @@ class KeycloakAdminPage {
         await this.page.getByTestId('user-creation-save').click();
     }
     async fillPassword(password) {
+        await (0, test_1.expect)(this.page.getByTestId('credentials')).toBeVisible({
+            timeout: 30000,
+        });
         await this.page.getByTestId('credentials').click();
+        await (0, test_1.expect)(this.page.getByTestId('no-credentials-empty-action')).toBeVisible({ timeout: 30000 });
         await this.page.getByTestId('no-credentials-empty-action').click();
         await this.page.getByTestId('passwordField').fill(password);
         await this.page.getByTestId('passwordConfirmationField').fill(password);

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

@@ -32,6 +32,8 @@ declare class ModelerCreatePage {
     readonly clientIdTextbox: Locator;
     readonly clientSecretTextbox: Locator;
     readonly rememberCredentialsCheckbox: Locator;
+    readonly deployDialogUsernameInput: Locator;
+    readonly deployDialogPasswordInput: Locator;
     readonly webhookMessageStartEventConnectorOption: Locator;
     readonly webhookIdInput: Locator;
     readonly implementationSection: Locator;

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

@@ -37,6 +37,8 @@ class ModelerCreatePage {
     clientIdTextbox;
     clientSecretTextbox;
     rememberCredentialsCheckbox;
+    deployDialogUsernameInput;
+    deployDialogPasswordInput;
     webhookMessageStartEventConnectorOption;
     webhookIdInput;
     implementationSection;
@@ -123,10 +125,12 @@ class ModelerCreatePage {
             name: 'Deploy & run',
             exact: true,
         });
-        this.deployAndRunSubButton = this.dialog.getByRole('button', {
+        this.deployAndRunSubButton = this.dialog
+            .getByRole('button', {
             name: 'Deploy & run',
             exact: true,
-        });
+        })
+            .last();
         this.viewProcessInstanceLink = page.getByRole('link', {
             name: 'View process instance',
         });
@@ -151,6 +155,12 @@ class ModelerCreatePage {
         this.clientIdTextbox = page.getByLabel('Client ID');
         this.clientSecretTextbox = page.getByLabel('Client secret');
         this.rememberCredentialsCheckbox = page.getByText('Remember credentials');
+        this.deployDialogUsernameInput = page
+            .getByRole('dialog')
+            .getByLabel('Username');
+        this.deployDialogPasswordInput = page
+            .getByRole('dialog')
+            .getByLabel('Password');
         this.webhookMessageStartEventConnectorOption = page.getByRole('listitem', {
             name: 'Webhook Message Start Event Connector',
             exact: true,
@@ -339,6 +349,24 @@ class ModelerCreatePage {
                 await (0, test_1.expect)(this.dialog).toBeVisible({
                     timeout: 30000,
                 });
+                // Fill credentials if the dialog requires them (first run on a fresh
+                // cluster). Two auth modes are possible depending on cluster setup:
+                //  - OAuth2: "Client ID" + "Client secret" fields
+                //  - Basic / username-password: "Username" + "Password" fields
+                const clientIdVisible = await this.clientIdTextbox.isVisible();
+                const usernameVisible = await this.deployDialogUsernameInput.isVisible();
+                if (clientIdVisible) {
+                    await this.completeDeploymentEndpointConfiguration();
+                }
+                else if (usernameVisible) {
+                    await this.deployDialogUsernameInput.fill(process.env.DEMO_USER_EMAIL || 'demo');
+                    await this.deployDialogPasswordInput.fill(process.env.DISTRO_QA_E2E_TESTS_IDENTITY_FIRSTUSER_PASSWORD || '');
+                    // "Remember credentials" checkbox may not be present in all SM setups
+                    const rememberVisible = await this.rememberCredentialsCheckbox.isVisible();
+                    if (rememberVisible) {
+                        await this.rememberCredentialsCheckbox.click({ timeout: 30000 });
+                    }
+                }
                 if (variables.length > 0) {
                     await (0, test_1.expect)(this.variableInput).toBeVisible({
                         timeout: 60000,
@@ -356,12 +384,12 @@ class ModelerCreatePage {
             }
             catch (error) {
                 if (attempt < maxRetries - 1) {
-                    console.warn(`Attempt ${attempt + 1} failed for deploy & run running process. Retrying...`);
+                    console.warn(`Attempt ${attempt + 1} failed for deploy & run: ${error}. Retrying...`);
                     await this.page.reload();
                     await (0, sleep_1.sleep)(10000);
                 }
                 else {
-                    throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                    throw new Error(`Assertion failed after ${maxRetries} attempts: ${error}`);
                 }
             }
         }
@@ -732,7 +760,7 @@ class ModelerCreatePage {
     }
     async instanceStartedAssertion() {
         await (0, test_1.expect)(this.page.getByText('Instance started!')).toBeVisible({
-            timeout: 10000,
+            timeout: 60000,
         });
     }
     async assertImplementationOption(implementationType) {

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