@camunda/e2e-test-suite 0.0.1217 → 0.0.1219

package/dist/pages/8.10/UtilitiesPage.d.ts

@@ -22,7 +22,7 @@ export declare function isSignedOut(page: Page): boolean;
 export declare function withSessionRecovery(page: Page, loginPage: LoginPage, appsPage: AppsPage, modelerBanner: Locator, testUser: {
     username: string;
     password: string;
-}, loginStagger: number, action: () => Promise<void>): Promise<void>;
+}, loginStagger: number, action: () => Promise<void>, maxRecoveries?: number): Promise<void>;
 export declare function modelDiagramFromFile(page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, processName: string, fileName?: string, nrOfRenamedUserTasks?: number, taskName?: string): Promise<void>;
 export declare function modelRestConnector(modelerCreatePage: ModelerCreatePage, connectorSettingsPage: ConnectorSettingsPage, processName: string, url: string, auth: string, resultExpression: string, resultVariable?: string, basicAuthCredentials?: {
     username: string;

package/dist/pages/8.10/UtilitiesPage.js

@@ -235,7 +235,7 @@ function isSignedOut(page) {
 }
 exports.isSignedOut = isSignedOut;
 // Runs `action`, and if it fails because the session was dropped mid-flow,
-// signs back in, returns to the Modeler projects list and runs it once more.
+// signs back in, returns to the Modeler projects list and runs it again.
 //
 // Without this the caller's own locator retries keep hunting for app controls
 // on the Auth0 form and expire against a page that is not the app at all —
@@ -243,21 +243,32 @@ exports.isSignedOut = isSignedOut;
 // than as the sign-out it actually was. Only a confirmed sign-out is retried;
 // any other failure propagates untouched, so a genuinely broken control still
 // fails the test.
-async function withSessionRecovery(page, loginPage, appsPage, modelerBanner, testUser, loginStagger, action) {
-    try {
-        await action();
-        return;
-    }
-    catch (error) {
-        if (!isSignedOut(page)) {
-            throw error;
+//
+// Recovers up to `maxRecoveries` times rather than once: under a concurrent
+// login burst the SaaS `/api/internal/login` hand-off can 500 and bounce the
+// tab back to Auth0 (see AppsPage.openModelerWithRetry) more than once in a
+// row, so the lowest-staggered workers get dropped, recovered, then dropped
+// again — spending the single recovery before landing a stable session. A
+// bounded re-login loop (the same shape as loginWithRetry's own retries) lets
+// those tail sessions settle; a session that never stabilises still exhausts
+// the loop and fails, so a genuinely broken login is not masked.
+async function withSessionRecovery(page, loginPage, appsPage, modelerBanner, testUser, loginStagger, action, maxRecoveries = 2) {
+    for (let recovery = 0; recovery <= maxRecoveries; recovery++) {
+        try {
+            await action();
+            return;
+        }
+        catch (error) {
+            if (!isSignedOut(page) || recovery === maxRecoveries) {
+                throw error;
+            }
+            console.warn(`Session was dropped mid-flow (tab landed on ${page.url()}); ` +
+                `signing back in and retrying (recovery ${recovery + 1} of ` +
+                `${maxRecoveries}).`);
         }
-        console.warn(`Session was dropped mid-flow (tab landed on ${page.url()}); ` +
-            'signing back in and retrying once.');
+        await loginWithRetry(page, loginPage, testUser, loginStagger);
+        await appsPage.openModelerWithRetry(modelerBanner);
     }
-    await loginWithRetry(page, loginPage, testUser, loginStagger);
-    await appsPage.openModelerWithRetry(modelerBanner);
-    await action();
 }
 exports.withSessionRecovery = withSessionRecovery;
 async function modelDiagramFromFile(page, modelerHomePage, modelerCreatePage, processName, fileName = '', nrOfRenamedUserTasks = 0, taskName = '') {

package/dist/tests/8.10/connectors-user-flows.spec.js

@@ -12,6 +12,7 @@ const apiHelpers_1 = require("../../utils/apiHelpers");
 const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
 const users_1 = require("../../utils/users");
 const connectorSecrets_1 = require("../../utils/connectorSecrets");
+const constants_1 = require("../../utils/constants");
 const testUser = (0, users_1.getTestUser)('seventeenthUser');
 _8_10_1.test.describe.configure({ mode: 'parallel' });
 _8_10_1.test.describe('Connectors User Flow Tests @tasklistV2', () => {
@@ -271,19 +272,21 @@ _8_10_1.test.describe('Connectors User Flow Tests @tasklistV2', () => {
             await operateHomePage.clickProcessesTab();
             await operateProcessesPage.clickProcessCompletedCheckbox();
             await operateProcessesPage.clickProcessInstanceLink(processName);
-            await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(page, operateProcessInstancePage.completedIcon, {
-                // This flow's REST connector call round-trips to a real AWS
-                // endpoint using the secrets above, which can take longer to
-                // complete than the suite's default 60s/3-retry budget (seen
-                // timing out in run 35340608406). Match the operateBanner budget
-                // above rather than the suite default used elsewhere.
-                totalTimeout: 120000,
-                visibilityTimeout: 30000,
-                maxRetries: 5,
-                postAction: async () => {
-                    await page.reload();
-                },
-            });
+            // Poll the instance deep link rather than reloading whatever page the
+            // tab is left on, the same way the identical processes-list flow in
+            // smoke-tests.spec.ts does. The completed filter also lists still-ACTIVE
+            // instances, so the link is regularly opened before this flow's REST
+            // connector has finished round-tripping to a real AWS endpoint, and
+            // expectLocatorWithRetry is blind to both that and to Operate's 404
+            // bounce: it reported only "Failed to assert visibility locator ...
+            // after 4 attempts" (run 35595548687) without saying which state the
+            // header had reached. waitForInstanceLocator re-asks Operate every few
+            // seconds within the same budget the other import gates use, names the
+            // rendered state on timeout, and fails immediately with the incident
+            // text when the connector job raised one -- COMPLETED is unreachable
+            // then, so waiting out the budget only hides the cause.
+            await operateProcessInstancePage.rememberInstanceUrl(constants_1.TIMEOUT.navigation);
+            await operateProcessInstancePage.waitForInstanceLocator(operateProcessInstancePage.completedIcon, 'Completed icon', constants_1.TIMEOUT.processImport);
             await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(page, operateProcessInstancePage.variablesList, {
                 postAction: async () => {
                     await page.reload();

package/dist/tests/8.10/optimize-sharing-alerts-export-ui.spec.js

@@ -177,11 +177,12 @@ _8_10_1.test.describe('Optimize Sharing & Export UI Tests @optimize-sharing-aler
     });
     (0, _8_10_1.test)('Enable dashboard sharing and expose a public share link', async ({ appsPage, optimizeHomePage, optimizeSharePage, }) => {
         await _8_10_1.test.step('Open Optimize from the Camunda apps launcher', async () => {
-            await appsPage.clickCamundaApps();
-            await appsPage.clickOptimize(clusterName);
-            await test_1.expect
-                .poll(async () => optimizeHomePage.optimizeBanner.isVisible({ timeout: 5000 }), { timeout: 120000 })
-                .toBe(true);
+            // Same retrying opener as the two tests above, for the same reason: a
+            // /sso-callback that answers 401 leaves the tab on a blank page that
+            // never renders the banner, and polling it can only watch that dead
+            // page time out (`expect(received).toBe(expected)` after 120s). Only
+            // re-entering through the apps menu starts a fresh hand-off.
+            await appsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, clusterName);
         });
         await _8_10_1.test.step('Navigate to the seeded dashboard', async () => {
             await optimizeSharePage.openEntityById(baseUrl, 'dashboard', dashboardId);

package/dist/utils/apiHelpers.js

@@ -740,6 +740,28 @@ async function probeOptimizeSession(page) {
     }
     return token;
 }
+// Starts a fresh OIDC code exchange with Optimize without touching the
+// identity provider session. The 401 that probeOptimizeSession catches is the
+// cluster rejecting one exchange, not the IdP rejecting the user: the Auth0
+// session minted moments earlier is still valid, so navigating to Optimize
+// again sends the browser back through the IdP, which answers from that
+// session and returns a brand new code. That costs seconds and no Auth0
+// credential round trip, where a full re-login costs another interactive
+// sign-in plus the minutes of backoff that precede it -- and there are only
+// four of those before the caller's beforeAll fails outright with
+// OPTIMIZE_SESSION_UNAUTHENTICATED.
+async function redoOptimizeSsoHandshake(page) {
+    const optimizeUrl = process.env.CAMUNDA_OPTIMIZE_BASE_URL;
+    await page.goto(optimizeUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
+    // The redirect chain has to land back on Optimize for the exchange to have
+    // completed. A chain that stops anywhere else (the IdP asking for
+    // credentials again, another rejected callback) throws a waitForURL
+    // timeout, which the caller's catch already classifies and backs off for.
+    await page.waitForURL((url) => url.toString().startsWith(optimizeUrl), {
+        timeout: 60000,
+        waitUntil: 'commit',
+    });
+}
 async function performOptimizeInteractiveLogin(page, callerLabel, verifySession) {
     const optimizeUrl = process.env.CAMUNDA_OPTIMIZE_BASE_URL;
     const maxLoginAttempts = 4;
@@ -764,7 +786,15 @@ async function performOptimizeInteractiveLogin(page, callerLabel, verifySession)
             await page.context().clearCookies();
             await (0, utils_1.loginToApp)(optimizeUrl, page);
             if (verifySession && !(await verifySession(page))) {
-                throw new Error(OPTIMIZE_SESSION_UNAUTHENTICATED);
+                // Redo the hand-off once before writing the attempt off: the rejected
+                // exchange is what has to be replaced, and re-navigating replaces it
+                // for seconds (see redoOptimizeSsoHandshake). Only when a second,
+                // freshly minted exchange is also unauthenticated is the login itself
+                // worth repeating.
+                await redoOptimizeSsoHandshake(page);
+                if (!(await verifySession(page))) {
+                    throw new Error(OPTIMIZE_SESSION_UNAUTHENTICATED);
+                }
             }
             return;
         }

package/package.json

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