@camunda/e2e-test-suite 0.0.1132 → 0.0.1133

package/dist/pages/8.9/ModelerCreatePage.js

@@ -1316,7 +1316,14 @@ class ModelerCreatePage {
     }
     async switchToPlay() {
         await this.suppressTestModeAnnouncement();
-        await this.playTab.click();
+        // completePlayConfiguration re-enters Play after ensureStageCluster's
+        // detour, which comes back through goto(..., 'domcontentloaded'). The
+        // modeler mounts its mode tablist well after that event -- measurably
+        // longer than the 10s default actionTimeout this click would otherwise
+        // inherit, which failed the re-entry outright on every run of the
+        // dispatched test. Wait for the tab to exist before clicking it.
+        await (0, test_1.expect)(this.playTab).toBeVisible({ timeout: 90000 });
+        await this.playTab.click({ timeout: 30000 });
     }
     async completePlayConfiguration(clusterName) {
         // Play is a tab on the diagram page, not its own URL, so the stage-cluster
@@ -1421,15 +1428,34 @@ class ModelerCreatePage {
         // keying on it would fall through to the legacy Continue flow.
         const isNewFlow = await configurationOverlay.isVisible();
         if (isNewFlow) {
-            // Step 1: connect cluster if not yet connected (modal with cluster dropdown)
+            // Step 1: connect cluster if not yet connected (modal with cluster
+            // dropdown). camunda-hub's ClusterStepContent renders "Connect cluster"
+            // only while NO cluster is bound; once one is, the very same modal is
+            // reached through "Change", and an unusable cluster shows the
+            // "Cluster unavailable. Choose a healthy cluster." error instead. That
+            // second state is not a slow state: DeployStepContent hardcodes
+            // `disabled={!isClusterStepComplete}`, so an unhealthy cluster keeps the
+            // Deploy button disabled forever -- which is exactly how the dispatched
+            // nightly failed, burning the whole 60s toBeEnabled budget. Treat it as
+            // "step 1 not done" and drive the same modal through "Change".
             const connectClusterButton = this.page.getByRole('button', {
                 name: 'Connect cluster',
             });
-            const needsConnect = await connectClusterButton
-                .isVisible({ timeout: 3000 })
+            const changeClusterButton = this.page
+                .getByRole('button', { name: 'Change', exact: true })
+                .first();
+            const clusterHealthyIcon = this.page.locator('[aria-label="Cluster healthy"]');
+            const clusterUnavailableIcon = this.page.locator('[aria-label="Cluster unavailable"]');
+            const hasConnectButton = await connectClusterButton
+                .isVisible()
                 .catch(() => false);
+            const needsConnect = hasConnectButton ||
+                (await clusterUnavailableIcon.isVisible().catch(() => false));
             if (needsConnect) {
-                await connectClusterButton.click({ timeout });
+                const openClusterModalButton = hasConnectButton
+                    ? connectClusterButton
+                    : changeClusterButton;
+                await openClusterModalButton.click({ timeout });
                 const configureEnvDialog = this.page
                     .getByRole('dialog')
                     .filter({ hasText: 'Configure environment' });
@@ -1458,6 +1484,15 @@ class ModelerCreatePage {
                     .getByRole('button', { name: 'Save' })
                     .click({ timeout });
             }
+            // Gate the deploy step on the cluster step actually having completed.
+            // ClusterStepIcon renders this label only for
+            // `!isVerifyingClusterAvailability && hasCluster && isClusterHealthy` --
+            // the exact condition DeployStepContent gates its Deploy button on --
+            // and it lives in the accordion *heading*, so it stays readable while
+            // the item collapses. Without this the flow raced ahead into step 2 and
+            // reported "Deploy button never enabled", which says nothing about the
+            // cluster being the thing that was wrong.
+            await (0, test_1.expect)(clusterHealthyIcon).toBeVisible({ timeout: 90000 });
             // Step 2: deploy, unless the overlay already opened with the
             // deploy step complete. checkExistingDeployment only runs when
             // processApplicationId is defined, which it now is, so re-entering
@@ -1493,12 +1528,23 @@ class ModelerCreatePage {
                 // which expands itself once the cluster step completes. Nudge the
                 // heading if it is still collapsed, otherwise the button is present
                 // but hidden and the click below would time out.
+                //
+                // This probe HAS to wait. `locator.isVisible({timeout})` never does --
+                // it answers for the DOM as it is right now and ignores the timeout --
+                // so it reported "not shown" in the gap before the item auto-expanded,
+                // and the nudge below then hit an item that was already open. That
+                // click is not idempotent: TestConfigurationPanel's
+                // handleDeployHeadingClick sets manualSetupStep to 'none' when the
+                // item was open, collapsing BOTH setup steps, and the retry loop that
+                // follows only ever clicked a *visible* button -- so the deploy was
+                // never triggered and the loop timed out with the step collapsed.
                 const deployButtonShown = await setupDeployButton
-                    .isVisible({ timeout: 30000 })
+                    .waitFor({ state: 'visible', timeout: 30000 })
+                    .then(() => true)
                     .catch(() => false);
                 if (!deployButtonShown) {
                     const canExpandDeployStep = await deployStepHeading
-                        .isEnabled({ timeout: 5000 })
+                        .isEnabled()
                         .catch(() => false);
                     if (canExpandDeployStep) {
                         await deployStepHeading.click({ timeout });
@@ -1520,9 +1566,21 @@ class ModelerCreatePage {
                     if (await isDeployComplete()) {
                         return;
                     }
-                    const canClick = (await setupDeployButton.isVisible().catch(() => false)) &&
-                        (await setupDeployButton.isEnabled().catch(() => false));
-                    if (canClick) {
+                    const isButtonShown = await setupDeployButton
+                        .isVisible()
+                        .catch(() => false);
+                    if (!isButtonShown) {
+                        // Collapsed, not gone: re-open the step instead of waiting the
+                        // budget out on a button that can never become visible on its own
+                        // once manualSetupStep is 'none'.
+                        const canExpand = await deployStepHeading
+                            .isEnabled()
+                            .catch(() => false);
+                        if (canExpand) {
+                            await deployStepHeading.click({ timeout });
+                        }
+                    }
+                    else if (await setupDeployButton.isEnabled().catch(() => false)) {
                         await setupDeployButton.click({ timeout });
                     }
                     (0, test_1.expect)(await isDeployComplete()).toBe(true);

package/dist/pages/8.9/ProcessApplicationPage.js

@@ -145,7 +145,6 @@ class ProcessApplicationPage {
     // taken -- callers that care assert the name in the deploy dialog anyway.
     async defineDevelopmentStage(clusterName) {
         await (0, test_1.expect)(this.defineStagesDialog).toBeVisible({ timeout: 60000 });
-        await this.developmentClusterSelect.click({ timeout: 30000 });
         // Escape before interpolating: a cluster name can carry regex
         // metacharacters -- "Test Cluster (v2)" is the common case -- which would
         // otherwise mis-match or throw. Same treatment as
@@ -159,9 +158,52 @@ class ProcessApplicationPage {
                 .getByRole('option')
                 .filter({ hasNotText: 'Select a development cluster' })
                 .first();
-        await option.click({ timeout: 30000 });
+        // The dropdown is fully controlled and DefineStagesModal resets its local
+        // state from processApplication.default*ClusterId in an effect. The modal
+        // itself triggers a cluster/application refresh when it opens, so a
+        // selection made before that refresh lands is silently reverted to
+        // whatever the application already pointed at -- and Save then persists
+        // THAT cluster. A failing nightly trace shows exactly this: the option
+        // click committed "Test Cluster", and ~0.5s later, with the Save click
+        // already in flight, the field had snapped back to "First RBA V2 Cluster".
+        // The application bound the wrong cluster, and Play's "Choose where to
+        // run" step then reported "Cluster unavailable" for it, which leaves the
+        // Deploy button hardcoded-disabled and fails the test 60s later, far from
+        // the cause. Re-select until the field still reads the requested cluster.
+        const selectedCluster = this.developmentClusterSelect.getByRole('combobox');
+        const isRequestedCluster = async () => {
+            const label = (await selectedCluster.textContent()) ?? '';
+            return clusterName
+                ? new RegExp(`^${escapedClusterName}`).test(label)
+                : !label.startsWith('[Select a');
+        };
+        await (0, test_1.expect)(async () => {
+            if (!(await isRequestedCluster())) {
+                await this.developmentClusterSelect.click({ timeout: 30000 });
+                await option.click({ timeout: 30000 });
+            }
+            (0, test_1.expect)(await isRequestedCluster()).toBe(true);
+        }).toPass({ timeout: 90000, intervals: [1000, 2000, 5000] });
         await this.defineStagesSaveButton.click({ timeout: 30000 });
         await (0, test_1.expect)(this.defineStagesDialog).toBeHidden({ timeout: 60000 });
+        // Verify what was actually persisted, not what was typed into the modal:
+        // the revert above can also land between the last check and the Save
+        // click. The Connected clusters card renders one row per bound stage with
+        // the cluster's full "<name> <generation>" as its title, so it is the
+        // cheapest read of the saved binding. Failing here re-runs the whole bind
+        // through ensureStageCluster's retry, which re-navigates first.
+        if (clusterName) {
+            const developmentRow = this.page
+                .getByRole('listitem')
+                .filter({
+                has: this.page.getByRole('button', {
+                    name: 'Development',
+                    exact: true,
+                }),
+            })
+                .first();
+            await (0, test_1.expect)(developmentRow.getByTitle(new RegExp(`^${escapedClusterName}( |$)`))).toBeVisible({ timeout: 60000 });
+        }
     }
     rememberResourceContainer(url) {
         resourceContainers.set(this.page, { url });

package/package.json

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