@camunda/e2e-test-suite 0.0.1108 → 0.0.1110

package/dist/pages/8.10/ClusterPage.d.ts

@@ -32,12 +32,15 @@ declare class ClusterPage {
     readonly tasklistV1Api: Locator;
     readonly tasklistV2Api: Locator;
     readonly cluster: (clusterName: string) => Locator;
+    readonly clusterRow: (clusterName: string) => Locator;
     readonly clusterHealthiness: (clusterName: string) => Locator;
     readonly clusterLink: (clusterName: string) => Locator;
     readonly dialog: Locator;
     readonly clusterVersion: (clusterName: string, versionText: string) => Locator;
     constructor(page: Page, testInfo?: TestInfo);
     clickClusterBanner(): Promise<void>;
+    private confirmClusterDeletion;
+    private dismissOpenDialog;
     deleteCluster(name: string): Promise<void>;
     clickClusterTab(): Promise<void>;
     clickCreateNewClusterButton(): Promise<void>;
@@ -54,6 +57,30 @@ declare class ClusterPage {
     clickConnectorSecretsTab(clusterName: string): Promise<void>;
     clickLatestStableForMinorVersion(): Promise<void>;
     clickClusterOption(): Promise<void>;
+    /**
+     * Counts the clusters carrying `clusterName`. The clusters table renders
+     * asynchronously after a navigation or reload, so a bare `count()` can read
+     * zero rows off a list that is merely still loading -- and the caller would
+     * then create a second cluster with the same name. Give the row a chance to
+     * appear before trusting a zero.
+     */
+    private countClusters;
+    /**
+     * Deletes the surplus rows when several clusters share `clusterName`, so the
+     * name identifies exactly one cluster again. Duplicates are created when
+     * concurrent workers run the same spec against a fixed cluster name: both
+     * see "no such cluster" and both create one (each in its own random region,
+     * which the Console accepts). Leaving them in place is not an option -- the
+     * cluster name is what every later step resolves the cluster by, in the
+     * Console list, in the apps menu, and in the Modeler deployment dialog, and
+     * those lists do not have to agree on ordering, so the flow could enable RBA
+     * on one cluster and then assert against the other.
+     *
+     * Always removes the trailing row so the surviving cluster stays the one
+     * `clusterRow()` resolves to, and a concurrent worker pruning the same list
+     * targets the same row rather than the survivor.
+     */
+    private pruneDuplicateClusters;
     createClusterIfNotExists(clusterName: string, region?: string): Promise<void>;
     assertClusterHealthyStatusWithRetry(name: string, visibilityTimeout?: number, totalTimeout?: number): Promise<void>;
     clickAlphaTab(): Promise<void>;

package/dist/pages/8.10/ClusterPage.js

@@ -37,6 +37,7 @@ class ClusterPage {
     tasklistV1Api;
     tasklistV2Api;
     cluster;
+    clusterRow;
     clusterHealthiness;
     clusterLink;
     dialog;
@@ -109,15 +110,22 @@ class ClusterPage {
         this.cluster = (clusterName) => this.clustersList.filter({
             has: page.getByRole('link', { name: clusterName, exact: true }),
         });
-        this.clusterHealthiness = (clusterName) => this.cluster(clusterName).getByText(`Healthy`, {
+        // The Console only enforces cluster-name uniqueness per region, so the
+        // org can hold several rows with the same name (parallel workers sharing
+        // a fixed cluster name do produce them). `cluster()` stays the full set --
+        // 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();
+        this.clusterHealthiness = (clusterName) => this.clusterRow(clusterName).getByText(`Healthy`, {
             exact: true,
         });
-        this.clusterLink = (clusterName) => this.cluster(clusterName).getByRole('link', {
+        this.clusterLink = (clusterName) => this.clusterRow(clusterName).getByRole('link', {
             name: clusterName,
             exact: true,
         });
         this.dialog = page.getByRole('dialog');
-        this.clusterVersion = (clusterName, versionText) => this.cluster(clusterName).getByText(versionText, { exact: false });
+        this.clusterVersion = (clusterName, versionText) => this.clusterRow(clusterName).getByText(versionText, { exact: false });
     }
     async clickClusterBanner() {
         await this.page
@@ -125,6 +133,30 @@ class ClusterPage {
             .getByRole('link', { name: 'Clusters' })
             .click({ timeout: 60000 });
     }
+    async confirmClusterDeletion() {
+        await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 60000 });
+        await (0, test_1.expect)(this.confirmDeleteInput).toBeVisible({ timeout: 60000 });
+        await this.confirmDeleteInput.click({ force: true, timeout: 60000 });
+        await this.confirmDeleteInput.fill('DELETE', { timeout: 60000 });
+        const dangerDeleteButtons = await this.dangerDeleteButton.all();
+        const lastDangerDeleteButton = dangerDeleteButtons[dangerDeleteButtons.length - 1];
+        await lastDangerDeleteButton.click();
+        await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
+            timeout: 60000,
+        });
+        await (0, test_1.expect)(this.dialog).not.toBeVisible({ timeout: 60000 });
+    }
+    async dismissOpenDialog() {
+        const cancelButton = this.dialog
+            .first()
+            .getByRole('button', { name: 'Cancel' });
+        const cancelVisible = await cancelButton
+            .isVisible({ timeout: 2000 })
+            .catch(() => false);
+        if (cancelVisible) {
+            await cancelButton.click({ timeout: 10000 }).catch(() => false);
+        }
+    }
     async deleteCluster(name) {
         await this.page.waitForTimeout(1000);
         const clusterInstance = this.cluster(name).first();
@@ -147,17 +179,7 @@ class ClusterPage {
                     await (0, test_1.expect)(deleteButton).toBeVisible({ timeout: 60000 });
                     await deleteButton.click({ force: true, timeout: 60000 });
                 }
-                await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 60000 });
-                await (0, test_1.expect)(this.confirmDeleteInput).toBeVisible({ timeout: 60000 });
-                await this.confirmDeleteInput.click({ force: true, timeout: 60000 });
-                await this.confirmDeleteInput.fill('DELETE', { timeout: 60000 });
-                const dangerDeleteButtons = await this.dangerDeleteButton.all();
-                const lastDangerDeleteButton = dangerDeleteButtons[dangerDeleteButtons.length - 1];
-                await lastDangerDeleteButton.click();
-                await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
-                    timeout: 60000,
-                });
-                await (0, test_1.expect)(this.dialog).not.toBeVisible({ timeout: 60000 });
+                await this.confirmClusterDeletion();
                 // Refresh the list of delete buttons
                 deleteButtons = this.cluster(name).getByRole('button', {
                     name: 'Delete',
@@ -245,15 +267,21 @@ class ClusterPage {
         await this.createClusterButton.click();
     }
     async clickClustersBreadcrumb(clusterName) {
-        const creatingCheckRegex = new RegExp(`${clusterName}.*?Creatingdev`);
-        const healthyCheckRegex = new RegExp(`${clusterName}.*?Healthydev`);
-        const clusterRowVisible = this.page
-            .getByText(creatingCheckRegex)
-            .or(this.page.getByText(healthyCheckRegex));
+        // Scope the status check to the cluster's own row instead of matching the
+        // status text anywhere on the page: a page-wide `getByText` regex also
+        // matches every ancestor whose combined text spans the name and a status
+        // (the whole app shell does, once a second row carries the same name),
+        // which turns this wait into a strict-mode violation.
+        const creatingRow = this.clusterRow(clusterName).filter({
+            hasText: 'Creating',
+        });
+        const clusterRowVisible = this.clusterRow(clusterName).filter({
+            hasText: /Creating|Healthy/,
+        });
         try {
             await (0, test_1.expect)(this.clustersBreadcrumb).toBeVisible({ timeout: 60000 });
             await this.clustersBreadcrumb.click({ timeout: 60000 });
-            await (0, test_1.expect)(this.page.getByText(creatingCheckRegex)).toBeVisible({
+            await (0, test_1.expect)(creatingRow).toBeVisible({
                 timeout: 30000,
             });
             return;
@@ -347,19 +375,84 @@ class ClusterPage {
         }
         throw new Error('Failed to find cluster generation');
     }
+    /**
+     * Counts the clusters carrying `clusterName`. The clusters table renders
+     * asynchronously after a navigation or reload, so a bare `count()` can read
+     * zero rows off a list that is merely still loading -- and the caller would
+     * then create a second cluster with the same name. Give the row a chance to
+     * appear before trusting a zero.
+     */
+    async countClusters(clusterName) {
+        await this.clusterRow(clusterName)
+            .waitFor({ state: 'visible', timeout: 30000 })
+            .catch(() => false);
+        return this.cluster(clusterName).count();
+    }
+    /**
+     * Deletes the surplus rows when several clusters share `clusterName`, so the
+     * name identifies exactly one cluster again. Duplicates are created when
+     * concurrent workers run the same spec against a fixed cluster name: both
+     * see "no such cluster" and both create one (each in its own random region,
+     * which the Console accepts). Leaving them in place is not an option -- the
+     * cluster name is what every later step resolves the cluster by, in the
+     * Console list, in the apps menu, and in the Modeler deployment dialog, and
+     * those lists do not have to agree on ordering, so the flow could enable RBA
+     * on one cluster and then assert against the other.
+     *
+     * Always removes the trailing row so the surviving cluster stays the one
+     * `clusterRow()` resolves to, and a concurrent worker pruning the same list
+     * targets the same row rather than the survivor.
+     */
+    async pruneDuplicateClusters(clusterName) {
+        const rows = this.cluster(clusterName);
+        const maxAttempts = 4;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const total = await this.countClusters(clusterName);
+            if (total <= 1)
+                return;
+            console.warn(`pruneDuplicateClusters: found ${total} clusters named '${clusterName}'; deleting the surplus row (attempt ${attempt}/${maxAttempts}).`);
+            try {
+                await rows
+                    .nth(total - 1)
+                    .getByRole('button', { name: 'Delete' })
+                    .click({ force: true, timeout: 60000 });
+                await this.confirmClusterDeletion();
+            }
+            catch (error) {
+                console.warn(`pruneDuplicateClusters: could not delete the surplus '${clusterName}' row: ${error}`);
+                await this.dismissOpenDialog();
+            }
+            await this.page.reload({ waitUntil: 'domcontentloaded' });
+        }
+        const remaining = await this.countClusters(clusterName);
+        if (remaining > 1) {
+            throw new Error(`Could not reduce the ${remaining} clusters named '${clusterName}' to a single one after ${maxAttempts} attempts; the cluster name no longer identifies one cluster.`);
+        }
+    }
     async createClusterIfNotExists(clusterName, region = 'GCP') {
         await (0, sleep_1.sleep)(15000);
-        if ((await this.cluster(clusterName).isVisible({ timeout: 20000 })) &&
-            (await this.clusterHealthiness(clusterName).isVisible({ timeout: 20000 }))) {
-            console.log(`${clusterName} exists and is healthy.`);
-        }
-        else {
+        await this.pruneDuplicateClusters(clusterName);
+        if ((await this.countClusters(clusterName)) === 0) {
             await this.createCluster(clusterName, region);
             await this.assertClusterHealthyStatusWithRetry(clusterName, 120000, 600000);
+            return;
         }
+        if (await this.clusterHealthiness(clusterName).isVisible({ timeout: 20000 })) {
+            console.log(`${clusterName} exists and is healthy.`);
+            return;
+        }
+        // The cluster exists but is not Healthy yet -- typically still Creating
+        // from a concurrent worker, or briefly status-less right after a reload.
+        // Wait for it to come up instead of deleting and recreating it: tearing
+        // down a cluster mid-provisioning is what leaves the "Delete cluster"
+        // dialog hanging open on a delete the backend rejects.
+        console.log(`${clusterName} exists but is not Healthy yet; waiting for it to come up.`);
+        await this.assertClusterHealthyStatusWithRetry(clusterName, 120000, 600000);
     }
     async assertClusterHealthyStatusWithRetry(name, visibilityTimeout = 100000, totalTimeout = 500000) {
-        const unhealthy = this.cluster(name).getByText('Unhealthy', { exact: true });
+        const unhealthy = this.clusterRow(name).getByText('Unhealthy', {
+            exact: true,
+        });
         const start = Date.now();
         const maxRetries = 5;
         let attempt = 0;
@@ -369,7 +462,7 @@ class ClusterPage {
             attempt++;
             try {
                 await this.page.reload();
-                await (0, test_1.expect)(this.cluster(name)).toBeVisible({ timeout: 10000 });
+                await (0, test_1.expect)(this.clusterRow(name)).toBeVisible({ timeout: 10000 });
                 // Only treat Unhealthy as terminal if it persists across two
                 // consecutive polling attempts. A cluster mid-provisioning can flash
                 // through Unhealthy briefly during the Unhealthy → Creating → Healthy

package/dist/pages/SM-8.10/ModelerCreatePage.js

@@ -1149,18 +1149,21 @@ class ModelerCreatePage {
             if (!alreadyDeployed) {
                 // Step 2: deploy
                 await setupDeployButton.click({ timeout });
-                // Test Studio dropped the "Process has been successfully deployed"
-                // toast: DeployStepContent now swaps the Deploy button for an inline
-                // `deploy-success-badge` ("Successfully deployed"), and
-                // TestConfigurationPanel's isDeployStepComplete effect calls
-                // hideConfigurationOverlay() as soon as deploy lands -- which
-                // collapses the Deploy step and opens "Configure test case" on its
-                // own. Accept either signal; a failed deploy renders a "Deployment
-                // failed" badge instead and matches neither.
-                await (0, test_1.expect)(this.page
-                    .getByTestId('deploy-success-badge')
-                    .or(configureTestPanel)
-                    .first()).toBeVisible({ timeout: 90000 });
+                // Deploy is done when the "Configure test case" button unlocks. There
+                // is no `deploy-success-badge` in the Test Studio DOM -- the overlay
+                // stays open with the deploy step showing a green check and that button
+                // enabled (this is how hub's own `Definition.setupEnvironment` e2e page
+                // object drives it: click Deploy, then click Configure, with no badge
+                // in between). On a build that auto-collapses the overlay the
+                // configure-test panel renders instead, so accept either. A failed
+                // deploy leaves the button disabled and the panel absent, so this still
+                // times out on a real deploy failure rather than masking it.
+                await (0, test_1.expect)(async () => {
+                    const deployComplete = (await configureScenarioButton
+                        .isEnabled({ timeout: 3000 })
+                        .catch(() => false)) || (await configureTestPanel.isVisible());
+                    (0, test_1.expect)(deployComplete).toBe(true);
+                }).toPass({ timeout: 90000 });
             }
             // Step 3: leave the overlay, and confirm we actually left it. The
             // button only calls hideConfigurationOverlay(); the overlay's own

package/package.json

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