@camunda/e2e-test-suite 0.0.1231 → 0.0.1232

package/dist/pages/8.8/FormJsPage.js

@@ -4,6 +4,7 @@ exports.FormJsPage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
+const sessionRecovery_1 = require("../../utils/sessionRecovery");
 class FormJsPage {
     page;
     processApplicationPage;
@@ -171,6 +172,10 @@ class FormJsPage {
         });
     }
     async clickDeployButton() {
+        // ensureStageCluster navigates away and back before every deploy, so the
+        // action bar this button lives in may belong to a page that never
+        // rendered. Recover before spending the click budget on it.
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         await this.deployButton.click({ timeout: 60000 });
     }
     async clickDeploySubButton() {

package/dist/pages/8.8/ModelerCreatePage.js

@@ -6,6 +6,7 @@ const sleep_1 = require("../../utils/sleep");
 const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
 const ConnectorMarketplacePage_1 = require("./ConnectorMarketplacePage");
 const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
+const sessionRecovery_1 = require("../../utils/sessionRecovery");
 class ModelerCreatePage {
     page;
     processApplicationPage;
@@ -583,6 +584,12 @@ class ModelerCreatePage {
         await (0, test_1.expect)(this.viewProcessLink).toBeHidden({ timeout: 30000 });
     }
     async clickStartInstanceMainButton() {
+        // ensureStageCluster runs immediately before this on every runProcessInstance
+        // attempt and navigates twice, so the diagram's action bar may belong to a
+        // page Modeler never rendered. Without this, each of the 10 retries burned
+        // 60s of probes here and the run surfaced as "View process instance" never
+        // appearing -- which reads as a failed deploy rather than a dead page.
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         if (await this.startInstanceMainButton.isVisible({ timeout: 30000 })) {
             await this.startInstanceMainButton.click({ timeout: 30000 });
         }
@@ -754,6 +761,11 @@ class ModelerCreatePage {
         await this.nameInput.fill(name, { timeout: 60000 });
     }
     async clickDiagramBreadcrumb() {
+        // Reached straight after opening a diagram, so the navigation that got us
+        // here is the one Modeler can answer with its hung /login. The breadcrumb
+        // never renders there, and at 10s this was the first thing to notice --
+        // as "breadcrumb not found", which says nothing about the real cause.
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         await this.diagramBreadcrumb.click({ timeout: 10000 });
     }
     // Opening the breadcrumb menu leaves the pointer on the breadcrumb button,
@@ -1631,6 +1643,7 @@ class ModelerCreatePage {
     }
     async fillStartEventVariablesForDocHandling(zeebeUrl, zeebeClientId, zeebeClientSecret) {
         console.log(`URL: ${zeebeUrl}, ClientId: ${zeebeClientId}, Secret: ${zeebeClientSecret}`);
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         await (0, test_1.expect)(this.connectorsDocHandlingStartEventElement).toBeVisible({
             timeout: 60000,
         });

package/dist/pages/8.8/ModelerHomePage.js

@@ -282,11 +282,27 @@ class ModelerHomePage {
     // 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))) {
+        // Two distinct ways Modeler loses its session, and only one of them shows
+        // the identity provider. When POST /api/internal/login 5xx's during the
+        // SPA's own sign-in it never logs out at all -- it parks on Modeler's
+        // /login route behind a spinner that nothing retries -- so the
+        // credentials path below cannot see it. Un-stick that first.
+        const unstuck = await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
+        if (!(await (0, sessionRecovery_1.restoreSessionIfLoggedOut)(this.page)) && !unstuck) {
             this.consecutiveSessionRecoveries = 0;
             return false;
         }
-        const shellVisible = await this.becameVisible(this.modelerPageBanner, 120000);
+        // Counted, not just reset: sessionDropError reports this number, and
+        // without the increment the counter read 0 forever, so the `> 0` guard at
+        // every call site was unreachable and the dropped-session diagnosis it
+        // exists to surface never once printed.
+        this.consecutiveSessionRecoveries++;
+        // The banner alone does not prove the session came back: Modeler renders
+        // its whole app shell, banner included, over the spinner on the hung
+        // /login route. Requiring the browser to have LEFT that route is what
+        // makes "recovered" mean recovered.
+        const shellVisible = !(0, sessionRecovery_1.isAtModelerLoginRoute)(this.page) &&
+            (await this.becameVisible(this.modelerPageBanner, 120000));
         if (shellVisible) {
             this.consecutiveSessionRecoveries = 0;
         }
@@ -386,6 +402,10 @@ class ModelerHomePage {
             // Reload so the check reflects the PERSISTED server state, not the
             // optimistic client render that can silently revert to "New project".
             await this.page.reload();
+            // A reload is also how the browser ends up on Modeler's hung /login, and
+            // the committed name can never render there -- which would read as "the
+            // rename did not persist" rather than "the page never loaded".
+            await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
             await (0, test_1.expect)(committedProjectName.first()).toBeVisible({ timeout: 15000 });
         }).toPass({ timeout: 120000 });
     }
@@ -413,6 +433,7 @@ class ModelerHomePage {
     // resource is one level down, so re-enter the container first.
     async clickProcessDiagram(name) {
         await this.ensureInResourceContainer();
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         const process = this.rows.filter({ hasText: name }).getByTitle(name).first();
         await (0, test_1.expect)(process).toBeVisible({ timeout: 90000 });
         await process.click();
@@ -426,6 +447,7 @@ class ModelerHomePage {
         const dropdown = this.processApplicationPage.createNewDropdown;
         for (let attempt = 0; attempt < 4; attempt++) {
             try {
+                await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
                 await this.dismissOverlays();
                 await (0, test_1.expect)(dropdown).toBeVisible({
                     timeout: 45000,
@@ -452,6 +474,7 @@ class ModelerHomePage {
     async clickWorkspaceDiagramTypeDropdown() {
         for (let attempt = 0; attempt < 4; attempt++) {
             try {
+                await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
                 await this.dismissOverlays();
                 await (0, test_1.expect)(this.diagramTypeDropdown).toBeVisible({
                     timeout: 45000,
@@ -483,7 +506,21 @@ class ModelerHomePage {
             if (await this.becameVisible(this.diagramPropertiesPanel, 1000)) {
                 return;
             }
-            if (!(await this.becameVisible(this.bpmnTemplateOption, 5000))) {
+            await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
+            const menuOpen = await this.becameVisible(this.bpmnTemplateOption, 5000);
+            // Hub disables this item while its own create-file request is in flight
+            // (`disabled={creatingType === BPMN}` in CreateActionDs). A request that
+            // never answers leaves it disabled for good -- yet still visible, so the
+            // probe above passed and the click below then spent its whole 30s on
+            // "element is not enabled" on every single attempt until the test timed
+            // out. Only a reload clears that React state; the menu is closed by it,
+            // which is why clickDiagramTypeDropdown has to reopen it.
+            const stuckDisabled = menuOpen &&
+                !(await this.bpmnTemplateOption.isEnabled().catch(() => false));
+            if (stuckDisabled) {
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+            }
+            if (!menuOpen || stuckDisabled) {
                 await this.clickDiagramTypeDropdown();
             }
             // 30s rather than the old 120s: the option is proven visible above, so a
@@ -493,9 +530,15 @@ class ModelerHomePage {
         }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
     }
     async clickFormOption() {
+        // The create menu only exists on a rendered container page. When the
+        // navigation that got us here bounced to Modeler's hung /login, this
+        // option is not merely late -- it is on a page that never renders -- so
+        // recover before spending the click budget looking for it.
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         await this.formTemplateOption.click();
     }
     async enterFormName(name) {
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         await (0, test_1.expect)(this.formNameInput).toBeVisible({ timeout: 120000 });
         await this.formNameInput.click({ timeout: 60000, force: true });
         await this.formNameInput.fill(name, { timeout: 60000 });

package/dist/pages/8.8/ProcessApplicationPage.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessApplicationPage = void 0;
 const test_1 = require("@playwright/test");
 const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
+const sessionRecovery_1 = require("../../utils/sessionRecovery");
 // Which process application holds the current test's resources, and which
 // cluster its development stage currently points at. Keyed by the Playwright
 // Page because the object that creates the container (ModelerHomePage) and the
@@ -92,6 +93,12 @@ class ProcessApplicationPage {
         return this.folderExplorer.or(this.breadcrumb).first();
     }
     async waitForProcessApplication(timeout = 90000) {
+        // Every route into this page is a navigation, and a navigation is exactly
+        // when Modeler can bounce the browser onto its own hung /login. Neither
+        // the folder explorer nor the breadcrumb can ever render there, so waiting
+        // the full timeout out first would only delay the recovery that has to
+        // happen anyway. No-ops when the page is where it should be.
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         await (0, test_1.expect)(this.pageReady()).toBeVisible({ timeout });
     }
     async clickCreateProcessApplicationButton() {
@@ -208,11 +215,16 @@ class ProcessApplicationPage {
             await this.page.goto(`${paUrl}/connected-clusters`, {
                 waitUntil: 'domcontentloaded',
             });
+            await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
             await this.openStageDefinition();
             await this.defineDevelopmentStage(clusterName);
         }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
         container.developmentCluster = clusterName;
         await this.page.goto(returnTo, { waitUntil: 'domcontentloaded' });
+        // Hand the caller back a page it can act on: this navigation can bounce to
+        // the hung /login just as easily as the one above, and the caller goes
+        // straight into a deploy dialog that would never open there.
+        await (0, sessionRecovery_1.recoverStuckModelerLogin)(this.page);
         return true;
     }
     // The /connected-clusters deep link opens the Define stages dialog by itself

package/dist/utils/sessionRecovery.d.ts

@@ -31,3 +31,43 @@ export declare function isAtIdentityProvider(page: Page): boolean;
  * needed here.
  */
 export declare function restoreSessionIfLoggedOut(page: Page): Promise<boolean>;
+/**
+ * Whether the browser is parked on Web Modeler's OWN `/login` route, as
+ * opposed to the identity provider's login form.
+ *
+ * Two different failure states that look alike in a screenshot and need
+ * opposite recoveries, so they are kept apart deliberately. The identity
+ * provider is a separate HOST (`weblogin.`/`login.`) and wants credentials
+ * typed into it -- that is {@link restoreSessionIfLoggedOut}. This one is a
+ * PATH on the application's own host, and wants a re-navigation.
+ */
+export declare function isAtModelerLoginRoute(page: Page): boolean;
+/**
+ * Un-sticks Web Modeler when its own `/login` route has hung, and reports
+ * whether it had to.
+ *
+ * Modeler establishes its session by POSTing `/api/internal/login` from
+ * `prepareSession()`. When that call 5xx's the promise rejects and nothing
+ * catches it: `history.push(returnTo)` never runs, the app never becomes
+ * ready, and the SPA sits on `/login?returnUrl=...` rendering its shell over
+ * an infinite spinner. There is no client-side retry and no error state, so
+ * the page cannot recover on its own -- every Modeler locator the test waits
+ * for simply never appears, and the test spends its entire budget on a page
+ * that will never render. The 2026-09-22 nightly lost 22 tests across nine
+ * specs to one intermittent backend this way, each reported as an unrelated
+ * "locator not found".
+ *
+ * Reloading re-runs `prepareSession()`, so it re-issues the POST; when that
+ * one succeeds the SPA pushes the `returnUrl` it kept and the browser lands on
+ * the page the caller was navigating to. Retried because the backend fails
+ * intermittently rather than continuously -- on that nightly roughly half the
+ * calls answered 200, so a few spaced attempts are what get through. The
+ * spacing is the `waitForURL` budget itself rather than a sleep: it returns
+ * the moment the session is accepted, and otherwise spends the wait backing
+ * off.
+ *
+ * Cheap to call speculatively -- a page that is not on `/login` costs one URL
+ * comparison and no DOM access, which is what lets the Modeler page objects
+ * guard their navigations with it.
+ */
+export declare function recoverStuckModelerLogin(page: Page, attempts?: number, settleTimeout?: number): Promise<boolean>;

package/dist/utils/sessionRecovery.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreSessionIfLoggedOut = exports.isAtIdentityProvider = exports.trackSignedInUser = void 0;
+exports.recoverStuckModelerLogin = exports.isAtModelerLoginRoute = 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
@@ -142,3 +142,85 @@ async function restoreSessionIfLoggedOut(page) {
     return true;
 }
 exports.restoreSessionIfLoggedOut = restoreSessionIfLoggedOut;
+const LOGIN_ROUTE = /\/login\/?$/;
+/**
+ * Whether the browser is parked on Web Modeler's OWN `/login` route, as
+ * opposed to the identity provider's login form.
+ *
+ * Two different failure states that look alike in a screenshot and need
+ * opposite recoveries, so they are kept apart deliberately. The identity
+ * provider is a separate HOST (`weblogin.`/`login.`) and wants credentials
+ * typed into it -- that is {@link restoreSessionIfLoggedOut}. This one is a
+ * PATH on the application's own host, and wants a re-navigation.
+ */
+function isAtModelerLoginRoute(page) {
+    if (isAtIdentityProvider(page)) {
+        return false;
+    }
+    try {
+        return LOGIN_ROUTE.test(new URL(page.url()).pathname);
+    }
+    catch {
+        return false;
+    }
+}
+exports.isAtModelerLoginRoute = isAtModelerLoginRoute;
+/**
+ * Un-sticks Web Modeler when its own `/login` route has hung, and reports
+ * whether it had to.
+ *
+ * Modeler establishes its session by POSTing `/api/internal/login` from
+ * `prepareSession()`. When that call 5xx's the promise rejects and nothing
+ * catches it: `history.push(returnTo)` never runs, the app never becomes
+ * ready, and the SPA sits on `/login?returnUrl=...` rendering its shell over
+ * an infinite spinner. There is no client-side retry and no error state, so
+ * the page cannot recover on its own -- every Modeler locator the test waits
+ * for simply never appears, and the test spends its entire budget on a page
+ * that will never render. The 2026-09-22 nightly lost 22 tests across nine
+ * specs to one intermittent backend this way, each reported as an unrelated
+ * "locator not found".
+ *
+ * Reloading re-runs `prepareSession()`, so it re-issues the POST; when that
+ * one succeeds the SPA pushes the `returnUrl` it kept and the browser lands on
+ * the page the caller was navigating to. Retried because the backend fails
+ * intermittently rather than continuously -- on that nightly roughly half the
+ * calls answered 200, so a few spaced attempts are what get through. The
+ * spacing is the `waitForURL` budget itself rather than a sleep: it returns
+ * the moment the session is accepted, and otherwise spends the wait backing
+ * off.
+ *
+ * Cheap to call speculatively -- a page that is not on `/login` costs one URL
+ * comparison and no DOM access, which is what lets the Modeler page objects
+ * guard their navigations with it.
+ */
+async function recoverStuckModelerLogin(page, attempts = 4, settleTimeout = 25000) {
+    if (!isAtModelerLoginRoute(page)) {
+        return false;
+    }
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+        console.warn(`recoverStuckModelerLogin: Modeler is stuck on ${page.url()} -- its ` +
+            `POST /api/internal/login is failing. Reload ${attempt}/${attempts}.`);
+        await page
+            .reload({ waitUntil: 'domcontentloaded', timeout: 60000 })
+            .catch(() => undefined);
+        // The reload can land on the identity provider instead -- Modeler calls
+        // Auth0 logout on some of these failures -- and there credentials, not
+        // another reload, are what gets us back.
+        await restoreSessionIfLoggedOut(page);
+        // Leaving /login is the signal that the session was accepted: the SPA only
+        // pushes the returnUrl once prepareSession() resolved.
+        const recovered = await page
+            .waitForURL((url) => !LOGIN_ROUTE.test(url.pathname), {
+            timeout: settleTimeout,
+        })
+            .then(() => true)
+            .catch(() => false);
+        if (recovered) {
+            return true;
+        }
+    }
+    console.warn('recoverStuckModelerLogin: Modeler never left /login -- its backend is ' +
+        'still failing the session call.');
+    return true;
+}
+exports.recoverStuckModelerLogin = recoverStuckModelerLogin;

package/package.json

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