@camunda/e2e-test-suite 0.0.938 → 0.0.940

package/dist/pages/8.10/TaskDetailsPage.js

@@ -121,11 +121,20 @@ class TaskDetailsPage {
     async clickUnassignButton() {
         await this.unassignButton.click();
     }
+    // The "Task completed" toast is a transient confirmation: the v2 webapp's
+    // notification store auto-removes it after 5s, and it is never rendered at
+    // all when the refreshed task list deselects the completed task before the
+    // completion state machine reaches CompletionSucceeded (which is what the
+    // nightly trace showed - the task was completed, but no toast ever entered
+    // the DOM). Accept the task's own completed state as well: the details panel
+    // only renders "Completion date" once the task has one, so this confirms the
+    // completion rather than weakening the check.
     async clickCompleteTaskButton() {
         await this.completeTaskButton.click({ timeout: 60000 });
-        await (0, test_1.expect)(this.page.getByText('Task completed')).toBeVisible({
-            timeout: 60000,
-        });
+        await (0, test_1.expect)(this.page
+            .getByText('Task completed')
+            .or(this.detailsPanel.getByText('Completion date'))
+            .first()).toBeVisible({ timeout: 60000 });
         await this.page.reload();
     }
     async clickAddVariableButton() {

package/dist/pages/8.10/UtilitiesPage.js

@@ -249,7 +249,11 @@ async function assertPageTextWithRetry(page, text, notVisible = false, timeout =
 }
 exports.assertPageTextWithRetry = assertPageTextWithRetry;
 async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, taskPriority, maxRetries = 3) {
+    const openTask = taskPanelPage.availableTasks
+        .getByText(taskName, { exact: true })
+        .first();
     for (let attempt = 0; attempt < maxRetries; attempt++) {
+        let completionRequested = false;
         try {
             await taskPanelPage.openTask(taskName);
             await (0, test_1.expect)(taskDetailsPage.detailsInfo.getByText(taskName, { exact: true })).toBeVisible();
@@ -257,11 +261,27 @@ async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, t
                 await taskDetailsPage.clickAssignToMeButton();
             }
             await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible();
+            completionRequested = true;
             await taskDetailsPage.clickCompleteTaskButton();
-            await (0, test_1.expect)(taskPanelPage.availableTasks.getByText(taskName, { exact: true }).first()).not.toBeVisible({ timeout: 30000 });
+            await (0, test_1.expect)(openTask).not.toBeVisible({ timeout: 30000 });
             return;
         }
         catch (error) {
+            // Once the Complete Task click has gone out, the task may well have been
+            // completed even though its confirmation was missed. Retrying blindly
+            // re-enters openTask, which waits 120s per attempt for a task that no
+            // longer exists and exhausts the 12 min test timeout, so first check the
+            // durable signal: the task leaving the open task list.
+            if (completionRequested) {
+                const taskGone = await openTask
+                    .waitFor({ state: 'hidden', timeout: 30000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (taskGone) {
+                    console.warn(`Confirmation for completing task ${taskName} was missed, but the task left the open task list - treating it as completed.`);
+                    return;
+                }
+            }
             if (attempt < maxRetries - 1) {
                 console.warn(`Attempt ${attempt + 1} failed for completing task ${taskName}. Retrying...`);
                 await (0, sleep_1.sleep)(2000);

package/dist/pages/8.8/ClusterDetailsPage.d.ts

@@ -74,6 +74,8 @@ declare class ClusterDetailsPage {
     selectEmailRadioButton(): Promise<void>;
     clickCreateAlertButton(): Promise<void>;
     deleteAlerts(): Promise<void>;
+    private confirmDelete;
+    private dismissDeleteDialog;
     private doDelete;
     assertComponentsHealth(components?: string[]): Promise<void>;
     createAPIClientAndReturnVariables(name: string, setEnvVariables?: boolean): Promise<{

package/dist/pages/8.8/ClusterDetailsPage.js

@@ -404,6 +404,45 @@ class ClusterDetailsPage {
     async deleteAlerts() {
         await this.doDelete(this.dialog, 'Alerts');
     }
+    // The confirmation modal only closes once the DELETE request resolves. When
+    // that call fails the modal stays open on an inline "We're having trouble
+    // deleting the alert / fetch error" banner, and Carbon's modal overlay then
+    // intercepts pointer events for the whole page — so the next row's Delete
+    // click can never land (the nightly trace shows
+    // `DELETE /api/orgs/<org>/clusters/<id>/alerts/<uuid>` ending in
+    // net::ERR_FAILED, followed by a 60s click timeout on the row button). Retry
+    // the confirmation while the modal is up, and guarantee it is gone before the
+    // caller touches the list again.
+    async confirmDelete(dialog) {
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await this.deleteSubButton.click({ timeout: 60000 });
+            await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
+                timeout: 60000,
+            });
+            const closed = await dialog
+                .waitFor({ state: 'hidden', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (closed) {
+                return true;
+            }
+            console.warn(`Confirmation dialog still open after delete attempt ${attempt} of ${maxAttempts}`);
+        }
+        await this.dismissDeleteDialog(dialog);
+        return false;
+    }
+    async dismissDeleteDialog(dialog) {
+        const cancelButton = dialog.getByRole('button', { name: 'Cancel' });
+        const hasCancel = await cancelButton.isVisible().catch(() => false);
+        if (hasCancel) {
+            await cancelButton.click({ timeout: 30000 });
+        }
+        else {
+            await this.page.keyboard.press('Escape');
+        }
+        await dialog.waitFor({ state: 'hidden', timeout: 30000 });
+    }
     async doDelete(dialog, text) {
         try {
             await (0, test_1.expect)(this.deleteButton.first()).toBeVisible({
@@ -414,9 +453,12 @@ class ClusterDetailsPage {
             return; //No items found in the list
         }
         try {
-            let deletes = await this.deleteButton.all();
-            while (deletes.length > 0) {
-                const deleteButton = deletes[0];
+            let remaining = await this.deleteButton.count();
+            // A failed DELETE leaves the row in place; retry it from a clean state
+            // instead of giving up on the first stalled round.
+            let stalledRounds = 0;
+            while (remaining > 0 && stalledRounds < 3) {
+                const deleteButton = this.deleteButton.first();
                 if (await deleteButton.isVisible()) {
                     await deleteButton.click({ timeout: 60000 });
                     // Handle confirmation dialog if it appears; some UI states delete without one
@@ -424,17 +466,18 @@ class ClusterDetailsPage {
                         .isVisible({ timeout: 5000 })
                         .catch(() => false);
                     if (dialogVisible) {
-                        await this.deleteSubButton.click();
-                        await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
-                            timeout: 60000,
-                        });
+                        if (!(await this.confirmDelete(dialog))) {
+                            console.warn(`Retrying ${text} deletion after a failed request`);
+                        }
                     }
                     else {
                         await (0, sleep_1.sleep)(2000);
                     }
                 }
                 await (0, sleep_1.sleep)(3000);
-                deletes = await this.deleteButton.all();
+                const left = await this.deleteButton.count();
+                stalledRounds = left < remaining ? 0 : stalledRounds + 1;
+                remaining = left;
             }
             await (0, test_1.expect)(this.deleteButton).not.toBeVisible({
                 timeout: 30000,

package/dist/tests/8.8/console-user-flows.spec.js

@@ -152,17 +152,23 @@ _8_8_1.test.describe('Console User Flow Tests @tasklistV2', () => {
             await homePage.clickClusters();
             await clusterPage.clickClusterLink(alertFlowClusterName);
         });
+        // Console's alerts panel renders its "Alerts keep you informed" empty state
+        // whenever the cluster-detail fetch fails (the nightly trace shows
+        // `/api/orgs/<org>/clusters/<id>*` calls ending in net::ERR_FAILED), so the
+        // alert rows can be missing for a while even though the alert exists and has
+        // already triggered. A reload re-issues those fetches, so give the recovery
+        // enough reload cycles instead of only three.
         await _8_8_1.test.step('Verify Alert Count Increases to 1 After Trigger', async () => {
             await clusterDetailsPage.clickAlertsTab();
             await (0, test_1.expect)(async () => {
                 await page.reload();
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.first()).toBeVisible({
-                    timeout: 30000,
+                    timeout: 20000,
                 });
                 (0, test_1.expect)(await clusterDetailsPage.alertsList.count()).toBeGreaterThan(1);
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.nth(0)).toContainText(`Email`);
                 await clusterDetailsPage.assertAlertText('Amount triggered1');
-            }).toPass({ timeout: 90000 });
+            }).toPass({ timeout: 240000 });
         });
         await _8_8_1.test.step('Verify Alerts Received via Email for Incident', async () => {
             await (0, sleep_1.sleep)(60000);
@@ -191,16 +197,17 @@ _8_8_1.test.describe('Console User Flow Tests @tasklistV2', () => {
             await homePage.clickClusters();
             await clusterPage.clickClusterLink(alertFlowClusterName);
         });
+        // Same empty-state recovery as the first count assertion above.
         await _8_8_1.test.step('Verify Alert Count Increases to 3 After Trigger', async () => {
             await clusterDetailsPage.clickAlertsTab();
             await (0, test_1.expect)(async () => {
                 await page.reload();
                 await (0, test_1.expect)(clusterDetailsPage.alertsList.first()).toBeVisible({
-                    timeout: 30000,
+                    timeout: 20000,
                 });
                 (0, test_1.expect)(await clusterDetailsPage.alertsList.count()).toBeGreaterThan(1);
                 await clusterDetailsPage.assertAlertText('Amount triggered3');
-            }).toPass({ timeout: 90000 });
+            }).toPass({ timeout: 240000 });
         });
         await _8_8_1.test.step('Verify Alerts Received via Email for Incident', async () => {
             await (0, sleep_1.sleep)(60000);

package/package.json

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