@camunda/e2e-test-suite 0.0.931 → 0.0.932

package/dist/pages/8.7/OptimizeDashboardPage.d.ts

@@ -3,8 +3,8 @@ declare class OptimizeDashboardPage {
     private page;
     readonly filterTable: Locator;
     constructor(page: Page);
-    clickFilterTable(): Promise<void>;
-    fillFilterTable(processName: string): Promise<void>;
+    clickFilterTable(timeout?: number): Promise<void>;
+    fillFilterTable(processName: string, timeout?: number): Promise<void>;
     processLinkAssertion(processName: string, maxRetries: number, retryDelay?: number): Promise<void>;
     processOwnerNameAssertion(processName: string, userEmail: string): Promise<void>;
 }

package/dist/pages/8.7/OptimizeDashboardPage.js

@@ -9,11 +9,11 @@ class OptimizeDashboardPage {
         this.page = page;
         this.filterTable = page.getByPlaceholder('Filter table');
     }
-    async clickFilterTable() {
-        await this.filterTable.click({ timeout: 120000 });
+    async clickFilterTable(timeout = 120000) {
+        await this.filterTable.click({ timeout });
     }
-    async fillFilterTable(processName) {
-        await this.filterTable.fill(processName, { timeout: 60000 });
+    async fillFilterTable(processName, timeout = 60000) {
+        await this.filterTable.fill(processName, { timeout });
         await this.filterTable.press('Enter');
     }
     async processLinkAssertion(processName, maxRetries, retryDelay = 60000) {
@@ -39,26 +39,40 @@ class OptimizeDashboardPage {
     async processOwnerNameAssertion(processName, userEmail) {
         // Optimize's Process Overview only refreshes its owner data on a page
         // reload (it does not poll in the background), so a long per-attempt
-        // assertion timeout just idles against a stale DOM. Poll more frequently
-        // instead: a short assertion timeout (enough for the table to render after
-        // reload) plus a shorter delay lets us reload roughly every ~55s and catch
-        // a slow owner import sooner. The total budget (~23 min) stays safely under
-        // the test timeout so a genuine failure surfaces as this clean error rather
-        // than an opaque "page closed" test-timeout.
-        const maxRetries = 25;
+        // assertion timeout just idles against a stale DOM. Poll frequently
+        // instead: a short assertion timeout (enough for the table to render) plus
+        // a short delay lets us reload roughly every ~45s and catch a slow owner
+        // import sooner.
+        //
+        // The reload also clears the "Filter table" search that
+        // processLinkAssertion applied, so every attempt re-applies it — otherwise
+        // attempts 2..n search the full, paginated org-wide process list and the
+        // row can be off-screen entirely. Filter waits are bounded per attempt so
+        // one slow render cannot consume the whole budget.
+        //
+        // Owner assignment is asynchronous (Optimize assigns the deploying Web
+        // Modeler user once the deployment is imported) and on a loaded nightly
+        // org it can lag well past 20 minutes, so the loop keeps polling until a
+        // wall-clock deadline. The deadline (not just the attempt count) is what
+        // keeps the total under the test.slow() timeout, so a genuine failure
+        // surfaces as this clean error rather than an opaque test-timeout.
+        const maxRetries = 32;
         const retryDelay = 25000;
+        const deadline = Date.now() + 25 * 60 * 1000;
         const localPart = userEmail.split('@')[0];
         const uuid = localPart.replace('qa-user-', '');
         const result = !uuid ? 'QA Camunda' : `QA User ${uuid}`;
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
+                await this.clickFilterTable(30000);
+                await this.fillFilterTable(processName, 15000);
                 await (0, test_1.expect)(this.page.getByRole('row', {
                     name: `${processName}\nProcess\n\t${result}`,
                 })).toBeVisible({ timeout: 20000 });
                 return;
             }
             catch (error) {
-                if (attempt < maxRetries - 1) {
+                if (attempt < maxRetries - 1 && Date.now() < deadline) {
                     console.warn(`Attempt ${attempt + 1} failed for asserting owner name ${result} assertion for ${processName} in Optimize.. Retrying...`);
                     try {
                         await this.page.reload();
@@ -69,7 +83,7 @@ class OptimizeDashboardPage {
                     await new Promise((resolve) => setTimeout(resolve, retryDelay));
                 }
                 else {
-                    throw new Error(`Owner name ${result} assertion for ${processName} failed after ${maxRetries} attempts`);
+                    throw new Error(`Owner name ${result} assertion for ${processName} failed after ${attempt + 1} attempts`);
                 }
             }
         }

package/package.json

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