@camunda/e2e-test-suite 0.0.1192 → 0.0.1194

package/dist/pages/8.10/OCIdentityHomePage.js

@@ -23,31 +23,48 @@ class OCIdentityHomePage {
         this.adminBanner = page.getByRole('link', {
             name: 'Camunda Admin',
         });
+        // The same redesign that renamed the logo link moved the nav out of the
+        // header: AppHeaderV2 renders an AppSidebar, a <nav aria-label="Main
+        // navigation">, so nothing is left under the old
+        // banner/aria-label="Admin" scope these tabs were written against. Both
+        // shells are matched, the way pages/SM-8.10/OCIdentityHomePage.ts already
+        // does, because the design-system rollout is still in flight.
         this.groupsTab = page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Groups', exact: true })
+            .or(page
             .getByRole('banner')
             .getByLabel('Admin')
             .locator('a')
-            .filter({ hasText: 'Groups' });
+            .filter({ hasText: 'Groups' }))
+            .first();
         this.rolesTab = page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Roles', exact: true })
+            .or(page
             .getByRole('banner')
             .getByLabel('Admin')
             .locator('a')
-            .filter({ hasText: 'Roles' });
+            .filter({ hasText: 'Roles' }))
+            .first();
         this.authorizationsTab = page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Authorizations', exact: true })
+            .or(page
             .getByRole('banner')
             .getByLabel('Admin')
             .locator('a')
-            .filter({ hasText: /^Authorizations$/ });
+            .filter({ hasText: /^Authorizations$/ }))
+            .first();
         this.clusterVariablesTab = page
-            .getByRole('banner')
-            .getByLabel('Admin')
-            .locator('a')
-            .filter({ hasText: /Cluster variables/i })
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Cluster variables', exact: true })
             .or(page
             .getByRole('banner')
             .getByLabel('Admin')
             .locator('a')
-            .filter({ hasText: /Variables/i }));
+            .filter({ hasText: /Cluster variables/i }))
+            .first();
         this.licenseKeyTagNonProduction = page
             .getByText('Non-production license')
             .first();

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

