@camunda/e2e-test-suite 0.0.1168 → 0.0.1170

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

@@ -217,7 +217,7 @@ declare class ModelerCreatePage {
     clickJobTypeInput(): Promise<void>;
     fillJobTypeInput(name: string): Promise<void>;
     private suppressTestModeAnnouncement;
-    switchToPlay(): Promise<void>;
+    switchToPlay(afterNavigation?: boolean): Promise<void>;
     completePlayConfiguration(clusterName: string): Promise<void>;
     embedForm(formName: string): Promise<void>;
     openDetailsPanelIfCollapsed(): Promise<void>;

package/dist/pages/8.10/ModelerCreatePage.js

@@ -1420,7 +1420,11 @@ class ModelerCreatePage {
             localStorage.setItem('play-testAnnouncementSeen', 'true');
         });
     }
-    async switchToPlay() {
+    // `afterNavigation` marks the call sites that land here straight off a
+    // page load (ensureStageCluster's goto() detour, the legacy retry's
+    // reload()) rather than off an already-rendered diagram. Only those recover
+    // by reloading -- see below.
+    async switchToPlay(afterNavigation = false) {
         await this.suppressTestModeAnnouncement();
         // completePlayConfiguration re-enters Play after ensureStageCluster's
         // goto() detour, and the diagram page keeps rendering well past the point
@@ -1428,7 +1432,34 @@ class ModelerCreatePage {
         // 10s after it returned, so the click burned the whole global
         // actionTimeout on a page that was merely still booting. Wait for the tab
         // on its own, longer budget first, then click within the normal one.
-        await this.playTab.waitFor({ state: 'visible', timeout: 90000 });
+        //
+        // Waiting longer is not enough on its own for the post-navigation call,
+        // because the tabs' absence there is not always transient. Hub renders the
+        // modes tablist only when `isCurrentDiagramValid && isBPMN &&
+        // allowedViewModes.length > 0`, and `currentDiagramStore.isValid` stays
+        // false until the diagram content has been fetched AND sanitised
+        // (`healthState.isValid && hasBeenValidated`). A diagram fetch that fails
+        // on that fresh load therefore renders an action bar with no mode tabs at
+        // all, permanently -- so the single-shot 90s wait could only ever expire on
+        // it. Re-navigate between attempts instead: the reload re-runs the fetch
+        // that did not land. Gated on `afterNavigation` so the in-place call from
+        // the spec, made on a diagram whose tabs have been on screen throughout
+        // modelling, can never reload mid-edit.
+        if (afterNavigation) {
+            await (0, test_1.expect)(async () => {
+                const visible = await this.playTab
+                    .waitFor({ state: 'visible', timeout: 45000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (!visible) {
+                    await this.page.reload({ waitUntil: 'domcontentloaded' });
+                    await this.playTab.waitFor({ state: 'visible', timeout: 45000 });
+                }
+            }).toPass({ timeout: 150000 });
+        }
+        else {
+            await this.playTab.waitFor({ state: 'visible', timeout: 90000 });
+        }
         await this.playTab.click();
     }
     async completePlayConfiguration(clusterName) {
@@ -1440,7 +1471,7 @@ class ModelerCreatePage {
         // which cluster the test plays on.
         const reboundStageCluster = await this.processApplicationPage.ensureStageCluster(clusterName);
         if (reboundStageCluster) {
-            await this.switchToPlay();
+            await this.switchToPlay(true);
         }
         const timeout = 30000;
         // New flow (8.10+): "Setup environment" panel with three steps:
@@ -1458,17 +1489,32 @@ class ModelerCreatePage {
         // data-testid is unchanged between the old overlay and the new panel, so
         // anchor on it instead.
         const setupDeployButton = this.page.getByTestId('test-configuration-deploy-button');
-        // The same commit dropped the "Process has been successfully deployed."
-        // sentence in favour of a "Successfully deployed" badge. Match the badge's
-        // test id first, keep the old sentence for pre-8b42269 modeler builds.
+        // "Deploy reported success" has moved twice. 8b42269 dropped the
+        // "Process has been successfully deployed." sentence in favour of a
+        // `deploy-success-badge` element, and camunda-hub d2fd90227c ("remove
+        // non-process-application deploy logic from test studio", #28585,
+        // 2026-09-11) then deleted that badge outright along with the rest of the
+        // non-process-application deploy path -- so neither locator matches
+        // anything on a current modeler build and this wait could only ever time
+        // out, even though the deploy itself succeeds.
+        //
+        // The surviving indicator is the accordion step icon: DeployStepIcon
+        // renders a check carrying `aria-label="Deployment complete"` exactly when
+        // `isDeployStepComplete` is true, which is the same `isTestEnvironmentReady`
+        // flag that opens step 3. Match it by attribute rather than getByLabel:
+        // TestConfigurationPanel wraps the icon in an `aria-hidden` span, so it is
+        // deliberately outside the accessibility tree. The sibling error state has
+        // its own label ("Deployment failed"), so a failed deploy still surfaces as
+        // a timeout here instead of passing. Keep both older locators for
+        // pre-d2fd902 modeler builds.
         //
-        // Probed by ATTACHMENT, never visibility: the badge renders only once the
-        // product reports the deploy succeeded, but the panel reacts to that same
-        // state by hiding the setup overlay, which collapses the "Deploy process"
-        // accordion item the badge lives in. So it is present-but-hidden within a
-        // frame of appearing, and a toBeVisible() wait on it can never pass.
+        // Probed by ATTACHMENT, never visibility: the panel reacts to the same
+        // completion state by hiding the setup overlay and collapsing the deploy
+        // accordion item, so the indicator can be present-but-hidden within a frame
+        // of appearing and a toBeVisible() wait on it can never pass.
         const deploySuccessBadge = this.page
-            .getByTestId('deploy-success-badge')
+            .locator('[aria-label="Deployment complete"]')
+            .or(this.page.getByTestId('deploy-success-badge'))
             .or(this.page.getByText('Process has been successfully deployed'))
             .first();
         const isDeployReported = async () => (await deploySuccessBadge.count()) > 0;
@@ -1669,8 +1715,10 @@ class ModelerCreatePage {
         const maxRetries = 2;
         while (attempts < maxRetries) {
             try {
+                // Call switchToPlay on subsequent attempts, i.e. after the reload at
+                // the bottom of this loop.
                 if (attempts > 0)
-                    await this.switchToPlay(); // Call switchToPlay on subsequent attempts
+                    await this.switchToPlay(true);
                 await this.selectCluster(clusterName);
                 await this.continueToPlayButton.click({ timeout });
                 await (0, test_1.expect)(this.page.getByText('Play environment is ready')).toBeVisible({ timeout: 90000 });

package/dist/pages/8.10/ProcessApplicationPage.js

@@ -225,10 +225,9 @@ class ProcessApplicationPage {
         }
         const returnTo = this.page.url();
         const paUrl = container.url.replace(/[?#].*$/, '').replace(/\/$/, '');
-        await this.page.goto(`${paUrl}/connected-clusters`, {
-            waitUntil: 'domcontentloaded',
-        });
-        await this.openStageDefinition();
+        const deepLink = `${paUrl}/connected-clusters`;
+        await this.page.goto(deepLink, { waitUntil: 'domcontentloaded' });
+        await this.openStageDefinition(deepLink);
         await this.defineDevelopmentStage(clusterName);
         container.developmentCluster = clusterName;
         await this.page.goto(returnTo, { waitUntil: 'domcontentloaded' });
@@ -240,7 +239,7 @@ class ProcessApplicationPage {
     // the affordances hub offers before failing with exactly what was looked for.
     // Worth the noise: an unbound cluster otherwise surfaces as a deploy dialog
     // that silently offers nothing, which says nothing about its own cause.
-    async openStageDefinition() {
+    async openStageDefinition(deepLink) {
         // Page-scoped .first(): hub renders one such control on this page, and a
         // second placement must not turn every rebinding test into a strict-mode
         // violation.
@@ -254,7 +253,30 @@ class ProcessApplicationPage {
         // dialog it was meant to open is already on screen. Re-probing for the
         // dialog at the top of every attempt settles that: whichever route got it
         // there, the next pass sees it and returns.
+        //
+        // Re-navigating between attempts is what makes that retry able to recover
+        // at all. Hub renders the "Configure" control and MOUNTS DefineStagesModal
+        // in the same component -- ConnectedClusters, inside the process
+        // application's right column -- and gates it on `isAdmin || isEditor`,
+        // i.e. on projectStore having loaded. processApplicationStore.init()
+        // swallows a failed fetch (it only toasts "Yikes! Couldn't retrieve your
+        // project" and clears its loading flag), so one transient 5xx on the
+        // freshly created application leaves a fully rendered page that has no
+        // card: no control to click, and the deep link's own auto-open never fires
+        // either, because useConnectedClustersDeepLink only calls open() when that
+        // same `canSee` is true. Re-probing and re-clicking cannot bring back a
+        // component that was never mounted -- only a reload, which re-runs the
+        // store init, can. Without it every attempt burned its two waits on
+        // elements that could not appear and the whole budget expired on a page
+        // that one navigation would have fixed.
+        let attempt = 0;
         await (0, test_1.expect)(async () => {
+            if (attempt++ > 0) {
+                await this.page.goto(deepLink, { waitUntil: 'domcontentloaded' });
+                // Proof the process application page itself came back, so a failure
+                // here still names the missing dialog rather than a blank page.
+                await this.waitForProcessApplication(60000);
+            }
             const opened = await this.defineStagesDialog
                 .waitFor({ state: 'visible', timeout: 15000 })
                 .then(() => true)
@@ -265,7 +287,7 @@ class ProcessApplicationPage {
             await reopen.waitFor({ state: 'visible', timeout: 10000 });
             await reopen.click({ timeout: 15000 });
             await (0, test_1.expect)(this.defineStagesDialog).toBeVisible({ timeout: 15000 });
-        }).toPass({ timeout: 150000 });
+        }).toPass({ timeout: 180000 });
     }
     async openByName(name) {
         const processApplication = this.page

package/dist/pages/c8Run-8.10/TaskPanelPage.d.ts

@@ -12,7 +12,10 @@ declare class TaskPanelPage {
     assertAssigmentStatus(status: string): Promise<void>;
     assignTaskToMe(): Promise<void>;
     completeATask(): Promise<void>;
-    openTask(name: string, userTaskName?: string): Promise<void>;
+    taskCard(name: string, userTaskName?: string): Locator;
+    revealTaskCard(card: Locator, name: string): Promise<void>;
+    assertTaskVisible(name: string): Promise<void>;
+    openTask(name: string, userTaskName?: string): Promise<string>;
     taskListBannerIsVisible(): Promise<void>;
     asssertUnnassignedTaskEmptyMessage(): Promise<void>;
     filterBy(option: 'All open tasks' | 'Unassigned' | 'Assigned to me' | 'Completed' | 'Custom'): Promise<void>;

package/dist/pages/c8Run-8.10/TaskPanelPage.js

@@ -56,16 +56,62 @@ class TaskPanelPage {
         await this.assignToMeButton.click();
         await this.completeTaskButton.click();
     }
-    async openTask(name, userTaskName = '') {
-        let tasks = this.availableTasks.getByText(name, { exact: true });
+    taskCard(name, userTaskName = '') {
+        let cards = this.availableTasks
+            .getByRole('article')
+            .filter({ has: this.page.getByText(name, { exact: true }) });
         if (userTaskName != '') {
-            tasks = this.availableTasks
-                .getByRole('article')
-                .filter({ hasText: name })
-                .filter({ hasText: userTaskName });
+            cards = cards.filter({ hasText: userTaskName });
         }
-        await (0, test_1.expect)(tasks.nth(0)).toBeVisible({ timeout: 20000 });
-        await tasks.nth(0).click({ timeout: 20000 });
+        return cards.first();
+    }
+    // AvailableTasks.tsx renders the list through @tanstack/react-virtual, so
+    // only the cards inside the scroll window (plus a five-item overscan) are
+    // in the DOM. A task further down the list is not hidden, it is not
+    // rendered at all, so getByText() keeps reporting "element(s) not found"
+    // however long it waits. Page through the list until the card renders,
+    // wrapping back to the top so the layout's 5s refetch can bring in a task
+    // that was still being indexed.
+    async revealTaskCard(card, name) {
+        const scrollableList = this.availableTasks.getByTestId('scrollable-list');
+        await test_1.expect
+            .poll(async () => {
+            if (await card.isVisible()) {
+                return true;
+            }
+            if (await scrollableList.isVisible()) {
+                await scrollableList.evaluate((list) => {
+                    const maxScrollTop = list.scrollHeight - list.clientHeight;
+                    if (list.scrollTop >= maxScrollTop - 1) {
+                        list.scrollTop = 0;
+                        return;
+                    }
+                    list.scrollTop += Math.max(list.clientHeight - 100, 200);
+                });
+            }
+            return false;
+        }, {
+            timeout: 90000,
+            intervals: [500],
+            message: `Task "${name}" never rendered in the task list`,
+        })
+            .toBe(true);
+    }
+    async assertTaskVisible(name) {
+        await this.revealTaskCard(this.taskCard(name), name);
+    }
+    // Returns the opened task's userTaskKey -- the only identifier that tells
+    // two tasks sharing a name apart.
+    async openTask(name, userTaskName = '') {
+        const card = this.taskCard(name, userTaskName);
+        await this.revealTaskCard(card, name);
+        await card.click({ timeout: 20000 });
+        await this.page.waitForURL(/\/tasklist\/\d+/, { timeout: 30000 });
+        const openedTask = /\/tasklist\/(\d+)/.exec(this.page.url());
+        if (openedTask === null) {
+            throw new Error(`Opening task "${name}" did not open a task`);
+        }
+        return openedTask[1];
     }
     async taskListBannerIsVisible() {
         await (0, test_1.expect)(this.taskListPageBanner).toBeVisible({ timeout: 30000 });
@@ -78,23 +124,44 @@ class TaskPanelPage {
         // appears. Unlike the old Carbon sidebar, the trigger is always visible
         // -- there's no separate expand/collapse step, and selecting an option
         // closes the menu on its own.
-        await (0, test_1.expect)(this.filterSelectButton).toBeVisible({ timeout: 10000 });
-        await this.filterSelectButton.click();
+        //
+        // The trigger also carries the active filter's label, so it doubles as
+        // the "selection applied" signal -- the same one camunda/camunda's own
+        // Filters.test.tsx and TasklistIndex.page.ts assert on. It replaces the
+        // heading the old Carbon panel rendered for the active filter, which the
+        // shadcn panel no longer has.
+        //
+        // TasksLayoutPage renders <Filters disabled={isPending} />, so a task
+        // list refetch landing while the menu is open disables the trigger and
+        // tears the menu down before Radix runs the item's onSelect: the menu
+        // closes but the filter never changes. Re-open and pick again rather
+        // than failing on the first dropped selection.
         const menuItem = this.page.getByRole('menuitem', {
             name: option,
             exact: true,
         });
-        await (0, test_1.expect)(menuItem).toBeVisible({ timeout: 10000 });
-        await menuItem.click();
-        await (0, test_1.expect)(menuItem).toBeHidden({ timeout: 10000 });
-        // The trigger renders the active filter's label, so this confirms the
-        // selection was applied -- the same signal camunda/camunda's own
-        // Filters.test.tsx asserts on the trigger. It replaces the heading the
-        // old Carbon panel rendered for the active filter, which the shadcn
-        // panel no longer has.
-        await (0, test_1.expect)(this.filterSelectButton).toContainText(option, {
-            timeout: 10000,
+        const triggerShowingOption = this.filterSelectButton.filter({
+            hasText: new RegExp(`^${option}$`),
         });
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await (0, test_1.expect)(this.filterSelectButton).toBeEnabled({ timeout: 30000 });
+            await this.filterSelectButton.click();
+            await (0, test_1.expect)(menuItem).toBeVisible({ timeout: 10000 });
+            await menuItem.click();
+            const applied = await triggerShowingOption
+                .waitFor({ state: 'visible', timeout: 15000 })
+                .then(() => true)
+                .catch(() => false);
+            if (applied) {
+                return;
+            }
+            console.warn(`Attempt ${attempt} to apply the "${option}" task filter did not ` +
+                'take effect. Retrying...');
+            await this.page.keyboard.press('Escape');
+            await (0, test_1.expect)(this.filterSelectButton).toHaveAttribute('aria-expanded', 'false', { timeout: 10000 });
+        }
+        throw new Error(`Task filter "${option}" was not applied after ${maxAttempts} attempts`);
     }
 }
 exports.TaskPanelPage = TaskPanelPage;

package/dist/pages/c8Run-8.10/UtilitiesPage.js

@@ -42,23 +42,32 @@ exports.validateURL = validateURL;
 async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, taskPriority, userTaskName = '', textInput = '', maxRetries = 5) {
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            await taskPanelPage.openTask(taskName, userTaskName);
-            const openTasksWithName = taskPanelPage.availableTasks.getByText(taskName, { exact: true });
-            const openTaskCount = await openTasksWithName.count();
+            const userTaskKey = await taskPanelPage.openTask(taskName, userTaskName);
             await (0, sleep_1.sleep)(500);
             if (!(await taskDetailsPage.assignedToMeText.isVisible())) {
                 await taskDetailsPage.clickAssignToMeButton();
             }
-            await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible();
+            // The details panel is fetched after the task is opened, so the
+            // priority label can lag the click by more than Playwright's 5s
+            // default expect timeout on a loaded c8Run runner. Every other wait
+            // in this helper already carries an explicit, generous timeout.
+            await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible({ timeout: 30000 });
             if (textInput != '') {
                 await taskDetailsPage.clickTextInput();
                 await taskDetailsPage.fillTextInput(textInput);
             }
             await taskDetailsPage.taskCompletedBanner.waitFor({ state: 'hidden' });
             await taskDetailsPage.clickCompleteTaskButton();
-            await (0, test_1.expect)(openTasksWithName).toHaveCount(openTaskCount - 1, {
-                timeout: 60000,
-            });
+            // clickCompleteTaskButton() already waits for the "Task completed"
+            // banner, so the completion itself is confirmed there. Counting the
+            // open cards that share this task's name cannot confirm it: the list
+            // is virtualised, so the count only ever covers the scrolled-in
+            // window, and any concurrently running copy of this spec completes
+            // tasks with the same name -- the count can stay flat or drop by two,
+            // and a false failure here sends the loop round to open and complete
+            // a second task. Wait for this exact card, keyed on its userTaskKey,
+            // to leave the open list instead.
+            await (0, test_1.expect)(taskPanelPage.availableTasks.locator(`[data-testid="task-${userTaskKey}"]`)).toHaveCount(0, { timeout: 60000 });
             return;
         }
         catch (error) {
@@ -67,7 +76,8 @@ async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, t
             }
             else {
                 console.error(error);
-                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                throw new Error(`Completing task ${taskName} failed after ${maxRetries} ` +
+                    `attempts: ${error}`);
             }
         }
     }

package/dist/tests/c8Run-8.10/hto-user-flows.spec.js

@@ -138,10 +138,10 @@ c8Run_8_10_1.test.describe('HTO User Flow Tests', () => {
             // The shadcn task panel no longer renders the active filter as a
             // heading (filterBy asserts it on the Filters trigger instead), so
             // wait for a completed task to actually appear in the list -- that
-            // also covers the indexing lag before the reload below.
-            await (0, test_1.expect)(taskPanelPage.availableTasks
-                .getByText('priorityTest4', { exact: true })
-                .first()).toBeVisible({ timeout: 45000 });
+            // also covers the indexing lag before the reload below. The list is
+            // virtualised, so this has to page through it rather than wait on a
+            // locator that is simply not rendered yet.
+            await taskPanelPage.assertTaskVisible('priorityTest4');
             await page.reload();
             await (0, sleep_1.sleep)(1000);
             await taskPanelPage.openTask('priorityTest4');

package/package.json

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