@camunda/e2e-test-suite 0.0.633 → 0.0.634

package/dist/pages/8.7/ClusterSecretsPage.js

@@ -63,21 +63,37 @@ class ClusterSecretsPage {
             return; //No Connector Secrets found in the list
         }
         try {
-            let options = await this.optionsButton.all();
-            while (options.length > 0) {
-                const optionButton = options[0];
-                if (await optionButton.isVisible()) {
+            for (let sweep = 0; sweep < 20; sweep++) {
+                const options = await this.optionsButton.all();
+                if (options.length === 0) {
+                    break;
+                }
+                let deletedAny = false;
+                for (const optionButton of options) {
+                    if (!(await optionButton.isVisible().catch(() => false))) {
+                        continue;
+                    }
                     await optionButton.click({ timeout: 60000 });
+                    await (0, test_1.expect)(this.deleteConnectorSecretButton).toBeVisible({
+                        timeout: 15000,
+                    });
+                    if (await this.deleteConnectorSecretButton.isDisabled()) {
+                        await this.page.keyboard.press('Escape').catch(() => { });
+                        continue;
+                    }
                     await this.deleteConnectorSecretButton.click({ timeout: 60000 });
                     await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 40000 });
                     await this.deleteConnectorSecretSubButton.click();
                     await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
                         timeout: 60000,
                     });
+                    deletedAny = true;
+                    await (0, sleep_1.sleep)(3000);
+                    break;
+                }
+                if (!deletedAny) {
+                    break;
                 }
