@camunda/e2e-test-suite 0.0.1389 → 0.0.1390

package/dist/pages/8.10/ClusterPage.js

@@ -132,7 +132,12 @@ class ClusterPage {
         // deleteCluster needs it -- while everything that means "the one cluster
         // under test" goes through this single row, so a duplicate can no longer
         // turn an ordinary visibility check into a strict-mode violation.
-        this.clusterRow = (clusterName) => this.cluster(clusterName).first();
+        // createCluster's pre-clean leaves same-named rows in "Deleting" for
+        // minutes, and they can sort above the new cluster; that row never shows
+        // Creating/Healthy, so it must not be picked as the cluster under test.
+        this.clusterRow = (clusterName) => this.cluster(clusterName)
+            .filter({ hasNotText: /Deleting/ })
+            .first();
         this.clusterHealthiness = (clusterName) => this.clusterRow(clusterName).getByText(`Healthy`, {
             exact: true,
         });
@@ -203,35 +208,104 @@ class ClusterPage {
         }
     }
     async deleteCluster(name) {
-        await this.page.waitForTimeout(1000);
-        const clusterInstance = this.cluster(name).first();
-        if ((await clusterInstance.count()) <= 0) {
+        // A full reload in the Hub shell bounces through /login, the identity
+        // provider and /login-callback (~35s) before the SPA pushes its returnUrl
+        // back to /clusters. Counting rows mid-bounce throws "Execution context
+        // was destroyed", so wait for the clusters page to have settled first.
+        await this.page.waitForURL((url) => /\/clusters\/?$/.test(url.pathname), {
+            timeout: 120000,
+        });
+        await (0, test_1.expect)(this.createNewClusterButton).toBeVisible({ timeout: 60000 });
+        // Hub's clusters data table renders skeleton rows (no links) while it
+        // fetches, and the "Create new cluster" button is visible before the data
+        // arrives. Counting matching rows at that point always returned 0, so the
+        // pre-clean was skipped and every run left one more same-named cluster
+        // behind until the org ran out of G3-Dev reservations (the type tile then
+        // renders disabled). Wait for the first loaded row before counting.
+        await this.clustersList
+            .getByRole('link')
+            .first()
+            .waitFor({ timeout: 30000 })
+            .catch(() => false);
+        // Rows whose deletion is already in progress keep the name until the
+        // backend removes them; exclude them so the loop does not revisit them.
+        const deletableRows = () => this.clustersList
+            .filter({
+            has: this.page.getByRole('link', { name, exact: true }),
+        })
+            .filter({ hasNotText: /Deleting/ });
+        if ((await deletableRows().count()) <= 0) {
             console.log(`No clusters found with name ${name}, skipping deletion.`);
             return;
         }
-        await clusterInstance.waitFor({ timeout: 10000 });
-        let deleteButtons = this.cluster(name).getByRole('button', {
-            name: 'Delete',
-        });
-        while ((await deleteButtons.count()) > 0) {
-            const deleteButton = deleteButtons.nth(0);
-            if (await deleteButton.isVisible()) {
-                try {
-                    await deleteButton.click({ force: true, timeout: 60000 });
-                }
-                catch (error) {
-                    await this.clickClusterBanner();
-                    await (0, test_1.expect)(deleteButton).toBeVisible({ timeout: 60000 });
-                    await deleteButton.click({ force: true, timeout: 60000 });
-                }
-                await this.confirmClusterDeletion();
-                // Refresh the list of delete buttons
-                deleteButtons = this.cluster(name).getByRole('button', {
-                    name: 'Delete',
+        // Legacy Console rendered a per-row "Delete" button; Hub's design-system
+        // data table instead puts it in the row's "Row actions" kebab menu.
+        const deleteMenuItem = this.page.getByRole('menuitem', { name: /^Delete/ });
+        const confirmInput = this.confirmDeleteInput.or(this.dialog.getByRole('textbox'));
+        const maxDeletions = 50;
+        for (let i = 0; i < maxDeletions; i++) {
+            if ((await deletableRows().count()) <= 0)
+                break;
+            const row = deletableRows().first();
+            const rowAction = row
+                .getByRole('button', { name: 'Delete' })
+                .or(row.getByRole('button', { name: 'Row actions', exact: true }));
+            try {
+                await (0, test_1.expect)(rowAction).toBeVisible({ timeout: 10000 });
+            }
+            catch {
+                // A cluster in a transient state (e.g. just created by a concurrent
+                // setup worker) may have its row present before the action renders.
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+                await this.clustersList.getByRole('link').first().waitFor({
+                    timeout: 30000,
+                });
+                continue;
+            }
+            // Rows share the cluster name, so remember this row's unique link (it
+            // carries the cluster id) to recognise when this cluster is gone.
+            const clusterHref = await row
+                .getByRole('link', { name, exact: true })
+                .getAttribute('href');
+            await rowAction.click({ timeout: 60000 });
+            // isVisible() does not wait, so a kebab menu that opens a moment after
+            // the click was missed and the confirm dialog never appeared. Wait for
+            // either the menu item (Hub) or the dialog (legacy per-row button).
+            await (0, test_1.expect)(deleteMenuItem.or(this.dialog)).toBeVisible({
+                timeout: 30000,
+            });
+            if (await deleteMenuItem.isVisible()) {
+                await deleteMenuItem.click({ timeout: 30000 });
+            }
+            await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 60000 });
+            await (0, test_1.expect)(confirmInput.first()).toBeVisible({ timeout: 60000 });
+            await confirmInput.first().fill('DELETE', { timeout: 60000 });
+            await this.dangerDeleteButton.last().click({ timeout: 60000 });
+            // When a concurrent worker already deleted this same cluster, the modal
+            // stays open with "We're having trouble deleting the cluster". Close it;
+            // the row check below still fails if the cluster was not removed.
+            const deleteError = this.dialog.getByText("We're having trouble deleting the cluster");
+            // The alert only renders once the delete request fails, so wait for the
+            // modal to either close or show it rather than probing once.
+            await (0, test_1.expect)(async () => {
+                const closed = !(await this.dialog.isVisible());
+                (0, test_1.expect)(closed || (await deleteError.isVisible())).toBe(true);
+            }).toPass({ timeout: 60000 });
+            if (await deleteError.isVisible()) {
+                await this.dialog.getByRole('button', { name: 'Cancel' }).click();
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+                await this.clustersList.getByRole('link').first().waitFor({
+                    timeout: 120000,
                 });
             }
+            await (0, test_1.expect)(this.dialog).not.toBeVisible({ timeout: 60000 });
+            // Wait until the deleted row is gone or flagged as deleting. The table
+            // is paginated, so the row count alone does not drop: the next page's
+            // rows slide in to fill the gap.
+            await (0, test_1.expect)(this.clustersList
+                .filter({ has: this.page.locator(`a[href="${clusterHref}"]`) })
+                .filter({ hasNotText: /Deleting/ })).toHaveCount(0, { timeout: 60000 });
         }
-        await this.page.waitForTimeout(500);
     }
     async clickClusterTab() {
         await Promise.race([

package/dist/pages/8.10/TaskPanelPage.js

@@ -27,7 +27,14 @@ class TaskPanelPage {
         // was plainly listed. The `<section aria-label="Tasks side panel">` that
         // wraps the panel is present on both shells -- it is what the product's own
         // qa/c8-orchestration-cluster-e2e-test-suite and pages/SM-8.10 now anchor on.
-        this.availableTasks = page.getByRole('region', { name: 'Tasks side panel' });
+        // Both are matched because the rollout is per app and not yet everywhere:
+        // a run still served the pre-#65074 shell (an older SaaS cluster, or a
+        // version that has not flipped) only exposes the title wrapper. `.first()`
+        // keeps the locator strict-mode safe on a shell that renders both.
+        this.availableTasks = page
+            .getByRole('region', { name: 'Tasks side panel' })
+            .or(page.getByTitle('Available tasks'))
+            .first();
         // 8.10 still serves Tasklist on the Carbon shell, so filtering lives in
         // the collapsible filter panel: the collapsed rail carries the expand
         // control (aria-controls="task-nav-bar") and the expanded nav lists each

package/package.json

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