@camunda/e2e-test-suite 0.0.1198 → 0.0.1199

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

@@ -22,8 +22,12 @@ declare class AppsPage {
     readonly tasklistMenuItem: Locator;
     readonly optimizeMenuItem: Locator;
     readonly adminMenuItem: Locator;
+    readonly operateMenuItem: Locator;
+    readonly consoleMenuItem: Locator;
+    readonly modelerMenuItem: Locator;
     constructor(page: Page);
     private reloadForRecovery;
+    private entryAppeared;
     clickCluster(component: Locator, name: string): Promise<void>;
     clickModeler(): Promise<void>;
     private isModelerAuthTransit;

package/dist/pages/8.10/AppsPage.js

@@ -27,6 +27,9 @@ class AppsPage {
     tasklistMenuItem;
     optimizeMenuItem;
     adminMenuItem;
+    operateMenuItem;
+    consoleMenuItem;
+    modelerMenuItem;
     constructor(page) {
         this.page = page;
         this.modelerLink = page.getByRole('link', { name: 'Modeler', exact: true });
@@ -52,6 +55,15 @@ class AppsPage {
         this.adminMenuItem = page.getByRole('menuitemradio', {
             name: /^(Admin|Identity)$/, // Identity Should be removed after https://github.com/camunda/camunda/issues/46447 is fixed
         });
+        // Admin is on nav V2 too now, so the switcher is also the way OUT of an
+        // app and not only the way in. Console and Modeler are org-level entries
+        // of the same dropdown (`CamundaAppKey` in @camunda/design-system covers
+        // operate | tasklist | optimize | admin | identity | modeler | console),
+        // so all three need the `menuitemradio` shape their link-role
+        // counterparts above no longer have.
+        this.operateMenuItem = page.getByRole('menuitemradio', { name: 'Operate' });
+        this.consoleMenuItem = page.getByRole('menuitemradio', { name: 'Console' });
+        this.modelerMenuItem = page.getByRole('menuitemradio', { name: 'Modeler' });
         this.tasklistListItem = this.page
             .getByRole('listitem')
             .filter({ hasText: 'Tasklist' });
@@ -115,6 +127,16 @@ class AppsPage {
             console.warn(`Could not reload while ${whileDoing}: ${error}`);
         }
     }
+    // Boolean probe for "did an apps-menu entry render?", with the same window
+    // the `expect(...).toBeVisible({timeout: 30000})` calls it replaces used —
+    // so a slow legacy flyout still gets its full 30s before any caller decides
+    // the entry is absent rather than merely late.
+    async entryAppeared(entry) {
+        return entry
+            .waitFor({ state: 'visible', timeout: 30000 })
+            .then(() => true)
+            .catch(() => false);
+    }
     async clickCluster(component, name) {
         // Cluster names are not unique in an org, so this app's sub-menu can list
         // the same name twice; pick the first entry (same row the Console cluster
@@ -131,17 +153,25 @@ class AppsPage {
             .getByText(/local_rate_limited/i)
             .or(this.page.getByText(/Well, that's awkward/i))
             .first();
+        // nav V2 breadcrumb switcher: Modeler is a `menuitemradio`, the legacy
+        // apps flyout renders it as a link. Resolve whichever this build shows.
+        const modelerEntry = this.modelerMenuItem.or(this.modelerLink).first();
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
-                if (retries === 0) {
-                    await (0, test_1.expect)(this.modelerLink).toBeVisible({ timeout: 30000 });
-                    await this.modelerLink.click();
+                if (retries > 0) {
+                    await this.clickCamundaApps();
                 }
-                else {
+                if (!(await this.entryAppeared(modelerEntry))) {
+                    // Nothing to click, because the nav V2 breadcrumb switcher lists
+                    // only the cluster's OWN webapps. Modeler is org-level, so unlike
+                    // Operate it has no entry there at all. Re-enter through Console,
+                    // whose apps flyout does list it — the same recovery the
+                    // `open*WithRetry` helpers below use.
+                    await this.page.goto('/', { waitUntil: 'domcontentloaded' });
                     await this.clickCamundaApps();
-                    await (0, test_1.expect)(this.modelerLink).toBeVisible({ timeout: 30000 });
-                    await this.modelerLink.click();
+                    await (0, test_1.expect)(modelerEntry).toBeVisible({ timeout: 30000 });
                 }
+                await modelerEntry.click();
                 // After clicking, the browser is redirected through
                 // modeler.ultrawombat.com/login which can return 429
                 // (`local_rate_limited`) or a generic "Well, that's awkward" error
@@ -473,24 +503,21 @@ class AppsPage {
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
-                if (retries === 0) {
-                    if (await this.operateLink.isVisible({ timeout: 5000 })) {
-                        //Single Cluster
-                        await this.operateLink.click({ timeout: 10000 });
-                    }
-                    else {
-                        //Multiple Cluster
-                        await this.doClickClusterInOperate(clusterName);
-                    }
+                if (retries > 0) {
+                    await this.clickCamundaApps();
+                }
+                if (await this.operateMenuItem.isVisible({ timeout: 5000 })) {
+                    // nav V2 breadcrumb switcher: apps are menuitemradio entries that
+                    // hop to the same cluster's app directly, no cluster sub-select.
+                    await this.operateMenuItem.click({ timeout: 10000 });
+                }
+                else if (await this.operateLink.isVisible({ timeout: 5000 })) {
+                    //Single Cluster
+                    await this.operateLink.click({ timeout: 10000 });
                 }
                 else {
-                    await this.clickCamundaApps();
-                    if (await this.operateLink.isVisible({ timeout: 5000 })) {
-                        await this.operateLink.click({ timeout: 10000 });
-                    }
-                    else {
-                        await this.doClickClusterInOperate(clusterName);
-                    }
+                    //Multiple Cluster
+                    await this.doClickClusterInOperate(clusterName);
                 }
                 return;
             }
@@ -562,17 +589,25 @@ class AppsPage {
     }
     async clickConsoleLink() {
         const maxRetries = 3;
+        // nav V2 breadcrumb switcher: Console is a `menuitemradio`, the legacy
+        // apps flyout renders it as a link. Resolve whichever this build shows.
+        const consoleEntry = this.consoleMenuItem.or(this.consoleLink).first();
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
-                if (retries === 0) {
-                    await (0, test_1.expect)(this.consoleLink).toBeVisible({ timeout: 30000 });
-                    await this.consoleLink.click();
-                }
-                else {
+                if (retries > 0) {
                     await this.clickCamundaApps();
-                    await (0, test_1.expect)(this.consoleLink).toBeVisible({ timeout: 30000 });
-                    await this.consoleLink.click();
                 }
+                if (await this.entryAppeared(consoleEntry)) {
+                    await consoleEntry.click();
+                    return;
+                }
+                // Nothing to click, because the nav V2 breadcrumb switcher lists only
+                // the cluster's OWN webapps (Operate, Tasklist, Optimize, Admin) —
+                // which is why `clickOperate` resolves from Admin through
+                // `operateMenuItem` and this does not. Console is org-level and has no
+                // entry there, but it IS what `baseURL` points at, so navigate to it
+                // directly rather than re-opening a menu that will never list it.
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
                 return;
             }
             catch (error) {

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

@@ -2,13 +2,16 @@ import { Page, Locator } from '@playwright/test';
 declare class Authorization {
     readonly page: Page;
     protected readonly selectResourceTypeTab: (name: string) => Locator;
+    protected readonly resourceTypeFilterCombobox: Locator;
     protected readonly createAuthorizationModal: Locator;
     protected readonly createAuthorizationButton: Locator;
     protected readonly createAuthorizationOwnerTypeCombobox: Locator;
     protected readonly createAuthorizationOwnerTypeOption: (name: string) => Locator;
     protected readonly createAuthorizationOwnerComboBox: Locator;
     protected readonly createAuthorizationOwnerSearchInput: Locator;
-    protected readonly createAuthorizationOwnerLegacyComboBox: Locator;
+    protected readonly createAuthorizationOwnerSearchOption: (name: string) => Locator;
+    protected readonly createAuthorizationOwnerCommandInput: Locator;
+    protected readonly createAuthorizationOwnerCommandOptions: Locator;
     protected readonly createAuthorizationOwnerOption: (name: string) => Locator;
     protected readonly createAuthorizationResourceTypeDropdown: Locator;
     protected readonly createAuthorizationResourceTypeOption: (name: string) => Locator;
@@ -19,8 +22,11 @@ declare class Authorization {
     protected readonly deleteAuthorizationButton: (name: string) => Locator;
     protected readonly deleteAuthorizationModal: Locator;
     protected readonly deleteAuthorizationModalDeleteButton: Locator;
+    protected readonly tableFilter: Locator;
     constructor(page: Page);
+    protected selectResourceType(resourceType: string, timeout?: number): Promise<void>;
     assertAuthorization(auth: string): Promise<void>;
+    private selectAuthorizationOwner;
     createAuthorization(authorization: {
         ownerType: string;
         ownerId: string;
@@ -29,6 +35,10 @@ declare class Authorization {
         accessPermissions: string[];
     }): Promise<void>;
     selectResourceTypeFromDialog(resourceType: string): Promise<void>;
+    private checkAccessPermission;
+    private authorizationRow;
+    private expectAuthorizationListed;
+    private filterAuthorizationsByOwner;
     deleteAuthorization(resourceId: string, resourceType: string): Promise<void>;
 }
 export { Authorization };

package/dist/pages/8.10/Authorization.js

@@ -2,18 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Authorization = void 0;
 const test_1 = require("@playwright/test");
-const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
 const expectLocatorWithPagination_1 = require("../../utils/assertionHelpers/expectLocatorWithPagination");
+const findLocatorWithPagination_1 = require("../../utils/assertionHelpers/findLocatorWithPagination");
+const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
 class Authorization {
     page;
     selectResourceTypeTab;
+    resourceTypeFilterCombobox;
     createAuthorizationModal;
     createAuthorizationButton;
     createAuthorizationOwnerTypeCombobox;
     createAuthorizationOwnerTypeOption;
     createAuthorizationOwnerComboBox;
     createAuthorizationOwnerSearchInput;
-    createAuthorizationOwnerLegacyComboBox;
+    createAuthorizationOwnerSearchOption;
+    createAuthorizationOwnerCommandInput;
+    createAuthorizationOwnerCommandOptions;
     createAuthorizationOwnerOption;
     createAuthorizationResourceTypeDropdown;
     createAuthorizationResourceTypeOption;
@@ -24,9 +28,20 @@ class Authorization {
     deleteAuthorizationButton;
     deleteAuthorizationModal;
     deleteAuthorizationModalDeleteButton;
+    tableFilter;
     constructor(page) {
         this.page = page;
         this.selectResourceTypeTab = (resourceType) => page.getByRole('tab', { name: resourceType });
+        // The Admin's Authorizations page moved onto the new design-system shell,
+        // which replaces the per-resource-type Carbon tabs with a single filter
+        // combobox in a left "Filter" card (identity/client ListV2.tsx). The
+        // combobox's accessible name was renamed from "Authorization type" to
+        // "Resource type" in camunda/camunda commit 377b0e3; match either so both
+        // image versions resolve.
+        this.resourceTypeFilterCombobox = page
+            .getByRole('combobox', { name: 'Resource type' })
+            .or(page.getByRole('combobox', { name: 'Authorization type' }))
+            .first();
         this.authorizationsList = page.getByRole('table');
         this.createAuthorizationButton = page.getByRole('button', {
             name: /create authorization/i,
@@ -38,63 +53,84 @@ class Authorization {
             this.createAuthorizationModal.getByRole('combobox', {
                 name: 'Owner type',
             });
-        this.createAuthorizationOwnerTypeOption = (name) => this.createAuthorizationModal.getByRole('option', {
+        // The design-system Select portals its listbox to the end of <body>, so
+        // the options are siblings of the dialog rather than descendants, and
+        // while the listbox is open Radix marks everything outside it aria-hidden
+        // — which takes the dialog itself out of the accessibility tree. Query the
+        // options from the page root so both placements resolve.
+        this.createAuthorizationOwnerTypeOption = (name) => this.page
+            .getByRole('option', {
             name,
             exact: true,
-        });
-        // The Owner field has two shapes depending on the build under test.
-        //
-        // Since camunda/camunda#57931 Identity renders an entity-search dropdown
-        // (identity/client/src/components/form/EntitySearchSingleSelect.tsx ->
-        // EntitySearchDropdown -> DropdownSearch): a bare `FormLabel` plus a
-        // Carbon `Search` input carrying only the "Search by owner ID"
-        // placeholder, with nothing exposing the accessible name "Owner".
-        //
-        // Builds that predate that change — notably released alpha generations
-        // such as 8.10.0-alpha5, tagged 2026-08-31 before the stable/8.10
-        // backport (#61570) landed on 2026-09-01 — still render the older Carbon
-        // `ComboBox` (owner-selection/OwnerSelection.tsx) whose `titleText` is
-        // "Owner". Match either so the suite runs against both.
-        this.createAuthorizationOwnerSearchInput =
-            this.createAuthorizationModal.getByPlaceholder('Search by owner ID');
-        this.createAuthorizationOwnerLegacyComboBox =
-            this.createAuthorizationModal.getByRole('combobox', {
-                name: 'Owner',
-                exact: true,
-            });
-        this.createAuthorizationOwnerComboBox =
-            this.createAuthorizationOwnerSearchInput
-                .or(this.createAuthorizationOwnerLegacyComboBox)
-                .first();
+        })
+            .first();
+        // On the design-system build the closed Owner control is a combobox-role
+        // trigger rendered by EntitySearchSingleSelect. Its <Label htmlFor> does
+        // not always name the focusable trigger, so the product team's own suite
+        // identifies it by the placeholder it paints as static text instead
+        // (camunda/camunda qa/c8-orchestration-cluster-e2e-test-suite/pages/
+        // IdentityAuthorizationsPage.ts). Match either, and keep `exact` on the
+        // label form so it cannot collide with "Owner type".
+        this.createAuthorizationOwnerComboBox = this.createAuthorizationModal
+            .getByRole('combobox', {
+            name: 'Owner',
+            exact: true,
+        })
+            .or(this.createAuthorizationModal
+            .getByRole('combobox')
+            .filter({ hasText: 'Search by owner ID' }))
+            .first();
         this.createAuthorizationOwnerOption = (name) => this.createAuthorizationModal.getByRole('option', {
             name,
             exact: true,
         });
+        // Every owner type now renders a server-backed search dropdown instead of
+        // the combobox that listed all owners up front. On the entity-search build
+        // that dropdown is a Carbon Search inside a ListBox, so it has no combobox
+        // role and its results are list-box menu items. The design-system build
+        // renders the same field as a cmdk command palette whose results are
+        // role=option items in a popover portalled out of the dialog.
+        this.createAuthorizationOwnerSearchInput =
+            this.createAuthorizationModal.getByPlaceholder('Search by owner ID');
+        this.createAuthorizationOwnerSearchOption = (name) => this.page.getByRole('option').filter({ hasText: name }).first();
+        // In the design-system build the closed Owner control is a combobox-role
+        // trigger that paints "Search by owner ID" as static text (no placeholder
+        // attribute), and the cmdk search box plus its result listbox only mount
+        // in a popover once the trigger is opened. That popover is portalled out
+        // of the dialog, and while it is open Radix marks the dialog aria-hidden,
+        // so both must be queried from the page root.
+        this.createAuthorizationOwnerCommandInput = this.page
+            .locator('[data-slot="command-input"]')
+            .first();
+        this.createAuthorizationOwnerCommandOptions = this.page
+            .getByRole('listbox')
+            .getByRole('option');
         this.createAuthorizationResourceTypeDropdown =
             this.createAuthorizationModal.getByRole('combobox', {
                 name: 'Resource type',
             });
-        this.createAuthorizationResourceTypeOption = (name) => this.createAuthorizationModal.getByRole('option', {
+        this.createAuthorizationResourceTypeOption = (name) => this.page
+            .getByRole('option', {
             name,
             exact: true,
-        });
+        })
+            .first();
         this.createAuthorizationResourceIdField =
             this.createAuthorizationModal.getByRole('textbox', {
                 name: 'Resource ID',
             });
-        this.createAuthorizationAccessPermission = (name) => this.createAuthorizationModal.getByRole('checkbox', {
-            name,
-        });
+        // Carbon wired its checkbox input and label together the same way the
+        // design-system Checkbox does (`id={permission}` / `htmlFor={permission}`),
+        // and on both builds the input itself is not the click target — the label
+        // is.
+        this.createAuthorizationAccessPermission = (name) => this.createAuthorizationModal.locator(`label[for="${name}"]`);
         this.createAuthorizationSubmitButton =
             this.createAuthorizationModal.getByRole('button', {
                 name: 'Create authorization',
             });
-        this.authorizationsList = page.getByRole('table');
         this.deleteAuthorizationButton = (name) => this.authorizationsList
-            .getByRole('row')
-            .filter({ hasText: name })
-            .first()
-            .getByRole('button', { name: 'danger Delete' });
+            .getByRole('row', { name })
+            .getByRole('button', { name: /^delete/i });
         this.deleteAuthorizationModal = page.getByRole('dialog', {
             name: /delete authorization/i,
         });
@@ -102,6 +138,30 @@ class Authorization {
             this.deleteAuthorizationModal.getByRole('button', {
                 name: /delete authorization/i,
             });
+        // Carbon labelled the table toolbar search "Filter table"; the
+        // design-system EntityList exposes the placeholder as the accessible name
+        // instead. Match either.
+        this.tableFilter = page
+            .getByRole('searchbox', { name: 'Filter table' })
+            .or(page.getByRole('searchbox', { name: 'Search by owner ID' }))
+            .first();
+    }
+    // Select the resource type through whichever control this build renders:
+    // click the Carbon tab, or open the design-system filter combobox and pick
+    // the option.
+    async selectResourceType(resourceType, timeout = 60000) {
+        const tab = this.selectResourceTypeTab(resourceType);
+        await (0, test_1.expect)(tab.or(this.resourceTypeFilterCombobox)).toBeVisible({
+            timeout,
+        });
+        if (await tab.isVisible()) {
+            await tab.click();
+            return;
+        }
+        await this.resourceTypeFilterCombobox.click();
+        await this.page
+            .getByRole('option', { name: resourceType, exact: true })
+            .click({ timeout: Math.min(timeout, 30000) });
     }
     // The authorizations table paginates, and the RBA clusters these flows run
     // against are long-lived: every night's run leaves more process-definition
@@ -114,100 +174,236 @@ class Authorization {
     async assertAuthorization(auth) {
         await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, this.authorizationsList.getByRole('row').filter({ hasText: auth }).first());
     }
+    // Released 8.10 alpha images still render the Carbon combobox that lists
+    // every owner, so accept whichever of the three owner fields this build
+    // shows: the Carbon search dropdown, the Carbon combobox that lists every
+    // owner inline, or the design-system combobox whose cmdk popover only loads
+    // results once the owner ID is typed.
+    async selectAuthorizationOwner(ownerId) {
+        await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput.or(this.createAuthorizationOwnerComboBox)).toBeVisible({ timeout: 60000 });
+        if (await this.createAuthorizationOwnerSearchInput.isVisible()) {
+            await this.createAuthorizationOwnerSearchInput.fill(ownerId);
+            const ownerOption = this.createAuthorizationOwnerSearchOption(ownerId);
+            // The search is debounced and served by the API, so a just-created
+            // owner can take a while to surface.
+            await (0, test_1.expect)(ownerOption).toBeVisible({ timeout: 60000 });
+            await ownerOption.click({ timeout: 30000 });
+            // Picking an owner replaces the search input with a tag holding the
+            // selection, which is how we know the choice was committed.
+            await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput).toBeHidden({
+                timeout: 30000,
+            });
+            return;
+        }
+        await this.createAuthorizationOwnerComboBox.click();
+        const commandInput = this.createAuthorizationOwnerCommandInput;
+        const inlineOwnerOption = this.createAuthorizationOwnerOption(ownerId);
+        await (0, test_1.expect)(commandInput.or(inlineOwnerOption).first()).toBeVisible({
+            timeout: 30000,
+        });
+        if (await commandInput.isVisible()) {
+            await commandInput.fill(ownerId);
+            // The result list is served by the API and debounced, and each option is
+            // labelled "<owner id> — <name>" rather than the bare ID
+            // (identity/client RoleSelection.tsx `itemLabel`), so narrow the search
+            // to the single row this unique owner ID resolves to instead of matching
+            // on the label text.
+            const ownerOptions = this.createAuthorizationOwnerCommandOptions;
+            await (0, test_1.expect)(ownerOptions).toHaveCount(1, { timeout: 60000 });
+            await ownerOptions.first().click({ timeout: 30000, force: true });
+            // Committing the choice closes the popover, which is what hands the
+            // dialog back to the accessibility tree for the fields that follow.
+            await (0, test_1.expect)(commandInput).toBeHidden({ timeout: 30000 });
+            return;
+        }
+        await (0, test_1.expect)(inlineOwnerOption).toBeVisible({ timeout: 30000 });
+        await inlineOwnerOption.click({ timeout: 30000 });
+    }
     async createAuthorization(authorization) {
         await this.createAuthorizationButton.click();
         await (0, test_1.expect)(this.createAuthorizationModal).toBeVisible();
         await this.createAuthorizationOwnerTypeCombobox.click();
         await this.createAuthorizationOwnerTypeOption(authorization.ownerType).click();
-        // Owner type selection re-renders the owner field, and on the
-        // entity-search build that swap is query-driven, so it can lag well past
-        // 30s under CI load — the product team's own e2e suite raised an
-        // analogous wait on the same widget from 20s to 60s (camunda/camunda#61353).
-        await (0, test_1.expect)(this.createAuthorizationOwnerComboBox).toBeVisible({
-            timeout: 60000,
-        });
-        const usesEntitySearch = await this.createAuthorizationOwnerSearchInput.isVisible();
-        const ownerField = usesEntitySearch
-            ? this.createAuthorizationOwnerSearchInput
-            : this.createAuthorizationOwnerLegacyComboBox;
-        if (!usesEntitySearch) {
-            // The legacy Carbon ComboBox renders its menu only once opened; the
-            // entity-search input renders results off the typed value alone.
-            await ownerField.click();
-        }
-        await ownerField.fill(authorization.ownerId);
-        // The dropdown renders results only while the search box holds text, and
-        // the list is fetched from the server on a debounce rather than filtered
-        // client-side, so the matching entry appears a beat later. Clicking the
-        // Carbon menu item is what commits the selection: DropdownSearch wires
-        // `onSelect` to `ListBox.MenuItem`'s onClick
-        // (identity/client/src/components/form/DropdownSearch.tsx), and that is
-        // the only path that promotes an entry into the form's owner value.
-        const ownerMenuItem = this.createAuthorizationModal
-            .locator('.cds--list-box__menu-item')
-            .filter({ hasText: authorization.ownerId })
-            .first();
-        await (0, test_1.expect)(ownerMenuItem).toBeVisible({ timeout: 60000 });
-        await ownerMenuItem.click({ timeout: 20000 });
-        // On the entity-search build a committed selection swaps the search box
-        // for a filter Tag (EntitySearchSingleSelect renders one or the other), so
-        // the box going away is how we know the owner actually landed on the form
-        // rather than the click being swallowed. The legacy ComboBox keeps its
-        // input and shows the selection as the input value, so this check only
-        // applies to the entity-search shape.
-        if (usesEntitySearch) {
-            await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput).toBeHidden({
-                timeout: 15000,
-            });
-        }
+        await this.selectAuthorizationOwner(authorization.ownerId);
         await this.selectResourceTypeFromDialog(authorization.resourceType);
         await this.createAuthorizationResourceIdField.fill(authorization.resourceId);
         for (const permission of authorization.accessPermissions) {
-            await this.createAuthorizationAccessPermission(permission).click({
-                force: true,
-            });
+            await this.checkAccessPermission(permission);
         }
-        await this.createAuthorizationSubmitButton.click();
-        await (0, test_1.expect)(this.createAuthorizationModal).not.toBeVisible({
+        await (0, submitModalWithRetry_1.submitModalWithRetry)(this.createAuthorizationSubmitButton, this.createAuthorizationModal);
+        await this.selectResourceType(authorization.resourceType);
+        await this.expectAuthorizationListed(authorization, this.authorizationRow(authorization));
+    }
+    // The Resource type field is pre-selected from the list's current resource
+    // type and rendered `disabled` on the design-system build
+    // (identity/client/src/pages/authorizations/modalsV2/add-modal/AddModal.tsx
+    // passes a literal `disabled`), so there is nothing to pick. Only open the
+    // dropdown when the field is still editable.
+    async selectResourceTypeFromDialog(resourceType) {
+        await (0, test_1.expect)(this.createAuthorizationResourceTypeDropdown).toBeVisible({
             timeout: 30000,
         });
-        await this.selectResourceTypeTab(authorization.resourceType).click();
-        const item = this.page.getByRole('row').filter({
-            hasText: `${authorization.ownerId}${authorization.resourceId}`,
-        });
-        await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, item, {
-            clickLocator: this.selectResourceTypeTab(authorization.resourceType),
+        if (!(await this.createAuthorizationResourceTypeDropdown.isEnabled())) {
+            return;
+        }
+        await this.createAuthorizationResourceTypeDropdown.click();
+        await this.createAuthorizationResourceTypeOption(resourceType).click({
+            timeout: 30000,
         });
     }
-    async selectResourceTypeFromDialog(resourceType) {
-        const isDisabled = await this.createAuthorizationResourceTypeDropdown.isDisabled();
-        if (isDisabled) {
+    // The permission control is a label + hidden input pair on both builds, so
+    // the label is the click target while the input carries the checked state.
+    // The design-system Checkbox re-renders on every toggle, which can swallow a
+    // click that lands mid-render, so confirm the state and re-click if needed.
+    async checkAccessPermission(permission) {
+        const permissionLabel = this.createAuthorizationAccessPermission(permission);
+        const permissionInput = this.createAuthorizationModal.locator(`input[id="${permission}"], [role="checkbox"][id="${permission}"]`);
+        await (0, test_1.expect)(permissionLabel).toBeVisible({ timeout: 30000 });
+        await permissionLabel.scrollIntoViewIfNeeded();
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt < maxAttempts; attempt++) {
+            if (await permissionInput.isChecked()) {
+                return;
+            }
+            await permissionLabel.click({ force: true });
+            try {
+                await (0, test_1.expect)(permissionInput).toBeChecked({ timeout: 5000 });
+                return;
+            }
+            catch {
+                // A click that landed mid-rerender is dropped: try again. The
+                // assertion after the loop is the one that reports a permission that
+                // never took.
+            }
+        }
+        if (!(await permissionInput.isChecked())) {
+            await permissionLabel.click({ force: true });
+        }
+        await (0, test_1.expect)(permissionInput).toBeChecked({ timeout: 10000 });
+    }
+    // The authorizations list caps every cell at 25 characters
+    // (`maxDisplayCellLength={25}` in camunda/camunda
+    // identity/client/src/pages/authorizations/AuthorizationsListV2.tsx), and on
+    // the design-system build `truncateCell` renders an over-long value as
+    // `<button aria-label="<full value>">{first 25 chars}…</button>` with the
+    // tooltip carrying the rest portalled out of the row. An owner ID longer
+    // than 25 characters - the RBA specs' 33-character
+    // `rbaSelectedProcessesPermission<xxx>` roles - is therefore absent from the
+    // row's text, so filtering rows on `<ownerId><resourceId>` cannot match it
+    // however long we wait. The full value survives in the cell's accessible
+    // name, so also accept a row that HAS a cell named exactly the owner ID.
+    // Carbon truncates at 25 as well, but renders its tooltip inline, which
+    // keeps the full value in the row's text - the `hasText` branch covers that
+    // build, and short owner IDs resolve on both.
+    authorizationRow(authorization) {
+        const rows = this.page.getByRole('row');
+        return rows
+            .filter({ hasText: `${authorization.ownerId}${authorization.resourceId}` })
+            .or(rows
+            .filter({
+            has: this.page.getByRole('cell', {
+                name: authorization.ownerId,
+                exact: true,
+            }),
+        })
+            .filter({ hasText: authorization.resourceId }))
+            .first();
+    }
+    // The toolbar search filters by owner ID, so filling it with the resource
+    // type narrows nothing, and the retry helper it fed reloads before it
+    // asserts, which dropped the filter entirely. That left the new row to be
+    // found on page 1 of the unfiltered table - and the authorizations table
+    // paginates, so with the RBA specs creating owners in parallel it is
+    // regularly on a later page. Filter by owner, then page through what is
+    // left; fall back to the unfiltered table for builds whose search has not
+    // caught up with a just-created owner yet.
+    async expectAuthorizationListed(authorization, item) {
+        const deadline = Date.now() + 180000;
+        const budget = (max) => Math.max(5000, Math.min(max, deadline - Date.now()));
+        const maxAttempts = 5;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (attempt > 0 && Date.now() >= deadline) {
+                break;
+            }
+            try {
+                await this.selectResourceType(authorization.resourceType, budget(30000));
+                for (const filterValue of [authorization.ownerId, '']) {
+                    await this.filterAuthorizationsByOwner(filterValue);
+                    const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, item, {
+                        timeout: budget(filterValue === '' ? 45000 : 15000),
+                    });
+                    if (found) {
+                        await (0, test_1.expect)(item).toBeVisible({ timeout: 5000 });
+                        return;
+                    }
+                }
+                throw new Error(`No row for owner "${authorization.ownerId}" and resource ` +
+                    `"${authorization.resourceId}" in the ` +
+                    `${authorization.resourceType} table`);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts - 1) {
+                    console.warn(`Attempt ${attempt + 1} did not list the ` +
+                        `${authorization.resourceType} authorization for ` +
+                        `"${authorization.ownerId}". Retrying...`);
+                    await this.page.reload();
+                    await this.page.waitForLoadState('domcontentloaded');
+                }
+            }
+        }
+        throw new Error(`Authorization for "${authorization.ownerId}" on ` +
+            `"${authorization.resourceId}" was not listed: ${String(lastError)}`);
+    }
+    async filterAuthorizationsByOwner(ownerId) {
+        const hasFilter = await this.tableFilter
+            .isVisible({ timeout: 5000 })
+            .catch(() => false);
+        if (!hasFilter) {
             return;
         }
-        await this.createAuthorizationResourceTypeDropdown.click();
-        await this.createAuthorizationResourceTypeOption(resourceType).click();
+        await this.tableFilter.fill(ownerId);
+        // The search is debounced and served by the API; the paginated lookup this
+        // feeds waits for the row itself, so there is nothing to wait on here
+        // beyond the value having landed in the box.
+        await (0, test_1.expect)(this.tableFilter).toHaveValue(ownerId);
     }
     async deleteAuthorization(resourceId, resourceType) {
-        const locator = this.deleteAuthorizationButton(resourceId);
-        await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, locator, {
-            clickLocator: this.selectResourceTypeTab(resourceType),
-        });
-        await locator.click();
+        // Same paginated table as createAuthorization: the row being deleted is
+        // not necessarily on page 1, and the toolbar search cannot narrow by
+        // resource ID.
+        const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, this.deleteAuthorizationButton(resourceId), { timeout: 60000 });
+        if (!found) {
+            throw new Error(`No ${resourceType} authorization row for resource "${resourceId}"`);
+        }
+        await this.deleteAuthorizationButton(resourceId).click();
         await (0, test_1.expect)(this.deleteAuthorizationModal).toBeVisible();
         await this.deleteAuthorizationModalDeleteButton.click();
         await (0, test_1.expect)(this.deleteAuthorizationModal).not.toBeVisible();
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.authorizationsList
-            .getByRole('cell', {
-            name: resourceId,
-        })
-            .first(), {
-            preAction: async () => {
-                await this.selectResourceTypeTab(resourceType);
-                await this.page.reload();
-                await this.page.waitForTimeout(1000);
-            },
-            shouldBeVisible: false,
-        });
+        // Re-selecting the resource type takes two interactions on the
+        // design-system build, so this cannot go through the shared
+        // reload-click-assert helper, which only accepts a single click locator.
+        const deletedCell = this.authorizationsList
+            .getByRole('cell', { name: resourceId })
+            .first();
+        let lastError;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            await this.page.reload();
+            await this.page.waitForLoadState('domcontentloaded');
+            await this.selectResourceType(resourceType);
+            try {
+                await (0, test_1.expect)(deletedCell).not.toBeVisible({ timeout: 5000 });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                console.warn(`Attempt ${attempt + 1} still listed the ${resourceType} ` +
+                    `authorization for "${resourceId}". Retrying...`);
+            }
+        }
+        throw new Error(`Authorization for resource "${resourceId}" is still listed: ` +
+            String(lastError));
     }
 }
 exports.Authorization = Authorization;

package/dist/pages/8.10/OCIdentityAuthorizationsPage.js

@@ -2,31 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OCIdentityAuthorizationsPage = void 0;
 const Authorization_1 = require("../8.10/Authorization");
-const test_1 = require("@playwright/test");
-const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
 class OCIdentityAuthorizationsPage extends Authorization_1.Authorization {
     constructor(page) {
         super(page);
     }
     async clickProcessDefinitionTab() {
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.selectResourceTypeTab('PROCESS_DEFINITION'));
-        await this.selectResourceTypeTab('PROCESS_DEFINITION').click();
+        await this.selectResourceType('PROCESS_DEFINITION');
     }
     async clickAuthorizationTab() {
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.selectResourceTypeTab('AUTHORIZATION'));
-        await this.selectResourceTypeTab('AUTHORIZATION').click();
+        await this.selectResourceType('AUTHORIZATION');
     }
     async clickRoleTab() {
-        await (0, test_1.expect)(this.selectResourceTypeTab('Role')).toBeVisible();
-        await this.selectResourceTypeTab('Role').click();
+        await this.selectResourceType('ROLE');
     }
     async clickComponentTab() {
-        await (0, test_1.expect)(this.selectResourceTypeTab('COMPONENT')).toBeVisible();
-        await this.selectResourceTypeTab('COMPONENT').click();
+        await this.selectResourceType('COMPONENT');
     }
     async clickResourceTab() {
-        await (0, test_1.expect)(this.selectResourceTypeTab('RESOURCE')).toBeVisible();
-        await this.selectResourceTypeTab('RESOURCE').click();
+        await this.selectResourceType('RESOURCE');
     }
 }
 exports.OCIdentityAuthorizationsPage = OCIdentityAuthorizationsPage;

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

@@ -13,6 +13,7 @@ export declare class OCIdentityClusterVariablesPage {
     readonly monacoEditorTextArea: Locator;
     readonly successMessage: Locator;
     readonly editMenuItem: Locator;
+    readonly editModalHeading: Locator;
     constructor(page: Page);
     editVariable(variableName: string, newValue: string): Promise<void>;
     assertVariableExists(variableName: string): Promise<void>;

package/dist/pages/8.10/OCIdentityClusterVariablesPage.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OCIdentityClusterVariablesPage = void 0;
 const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
 class OCIdentityClusterVariablesPage {
     page;
     variablesList;
@@ -16,21 +18,36 @@ class OCIdentityClusterVariablesPage {
     monacoEditorTextArea;
     successMessage;
     editMenuItem;
+    editModalHeading;
     constructor(page) {
         this.page = page;
-        this.variablesList = page.locator('table.cds--data-table');
-        this.variableRow = (variableName) => this.variablesList
-            .locator('tbody')
-            .getByRole('row')
-            .filter({ hasText: variableName });
-        this.editVariableButton = (variableName) => this.variableRow(variableName).getByRole('button', { name: 'Options' });
+        // The Admin UI moved off Carbon onto the Camunda design system:
+        // `identity/client/src/pages/cluster-variables/index.tsx` renders ListV2
+        // (design-system `DataTable`, Radix dialog/menu) when the
+        // `isNewDesignSystemEnabled` client config is on, which SaaS clusters now
+        // ship with, so the Carbon `table.cds--data-table` this was scoped to no
+        // longer exists. The table role resolves both DOMs, and filtering the rows
+        // by the variable name already excludes the header row, so the removed
+        // tbody scoping is not needed. Mirrors
+        // pages/SM-8.10/OCIdentityClusterVariablesPage.ts.
+        this.variablesList = page.getByRole('table');
+        this.variableRow = (variableName) => this.variablesList.getByRole('row').filter({ hasText: variableName });
+        // Carbon's OverflowMenu labels its trigger "Options"; the design-system
+        // DataTable labels it "Row actions".
+        this.editVariableButton = (variableName) => this.variableRow(variableName).getByRole('button', {
+            name: /^(Options|Row actions)$/,
+        });
         this.editVariableModal = page.getByRole('dialog', {
             name: /Edit.*variable/i,
         });
         this.variableValueField = this.editVariableModal.getByRole('textbox', {
             name: 'Editor content',
         });
-        this.saveVariableButton = this.editVariableModal.locator('.cds--modal-footer button.cds--btn--primary');
+        // Both modals pass `confirmLabel={t("save")}`, so the accessible name is
+        // stable across the two footers.
+        this.saveVariableButton = this.editVariableModal.getByRole('button', {
+            name: 'Save',
+        });
         this.closeEditVariableModal = this.editVariableModal.getByRole('button', {
             name: 'Close',
         });
@@ -40,9 +57,15 @@ class OCIdentityClusterVariablesPage {
         this.monacoEditor = this.editVariableModal.locator('.monaco-editor');
         this.monacoEditorTextArea = this.monacoEditor.locator('textarea.inputarea');
         this.successMessage = this.page.getByText('Cluster variable updated');
-        this.editMenuItem = this.page
-            .locator('button[role="menuitem"]')
-            .filter({ hasText: /^Edit$/ });
+        // Carbon renders the modal title as an h3, the design-system dialog as an
+        // h2; the heading role covers both.
+        this.editModalHeading = this.editVariableModal.getByRole('heading').first();
+        // Carbon menu items are buttons, Radix menu items are divs — match on the
+        // role instead of the tag.
+        this.editMenuItem = this.page.getByRole('menuitem', {
+            name: 'Edit',
+            exact: true,
+        });
     }
     async editVariable(variableName, newValue) {
         await this.editVariableButton(variableName).click();
@@ -50,21 +73,50 @@ class OCIdentityClusterVariablesPage {
         await this.editMenuItem.click();
         await (0, test_1.expect)(this.variableValueField).toBeVisible();
         await (0, test_1.expect)(this.monacoEditor).toBeVisible();
-        // Monaco's hidden <textarea> only forwards keyboard events to the
-        // editor model — `fill()` writes the value but doesn't trigger
-        // Monaco's onDidChangeContent, so the modal's JSON validator never
-        // re-runs and Save stays disabled. Use real keyboard input instead.
-        await this.monacoEditor.click();
-        await this.page.keyboard.press('ControlOrMeta+A');
-        await this.page.keyboard.press('Delete');
-        await this.page.keyboard.type(newValue);
-        await (0, test_1.expect)(this.saveVariableButton).toBeEnabled();
+        // Monaco's hidden <textarea> only forwards keyboard events to the editor
+        // model — `fill()` writes the value but doesn't trigger Monaco's
+        // onDidChangeContent, so the modal's JSON validator never re-runs and Save
+        // stays disabled. Use real keyboard input instead, and retry the
+        // clear-type-enable cycle because Monaco's auto-closing brackets/quotes can
+        // corrupt the JSON on the first attempt.
+        const MAX_TYPE_ATTEMPTS = 3;
+        for (let attempt = 1; attempt <= MAX_TYPE_ATTEMPTS; attempt++) {
+            await this.monacoEditor.click();
+            await this.monacoEditorTextArea.press('ControlOrMeta+A');
+            await this.monacoEditorTextArea.press('Delete');
+            // Let Monaco settle after clearing content
+            await (0, sleep_1.sleep)(500);
+            await this.monacoEditorTextArea.pressSequentially(newValue, { delay: 20 });
+            // Dismiss any auto-complete popup by clicking the modal heading.
+            // Do NOT use press('Escape') on the textarea — when no autocomplete
+            // is showing, the Escape event propagates to the dialog and closes it.
+            await this.editModalHeading.click();
+            // Let Monaco settle and validate the new content
+            await (0, sleep_1.sleep)(500);
+            try {
+                await (0, test_1.expect)(this.saveVariableButton).toBeEnabled({ timeout: 10000 });
+                break;
+            }
+            catch {
+                if (attempt === MAX_TYPE_ATTEMPTS) {
+                    throw new Error(`Save button did not become enabled after ${MAX_TYPE_ATTEMPTS} typing attempts`);
+                }
+            }
+        }
         await this.saveVariableButton.click();
         await (0, test_1.expect)(this.successMessage).toBeVisible();
         await (0, test_1.expect)(this.editVariableModal).toBeHidden();
     }
     async assertVariableExists(variableName) {
-        await (0, test_1.expect)(this.variableRow(variableName)).toBeVisible();
+        // ListV2 fetches the variables with react-query after the Cluster
+        // variables nav link is followed, so the table can still be empty when
+        // this runs; reload between attempts rather than racing a single wait.
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.variableRow(variableName), {
+            visibilityTimeout: 30000,
+            postAction: async () => {
+                await this.page.reload();
+            },
+        });
     }
     async assertVariableValue(variableName, expectedValue) {
         const row = this.variableRow(variableName);

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

@@ -10,6 +10,7 @@ declare class OCIdentityRolesPage {
     readonly rolesList: Locator;
     readonly roleCell: (name: string) => Locator;
     readonly rowValue: (name: string) => Locator;
+    readonly memberCell: (name: string) => Locator;
     readonly createRoleButton: Locator;
     readonly createRoleModal: Locator;
     readonly createNameField: Locator;

package/dist/pages/8.10/OCIdentityRolesPage.js

@@ -15,6 +15,7 @@ class OCIdentityRolesPage {
     rolesList;
     roleCell;
     rowValue;
+    memberCell;
     createRoleButton;
     createRoleModal;
     createNameField;
@@ -52,6 +53,18 @@ class OCIdentityRolesPage {
         });
         this.roleCell = (roleID) => this.rolesList.getByRole('cell', { name: roleID, exact: true });
         this.rowValue = (name) => page.getByRole('row').filter({ hasText: name });
+        // The role detail page's members table is the design-system EntityList,
+        // which truncates any cell longer than 50 characters: `truncateCell` in
+        // camunda/camunda identity/client/src/components/entityListV2/EntityList.tsx
+        // replaces the text with
+        // `<button aria-label="<full value>">{first 50 chars}…</button>`, and the
+        // tooltip that carries the rest is portalled out of the row. The QA
+        // usernames are 60-character addresses, so the row's text no longer
+        // contains the address at all and `hasText` cannot see it — the full value
+        // now only survives in the accessible name, which a `cell` derives from its
+        // contents. Matching on the cell name resolves the untruncated (Carbon)
+        // rendering just as well, so this covers both builds.
+        this.memberCell = (name) => this.rolesList.getByRole('cell', { name });
         this.createRoleModal = page.getByRole('dialog', {
             name: 'Create role',
         });
@@ -64,7 +77,13 @@ class OCIdentityRolesPage {
             exact: true,
         });
         this.createRoleModalCreateButton = this.createRoleModal.getByRole('button', { name: 'Create role' });
-        this.deleteRoleButton = (rowName) => this.rolesList.getByRole('row', { name: rowName }).getByLabel('Delete');
+        // Carbon rendered the row's delete action as an icon-only button carrying
+        // an aria-label; the design-system EntityList renders the (dangerous) row
+        // action inline as a button with visible text instead, so there is no label
+        // to match. The accessible name covers both shapes.
+        this.deleteRoleButton = (rowName) => this.rolesList
+            .getByRole('row', { name: rowName })
+            .getByRole('button', { name: /^delete/i });
         this.deleteRoleModal = page.getByRole('dialog', { name: /delete role/i });
         this.closeDeleteRoleModal = this.deleteRoleModal.getByRole('button', {
             name: 'Close',
@@ -159,13 +178,12 @@ class OCIdentityRolesPage {
             await this.createRole({ id: role, name: role });
         }
         await this.doAssignUserToRole(role, email);
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.rowValue(email).first(), {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.memberCell(email).first(), {
             preAction: async () => {
                 await this.page.reload();
                 await (0, test_1.expect)(this.rolesList.first()).toBeVisible({ timeout: 20000 });
             },
         });
-        await (0, test_1.expect)(this.rowValue(email)).toContainText(`${email}`);
     }
     async deleteRole(name) {
         const locator = this.deleteRoleButton(name);

package/package.json

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