@@ -2,6 +2,8 @@ import { Page, Locator } from '@playwright/test';
 declare class TaskPanelPage {
     private page;
     readonly availableTasks: Locator;
+    readonly filterPanelExpandButton: Locator;
+    readonly filterPanelCollapseButton: Locator;
     readonly filterSelectButton: Locator;
     readonly taskListPageBanner: Locator;
     readonly processesPageTab: Locator;
@@ -12,6 +14,9 @@ declare class TaskPanelPage {
     taskInList(name: string): Locator;
     openTask(name: string, totalTimeout?: number): Promise<void>;
     filterBy(option: 'All open tasks' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
+    private openFilterControls;
+    private collapseFilterPanel;
+    private static appliedFilter;
     taskCount(name: string): Promise<number>;
     clickTasksTab(): Promise<void>;
     scrollToLastTask(name: string): Promise<void>;

package/dist/pages/8.10/TaskPanelPage.js

@@ -8,6 +8,8 @@ const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLoc
 class TaskPanelPage {
     page;
     availableTasks;
+    filterPanelExpandButton;
+    filterPanelCollapseButton;
     filterSelectButton;
     taskListPageBanner;
     processesPageTab;
@@ -17,12 +19,19 @@ class TaskPanelPage {
     constructor(page) {
         this.page = page;
         this.availableTasks = page.getByTitle('Available tasks');
-        // The old Carbon expandable filter sidebar (aria-controls="task-nav-bar",
-        // "Expand to show filters") is gone after Tasklist's redesign. Filtering is
-        // now a single dropdown-trigger button (id="filter-select") whose
-        // accessible name is the static "Filters" aria-label; clicking it opens a
-        // Radix DropdownMenu of filter options (matches the current locator in
-        // camunda/camunda's own qa/c8-orchestration-cluster-e2e-test-suite).
+        // 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
+        // filter as a link. Tasklist's design-system redesign -- a single
+        // "Filters" dropdown trigger opening a Radix menu -- landed on main
+        // (8.11) only: `stable/8.10` has no FilterSelect.tsx and its Filters.tsx
+        // still renders the Carbon panel against the /_carbon route tree, which
+        // is why targeting the redesign found no "Filters" button at all.
+        // Both shells are matched below because the SaaS design-system rollout is
+        // per app and still in flight (Admin has already flipped, hence the
+        // dual-shell locators in OCIdentityHomePage).
+        this.filterPanelExpandButton = page.locator('button[aria-controls="task-nav-bar"][aria-expanded="false"]');
+        this.filterPanelCollapseButton = page.locator('button[aria-controls="task-nav-bar"][aria-expanded="true"]');
         this.filterSelectButton = page.getByRole('button', {
             name: 'Filters',
             exact: true,
@@ -87,47 +96,100 @@ class TaskPanelPage {
             `${totalTimeout}ms: ${lastError}`);
     }
     async filterBy(option) {
-        // Open the always-visible filter dropdown, then pick the option from the
-        // Radix menu that appears (role="menuitem"). There is no separate
-        // expand/collapse step like the old Carbon sidebar had.
-        //
-        // The trigger also carries the active filter's label, so it doubles as
-        // the "selection applied" signal, replacing the heading the old Carbon
-        // panel rendered for the active filter.
-        //
-        // 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 returning with the list still on the previous filter (same
-        // bounded retry as pages/c8Run-8.10/TaskPanelPage.ts).
-        const menuItem = this.page.getByRole('menuitem', {
-            name: option,
-            exact: true,
-        });
-        const triggerShowingOption = this.filterSelectButton.filter({
-            hasText: new RegExp(`^${option}$`),
-        });
+        // The filter is a link in the Carbon panel's expanded nav and a
+        // role="menuitem" in the redesigned dropdown, so match either. The
+        // Carbon links are scoped to #task-nav-bar so "Completed" cannot pick up
+        // a custom filter or a task row carrying the same words.
+        const filterOption = this.page
+            .locator('#task-nav-bar')
+            .getByRole('link', { name: option, exact: true })
+            .or(this.page.getByRole('menuitem', { name: option, exact: true }));
         const maxAttempts = 3;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            await (0, test_1.expect)(this.filterSelectButton).toBeEnabled({ timeout: 60000 });
-            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);
+            await this.openFilterControls();
+            // Only the first attempt waits out a slow first render; later attempts
+            // pick from controls that have already rendered once, so three
+            // attempts at the full budget cannot outlast the test timeout.
+            const renderTimeout = attempt === 1 ? 60000 : 15000;
+            await (0, test_1.expect)(filterOption).toBeVisible({ timeout: renderTimeout });
+            await filterOption.click({ timeout: renderTimeout });
+            // The route -- not the panel -- is what proves the pick landed.
+            // Tasklist refetches the list every 5s behind a suspense boundary, and
+            // a poll landing on the click tears the controls down before the
+            // router navigates: they close but the filter never changes, and
+            // nothing downstream notices until a much later assertion reads the
+            // still-unfiltered list.
+            // Only a timeout means "the pick did not land", which is what the
+            // retry below is for. Anything else -- a closed page, a failed
+            // navigation -- is fatal, and swallowing it would surface three
+            // attempts later as the misleading "filter was not applied" error
+            // instead of its real cause.
+            let applied = true;
+            try {
+                await this.page.waitForURL(TaskPanelPage.appliedFilter(option), {
+                    timeout: 15000,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof test_1.errors.TimeoutError)) {
+                    throw error;
+                }
+                applied = false;
+            }
             if (applied) {
+                await this.collapseFilterPanel();
                 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`);
     }
+    // The Carbon panel renders either the collapsed rail (which carries the
+    // expand control) or the expanded nav -- never both -- and picking a filter
+    // leaves it expanded, so a retry must not click "expand" a second time. The
+    // redesigned dropdown instead has to be re-opened every attempt, because
+    // picking an option closes the menu.
+    async openFilterControls() {
+        const alreadyExpanded = await this.filterPanelCollapseButton
+            .waitFor({ state: 'visible', timeout: 2000 })
+            .then(() => true)
+            .catch(() => false);
+        if (alreadyExpanded) {
+            return;
+        }
+        await this.filterPanelExpandButton
+            .or(this.filterSelectButton)
+            .first()
+            .click({ timeout: 60000 });
+    }
+    // Picking a filter leaves the Carbon panel expanded, and it floats over the
+    // task list -- callers that go straight to a task row would be clicking
+    // through the overlay (pages/SM-8.10 collapses it from the specs for the
+    // same reason). The redesigned dropdown closes itself on select, so this is
+    // a probe rather than an unconditional click.
+    async collapseFilterPanel() {
+        const expanded = await this.filterPanelCollapseButton
+            .waitFor({ state: 'visible', timeout: 2000 })
+            .then(() => true)
+            .catch(() => false);
+        if (expanded) {
+            await this.filterPanelCollapseButton.click({ timeout: 30000 });
+        }
+    }
+    // Tasklist keeps the active filter in the `filter` search param, on both
+    // shells. "All open tasks" is the route default and is stripped from the
+    // URL, so it is asserted as the absence of the param.
+    static appliedFilter(option) {
+        const filterParam = {
+            Unassigned: 'unassigned',
+            'Assigned to me': 'assigned-to-me',
+            Completed: 'completed',
+        };
+        const param = filterParam[option] ?? null;
+        return (url) => url.searchParams.get('filter') === param;
+    }
     async taskCount(name) {
         await (0, sleep_1.sleep)(20000);
         return this.availableTasks.getByText(name, { exact: true }).count();

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

@@ -16,9 +16,9 @@ declare class TaskPanelPage {
     filterBy(option: 'All open' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
     private expandFilterPanel;
     private static appliedFilterUrl;
+    clickCollapseFilter(): Promise<void>;
     scrollToLastTask(name: string): Promise<void>;
     scrollToFirstTask(name: string): Promise<void>;
-    clickCollapseFilter(): Promise<void>;
     clickProcessesTab(): Promise<void>;
     taskCount(name: string, waitForStable?: boolean): Promise<number>;
     clickTasksTab(): Promise<void>;

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

@@ -76,35 +76,46 @@ class TaskPanelPage {
         // landing on the filter click tears the floating filter panel down before
         // the router navigates: the panel closes but the filter never changes.
         // Nothing downstream notices, so the test fails much later on an assertion
-        // that reads the still-unfiltered list -- which is how a dropped click on
-        // "Completed" surfaced as the completed-filter heading never appearing.
-        // Confirm the route actually carries the filter, and re-pick if it does not.
+        // that reads the still-unfiltered list. Confirm the route actually
+        // carries the filter, and re-pick if it does not.
         const maxAttempts = 3;
+        let lastError;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            await this.expandFilterPanel();
-            // Deliberately not `exact`: the panel spells the default filter
-            // "All open tasks" while callers pass "All open".
-            const filterLink = this.page.getByRole('link', { name: option });
-            // Only the first attempt waits out a slow first render. Later attempts
-            // re-pick from a panel that has already rendered once, so they stay
-            // short -- three attempts at the full budget would outlast the
-            // 12-minute test timeout and turn a dropped click into a timeout with
-            // no retry spent.
-            const renderTimeout = attempt === 1 ? 120000 : 15000;
-            await (0, test_1.expect)(filterLink).toBeVisible({ timeout: renderTimeout });
-            await filterLink.click({ timeout: renderTimeout });
-            const applied = await this.page
-                .waitForURL(TaskPanelPage.appliedFilterUrl(option), { timeout: 15000 })
-                .then(() => true)
-                .catch(() => false);
-            if (applied) {
-                return;
+            try {
+                await this.expandFilterPanel();
+                // Deliberately not `exact`: the panel spells the default filter
+                // "All open tasks" while callers pass "All open".
+                const filterLink = this.page.getByRole('link', { name: option });
+                // Only the first attempt waits out a slow first render. Later
+                // attempts re-pick from a panel that has already rendered once, so
+                // they stay short -- three attempts at the full budget would outlast
+                // the 12-minute test timeout and turn a dropped click into a timeout
+                // with no retry spent.
+                const renderTimeout = attempt === 1 ? 120000 : 15000;
+                await (0, test_1.expect)(filterLink).toBeVisible({ timeout: renderTimeout });
+                await filterLink.click({ timeout: renderTimeout });
+                const applied = await this.page
+                    .waitForURL(TaskPanelPage.appliedFilterUrl(option), { timeout: 15000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (applied) {
+                    return;
+                }
+                lastError = new Error(`Filter "${option}" was picked but the URL never carried it`);
+            }
+            catch (error) {
+                // Without this catch, a thrown assertion (the expand control or the
+                // filter link never appearing) propagated straight out of filterBy()
+                // on attempt 1, so attempts 2 and 3 -- and their shorter, faster-
+                // failing budget -- could never run. maxAttempts was dead code for
+                // every failure mode except a click that landed but didn't navigate.
+                lastError = error;
             }
             if (attempt < maxAttempts) {
                 console.warn(`Attempt ${attempt} did not apply the "${option}" filter. Retrying...`);
             }
         }
-        throw new Error(`Filter "${option}" was not applied after ${maxAttempts} attempts`);
+        throw new Error(`Filter "${option}" was not applied after ${maxAttempts} attempts: ${lastError}`);
     }
     // The filter panel renders either the collapsed rail (which carries the
     // expand control) or the expanded nav -- never both -- and picking a filter
@@ -133,27 +144,52 @@ class TaskPanelPage {
             ? /\/tasklist(?:\/[^?]*)?(?:\?(?!.*\bfilter=).*)?$/
             : new RegExp(`[?&]filter=${param}(?:&|$)`);
     }
+    async clickCollapseFilter() {
+        await this.collapseFilter.click({ timeout: 45000 });
+    }
     async scrollToLastTask(name) {
         await this.page.getByText(name).last().scrollIntoViewIfNeeded();
     }
     async scrollToFirstTask(name) {
         await this.page.getByText(name).first().scrollIntoViewIfNeeded();
     }
-    async clickCollapseFilter() {
-        await this.collapseFilter.click({ timeout: 45000 });
-    }
     async clickProcessesTab() {
         await (0, test_1.expect)(this.processesPageTab).toBeVisible();
+        // Landing on Processes shows either the process search box or, on the
+        // first visit, the "Start your process on demand" onboarding dialog.
+        // `FirstTimeProcessWarning` renders the Processes content only after
+        // consent, so while that dialog is open the search box is not in the
+        // DOM at all -- confirming via the search box alone would never resolve
+        // on a first visit, and the retry would re-click Processes, which the
+        // dialog's modal overlay now covers. Treat either as proof the Processes
+        // view rendered; the caller dismisses the dialog.
+        const processesReady = this.page
+            .getByRole('searchbox', { name: 'Search processes' })
+            .or(this.page.getByRole('dialog', {
+            name: 'Start your process on demand',
+        }));
         const maxAttempts = 3;
+        let lastError;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            await this.processesPageTab.click();
+            try {
+                await this.processesPageTab.click();
+            }
+            catch (error) {
+                // The click belongs inside the try for the same reason filterBy()'s
+                // assertions do: the onboarding dialog's modal overlay covers the
+                // nav, so a click that lands on it throws once the repo's 10s action
+                // timeout expires. Letting that escape made maxAttempts dead code on
+                // exactly the path that needs it. Fall through to the landing probe
+                // below -- a click that threw may still have navigated.
+                lastError = error;
+            }
             // A newly-arrived task can bounce the app back to the Tasks tab right
             // as this click lands (nightly SM-8.10 run 31782502787: the click
             // itself succeeded but the app ended up back on Tasks with the new
             // task selected), so confirm the Processes view actually rendered
             // before returning instead of trusting the click alone.
-            const landedOnProcesses = await this.page
-                .getByRole('searchbox', { name: 'Search processes' })
+            const landedOnProcesses = await processesReady
+                .first()
                 .waitFor({ state: 'visible', timeout: 5000 })
                 .then(() => true)
                 .catch(() => false);
@@ -164,7 +200,7 @@ class TaskPanelPage {
                 console.warn(`Attempt ${attempt} landed back on Tasks instead of Processes. Retrying...`);
             }
         }
-        throw new Error('Processes tab did not open after 3 attempts');
+        throw new Error(`Processes tab did not open after ${maxAttempts} attempts: ${lastError}`);
     }
     async taskCount(name, waitForStable = true) {
         // Removed waitForLoadState('networkidle') — Tasklist polls;

package/package.json

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