@camunda/e2e-test-suite 0.0.1233 → 0.0.1234

package/dist/pages/c8Run-8.10/OperateProcessInstancePage.d.ts

@@ -11,6 +11,7 @@ declare class OperateProcessInstancePage {
     constructor(page: Page);
     connectorResultVariableName(name: string): Promise<Locator>;
     connectorResultVariableValue(variableName: string): Promise<Locator>;
+    private assertInstanceStatusIcon;
     completedIconAssertion(): Promise<void>;
     activeIconAssertion(): Promise<void>;
     getProcessVariableValue(variableName: string): Promise<Locator>;

package/dist/pages/c8Run-8.10/OperateProcessInstancePage.js

@@ -32,45 +32,47 @@ class OperateProcessInstancePage {
     async connectorResultVariableValue(variableName) {
         return await this.page.getByTestId(variableName).locator('td').last();
     }
-    async completedIconAssertion() {
-        let retryCount = 0;
-        const maxRetries = 6;
-        while (retryCount < maxRetries) {
+    // The instance header renders the status the instance had when the page was
+    // loaded, so a status that flips afterwards -- ACTIVE once the instance is
+    // exported, COMPLETED once the last task finishes -- only becomes visible on
+    // a reload. Sitting out a 60-90s per-attempt timeout before reloading
+    // therefore buys nothing: the page under the wait can no longer change. Poll
+    // on a short cadence and reload between polls instead, so the status is
+    // picked up shortly after it lands rather than at the next minute boundary.
+    //
+    // The per-attempt timeout escalates rather than staying at its opening
+    // value: on a loaded c8Run runner the instance page itself can take longer
+    // than the first interval to render, and a fixed short interval would keep
+    // reloading a page that was about to show the icon. `deadlineMs` bounds the
+    // whole assertion, so a status that never arrives still fails after at least
+    // as long as the retry loop this replaces waited.
+    async assertInstanceStatusIcon(icon, status, deadlineMs) {
+        const attemptTimeouts = [15000, 15000, 30000, 30000, 60000];
+        const deadline = Date.now() + deadlineMs;
+        let attempt = 0;
+        let lastError;
+        while (Date.now() < deadline) {
             try {
-                await (0, test_1.expect)(this.completedIcon).toBeVisible({
-                    timeout: 60000,
+                await (0, test_1.expect)(icon).toBeVisible({
+                    timeout: attemptTimeouts[Math.min(attempt, attemptTimeouts.length - 1)],
                 });
-                return; // Exit the function if the expectation is met
+                return;
             }
             catch (error) {
-                // If the active icon isn't found, reload the page and try again
-                retryCount++;
-                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                lastError = error;
+                attempt++;
+                console.log(`${status} icon not visible yet (attempt ${attempt}). Reloading...`);
                 await this.page.reload();
-                await (0, sleep_1.sleep)(10000);
             }
         }
-        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+        throw new Error(`${status} icon not visible after ${deadlineMs}ms and ${attempt} ` +
+            `reload(s): ${String(lastError)}`);
+    }
+    async completedIconAssertion() {
+        await this.assertInstanceStatusIcon(this.completedIcon, 'COMPLETED', 420000);
     }
     async activeIconAssertion() {
-        let retryCount = 0;
-        const maxRetries = 3;
-        while (retryCount < maxRetries) {
-            try {
-                await (0, test_1.expect)(this.activeIcon).toBeVisible({
-                    timeout: 90000,
-                });
-                return; // Exit the function if the expectation is met
-            }
-            catch (error) {
-                // If the active icon isn't found, reload the page and try again
-                retryCount++;
-                console.log(`Attempt ${retryCount} failed. Retrying...`);
-                await this.page.reload();
-                await (0, sleep_1.sleep)(10000);
-            }
-        }
-        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+        await this.assertInstanceStatusIcon(this.activeIcon, 'ACTIVE', 300000);
     }
     async getProcessVariableValue(variableName) {
         return await this.page

package/dist/pages/c8Run-8.10/OperateProcessesPage.js

@@ -97,11 +97,10 @@ class OperateProcessesPage {
                 return; // Exit the function if the click is successful
             }
             catch (error) {
-                // If process isn't found, reload the page and try again
+                // The next iteration opens with its own reload, so reloading and
+                // sleeping here only parks the worker for 10s on top of it.
                 retryCount++;
                 console.log(`Attempt ${retryCount} failed. Retrying...`);
-                await this.page.reload();
-                await (0, sleep_1.sleep)(10000);
             }
         }
         throw new Error(`Failed to click on process instance link after ${maxRetries} attempts.`);

package/package.json

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