@camunda/e2e-test-suite 0.0.1468 → 0.0.1470

package/dist/utils/sessionRecovery.d.ts

@@ -66,8 +66,14 @@ export declare function isAtModelerLoginRoute(page: Page): boolean;
  * the moment the session is accepted, and otherwise spends the wait backing
  * off.
  *
+ * Every healthy reload also passes through `/login?returnUrl=...` while the
+ * session call is in flight, and callers often check right after a
+ * `domcontentloaded` reload. So the page only counts as stuck once it has stayed
+ * on `/login` for `graceTimeout`; reloading earlier interrupts a working
+ * hand-off and sends a second session call for the same user.
+ *
  * 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>;
+export declare function recoverStuckModelerLogin(page: Page, attempts?: number, settleTimeout?: number, graceTimeout?: number): Promise<boolean>;

package/dist/utils/sessionRecovery.js

@@ -15,8 +15,48 @@ const signedInUser = new WeakMap();
  */
 function trackSignedInUser(page, username) {
     signedInUser.set(page, username);
+    watchModelerSessionCalls(page);
 }
 exports.trackSignedInUser = trackSignedInUser;
+const SESSION_CALL_PATH = /\/api\/internal\/login\/?$/;
+// The status of the last `POST /api/internal/login` this page received, so a
+// "stuck on /login" verdict can say what the backend actually answered rather
+// than assume a 5xx from the URL alone.
+const lastSessionCallStatus = new WeakMap();
+const watchedPages = new WeakSet();
+function watchModelerSessionCalls(page) {
+    if (watchedPages.has(page)) {
+        return;
+    }
+    watchedPages.add(page);
+    page.on('response', (response) => {
+        if (response.request().method() !== 'POST') {
+            return;
+        }
+        let pathname;
+        try {
+            pathname = new URL(response.url()).pathname;
+        }
+        catch {
+            return;
+        }
+        if (!SESSION_CALL_PATH.test(pathname)) {
+            return;
+        }
+        const status = response.status();
+        lastSessionCallStatus.set(page, status);
+        if (status >= 500) {
+            console.warn(`Modeler session call failed: POST ${response.url()} answered ` +
+                `${status} at ${new Date().toISOString()}`);
+        }
+    });
+}
+function describeLastSessionCall(page) {
+    const status = lastSessionCallStatus.get(page);
+    return status === undefined
+        ? 'no response to POST /api/internal/login was seen'
+        : `the last POST /api/internal/login answered ${status}`;
+}
 // Read back out of the environment at the moment it is needed, from the
 // `C8_USERNAME*` / `C8_PASSWORD*` pair that defines this user -- the same
 // source LoginPage reads its own defaults from. Nothing secret is carried
@@ -189,17 +229,35 @@ exports.isAtModelerLoginRoute = isAtModelerLoginRoute;
  * the moment the session is accepted, and otherwise spends the wait backing
  * off.
  *
+ * Every healthy reload also passes through `/login?returnUrl=...` while the
+ * session call is in flight, and callers often check right after a
+ * `domcontentloaded` reload. So the page only counts as stuck once it has stayed
+ * on `/login` for `graceTimeout`; reloading earlier interrupts a working
+ * hand-off and sends a second session call for the same user.
+ *
  * 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) {
+async function recoverStuckModelerLogin(page, attempts = 4, settleTimeout = 25000, graceTimeout = 20000) {
     if (!isAtModelerLoginRoute(page)) {
         return false;
     }
+    watchModelerSessionCalls(page);
+    const leftOnItsOwn = await page
+        .waitForURL((url) => !LOGIN_ROUTE.test(url.pathname), {
+        timeout: graceTimeout,
+        waitUntil: 'commit',
+    })
+        .then(() => true)
+        .catch(() => false);
+    if (leftOnItsOwn) {
+        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}.`);
+        console.warn(`recoverStuckModelerLogin: Modeler is still on ${page.url()} after ` +
+            `${graceTimeout / 1000}s; ${describeLastSessionCall(page)}. ` +
+            `Reload ${attempt}/${attempts}.`);
         await page
             .reload({ waitUntil: 'domcontentloaded', timeout: 60000 })
             .catch(() => undefined);
@@ -212,6 +270,7 @@ async function recoverStuckModelerLogin(page, attempts = 4, settleTimeout = 2500
         const recovered = await page
             .waitForURL((url) => !LOGIN_ROUTE.test(url.pathname), {
             timeout: settleTimeout,
+            waitUntil: 'commit',
         })
             .then(() => true)
             .catch(() => false);
@@ -219,8 +278,8 @@ async function recoverStuckModelerLogin(page, attempts = 4, settleTimeout = 2500
             return true;
         }
     }
-    console.warn('recoverStuckModelerLogin: Modeler never left /login -- its backend is ' +
-        'still failing the session call.');
+    console.warn(`recoverStuckModelerLogin: Modeler never left /login; ` +
+        `${describeLastSessionCall(page)}.`);
     return true;
 }
 exports.recoverStuckModelerLogin = recoverStuckModelerLogin;

package/package.json

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