@camunda/e2e-test-suite 0.0.1122 → 0.0.1123

package/dist/pages/8.7/ModelerCreatePage.js

@@ -1364,6 +1364,37 @@ class ModelerCreatePage {
             const isDeployComplete = async () => (await deployCompleteIcon.isVisible().catch(() => false)) ||
                 (await deploySuccessBadge.isVisible().catch(() => false)) ||
                 (await configureTestPanel.isVisible().catch(() => false));
+            // A deploy that FAILED looks, to the probe above, exactly like a deploy
+            // that has not been triggered yet. DeployStepContent renders a
+            // "Deployment failed" badge (or "Missing permissions to deploy" for a
+            // 403) and relabels the very same `test-configuration-deploy-button` to
+            // "Retry" -- still visible, still enabled -- so the loop below happily
+            // re-clicks an action the backend is rejecting and finally reports
+            // `Expected: true Received: false`, which names neither the failure nor
+            // its cause. Read the panel's own verdict instead and put it in the
+            // assertion message, and expand the "Show details" disclosure so the
+            // server message lands in the afterEach screenshot and the trace.
+            const deployErrorBadge = this.page
+                .getByText('Deployment failed', { exact: true })
+                .or(this.page.getByText('Missing permissions to deploy'))
+                .first();
+            const deployErrorDetailsToggle = this.page.locator('[data-test="test-studio-configuration-toggle-details"]');
+            const readDeployError = async () => {
+                const failed = await deployErrorBadge.isVisible().catch(() => false);
+                if (!failed) {
+                    return undefined;
+                }
+                const hasDetails = await deployErrorDetailsToggle
+                    .isVisible()
+                    .catch(() => false);
+                const isExpanded = hasDetails &&
+                    (await deployErrorDetailsToggle.getAttribute('aria-expanded')) ===
+                        'true';
+                if (hasDetails && !isExpanded) {
+                    await deployErrorDetailsToggle.click({ timeout: 5000 });
+                }
+                return deployErrorBadge.innerText();
+            };
             if (!(await isDeployComplete())) {
                 // The Deploy button lives inside the "Deploy process" accordion item,
                 // which expands itself once the cluster step completes. Nudge the
@@ -1389,19 +1420,50 @@ class ModelerCreatePage {
                 // ("element is not visible", 58 retries, in the click call log). A
                 // re-click can only happen while the deploy is provably still
                 // incomplete AND the button is enabled -- a deploy in flight disables
-                // it and a finished deploy replaces it with the badge, so this cannot
-                // double-deploy. If the deploy never completes the loop still fails.
+                // it (or replaces it with the "Deploying..." loader), so this cannot
+                // pile up requests. If the deploy never completes the loop still
+                // fails, now naming the panel's own error when there is one.
+                //
+                // The budget is 4 minutes, not the 2 it used to be: a process
+                // application deploy on SaaS serialises deployProcessApplication(),
+                // fetchLinkedStartForm() and the connector-secret fetch before
+                // TestConfigurationPanel reports the step complete, and the previous
+                // budget expired while that chain was still in flight. The test is
+                // test.slow() (36 min), so the extra headroom is affordable.
+                //
+                // One stall shape is invisible to the re-click above: while the deploy
+                // request is in flight the panel keeps `status === 'deploying-files'`,
+                // which renders the button `disabled` (camunda-hub test-studio
+                // DeployStepContent), so a request that never settles leaves the loop
+                // with nothing clickable and no error badge to report -- it just polls
+                // until the budget expires and reports the bare "never reported
+                // completion". Remount the panel once when that happens: on a fresh
+                // Play mount useSetupEnvironmentStep re-runs
+                // testEnvironmentStore.checkExistingDeployment(), which marks the step
+                // complete when the deployment actually landed, and otherwise leaves an
+                // enabled Deploy button for this loop to click -- i.e. a real retry
+                // either way, not a masked failure.
+                let hasRemountedAfterStall = false;
+                const stallDeadline = Date.now() + 120000;
                 await (0, test_1.expect)(async () => {
                     if (await isDeployComplete()) {
                         return;
                     }
+                    const deployError = await readDeployError();
                     const canClick = (await setupDeployButton.isVisible().catch(() => false)) &&
                         (await setupDeployButton.isEnabled().catch(() => false));
                     if (canClick) {
                         await setupDeployButton.click({ timeout });
                     }
-                    (0, test_1.expect)(await isDeployComplete()).toBe(true);
-                }).toPass({ timeout: 120000, intervals: [1000, 2000, 5000] });
+                    else if (!hasRemountedAfterStall && Date.now() > stallDeadline) {
+                        hasRemountedAfterStall = true;
+                        await this.page.reload();
+                        await this.switchToPlay();
+                    }
+                    (0, test_1.expect)(await isDeployComplete(), deployError === undefined
+                        ? 'Play "Deploy process" step never reported completion'
+                        : `Play "Deploy process" step reported: ${deployError}`).toBe(true);
+                }).toPass({ timeout: 300000, intervals: [1000, 2000, 5000] });
             }
             // Step 3: the configure-test-case step opens on its own once the deploy
             // step completes (TestConfigurationPanel hides the setup overlay in an

