@camunda/e2e-test-suite 0.0.1277 → 0.0.1279

package/dist/pages/8.7/AppsPage.js

@@ -83,8 +83,14 @@ class AppsPage {
     // (see clickHubClusterApp and isHubClusterAppPresent below) gets at most
     // one match, scoped to this cluster.
     async expandHubClusterGroup(clusterName) {
+        // Anchored at the start: an unanchored substring match on "Test Cluster"
+        // also matches "UI Test Cluster" (created by console-user-flows in the
+        // same org), and .first() then opened that cluster's popover instead --
+        // a nightly trace shows the "UI Test Cluster" group open while the
+        // "Tasklist"/"Operate" lookup for "Test Cluster" timed out.
+        const clusterNamePattern = new RegExp(`^${escapeRegExp(clusterName)}\\b`);
         const toggle = this.hubSidebar
-            .getByRole('button', { name: clusterName })
+            .getByRole('button', { name: clusterNamePattern })
             .first();
         // The diagram editor (and other full-screen views reached from it, e.g.
         // right after runProcessInstance/deployDiagram) has no "Main navigation"
@@ -165,14 +171,16 @@ class AppsPage {
         // of its own, in which case hasNotText would fail to exclude the toggle
         // we just expanded and this loop would immediately collapse it again.
         // Match by accessible name (same algorithm getByRole's own name option
-        // uses) instead, excluding any name CONTAINING clusterName -- not just
-        // one exactly equal to it, since (per the toggle locator above) the
-        // current cluster's own toggle name is not exactly clusterName either,
-        // and an exact-equality exclusion would wrongly treat it as "other" and
-        // immediately re-collapse the group this method just expanded.
+        // uses) instead, excluding any name STARTING WITH clusterName (the same
+        // anchoring as the toggle locator, so "UI Test Cluster" still counts as
+        // another group) -- not just one exactly equal to it, since (per the
+        // toggle locator above) the current cluster's own toggle name is not
+        // exactly clusterName either, and an exact-equality exclusion would
+        // wrongly treat it as "other" and immediately re-collapse the group this
+        // method just expanded.
         const otherExpandedToggles = this.hubSidebar.getByRole('button', {
             expanded: true,
-            name: new RegExp(`^(?!.*${escapeRegExp(clusterName)}).+$`),
+            name: new RegExp(`^(?!${escapeRegExp(clusterName)}\\b).+$`),
         });
         for (let i = 0; i < 5 && (await otherExpandedToggles.count()) > 0; i++) {
             // Let a failed collapse throw rather than swallowing it: the app link

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

@@ -62,6 +62,7 @@ declare class ClusterDetailsPage {
     clickCreateButton(): Promise<void>;
     clickCloseModalButton(): Promise<void>;
     clickSettingsTab(): Promise<void>;
+    private isRBAToggleInState;
     enableRBA(): Promise<void>;
     disableRBA(): Promise<void>;
     searchAndClickClientCredentialsLink(name: string): Promise<ClientCredentialsDetailsPage>;

package/dist/pages/8.7/ClusterDetailsPage.js

@@ -234,9 +234,21 @@ class ClusterDetailsPage {
     async clickSettingsTab() {
         await this.settingsTab.click({ timeout: 60000 });
     }
+    // The switch reports its state through aria-checked. Clicking it
+    // unconditionally opened the opposite confirmation dialog whenever the
+    // cluster was already in the requested state (e.g. "Ensure RBA is
+    // Disabled" on a cluster that never had it on), so the Enable/Disable
+    // dialog wait below timed out. Returns false when the state is unknown.
+    async isRBAToggleInState(enabled) {
+        const checked = await this.rbaToggle.getAttribute('aria-checked');
+        return checked !== null && (checked === 'true') === enabled;
+    }
     async enableRBA() {
         await (0, test_1.expect)(this.rbaHeading).toBeVisible({ timeout: 60000 });
         await (0, test_1.expect)(this.rbaToggle).toBeVisible({ timeout: 30000 });
+        if (await this.isRBAToggleInState(true)) {
+            return;
+        }
         await this.rbaToggle.click();
         await (0, test_1.expect)(this.enableRBADialog).toBeVisible({ timeout: 60000 });
         await this.rbaEnableButton.click();
@@ -247,6 +259,9 @@ class ClusterDetailsPage {
     async disableRBA() {
         await (0, test_1.expect)(this.rbaHeading).toBeVisible({ timeout: 60000 });
         await (0, test_1.expect)(this.rbaToggle).toBeVisible({ timeout: 30000 });
+        if (await this.isRBAToggleInState(false)) {
+            return;
+        }
         await this.rbaToggle.click();
         await (0, test_1.expect)(this.disableRBADialog).toBeVisible({ timeout: 60000 });
         await this.rbaDisableButton.click();

package/dist/pages/8.7/ClusterSecretsPage.js

@@ -31,9 +31,16 @@ class ClusterSecretsPage {
         this.connectorSecretsTable = page.getByRole('table', {
             name: 'Connector secrets',
         });
+        // Legacy Carbon table: an "Options" cell holding the kebab. Hub's
+        // design-system data table instead labels each row's kebab
+        // "Row actions" (data-slot="data-table-actions-trigger"), with no
+        // "Options" cell -- so the old locator found nothing, the pre-clean
+        // returned early, and re-creating an existing secret failed with
+        // "Secret names must be unique".
         this.optionsButton = page
             .getByRole('cell', { name: 'Options' })
-            .getByRole('button');
+            .getByRole('button')
+            .or(page.getByRole('button', { name: 'Row actions', exact: true }));
         this.deleteConnectorSecretButton = page.getByRole('menuitem', {
             name: 'Delete',
             exact: true,
@@ -124,7 +131,7 @@ class ClusterSecretsPage {
             // that nothing *deletable* is left behind.
             const deletableSecretRows = this.page
                 .getByRole('row')
-                .filter({ has: this.page.getByRole('cell', { name: 'Options' }) })
+                .filter({ has: this.optionsButton })
                 .filter({ hasNotText: 'CAMUNDA_PROVIDED_' });
             await (0, test_1.expect)(deletableSecretRows).toHaveCount(0, { timeout: 30000 });
         }

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

@@ -7,6 +7,7 @@ declare class ConnectorMarketplacePage {
     readonly replaceResourceButton: Locator;
     readonly addToProjectButton: Locator;
     readonly cancelButton: Locator;
+    readonly tryAgainButton: Locator;
     readonly closeButton: Locator;
     readonly browseAllMarketplaceDetailsButton: Locator;
     constructor(page: Page);

package/dist/pages/8.7/ConnectorMarketplacePage.js

@@ -10,6 +10,7 @@ class ConnectorMarketplacePage {
     replaceResourceButton;
     addToProjectButton;
     cancelButton;
+    tryAgainButton;
     closeButton;
     browseAllMarketplaceDetailsButton;
     constructor(page) {
@@ -38,6 +39,7 @@ class ConnectorMarketplacePage {
             name: 'Add to project',
         });
         this.cancelButton = page.getByRole('button', { name: 'Cancel' });
+        this.tryAgainButton = page.getByRole('button', { name: 'Try again' });
         this.closeButton = page.getByRole('button', { name: 'Close' });
     }
     async clickSearchForConnectorTextbox() {
@@ -72,11 +74,33 @@ class ConnectorMarketplacePage {
         // genuine timeout here throw rather than silently falling through to the
         // immediate isVisible() probes below, which would just repeat the same
         // race this wait exists to close.
-        await this.addToProjectButton
+        //
+        // The Browse all review step first "checks this project" (camunda-hub
+        // marketplace-connector-detail-state.ts), which waits on the project's
+        // element-template metadata request -- nightly and live traces show that
+        // request still pending 30s in. When the check fails the footer offers
+        // "Try again" (RETRY_INSPECTION) instead of "Add to project", so give the
+        // check longer and re-run it on failure rather than timing out.
+        const outcome = this.addToProjectButton
             .or(this.replaceResourceButton)
             .or(this.cancelButton)
-            .first()
-            .waitFor({ state: 'visible', timeout: 30000 });
+            .first();
+        for (let attempt = 0; attempt < 3; attempt++) {
+            await outcome
+                .or(this.tryAgainButton)
+                .first()
+                .waitFor({ state: 'visible', timeout: 120000 });
+            if (await outcome.isVisible()) {
+                break;
+            }
+            // The retrying check keeps "Try again" on screen (as a loading button),
+            // so wait for its result here instead of re-polling the union above.
+            await this.tryAgainButton.click({ timeout: 10000 });
+            await outcome
+                .waitFor({ state: 'visible', timeout: 120000 })
+                .catch(() => { });
+        }
+        await outcome.waitFor({ state: 'visible', timeout: 10000 });
         let imported = false;
         // A fresh download shows "Add to project"; an already-present resource
         // shows "Replace resource". Pick whichever the ImportModal rendered —

package/dist/pages/8.7/LoginPage.js

@@ -77,8 +77,20 @@ class LoginPage {
         // before) must clear it too, or getUserToken() can return the previous
         // user's cached token.
         (0, consoleApiHelpers_1.resetHubBearerToken)(this.page);
-        // Navigate to app root to start the auth flow.
-        await this.page.goto('/');
+        // Navigate to app root to start the auth flow. Callers usually arrive
+        // here straight from a "Log out" click, whose own redirect chain (Hub's
+        // /login?returnUrl=/logout -> Auth0 logout) can still be in flight and
+        // interrupt this goto. Let that navigation land, then start over once.
+        try {
+            await this.page.goto('/');
+        }
+        catch (error) {
+            if (!String(error).includes('is interrupted by another navigation')) {
+                throw error;
+            }
+            await this.page.waitForLoadState('domcontentloaded', { timeout: 60000 });
+            await this.page.goto('/');
+        }
         await this.page
             .waitForURL((url) => !url.hostname.includes('console'), { timeout: 60000 })
             .catch(() => { });
@@ -86,8 +98,18 @@ class LoginPage {
         // logout/session-reset, keeping the page on Console instead of redirecting
         // to the Auth0 login form. Detect Console (settings button visible) and
         // force logout until the Auth0 email input appears.
-        const settingsBtn = this.page.getByLabel('Open Settings');
-        const logoutBtn = this.page.getByRole('button', { name: 'Log out' });
+        // Hub's design-system shell has no "Open Settings" button: its user menu
+        // is a "User menu, <full name>" button whose "Log out" is a menuitem (see
+        // SettingsPage). Without these the loop never noticed it had been
+        // silently re-authenticated on Hub and waited out the username input.
+        const settingsBtn = this.page
+            .getByLabel('Open Settings')
+            .or(this.page.getByRole('button', { name: /^User menu,/ }))
+            .first();
+        const logoutBtn = this.page
+            .getByRole('button', { name: 'Log out' })
+            .or(this.page.getByRole('menuitem', { name: 'Log out' }))
+            .first();
         for (let i = 0; i < 3; i++) {
             const onAuth0 = await this.usernameInput
                 .waitFor({ state: 'visible', timeout: 15000 })

package/dist/pages/8.7/UtilitiesPage.js

@@ -8,6 +8,7 @@ const sleep_1 = require("../../utils/sleep");
 const fileUpload_1 = require("../../utils/fileUpload");
 const mailSlurpClient_1 = require("../../utils/mailSlurpClient");
 const consoleApiHelpers_1 = require("../../utils/consoleApiHelpers");
+const sessionRecovery_1 = require("../../utils/sessionRecovery");
 // Tracks which worker-derived `timeout` values have already paid the
 // pre-flight stagger below, so a worker only pays it once per process
 // lifetime rather than on every call -- see the comment at the call sites.
@@ -601,7 +602,11 @@ async function modelAndRunConnectorsDocHandlingDiagram(modelerCreatePage, modele
     });
     await connectorMarketplacePage.downloadConnectorToProject();
     await (0, sleep_1.sleep)(5000);
-    await page.reload();
+    // A live run showed this reload bounce through Hub's /login?returnUrl=...
+    // and never reach "load" -- the stuck-session case recoverStuckModelerLogin
+    // exists for. Wait for the document only, then recover if it is stuck.
+    await page.reload({ waitUntil: 'domcontentloaded' });
+    await (0, sessionRecovery_1.recoverStuckModelerLogin)(page);
     await (0, sleep_1.sleep)(5000);
     await modelerCreatePage.fillStartEventVariablesForDocHandling(zeebeUrl, zeebeClientId, zeebeClientSecret);
     await modelerCreatePage.runProcessInstance(clusterName);

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

@@ -22,7 +22,6 @@ declare class AppsPage {
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
     private expandHubClusterGroup;
-    private expandHubSidebar;
     private showAllWorkspaces;
     private clickHubClusterApp;
     private isOnHub;

package/dist/pages/8.8/AppsPage.js

@@ -113,11 +113,6 @@ class AppsPage {
         // /workspaces, right after a mid-test re-login. Route through the same
         // clickModeler() recovery whenever the toggle itself hasn't shown up
         // either, not only when the whole sidebar is missing.
-        // Before deciding whether the group is reachable: a collapsed rail hides
-        // every cluster trigger, so the probe below would report "not ready" and
-        // the recovery would then wait out its own timeout on the same hidden
-        // element.
-        await this.expandHubSidebar();
         const sidebarReady = (await this.hubSidebar.isVisible({ timeout: 5000 }).catch(() => false)) &&
             (await toggle
                 .waitFor({ state: 'visible', timeout: 10000 })
@@ -126,18 +121,21 @@ class AppsPage {
         if (!sidebarReady) {
             await this.clickModeler();
             await (0, test_1.expect)(this.hubSidebar).toBeVisible({ timeout: 30000 });
-            // Since camunda-hub #28956 the Workspaces overview defaults to "My
-            // workspaces" -- only the ones the current user is an EXPLICIT member
-            // of -- and resets to it on every load. The shared workspace is created
-            // by whichever setup user won the race, so a role-flow user lands on
-            // "No workspaces match this filter / You don't have explicit membership
-            // in any workspace in this organization" (confirmed live) and the
-            // sidebar never renders this cluster's group. Widening the scope is
-            // what makes it appear; without it the wait below can only time out.
-            // ModelerHomePage.showAllWorkspaces() covers the project-folder paths,
-            // but nothing covered the app-switcher path until here.
-            await this.showAllWorkspaces(5000);
-            await this.expandHubSidebar();
+            // Hub's Workspaces overview defaults to "My workspaces" -- only the
+            // ones the current user is an EXPLICIT member of -- and resets to it on
+            // every load (camunda-hub #28956). That default is what a real user
+            // sees, so leave it alone and widen only when this cluster's group is
+            // genuinely not in it: the shared workspace is created by whichever
+            // setup user won the race, so a role-flow user otherwise lands on "You
+            // don't have explicit membership in any workspace in this
+            // organization" and the group never renders.
+            const groupUnderDefaultScope = await toggle
+                .waitFor({ state: 'visible', timeout: 10000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!groupUnderDefaultScope) {
+                await this.showAllWorkspaces(5000);
+            }
             await (0, test_1.expect)(toggle).toBeVisible({ timeout: 30000 });
         }
         // camunda-hub's own nav-shell-ds.spec.saas.tsx documents the actual
@@ -211,26 +209,6 @@ class AppsPage {
     // Apps -> Modeler navigation path circular. The control is absent outside
     // Hub and for non-elevated users, where a membership-scoped list is already
     // correct, so a missing control is a no-op.
-    // Opens Hub's collapsed left rail. While collapsed it shows only the
-    // top-level nav icons: the per-cluster group triggers are in the DOM
-    // (data-slot="app-sidebar-group-trigger", aria-label="<cluster>") but never
-    // visible, so a toBeVisible() wait on one can only time out. A failing run's
-    // trace carries "Expand sidebar" seven times and "Collapse sidebar" not
-    // once, i.e. the rail stayed shut for its whole duration. A no-op when the
-    // rail is already open, since the toggle is then labelled "Collapse sidebar".
-    async expandHubSidebar() {
-        const expandToggle = this.page
-            .getByRole('button', { name: 'Expand sidebar' })
-            .or(this.page
-            .locator('[data-slot="app-sidebar-collapse-toggle"]')
-            .and(this.page.getByLabel('Expand sidebar')))
-            .first();
-        if (!(await expandToggle.isVisible().catch(() => false))) {
-            return;
-        }
-        await expandToggle.click({ timeout: 10000 });
-        await (0, test_1.expect)(expandToggle).toBeHidden({ timeout: 10000 });
-    }
     async showAllWorkspaces(probeTimeout) {
         // The empty state offers an explicit "Switch to All workspaces" button
         // next to "You don't have explicit membership in any workspace in this

package/dist/pages/8.8/WorkspaceMembersPage.d.ts

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+type WorkspaceRole = 'Workspace Admin' | 'Editor' | 'Commenter' | 'Viewer';
+declare class WorkspaceMembersPage {
+    private page;
+    readonly membersTab: Locator;
+    readonly manageMembersHeading: Locator;
+    readonly addMembersButton: Locator;
+    readonly addMemberSearchbox: Locator;
+    readonly addMemberSubmitButton: Locator;
+    constructor(page: Page);
+    showAllWorkspaces(): Promise<void>;
+    openManageMembers(workspaceName: string): Promise<void>;
+    private memberRow;
+    isMember(email: string): Promise<boolean>;
+    addMember(email: string, role: WorkspaceRole): Promise<void>;
+    private selectRoleIn;
+    setMemberRole(email: string, role: WorkspaceRole): Promise<void>;
+    removeMember(email: string): Promise<void>;
+}
+export { WorkspaceMembersPage, WorkspaceRole };

package/dist/pages/8.8/WorkspaceMembersPage.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceMembersPage = void 0;
+const test_1 = require("@playwright/test");
+// Camunda Hub's workspace "Manage members" view: Members / Environments /
+// General tabs over a member table of Name | Email | Workspace role | Joined,
+// an "Add members" panel, and a role cell that becomes a select once clicked.
+//
+// This page matters to the role flows because an organization role alone no
+// longer decides what a non-admin can reach. Since camunda-hub's environments
+// work, an environment -- and so the cluster app behind it -- is visible only
+// to a user who is Editor or Workspace Admin on a workspace it is assigned to
+// (pdp-3715); organization admins and owners see every environment.
+class WorkspaceMembersPage {
+    page;
+    membersTab;
+    manageMembersHeading;
+    addMembersButton;
+    addMemberSearchbox;
+    addMemberSubmitButton;
+    constructor(page) {
+        this.page = page;
+        this.membersTab = page.getByRole('tab', { name: 'Members' });
+        this.manageMembersHeading = page.getByRole('heading', {
+            name: 'Manage members',
+        });
+        this.addMembersButton = page
+            .locator('[data-test="add-members-button"]')
+            .or(page.getByRole('button', { name: 'Add members' }))
+            .first();
+        // A cmdk combobox: <input cmdk-input role="combobox"
+        // aria-label="Search members" placeholder="Search members or enter an
+        // email to invite">. Prefer the accessible name over the placeholder,
+        // which is the longer and more churn-prone of the two.
+        this.addMemberSearchbox = page
+            .getByRole('combobox', { name: 'Search members' })
+            .or(page.getByPlaceholder('Search members or enter an email to invite'))
+            .first();
+        // `exact` matters: the panel's own trigger is "Add members", which a
+        // substring match on "Add" would also resolve.
+        this.addMemberSubmitButton = page.getByRole('button', {
+            name: 'Add',
+            exact: true,
+        });
+    }
+    // Hub's Workspaces overview defaults to "My workspaces" -- only the ones the
+    // current user is an explicit member of -- and resets to it on every load,
+    // so a workspace created by another user is invisible until the scope is
+    // widened. The empty state offers an explicit button; the populated view
+    // offers the filter instead. A no-op where neither is rendered.
+    async showAllWorkspaces() {
+        const switchButton = this.page.getByRole('button', {
+            name: 'Switch to All workspaces',
+        });
+        const scopeFilter = this.page.getByRole('combobox', {
+            name: 'Filter workspaces',
+        });
+        const appeared = await switchButton
+            .or(scopeFilter)
+            .first()
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!appeared) {
+            return;
+        }
+        if (await switchButton.isVisible().catch(() => false)) {
+            await switchButton.click({ timeout: 10000 });
+            await (0, test_1.expect)(switchButton).toBeHidden({ timeout: 10000 });
+            return;
+        }
+        if ((await scopeFilter.innerText()).includes('All workspaces')) {
+            return;
+        }
+        await scopeFilter.click({ timeout: 10000 });
+        await this.page
+            .getByRole('option', { name: 'All workspaces' })
+            .click({ timeout: 10000 });
+        await (0, test_1.expect)(scopeFilter).toContainText('All workspaces', {
+            timeout: 10000,
+        });
+    }
+    async openManageMembers(workspaceName) {
+        // `.first()`: an org can hold several workspaces sharing a name -- the
+        // nightly's environments card lists "Cross Component Test Project" twice
+        // -- and an unqualified match is then a strict-mode violation.
+        const manageButton = this.page
+            .getByRole('button', { name: `Manage workspace ${workspaceName}` })
+            .first();
+        // Keep Hub's default "My workspaces" scope, which is what a real user
+        // sees, and widen only when the target is not in it -- e.g. it was
+        // created by another user and this one holds no explicit membership.
+        const visibleUnderDefaultScope = await manageButton
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!visibleUnderDefaultScope) {
+            await this.showAllWorkspaces();
+        }
+        await (0, test_1.expect)(manageButton).toBeVisible({ timeout: 60000 });
+        await manageButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.manageMembersHeading).toBeVisible({ timeout: 60000 });
+        if ((await this.membersTab
+            .getAttribute('aria-selected')
+            .catch(() => null)) !== 'true') {
+            await this.membersTab.click({ timeout: 30000 });
+        }
+    }
+    memberRow(email) {
+        return this.page.getByRole('row').filter({ hasText: email }).first();
+    }
+    async isMember(email) {
+        return this.memberRow(email)
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+    }
+    // Adds a user who is not on the member list yet. The panel is collapsed
+    // until its trigger is clicked, and its own "Workspace role" select already
+    // defaults to Editor, so it is only driven when a different role is wanted.
+    async addMember(email, role) {
+        await this.addMembersButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.addMemberSearchbox).toBeVisible({ timeout: 30000 });
+        await this.addMemberSearchbox.click({ timeout: 30000 });
+        await this.addMemberSearchbox.fill(email);
+        // An org member shows up as a pickable result; picking it is what enables
+        // the submit. Typing alone leaves an invite-by-email candidate that some
+        // builds require to be committed the same way.
+        // cmdk renders its results as [cmdk-item] nodes with role="option",
+        // filtered live against what was typed.
+        const result = this.page
+            .getByRole('option', { name: new RegExp(escapeRegExp(email), 'i') })
+            .or(this.page.locator('[cmdk-item]').filter({ hasText: email }))
+            .first();
+        // The result list is a multi-select, and its checkbox is NOT a checkbox:
+        // a trace of the live DOM shows each row as
+        //   <div cmdk-item role="option" data-staged="false" aria-selected="true">
+        //     <svg aria-hidden="true"><rect .../></svg> <div>name / email</div>
+        // so getByRole('checkbox') matches nothing, and clicking the row only
+        // sets cmdk's highlight -- aria-selected and data-selected both read
+        // "true" while data-staged stays "false" and "Add" stays disabled.
+        // Click the leading svg, which is the box itself, and gate on the one
+        // attribute that actually tracks the pick.
+        await (0, test_1.expect)(result).toBeVisible({ timeout: 30000 });
+        // Neither the row nor its box can be clicked into a staged state: the box
+        // is a decorative svg the design system gives `pointer-events: none`, so
+        // that click lands on the row, and a row click only moves cmdk's
+        // highlight -- across three live runs `data-staged` never left "false"
+        // while `aria-selected` read "true" and "Add" stayed disabled. The
+        // list's "Select all" control is what actually stages. It is a
+        // <button data-test="members-picker-select-all">, not a cmdk item, and
+        // its label is split across text nodes ("Select all (", "1", ")"), so it
+        // is addressed by its test id. The search box above has already been
+        // filled with this one address, so the guard below holds it to exactly
+        // the intended user rather than trusting the label's count.
+        const candidates = this.page
+            .locator('[cmdk-item]')
+            .filter({ hasText: email });
+        await (0, test_1.expect)(candidates).toHaveCount(1, { timeout: 15000 });
+        await this.page
+            .locator('[data-test="members-picker-select-all"]')
+            .click({ timeout: 15000 });
+        await (0, test_1.expect)(result).toHaveAttribute('data-staged', 'true', {
+            timeout: 15000,
+        });
+        if (role !== 'Editor') {
+            await this.selectRoleIn(this.page.getByRole('combobox', { name: 'Workspace role' }).first(), role);
+        }
+        await (0, test_1.expect)(this.addMemberSubmitButton).toBeEnabled({ timeout: 30000 });
+        await this.addMemberSubmitButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.memberRow(email)).toBeVisible({ timeout: 60000 });
+    }
+    async selectRoleIn(control, role) {
+        await control.click({ timeout: 30000 });
+        await this.page
+            .getByRole('option', { name: role, exact: true })
+            .or(this.page.getByRole('menuitem', { name: role, exact: true }))
+            .first()
+            .click({ timeout: 30000 });
+    }
+    // Ensures the user holds `role` on this workspace, adding them first when
+    // they are not a member at all -- which is the usual case for a role flow,
+    // since the shared workspace is created by whichever setup user won the
+    // race and nobody else is added to it.
+    async setMemberRole(email, role) {
+        if (!(await this.isMember(email))) {
+            await this.addMember(email, role);
+            return;
+        }
+        const row = this.memberRow(email);
+        if ((await row.getByText(role, { exact: true }).count()) > 0) {
+            return;
+        }
+        // The role cell renders as a static pill until clicked, then becomes a
+        // select with its own confirm control; leaving it unconfirmed silently
+        // reverts the row to its previous role.
+        const roleControl = row
+            .getByRole('combobox')
+            .or(row.getByRole('button', {
+            name: /^(Workspace Admin|Editor|Commenter|Viewer)$/,
+        }))
+            .first();
+        await roleControl.click({ timeout: 30000 });
+        await this.selectRoleIn(roleControl, role);
+        // Clicked unconditionally, not behind an `isVisible()` probe: the
+        // confirmation is what persists the change, and the control can render a
+        // beat after the select. A probe would read `false` in that window, skip
+        // the click, and let the assertion below match the still-uncommitted
+        // value in the open editor just before the row reverts. Clicking outright
+        // makes Playwright wait for the control and fail here when it never
+        // arrives, rather than passing on an edit that was never saved.
+        await row
+            .getByRole('button', { name: /^(Confirm|Save|Apply|Update)$/i })
+            .or(row.locator('button[type="submit"]'))
+            .first()
+            .click({ timeout: 30000 });
+        await (0, test_1.expect)(row.getByText(role, { exact: true })).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    // Undoes `setMemberRole`/`addMember`. Workspace membership is durable org
+    // state: left behind, it survives the test that granted it, so a Playwright
+    // retry starts with the user already an Editor and any assertion about the
+    // un-granted state fails on the second attempt. A no-op when the user is
+    // not on the list, so it is safe to call from teardown after a failure at
+    // any point in the flow.
+    async removeMember(email) {
+        if (!(await this.isMember(email))) {
+            return;
+        }
+        const row = this.memberRow(email);
+        // The destructive action lives behind the row's own overflow menu; its
+        // trigger is an icon button, so it is matched on its accessible name
+        // rather than on text.
+        await row
+            .getByRole('button', { name: /(more|actions|options|menu)/i })
+            .or(row.locator('[data-test="member-row-actions"]'))
+            .first()
+            .click({ timeout: 30000 });
+        await this.page
+            .getByRole('menuitem', { name: /^Remove( member)?$/i })
+            .or(this.page.getByRole('option', { name: /^Remove( member)?$/i }))
+            .first()
+            .click({ timeout: 30000 });
+        // Removal is confirmed in a dialog. Scoped to it so the match cannot
+        // resolve back to the menu item that opened it.
+        const dialog = this.page.getByRole('dialog').first();
+        await dialog
+            .getByRole('button', { name: /^(Remove|Confirm|Delete)$/i })
+            .first()
+            .click({ timeout: 30000 });
+        await (0, test_1.expect)(row).toBeHidden({ timeout: 60000 });
+    }
+}
+exports.WorkspaceMembersPage = WorkspaceMembersPage;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/tests/8.7/connectors-user-flows.spec.js

@@ -182,7 +182,9 @@ _8_7_1.test.describe('Connectors User Flow Tests', () => {
                 timeout: 20000,
             });
             await appsPage.clickCamundaApps();
-            await (0, test_1.expect)(appsPage.modelerLink).toBeVisible({ timeout: 20000 });
+            // No separate modelerLink check: Hub has no app-switcher "Modeler" link
+            // (clickModeler() goes through its home link instead), and on the
+            // legacy shell clickModeler() asserts modelerLink itself.
             await appsPage.clickModeler();
             await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
                 timeout: 120000,

package/dist/tests/8.8/access-user-role-management.spec.js

@@ -6,9 +6,15 @@ const UtilitiesPage_1 = require("../../pages/8.8/UtilitiesPage");
 const sleep_1 = require("../../utils/sleep");
 const resetSession_1 = require("../../utils/resetSession");
 const LoginPage_1 = require("../../pages/8.8/LoginPage");
+const WorkspaceMembersPage_1 = require("../../pages/8.8/WorkspaceMembersPage");
 const test_1 = require("@playwright/test");
 const users_1 = require("../../utils/users");
 const testUser = (0, users_1.getTestUser)('mainUser');
+// The workspace the Analyst flow borrows Editor rights on, and whether that
+// grant is currently outstanding. Read by the teardown below so it only
+// reaches for Hub's Manage members view when there is something to undo.
+const analystWorkspaceName = 'Cross Component Test Project';
+let analystWorkspaceGrantMade = false;
 _8_8_1.test.describe.configure({ mode: 'parallel' });
 _8_8_1.test.describe('User Roles User Flow', () => {
     const clusterNames = {
@@ -35,6 +41,29 @@ _8_8_1.test.describe('User Roles User Flow', () => {
         await (0, _setup_1.captureScreenshot)(page, testInfo);
         await (0, _setup_1.captureFailureVideo)(page, testInfo);
     });
+    // Workspace membership is durable organization state, so the Editor rights
+    // the Analyst flow grants must be handed back whether the test passed or
+    // failed. Left behind, a retry would start with the analyst already an
+    // Editor and its own "not reachable without workspace access" assertion
+    // would fail on the second attempt; the grant would also leak into every
+    // later nightly run against the same org.
+    _8_8_1.test.afterEach(async ({ page, browser }, testInfo) => {
+        if (!testInfo.title.startsWith('Analyst Role User Flow')) {
+            return;
+        }
+        if (!analystWorkspaceGrantMade) {
+            return;
+        }
+        await (0, resetSession_1.resetSession)(browser, page);
+        await new LoginPage_1.LoginPage(page).loginWithTestUser({
+            username: process.env.C8_USERNAME,
+            password: process.env.C8_PASSWORD,
+        });
+        const workspaceMembersPage = new WorkspaceMembersPage_1.WorkspaceMembersPage(page);
+        await workspaceMembersPage.openManageMembers(analystWorkspaceName);
+        await workspaceMembersPage.removeMember(process.env.C8_USERNAME_TEST_9);
+        analystWorkspaceGrantMade = false;
+    });
     // Skipped due to bug #58514: https://github.com/camunda/camunda/issues/58514
     _8_8_1.test.skip('Modeler Role User Flow', async ({ page, modelerHomePage, appsPage, homePage, clusterPage, clusterDetailsPage, context, consoleOrganizationsPage, settingsPage, operateHomePage, ocIdentityHomePage, taskPanelPage, optimizeHomePage, modelerCreatePage, }) => {
         const randomString = await (0, _setup_1.generateRandomStringAsync)(3);
@@ -158,6 +187,72 @@ _8_8_1.test.describe('User Roles User Flow', () => {
                 password: process.env.C8_PASSWORD_TEST_9,
             });
         });
+        // An organization role no longer decides on its own what a non-admin can
+        // reach. Since camunda-hub's environments work (pdp-3443, pdp-3715), a
+        // cluster's apps are surfaced through an ENVIRONMENT, and an environment
+        // is visible only to users who are Editor or Workspace Admin on a
+        // workspace it is assigned to -- organization admins and owners excepted,
+        // who see every environment unconditionally. An Analyst with no workspace
+        // membership therefore reaches nothing, which is the decided design
+        // rather than a defect: "Clusters are shown only to org admins.
+        // Non-admins do not have cluster visibility (they operate with
+        // environments instead)."
+        //
+        // Assert that gate before granting the membership the rest of this test
+        // depends on, so both halves are covered: the role alone grants no
+        // access, and the role plus workspace editorship does.
+        await _8_8_1.test.step('Ensure Optimize is not reachable without workspace access', async () => {
+            // Assert the cause, not just the consequence. Hub shows the analyst an
+            // empty Workspaces overview -- "You don't have explicit membership in
+            // any workspace in this organization" before the scope is widened, and
+            // "Your organization has no workspaces yet" after -- because the
+            // workspace belongs to whoever created it. With no workspace there is
+            // no environment, and with no environment no cluster app, so checking
+            // the Optimize banner alone would pass for unrelated reasons too.
+            await appsPage.clickCamundaApps();
+            await (0, test_1.expect)(page
+                .getByText('Your organization has no workspaces yet')
+                .or(page.getByText("You don't have explicit membership in any workspace"))
+                .first()).toBeVisible({ timeout: 60000 });
+            // Assert the absence of THIS cluster's Optimize target directly rather
+            // than calling clickOptimize() and swallowing whatever it throws: a
+            // swallowed error would let this step pass because the hand-off helper
+            // itself broke and the page simply stayed on Hub, where the Optimize
+            // banner is absent for reasons that have nothing to do with the gate.
+            // On Hub a cluster's apps hang off the sidebar group named for the
+            // cluster, so with no environment neither the group nor the Optimize
+            // link inside it is ever rendered.
+            const hubSidebar = page.getByRole('navigation', {
+                name: 'Main navigation',
+            });
+            await (0, test_1.expect)(hubSidebar.getByRole('button', { name: clusterName })).toHaveCount(0, { timeout: 30000 });
+            await (0, test_1.expect)(hubSidebar.getByRole('link', { name: /Optimize/ })).toHaveCount(0, { timeout: 30000 });
+            await (0, test_1.expect)(optimizeHomePage.optimizeBanner).not.toBeVisible({
+                timeout: 30000,
+            });
+        });
+        await _8_8_1.test.step('Grant the analyst Editor rights on the shared workspace', async () => {
+            // Only an organization admin may change workspace membership, so this
+            // switches to the main user and back rather than doing it as the
+            // analyst under test.
+            await (0, resetSession_1.resetSession)(browser, page);
+            await new LoginPage_1.LoginPage(page).loginWithTestUser({
+                username: process.env.C8_USERNAME,
+                password: process.env.C8_PASSWORD,
+            });
+            const workspaceMembersPage = new WorkspaceMembersPage_1.WorkspaceMembersPage(page);
+            await workspaceMembersPage.openManageMembers(analystWorkspaceName);
+            // Flagged before the grant, not after: a failure partway through
+            // setMemberRole can still have added the member, and teardown must
+            // clean that up too.
+            analystWorkspaceGrantMade = true;
+            await workspaceMembersPage.setMemberRole(process.env.C8_USERNAME_TEST_9, 'Editor');
+            await (0, resetSession_1.resetSession)(browser, page);
+            await new LoginPage_1.LoginPage(page).loginWithTestUser({
+                username: process.env.C8_USERNAME_TEST_9,
+                password: process.env.C8_PASSWORD_TEST_9,
+            });
+        });
         await _8_8_1.test.step('Wait for the role change to reach Optimize', async () => {
             // Replaces a blind `sleep(600000)`. The role change only takes effect in
             // Optimize once its permission cache refreshes, and reaching Optimize is

package/package.json

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