-                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-                await sleep(3000);
-                options = await this.optionsButton.all();
             }
             await (0, test_1.expect)(this.optionsButton).not.toBeVisible({
                 timeout: 30000,

package/dist/pages/8.7/ConsoleOrganizationPage.js

@@ -194,7 +194,16 @@ class ConsoleOrganizationPage {
         }
     }
     async clickUsersTab() {
-        await (0, test_1.expect)(this.usersTab).toBeVisible({ timeout: 60000 });
+        // The Users tab can fail to render if the Org page is mid-load when we
+        // arrive. Try once with a shorter window, reload on failure, then give
+        // the second attempt the full timeout before surfacing the error.
+        try {
+            await (0, test_1.expect)(this.usersTab).toBeVisible({ timeout: 30000 });
+        }
+        catch {
+            await this.page.reload();
+            await (0, test_1.expect)(this.usersTab).toBeVisible({ timeout: 60000 });
+        }
         await this.usersTab.click({ timeout: 60000 });
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.filterTableSearchbox, {
             postAction: async () => {

package/dist/pages/8.7/HomePage.js

@@ -74,7 +74,13 @@ class HomePage {
             if (!(await next.isVisible({ timeout: visibleTimeout }))) {
                 return;
             }
-            await next.click({ timeout: 30000, force: true });
+            try {
+                await next.click({ timeout: 30000, force: true });
+            }
+            catch {
+                // Close buttons are occasionally replaced during modal animation;
+                // continue and retry with the latest visible control.
+            }
         }
     }
     organizationUuid() {
@@ -89,15 +95,13 @@ class HomePage {
         await this.openOrganizationButton.click({ timeout: 60000 });
     }
     async clickSkipCustomization() {
-        try {
-            await (0, test_1.expect)(this.buttonSkipCustomization).toBeVisible({ timeout: 30000 });
-            await this.buttonSkipCustomization.click({ timeout: 60000 });
-            await this.closeInformationDialog();
-            return;
-        }
-        catch (error) {
-            console.error(error);
+        const hasCustomizationModal = await this.buttonSkipCustomization
+            .isVisible({ timeout: 30000 })
+            .catch(() => false);
+        if (hasCustomizationModal) {
+            await this.buttonSkipCustomization.click({ timeout: 60000, force: true });
         }
+        await this.closeInformationDialog();
     }
 }
 exports.HomePage = HomePage;

package/dist/pages/8.7/LoginPage.js

@@ -19,8 +19,11 @@ class LoginPage {
         // resolves to the auth0 email input, regardless of redirect timing.
         this.usernameInput = page
             .getByLabel('Email address')
-            .and(page.locator(':not(#c4-invite-email)'));
-        this.passwordInput = page.getByLabel('Password *');
+            .and(page.locator(':not([id="c4-invite-email"])'));
+        this.passwordInput = page
+            .getByLabel(/^Password\s*\*?$/i)
+            .or(page.locator('input[type="password"]'))
+            .first();
         this.continueButton = page.getByRole('button', {
             name: 'Continue',
             exact: true,
@@ -62,6 +65,9 @@ class LoginPage {
         const { username = process.env.C8_USERNAME_TEST, password = process.env.C8_PASSWORD_TEST, } = credentials;
         // Navigate to app root to start the auth flow.
         await this.page.goto('/');
+        await this.page
+            .waitForURL((url) => !url.hostname.includes('console'), { timeout: 60000 })
+            .catch(() => { });
         // SSO re-auth may silently log us back in as the previous user after
         // logout/session-reset, keeping the page on Console instead of redirecting
         // to the Auth0 login form. Detect Console (settings button visible) and
@@ -81,9 +87,16 @@ class LoginPage {
                 await this.page.waitForLoadState('domcontentloaded', { timeout: 30000 });
             }
         }
-        await (0, test_1.expect)(this.usernameInput).toBeVisible({ timeout: 120000 });
-        await this.fillUsername(username);
-        await this.clickContinueButton();
+        const onPasswordStep = (await this.passwordHeading
+            .isVisible({ timeout: 5000 })
+            .catch(() => false)) ||
+            (await this.passwordInput.isVisible({ timeout: 5000 }).catch(() => false));
+        if (!onPasswordStep) {
+            await (0, test_1.expect)(this.usernameInput).toBeVisible({ timeout: 120000 });
+            await this.fillUsername(username);
+            await this.clickContinueButton();
+        }
+        await (0, test_1.expect)(this.passwordInput).toBeVisible({ timeout: 180000 });
         await this.fillPassword(password);
         await (0, test_1.expect)(this.loginButton).toBeVisible({ timeout: 120000 });
         await this.clickLoginButton();

package/dist/pages/8.7/PlayPage.d.ts

@@ -1,8 +1,12 @@
 import { Page, Locator } from '@playwright/test';
 declare class PlayPage {
     private page;
+    readonly diagram: Locator;
+    readonly playTab: Locator;
     readonly completeJobButton: Locator;
-    readonly startInstanceButton: Locator;
+    readonly configureTestPanel: Locator;
+    readonly configureTestPanelStartButton: Locator;
+    readonly startInstanceOverlayButton: Locator;
     constructor(page: Page);
     waitForCompleteJobButtonToBeAvailable(): Promise<void>;
     clickCompleteJobButton(): Promise<void>;

package/dist/pages/8.7/PlayPage.js

@@ -2,19 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlayPage = void 0;
 const test_1 = require("@playwright/test");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
 const maxWaitTimeSeconds = 180000;
 class PlayPage {
     page;
+    diagram;
+    playTab;
     completeJobButton;
-    startInstanceButton;
+    configureTestPanel;
+    configureTestPanelStartButton;
+    startInstanceOverlayButton;
     constructor(page) {
         this.page = page;
-        this.completeJobButton = page
-            .getByTestId('diagram')
-            .getByLabel('Complete job');
-        this.startInstanceButton = this.page
-            .getByTestId('diagram')
-            .getByLabel('Start instance', { exact: true });
+        this.diagram = page.getByTestId('diagram');
+        this.playTab = page.getByRole('tab', { name: 'Play' });
+        this.completeJobButton = this.diagram.getByLabel('Complete job');
+        // Newer Modeler Play UI: the "Configure Scenario" floating card hosts a
+        // primary "Start" Carbon button (variants: "Start", "Start with
+        // variables", "Start with a form"). Source:
+        // camunda-hub frontend/packages/modeler/play/src/Definition/
+        //   ConfigureTestPanel/index.tsx — renders <FloatingCard
+        //   data-testid="configure-test-panel"> with a <Button> whose visible
+        //   text starts with "Start".
+        this.configureTestPanel = page.getByTestId('configure-test-panel');
+        this.configureTestPanelStartButton = this.configureTestPanel.getByRole('button', { name: /^Start( with .*)?$/, exact: false });
+        // Legacy bpmn-js canvas overlay button (still emitted by older Modeler
+        // builds, also relabeled with cached/example-data suffixes). Kept as a
+        // fallback for environments that haven't shipped the ConfigureTestPanel
+        // yet.
+        this.startInstanceOverlayButton = this.diagram.getByLabel('Start instance', { exact: false });
     }
     async waitForCompleteJobButtonToBeAvailable() {
         await (0, test_1.expect)(this.completeJobButton).toBeVisible({
@@ -28,17 +44,62 @@ class PlayPage {
         await this.completeJobButton.click();
     }
     async clickStartInstanceButton() {
-        await (0, test_1.expect)(this.startInstanceButton).toBeVisible({
-            timeout: 30000,
-        });
-        await this.startInstanceButton.click();
+        // The Modeler Play UI has two surfaces that can hold the start trigger:
+        //   - new: a "Start" Carbon button inside the ConfigureTestPanel
+        //     floating card (`[data-testid="configure-test-panel"]`). This is
+        //     what newer Modeler builds render. Variants: "Start",
+        //     "Start with variables", "Start with a form".
+        //   - legacy: a bpmn-js canvas overlay labelled "Start instance"
+        //     (sometimes "Start instance with cached data" once a scenario
+        //     chip exists). Older Modeler builds emit this; newer builds do
+        //     not, so it cannot be the only locator.
+        //
+        // Try whichever appears first. On total failure, reload AND re-open
+        // the Play tab (the legacy code path called `page.reload()` alone,
+        // which dumped the user back on the Implement tab on stable/8.7).
+        const startTrigger = this.configureTestPanelStartButton
+            .or(this.startInstanceOverlayButton)
+            .first();
+        const tryClick = async () => {
+            await (0, test_1.expect)(this.diagram).toBeVisible({ timeout: 120000 });
+            await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, startTrigger, {
+                totalTimeout: 240000,
+                visibilityTimeout: 60000,
+                maxRetries: 8,
+                retryDelayMs: 5000,
+            });
+        };
+        try {
+            await tryClick();
+        }
+        catch (error) {
+            console.warn(`clickStartInstanceButton: first pass failed (${error}); reloading, re-opening Play tab, and retrying once`);
+            await this.page.reload();
+            // After reload, the Modeler defaults to the Implement tab. Move
+            // back to Play before trying again — otherwise the diagram
+            // visibility check times out against the Implement-tab DOM.
+            if (await this.playTab.isVisible({ timeout: 30000 }).catch(() => false)) {
+                await this.playTab.click();
+            }
+            await tryClick();
+        }
     }
     async dismissStartModal() {
-        await this.page
-            .getByRole('button', {
-            name: 'Start a process instance',
-        })
-            .click();
+        // The intro dialog cycles labels across Modeler versions/states.
+        // Try the known variations in order; first match wins.
+        const buttonVariations = [
+            'Start a process instance',
+            'Start another instance',
+            'Start new instance',
+            'Start instance',
+        ];
+        for (const buttonName of buttonVariations) {
+            const button = this.page.getByRole('button', { name: buttonName });
+            if ((await button.count()) > 0) {
+                await button.first().click();
+                return;
+            }
+        }
     }
     async waitForInstanceDetailsToBeLoaded() {
         const maxRetries = 2;

package/dist/pages/8.7/SignUpPage.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignUpPage = void 0;
+const test_1 = require("@playwright/test");
 class SignUpPage {
     page;
     firstNameInput;
@@ -90,10 +91,33 @@ class SignUpPage {
         await this.clickPasswordInput();
         await this.fillPasswordInput(password);
         await this.clickSignupButton();
-        // Detect completion: URL leaves /signup OR the submit button disappears.
-        // waitForFunction handles any Auth0 post-signup page variant.
-        await this.page.waitForFunction(() => window.location.pathname !== '/signup' ||
-            !document.querySelector('button.signUpButton'), undefined, { timeout: 180000 });
+        // Sign-up can complete through multiple UI states across Auth0 variants.
+        await test_1.expect
+            .poll(async () => {
+            const pathname = new URL(this.page.url()).pathname;
+            if (pathname !== '/signup') {
+                return true;
+            }
+            const canSeeVerificationText = await this.verifyEmailText
+                .isVisible({ timeout: 1000 })
+                .catch(() => false);
+            if (canSeeVerificationText) {
+                return true;
+            }
+            const canSeeLoginButton = await this.loginToCamundaButton
+                .isVisible({ timeout: 1000 })
+                .catch(() => false);
+            if (canSeeLoginButton) {
+                return true;
+            }
+            const signUpButtonHidden = await this.signupButton
+                .isHidden({ timeout: 1000 })
+                .catch(() => false);
+            return signUpButtonHidden;
+        }, {
+            timeout: 240000,
+        })
+            .toBe(true);
     }
     async clickFirstNameInput() {
         await this.firstNameInput.click({ timeout: 30000 });

package/dist/pages/8.7/TaskDetailsPage.js

@@ -229,9 +229,20 @@ class TaskDetailsPage {
         const lastPdfViewer = containers
             .last()
             .locator('.fjs-documentPreview-pdf-viewer');
-        await (0, test_1.expect)(firstPdfViewer.or(lastPdfViewer)).toBeVisible({
-            timeout: 60000,
-        });
+        // The PDF viewer can take longer to mount on AWS clusters; if the first
+        // wait misses, reload once and give the second wait more headroom before
+        // failing the test.
+        try {
+            await (0, test_1.expect)(firstPdfViewer.or(lastPdfViewer)).toBeVisible({
+                timeout: 60000,
+            });
+        }
+        catch {
+            await this.page.reload();
+            await (0, test_1.expect)(firstPdfViewer.or(lastPdfViewer)).toBeVisible({
+                timeout: 90000,
+            });
+        }
     }
     async clickSubmitButton() {
         await (0, test_1.expect)(this.submitButton).toBeVisible();

package/dist/pages/8.7/TaskPanelPage.js

@@ -23,12 +23,13 @@ class TaskPanelPage {
     async openTask(name) {
         let attempts = 0;
         const maxAttempts = 3;
+        const taskLocator = this.availableTasks
+            .getByText(name, { exact: true })
+            .first();
         while (attempts < maxAttempts) {
             try {
-                await this.availableTasks
-                    .getByText(name, { exact: true })
-                    .nth(0)
-                    .click({ timeout: 120000 });
+                await (0, test_1.expect)(taskLocator).toBeVisible({ timeout: 120000 });
+                await taskLocator.click({ timeout: 180000 });
                 return;
             }
             catch (error) {

package/dist/pages/8.7/UtilitiesPage.js

@@ -5,13 +5,37 @@ const test_1 = require("@playwright/test");
 const ModelerHomePage_1 = require("./ModelerHomePage");
 const HomePage_1 = require("./HomePage");
 const sleep_1 = require("../../utils/sleep");
-const randomSleep_1 = require("../../utils/randomSleep");
 const fileUpload_1 = require("../../utils/fileUpload");
 const mailSlurpClient_1 = require("../../utils/mailSlurpClient");
-async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 3, skipOrgAssertion = false) {
+async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5, skipOrgAssertion = false) {
+    // Pre-flight worker stagger: spread the initial Auth0 hits across parallel
+    // workers BEFORE the first goto, otherwise all workers slam the tenant at
+    // the same instant and several get throttled into the retry loop.
+    await (0, sleep_1.sleep)(timeout);
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            await page.goto('/');
+            await page.context().clearCookies();
+            await page.goto('about:blank');
+            await page
+                .evaluate(() => {
+                try {
+                    localStorage.clear();
+                }
+                catch (_) {
+                    // Storage can be unavailable in some contexts.
+                }
+                try {
+                    sessionStorage.clear();
+                }
+                catch (_) {
+                    // Storage can be unavailable in some contexts.
+                }
+            })
+                .catch(() => { });
+            await page.goto('/', { waitUntil: 'domcontentloaded', timeout: 60000 });
+            await page
+                .waitForLoadState('networkidle', { timeout: 30000 })
+                .catch(() => { });
             await (0, sleep_1.sleep)(timeout);
             // Always detect SSO re-auth: after a logout + clearCookies, Auth0 may
             // silently log the previous user back in without showing the login form.
@@ -23,7 +47,10 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 3
                     .waitFor({ state: 'visible', timeout: 15000 })
                     .then(() => true)
                     .catch(() => false);
-                if (onAuth0)
+                const onPasswordStep = await loginPage.passwordHeading
+                    .isVisible({ timeout: 3000 })
+                    .catch(() => false);
+                if (onAuth0 || onPasswordStep)
                     break;
                 if (await settingsBtn.isVisible({ timeout: 3000 })) {
                     await settingsBtn.click({ timeout: 30000 });
@@ -31,6 +58,7 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 3
                     await page.waitForLoadState('domcontentloaded', { timeout: 30000 });
                 }
             }
+            await (0, test_1.expect)(loginPage.loginMessage.or(loginPage.passwordHeading)).toBeVisible({ timeout: 60000 });
             if (skipOrgAssertion) {
                 await loginPage.loginWithoutOrgAssertion(testUser);
             }
@@ -41,8 +69,13 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 3
         }
         catch (error) {
             if (attempt < maxRetries - 1) {
-                console.warn(`Attempt ${attempt + 1} failed for logging in. Retrying...`);
-                await (0, randomSleep_1.randomSleep)(10000, 20000);
+                // Exponential backoff with jitter: 10s, 20s, 40s, 80s (capped at 80s).
+                // Auth0 throttling under heavy parallel load needs longer recovery
+                // than a flat 10-20s — give the tenant time to drain.
+                const base = Math.min(10000 * 2 ** attempt, 80000);
+                const backoff = base + Math.floor(Math.random() * 10000);
+                console.warn(`Attempt ${attempt + 1} failed for logging in. Retrying in ${backoff}ms...`);
+                await (0, sleep_1.sleep)(backoff);
             }
             else {
                 console.error(error);

package/dist/tests/8.7/hto-user-flows.spec.js

@@ -434,7 +434,7 @@ _8_7_1.test.describe('HTO User Flow Tests', () => {
             await (0, UtilitiesPage_1.completeTaskWithRetry)(taskPanelPage, taskDetailsPage, `${taskName}1`, 'low');
             await taskPanelPage.filterBy('Completed');
             await (0, test_1.expect)(page.getByText(processName).first()).toBeVisible({
-                timeout: 60000,
+                timeout: 120000,
             });
             await (0, test_1.expect)(page.getByText(processName)).toHaveCount(4);
             await taskPanelPage.openTask(`${taskName}4`);

package/dist/tests/8.7/web-modeler-user-flows.spec.js

@@ -432,9 +432,20 @@ _8_7_1.test.describe('Web Modeler User Flow Tests', () => {
         });
         await _8_7_1.test.step('Log in to C8 as New User', async () => {
             await (0, UtilitiesPage_1.clickInvitationLinkInEmail)(page, id);
-            await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
-                timeout: 180000,
-            });
+            // The OAuth redirect chain after the invitation link can stall and
+            // never resolve to the Modeler banner within a single wait window.
+            // Reload the page once and try again before giving up.
+            try {
+                await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
+                    timeout: 90000,
+                });
+            }
+            catch {
+                await page.reload();
+                await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
+                    timeout: 180000,
+                });
+            }
             await modelerHomePage.clickMessageBanner();
             await settingsPage.clickOpenSettingsButton();
             await settingsPage.clickLogoutButton();

package/dist/utils/mailSlurpClient.js

@@ -17,20 +17,19 @@ async function createInbox(emailAddress, expriesIn = 1200000) {
 }
 exports.createInbox = createInbox;
 async function deleteInbox(id) {
+    if (!id) {
+        return;
+    }
     try {
         console.log(`Deleting inbox ${id}`);
-        await exports.mailSlurp.deleteInbox(id);
+        await Promise.race([
+            exports.mailSlurp.deleteInbox(id),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('deleteInbox timeout exceeded')), 20000)),
+        ]);
     }
     catch (error) {
-        if (error instanceof Error &&
-            (error.message.includes('404') ||
-                error.message.includes('does not exist'))) {
-            console.log('Failed to create inbox, could be a timing issue on MailSlurp side: ' +
-                String(error));
-        }
-        else {
-            throw new Error('Failed to delete inbox: ' + String(error));
-        }
+        // Cleanup should be best-effort and must not fail the test flow.
+        console.warn('Failed to delete inbox: ' + String(error));
     }
 }
 exports.deleteInbox = deleteInbox;

package/package.json

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