@camunda/e2e-test-suite 0.0.1209 → 0.0.1210

package/dist/pages/8.8/ModelerHomePage.d.ts

@@ -39,6 +39,9 @@ declare class ModelerHomePage {
     dismissBlockingDialog(): Promise<void>;
     private dismissUncataloguedDialog;
     dismissOverlays(): Promise<void>;
+    private consecutiveSessionRecoveries;
+    private recoverModelerSession;
+    private sessionDropError;
     clickCreateNewProjectButton(): Promise<void>;
     enterNewProjectName(name: string): Promise<void>;
     enterIdpApplicationName(name: string): Promise<void>;
@@ -65,6 +68,7 @@ declare class ModelerHomePage {
     createForm(formName: string): Promise<void>;
     clickCreateIdpApplicationButton(): Promise<void>;
     clickCrossComponentProjectFolder(): Promise<void>;
+    private clickCrossComponentProjectFolderWithRetry;
     createCrossComponentProjectFolder(): Promise<void>;
     clickManageButton(retries?: number): Promise<void>;
     clickUploadFilesButton(): Promise<void>;

package/dist/pages/8.8/ModelerHomePage.js

@@ -180,6 +180,14 @@ class ModelerHomePage {
     // the What's New modal and the migration notice, and closing one reveals the
     // next.
     async dismissBlockingDialog() {
+        // Nothing Modeler owns can be open on the identity provider's login form,
+        // and the probes below cost ~27s there for certain (a networkidle wait that
+        // does not settle plus a 10s label lookup). When Modeler has dropped the
+        // session that is the single largest slice of every retry attempt, spent
+        // looking for a dialog that cannot exist. Caller recovers the session; this
+        // just refuses to pay for the search in the meantime.
+        if ((0, sessionRecovery_1.isAtIdentityProvider)(this.page))
+            return;
         await this.page
             .waitForLoadState('networkidle', { timeout: 15000 })
             .catch(() => false);
@@ -244,6 +252,8 @@ class ModelerHomePage {
         // `.or(...).first()` unions in DOM order, where the top banner comes first,
         // so on their own they close the banner and leave the dialog open.
         await this.dismissBlockingDialog();
+        if ((0, sessionRecovery_1.isAtIdentityProvider)(this.page))
+            return;
         for (const locator of [
             this.closeButton,
             this.page.getByRole('button', { name: 'Close' }).first(),
@@ -255,18 +265,70 @@ class ModelerHomePage {
                 .catch(() => { });
         }
     }
+    // How many times in a row a retry attempt has found the page bounced back to
+    // the identity provider. Reset as soon as one finds it still signed in.
+    consecutiveSessionRecoveries = 0;
+    // Modeler drops the SPA session when one of its own backend calls 5xx's, and
+    // the call it drops on -- POST /api/internal/login -- is the very call the
+    // next sign-in has to make on the way back in. Auth0 hands the browser back
+    // within a couple of seconds, but that call then runs for up to 30s before
+    // failing and logging the SPA straight out again, so returning as soon as the
+    // credentials are accepted hands the caller a page that is about to bounce --
+    // and the attempt is spent probing Modeler UI on the login form.
+    //
+    // Wait for Modeler's own shell instead. It is the one signal that says the
+    // backend accepted the session, it returns the instant the backend comes back
+    // (rather than at the next attempt boundary, which is how a recovery that
+    // lands mid-outage used to lose the rest of its budget), and when the backend
+    // stays down the wait is spent on the thing the test is actually waiting for.
+    async recoverModelerSession() {
+        if (!(await (0, sessionRecovery_1.restoreSessionIfLoggedOut)(this.page))) {
+            this.consecutiveSessionRecoveries = 0;
+            return false;
+        }
+        const shellVisible = await this.becameVisible(this.modelerPageBanner, 120000);
+        if (shellVisible) {
+            this.consecutiveSessionRecoveries = 0;
+        }
+        return shellVisible;
+    }
+    // Reported instead of the retry helper's "Failed to click locator ..." when
+    // the reason the locator never appeared is that Modeler kept logging the
+    // session out. The 2026-09-21 nightly dispatched 27 separate "locator never
+    // appeared" failures that were one Modeler auth outage; naming the cause here
+    // is what makes that legible from the report alone.
+    sessionDropError(action, cause) {
+        return new Error(`${action}: Modeler dropped the session ` +
+            `${this.consecutiveSessionRecoveries} time(s) and re-authentication ` +
+            'never got the app back -- its own POST /api/internal/login is ' +
+            `failing. Underlying error: ${cause}`);
+    }
     async clickCreateNewProjectButton() {
-        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.createNewProjectButton, {
-            preAction: async () => {
-                // Modeler logs the SPA out on its own when a backend call fails, and
-                // every later attempt then waits for this button on the Auth0 form
-                // instead of on Modeler. Get the session back before looking for it.
-                await (0, sessionRecovery_1.restoreSessionIfLoggedOut)(this.page);
-                await this.dismissOverlays();
-            },
-            totalTimeout: 120000,
-            visibilityTimeout: 10000,
-        });
+        try {
+            await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.createNewProjectButton, {
+                preAction: async () => {
+                    // Modeler logs the SPA out on its own when a backend call fails, and
+                    // every later attempt then waits for this button on the Auth0 form
+                    // instead of on Modeler. Get the session back before looking for it.
+                    await this.recoverModelerSession();
+                    await this.dismissOverlays();
+                },
+                // Raised from 120s. This is the same dropped-session failure the sibling
+                // clickCrossComponentProjectFolder budget was twice widened for, and it
+                // was carrying a third of that budget: on the 2026-09-21 nightly all
+                // three attempts were spent inside the first two minutes of a Modeler
+                // auth outage, so the call gave up with the outage still running.
+                totalTimeout: 360000,
+                maxRetries: 5,
+                visibilityTimeout: 10000,
+            });
+        }
+        catch (error) {
+            if (this.consecutiveSessionRecoveries > 0) {
+                throw this.sessionDropError('clickCreateNewProjectButton', error);
+            }
+            throw error;
+        }
     }
     async enterNewProjectName(name) {
         // The inline rename silently drops the value when the editable title field
@@ -609,6 +671,17 @@ class ModelerHomePage {
         await this.createIdpApplicationButton.click();
     }
     async clickCrossComponentProjectFolder() {
+        try {
+            await this.clickCrossComponentProjectFolderWithRetry();
+        }
+        catch (error) {
+            if (this.consecutiveSessionRecoveries > 0) {
+                throw this.sessionDropError('clickCrossComponentProjectFolder', error);
+            }
+            throw error;
+        }
+    }
+    async clickCrossComponentProjectFolderWithRetry() {
         await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.crossComponentProjectFolder, {
             visibilityTimeout: 60000,
             // Widened from 180s: dismissing the announcement dialog costs up to ~25s
@@ -621,9 +694,21 @@ class ModelerHomePage {
             // attempt costs ~80s instead of ~25s, so the 240s budget ran out after
             // three of the five retries configured below. The 2026-09-01 nightly
             // took two such 5xx to bury a test that had three unused attempts left.
-            totalTimeout: 360000,
-            maxRetries: 5,
+            //
+            // Widened once more, from 360s. On the 2026-09-21 nightly Modeler's
+            // /api/internal/login 5xx'd for ~27 minutes and the retries that stood
+            // the best chance -- the ones that started late enough to overlap its
+            // recovery -- ran out of budget minutes before it. 480s still leaves room
+            // under the 720s test timeout for the rest of a spec's work.
+            totalTimeout: 480000,
+            maxRetries: 6,
             preAction: async () => {
+                // Before the overlay passes, not only after a failed attempt: a dropped
+                // session leaves the browser on the Auth0 form, where every dismissal
+                // probe below is a guaranteed miss and the tile can never render. The
+                // postAction recovery only runs once an attempt has already burnt its
+                // 60s visibility timeout there.
+                await this.recoverModelerSession();
                 // Dismiss the dialog BEFORE the banner: the Modeler home page can
                 // stack both at once, and clickMessageBanner resolves an
                 // `.or(...).first()` union in DOM order — the top banner comes first,
@@ -640,7 +725,7 @@ class ModelerHomePage {
                 // remaining attempt burns its visibility timeout for nothing. Recover
                 // the session as the current test user and let the next attempt probe
                 // the tile again.
-                if (await (0, sessionRecovery_1.restoreSessionIfLoggedOut)(this.page)) {
+                if (await this.recoverModelerSession()) {
                     return;
                 }
                 // The project tile only renders on the Modeler home page. A failure
@@ -695,6 +780,12 @@ class ModelerHomePage {
         await this.uploadFilesButton.click({ timeout: 60000 });
     }
     async clickMessageBanner() {
+        // Same reasoning as dismissBlockingDialog: Modeler's banner cannot be on
+        // the identity provider's login form, so the 15s probe below is a
+        // guaranteed miss there and only shortens the budget left for the session
+        // to come back.
+        if ((0, sessionRecovery_1.isAtIdentityProvider)(this.page))
+            return;
         try {
             const button = this.messageBanner
                 .or(this.closeButton)

package/dist/utils/sessionRecovery.d.ts

@@ -6,6 +6,14 @@ import type { Page } from '@playwright/test';
  * verifies, so recovery is skipped entirely when nothing was recorded.
  */
 export declare function trackSignedInUser(page: Page, username: string): void;
+/**
+ * Whether the browser is currently parked on the identity provider rather than
+ * on the application. The provider is a different host, so this settles it
+ * without touching the DOM -- which is what makes it cheap enough to gate the
+ * application-side waits (overlay probes, locator visibility) that cannot
+ * possibly succeed there.
+ */
+export declare function isAtIdentityProvider(page: Page): boolean;
 /**
  * Re-authenticates when the page has been bounced to the identity provider
  * mid-test, and reports whether it had to.

package/dist/utils/sessionRecovery.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreSessionIfLoggedOut = exports.trackSignedInUser = void 0;
+exports.restoreSessionIfLoggedOut = exports.isAtIdentityProvider = exports.trackSignedInUser = void 0;
 // Only the username is kept -- no password, no cookie, no token. Keyed by the
 // Playwright Page because the object that logs in (LoginPage) and the objects
 // that later have to recover a dropped session (ModelerHomePage) are separate
@@ -43,6 +43,17 @@ const passwordInput = (page) => page
     .first();
 const continueButton = (page) => page.getByRole('button', { name: 'Continue', exact: true });
 const passwordHeading = (page) => page.getByRole('heading', { name: 'Enter Your Password' });
+/**
+ * Whether the browser is currently parked on the identity provider rather than
+ * on the application. The provider is a different host, so this settles it
+ * without touching the DOM -- which is what makes it cheap enough to gate the
+ * application-side waits (overlay probes, locator visibility) that cannot
+ * possibly succeed there.
+ */
+function isAtIdentityProvider(page) {
+    return /:\/\/(weblogin|login)\./.test(page.url());
+}
+exports.isAtIdentityProvider = isAtIdentityProvider;
 const isVisibleWithin = (locator, timeout) => locator
     .waitFor({ state: 'visible', timeout })
     .then(() => true)
@@ -90,8 +101,7 @@ async function restoreSessionIfLoggedOut(page) {
     // this without touching the DOM. Only pages that are NOT obviously on it pay
     // for a probe, and that probe has to be a real wait -- isVisible() does not
     // wait, and the logout redirect is often still in flight when we look.
-    const atIdentityProvider = /:\/\/(weblogin|login)\./.test(page.url());
-    const probeTimeout = atIdentityProvider ? 30000 : 2000;
+    const probeTimeout = isAtIdentityProvider(page) ? 30000 : 2000;
     const onEmailStep = await isVisibleWithin(emailInput(page), probeTimeout);
     const onPasswordStep = !onEmailStep && (await isVisibleWithin(passwordHeading(page), 1000));
     if (!onEmailStep && !onPasswordStep) {

package/package.json

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