package/dist/pages/8.7/ModelerHomePage.d.ts

@@ -59,6 +59,7 @@ declare class ModelerHomePage {
     returnToResourceContainer(): Promise<void>;
     startBlankBpmnDiagram(): Promise<void>;
     private becameVisible;
+    isModelerPageBannerVisible(timeout: number): Promise<boolean>;
     clickHomeBreadcrumb(): Promise<void>;
     clickOpenOrganizationsButton(): Promise<void>;
     clickCrossComponentProjectFolder(): Promise<void>;

package/dist/pages/8.7/ModelerHomePage.js

@@ -426,6 +426,11 @@ class ModelerHomePage {
             .then(() => true)
             .catch(() => false);
     }
+    // Boolean form of the modeler-banner assertion, so a caller can re-open
+    // Modeler instead of failing outright when the app shell never mounts.
+    async isModelerPageBannerVisible(timeout) {
+        return this.becameVisible(this.modelerPageBanner, timeout);
+    }
     async clickHomeBreadcrumb() {
         try {
             await this.homeBreadcrumb.click();

package/dist/pages/8.7/PlayPage.js

@@ -48,7 +48,20 @@ class PlayPage {
         });
     }
     async clickCompleteJobButton() {
-        await this.completeJobButton.click();
+        // The complete-job action is a bpmn-js canvas overlay pinned to the active
+        // element, so it is re-laid-out (and briefly detached) whenever the diagram
+        // re-renders -- which it does on every job/instance update arriving from
+        // the cluster. A bare click that lands in that window silently resolves
+        // against a stale node, the job is never completed, and the failure only
+        // surfaces two calls later as "waitForNextElementToBeActive" timing out on
+        // the next element that consequently never became active. Retry the click
+        // against a fresh visibility + clickability check instead.
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.completeJobButton, {
+            totalTimeout: 120000,
+            visibilityTimeout: 30000,
+            maxRetries: 3,
+            retryDelayMs: 3000,
+        });
     }
     async clickStartInstanceButton() {
         // The Modeler Play UI has two surfaces that can hold the start trigger:
@@ -133,8 +146,36 @@ class PlayPage {
         });
     }
     async waitForProcessToBeCompleted() {
-        await (0, test_1.expect)(this.page.getByText('Completed')).toBeVisible({
+        // "Completed" is the bpmn-js overlay Modeler pins to the end event once the
+        // instance reaches COMPLETED (camunda-hub test-studio DiagramOverlay ->
+        // CompletedOverlay), so it can only render after the LAST job has actually
+        // been completed. That makes this the only place where a silently
+        // ineffective final complete-job click can surface: the two earlier tasks
+        // are each followed by waitForNextElementToBeActive, which catches a lost
+        // click, but nothing follows the third one -- so a click that resolved
+        // against a re-laid-out (briefly detached) overlay leaves the service-task
+        // job pending and the sole symptom is this locator timing out with
+        // "element(s) not found", exactly the nightly failure.
+        //
+        // While the overlay is absent AND a complete-job overlay button is still on
+        // the canvas, the job demonstrably was not completed, so re-issue it rather
+        // than waiting out the whole budget on a job nothing will complete. The
+        // assertion itself is unchanged: the step still only passes on a visible
+        // "Completed" overlay.
+        const completedOverlay = this.page.getByText('Completed').first();
+        await (0, test_1.expect)(async () => {
+            const isCompleted = await completedOverlay.isVisible().catch(() => false);
+            if (!isCompleted) {
+                const isJobStillPending = (await this.completeJobButton.isVisible().catch(() => false)) &&
+                    (await this.completeJobButton.isEnabled().catch(() => false));
+                if (isJobStillPending) {
+                    await this.completeJobButton.click({ timeout: 30000 });
+                }
+            }
+            await (0, test_1.expect)(completedOverlay).toBeVisible({ timeout: 15000 });
+        }).toPass({
             timeout: maxWaitTimeSeconds,
+            intervals: [2000, 5000, 10000],
         });
     }
 }

package/dist/tests/8.7/play.spec.js

@@ -27,9 +27,18 @@ _8_7_1.test.describe('Deploy and run a process in Play', () => {
             });
             await appsPage.clickCamundaApps();
             await appsPage.clickModeler();
-            await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
-                timeout: 120000,
-            });
+            // Following the Modeler link occasionally leaves the browser on the
+            // Console shell with the Modeler app never mounting, so the banner never
+            // renders and the whole flow dies before it has done anything. The link
+            // click itself succeeded, so AppsPage's own retry loop does not fire --
+            // re-open Modeler from the apps menu here instead.
+            if (!(await modelerHomePage.isModelerPageBannerVisible(120000))) {
+                await appsPage.clickCamundaApps();
+                await appsPage.clickModeler();
+                await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
+                    timeout: 120000,
+                });
+            }
         });
         await _8_7_1.test.step('Open Cross Component Test Project', async () => {
             await modelerHomePage.clickCrossComponentProjectFolder();

package/package.json

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