@camunda/e2e-test-suite 0.0.931 → 0.0.933

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/dist/pages/8.8/IdpCreatePage.d.ts

@@ -28,6 +28,7 @@ declare class IdpCreatePage {
     readonly selectUnstructuredDataExtraction: Locator;
     readonly selectStructuredDataExtraction: Locator;
     readonly extractionInProgressNotification: Locator;
+    readonly extractionFailureIndicator: Locator;
     readonly structured_FieldsTab: Locator;
     readonly structured_TablesTab: Locator;
     readonly structured_CheckboxSelectAllFields: Locator;
@@ -42,6 +43,12 @@ declare class IdpCreatePage {
     readonly structured_PublishTemplateToProjectButton: Locator;
     readonly structured_SuccessfullPublishNotification: Locator;
     constructor(page: Page);
+    /**
+     * Surfaces a product-side extraction failure as the test error instead of
+     * letting the next assertion block for its full timeout and report only
+     * "locator timed out" — the on-screen error carries the actual cause.
+     */
+    private assertNoExtractionFailure;
     clickCreateIdpTemplateButton(): Promise<void>;
     fillIdpExtractionTemplateName(name: string): Promise<void>;
     clickCreateIdpExtractationTemplateButton(): Promise<void>;

package/dist/pages/8.8/IdpCreatePage.js

@@ -32,6 +32,7 @@ class IdpCreatePage {
     selectUnstructuredDataExtraction;
     selectStructuredDataExtraction;
     extractionInProgressNotification;
+    extractionFailureIndicator;
     structured_FieldsTab;
     structured_TablesTab;
     structured_CheckboxSelectAllFields;
@@ -101,6 +102,15 @@ class IdpCreatePage {
         this.selectUnstructuredDataExtraction = page.getByText('Unstructured data extraction');
         this.selectStructuredDataExtraction = page.getByText('Structured form extraction');
         this.extractionInProgressNotification = page.getByText('Extracting document...');
+        // Terminal states the product renders when extraction itself fails: the
+        // error toast (unstructured) and the empty state (structured). Both persist,
+        // so they can be probed once the in-progress indicator clears.
+        this.extractionFailureIndicator = page
+            .getByRole('alert')
+            .filter({ has: page.getByText(/^(Error|Extraction failed)$/) })
+            .or(page.getByRole('heading', {
+            name: 'Extraction could not be completed',
+        }));
         this.structured_uploadFilesButton = page
             .getByRole('button', {
             name: /Drag and drop.*PDF.*upload/i,
@@ -141,6 +151,22 @@ class IdpCreatePage {
             page.getByText('Template published');
         this.providerDropdown = page.getByRole('combobox', { name: 'Provider' });
     }
+    /**
+     * Surfaces a product-side extraction failure as the test error instead of
+     * letting the next assertion block for its full timeout and report only
+     * "locator timed out" — the on-screen error carries the actual cause.
+     */
+    async assertNoExtractionFailure(step) {
+        const failure = this.extractionFailureIndicator.first();
+        const failed = await failure.isVisible().catch(() => false);
+        if (!failed) {
+            return;
+        }
+        const detail = (await failure.innerText().catch(() => ''))
+            .replace(/\s+/g, ' ')
+            .trim();
+        throw new Error(`${step} failed in the product: ${detail}`);
+    }
     async clickCreateIdpTemplateButton() {
         await this.createIdpTemplateButton.click({ timeout: 60000 });
     }
@@ -192,12 +218,19 @@ class IdpCreatePage {
         await (0, test_1.expect)(this.page.getByText('Extracting..')).not.toBeVisible({
             timeout: 300000,
         });
+        await this.assertNoExtractionFailure('Document extraction');
         await (0, test_1.expect)(this.unstructured_saveAsTestCaseButton).toBeVisible({
             timeout: 300000,
         });
-        await (0, test_1.expect)(this.unstructured_saveAsTestCaseButton).toBeEnabled({
-            timeout: 300000,
-        });
+        try {
+            await (0, test_1.expect)(this.unstructured_saveAsTestCaseButton).toBeEnabled({
+                timeout: 300000,
+            });
+        }
+        catch (error) {
+            await this.assertNoExtractionFailure('Document extraction');
+            throw error;
+        }
     }
     async clickSaveAsTestCaseButton() {
         await this.unstructured_saveAsTestCaseButton.click({ timeout: 60000 });
@@ -271,9 +304,16 @@ class IdpCreatePage {
         await (0, test_1.expect)(this.extractionInProgressNotification).not.toBeVisible({
             timeout: 300000,
         });
-        await (0, test_1.expect)(this.structured_FieldsTab).toBeVisible({
-            timeout: 300000,
-        });
+        await this.assertNoExtractionFailure('Structured form extraction');
+        try {
+            await (0, test_1.expect)(this.structured_FieldsTab).toBeVisible({
+                timeout: 300000,
+            });
+        }
+        catch (error) {
+            await this.assertNoExtractionFailure('Structured form extraction');
+            throw error;
+        }
         await (0, test_1.expect)(this.structured_CheckboxSelectAllFields).toBeVisible({
             timeout: 60000,
         });

package/package.json

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