@camunda/e2e-test-suite 0.0.1287 → 0.0.1289

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

@@ -19,11 +19,13 @@ declare class AppsPage {
     readonly camundaComponentsButton: Locator;
     readonly camundaAppsButton: Locator;
     readonly hubSidebar: Locator;
+    private hubReturnUrl?;
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
     private expandHubClusterGroup;
     private showAllWorkspaces;
     private clickHubClusterApp;
+    goBackToHub(): Promise<void>;
     private isOnHub;
     clickModeler(): Promise<void>;
     private clickHubModelerHome;
@@ -54,8 +56,10 @@ declare class AppsPage {
     clickCamundaApps(maxRetries?: number): Promise<void>;
     private dismissBlockingModal;
     clickConsoleLink(): Promise<void>;
-    assertOperatePresent(shouldBeVisible?: boolean): Promise<void>;
-    assertTasklistPresent(shouldBeVisible?: boolean): Promise<void>;
-    assertOptimizePresent(shouldBeVisible?: boolean): Promise<void>;
+    private hubClusterAppLink;
+    private assertHubClusterAppPresent;
+    assertOperatePresent(clusterName: string, shouldBeVisible?: boolean): Promise<void>;
+    assertTasklistPresent(clusterName: string, shouldBeVisible?: boolean): Promise<void>;
+    assertOptimizePresent(clusterName: string, shouldBeVisible?: boolean): Promise<void>;
 }
 export { AppsPage };

package/dist/pages/8.8/AppsPage.js

@@ -27,9 +27,19 @@ class AppsPage {
     camundaComponentsButton;
     camundaAppsButton;
     hubSidebar;
+    hubReturnUrl;
     constructor(page) {
         this.page = page;
-        this.modelerLink = page.getByRole('link', { name: 'Modeler', exact: true });
+        // Hub has no "Modeler" switcher entry; Modeler is Hub's home, reached
+        // through the header logo link clickHubModelerHome() uses
+        // (NavShellDs.common.tsx). The final .first() keeps this strict-safe on a
+        // page that carries both.
+        this.modelerLink = page
+            .getByRole('link', { name: 'Modeler', exact: true })
+            .or(page
+            .locator('header[data-slot="app-header"]')
+            .getByRole('link', { name: /^Camunda (Modeler|Hub) home$/ }))
+            .first();
         this.appSwitcherButton = page.getByLabel('App Switcher');
         this.tasklistLink = page.getByRole('link', { name: 'Tasklist', exact: true });
         this.identityLink = page.getByRole('link', { name: /^(Admin|Identity)$/ });
@@ -253,14 +263,8 @@ class AppsPage {
         // cluster name and portalled OUTSIDE the "Main navigation" <nav> -- so a
         // sidebar-scoped lookup finds nothing there. Look in that popover first;
         // keep the sidebar-scoped lookup for the expanded-sidebar layout, where
-        // the links render inline. Not exact: the rendered accessible name
-        // carries more than the bare app name (e.g. "Operate in <cluster>
-        // (opens in a new tab)").
-        const appLink = this.page
-            .getByRole('dialog', { name: clusterName, exact: true })
-            .getByRole('link', { name: appName })
-            .or(this.hubSidebar.getByRole('link', { name: appName }))
-            .first();
+        // the links render inline.
+        const appLink = this.hubClusterAppLink(clusterName, appName);
         // Decide whether to expand from clusterName's OWN toggle state, not from
         // whether "some" appLink is already visible sidebar-wide: in a
         // multi-cluster org another cluster's group can already be expanded with
@@ -279,11 +283,22 @@ class AppsPage {
         // navigation the Console app switcher gave these callers.
         const href = await appLink.getAttribute('href');
         if (href) {
+            this.hubReturnUrl = this.page.url();
             await this.page.goto(new URL(href, this.page.url()).toString());
             return;
         }
         await appLink.click({ timeout: 10000 });
     }
+    // Returns from an app that clickHubClusterApp opened. page.goBack() alone
+    // can stop on one of the app's own login-redirect history entries, and the
+    // next Hub sidebar lookup then runs against the app instead of Hub.
+    async goBackToHub() {
+        await this.page.goBack();
+        if (this.hubReturnUrl &&
+            !new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.page.goto(this.hubReturnUrl);
+        }
+    }
     // True once the tab is on a Camunda Hub host, where Modeler home is Hub's
     // own home rather than a modeler.* hostname.
     isOnHub() {
@@ -459,10 +474,7 @@ class AppsPage {
     }
     async clickIdentity(clusterName) {
         if (new URL(this.page.url()).hostname.startsWith('hub.')) {
-            // Non-anchored, matching the substring lookup clickHubClusterApp uses
-            // for Operate/Tasklist/Optimize -- an anchored pattern fails the same
-            // way an exact-string match did for those apps if the rendered link's
-            // accessible name carries any extra content (icon/badge).
+            // Identity should be removed once camunda/camunda#46447 is fixed.
             await this.clickHubClusterApp(clusterName, /Admin|Identity/);
             return;
         }
@@ -716,17 +728,26 @@ class AppsPage {
             .catch(() => { });
     }
     async clickConsoleLink() {
-        // Camunda Hub replaced Console on SaaS: there is no "Console" entry in a
-        // switcher, and the org-scoped Console area is the sidebar's
-        // Clusters/Environments section. Going there is what callers assert on
-        // (HomePage.consoleBanner resolves to Hub's authenticated header).
+        // Camunda Hub folded Console into the same persistent shell as
+        // Modeler/home: Console's Dashboard/Clusters/Organization links are just
+        // another section of the same "Main navigation" sidebar, not a separate
+        // app to switch into. Its header banner (homePage.consoleBanner, via
+        // hubHeader) is already visible from any Hub page, so there is no
+        // navigation action needed here -- mirrors the same hostname guard in
+        // clickModeler(). Clicking the sidebar's Clusters/Environments link is
+        // not just unnecessary but wrong: Hub shows that section only to org
+        // admins, so requiring it broke every RBA step that reaches here as a
+        // handed-off non-admin test user. Callers that do need the Clusters page
+        // call clickClusters() themselves; the rest assert consoleBanner.
+        //
+        // The diagram editor is the exception: it has no "Main navigation"
+        // sidebar at all, so a caller arriving from "Deploy & run" would find
+        // nothing here. Go home first there.
         if (new URL(this.page.url()).hostname.startsWith('hub.')) {
-            const consoleArea = this.hubSidebar
-                .locator('a[href$="/clusters"]')
-                .or(this.hubSidebar.locator('a[href$="/environments"]'))
-                .first();
-            await (0, test_1.expect)(consoleArea).toBeVisible({ timeout: 30000 });
-            await consoleArea.click({ timeout: 30000 });
+            if (!(await this.hubSidebar.isVisible().catch(() => false))) {
+                await this.clickModeler();
+                await (0, test_1.expect)(this.hubSidebar).toBeVisible({ timeout: 30000 });
+            }
             return;
         }
         const maxRetries = 3;
@@ -750,7 +771,46 @@ class AppsPage {
         }
         throw new Error(`Failed to click the console link after ${maxRetries} attempts.`);
     }
-    async assertOperatePresent(shouldBeVisible = true) {
+    // Hub's replacement for the app switcher: a cluster's apps are the child
+    // links of its own sidebar group. Hub names every app link "<app> in
+    // <environment>", plus " (opens in a new tab)" when it leads to the live app
+    // (camunda-hub environment-sidebar-rows.ts) -- the nightly traces carry both
+    // shapes ("Operate in Third RBA V2 Cluster", "Admin in Admin Role Cluster
+    // (opens in a new tab)"). Anchor both halves rather than matching the bare
+    // app name: the flyout's first link is "Details of <environment>", so for
+    // "Admin Role Cluster" a bare /Admin|Identity/ resolved to that link, and
+    // inline it resolved to "Operate in Admin Role Cluster (opens in a new
+    // tab)", which precedes the Admin link. Anchoring on the environment also
+    // stops "Test Cluster" matching "UI Test Cluster".
+    hubClusterAppLink(clusterName, appName) {
+        const appPattern = typeof appName === 'string' ? escapeRegExp(appName) : appName.source;
+        const cluster = escapeRegExp(clusterName);
+        const appLinkName = new RegExp(`^(?:${appPattern}) in ${cluster}(?: \\(opens in a new tab\\))?$`);
+        return this.page
+            .getByRole('dialog', { name: clusterName, exact: true })
+            .getByRole('link', { name: appLinkName })
+            .or(this.hubSidebar.getByRole('link', { name: appLinkName }))
+            .first();
+    }
+    async assertHubClusterAppPresent(clusterName, appName, shouldBeVisible) {
+        const appLink = this.hubClusterAppLink(clusterName, appName);
+        // Not expanded for an absence check: expandHubClusterGroup throws when
+        // the user cannot see the environment at all, which is a pass here.
+        if (!shouldBeVisible) {
+            await (0, test_1.expect)(appLink).toBeHidden({ timeout: 30000 });
+            return;
+        }
+        await this.expandHubClusterGroup(clusterName);
+        await (0, test_1.expect)(appLink).toBeVisible({ timeout: 30000 });
+    }
+    // On Hub the cluster name is what scopes the lookup: there is no app
+    // switcher panel listing apps org-wide, only each cluster's own sidebar
+    // group.
+    async assertOperatePresent(clusterName, shouldBeVisible = true) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.assertHubClusterAppPresent(clusterName, 'Operate', shouldBeVisible);
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -779,7 +839,12 @@ class AppsPage {
         }
         throw new Error(`Failed to assert the operate link visibility after ${maxRetries} attempts.`);
     }
-    async assertTasklistPresent(shouldBeVisible = true) {
+    // See assertOperatePresent for the clusterName/Hub note.
+    async assertTasklistPresent(clusterName, shouldBeVisible = true) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.assertHubClusterAppPresent(clusterName, 'Tasklist', shouldBeVisible);
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
@@ -808,7 +873,12 @@ class AppsPage {
         }
         throw new Error(`Failed to assert the tasklist link visibility after ${maxRetries} attempts.`);
     }
-    async assertOptimizePresent(shouldBeVisible = true) {
+    // See assertOperatePresent for the clusterName/Hub note.
+    async assertOptimizePresent(clusterName, shouldBeVisible = true) {
+        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
+            await this.assertHubClusterAppPresent(clusterName, 'Optimize', shouldBeVisible);
+            return;
+        }
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
             try {

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

@@ -103,6 +103,8 @@ declare class ModelerCreatePage {
     readonly timerValue: Locator;
     readonly eighthPlacedElement: Locator;
     readonly deployAndRunMainButton: Locator;
+    readonly deployRunActions: Locator;
+    readonly deployAndRunMenuItem: Locator;
     readonly deployAndRunSubButton: Locator;
     readonly dialog: Locator;
     readonly backupDeployButton: Locator;
@@ -141,6 +143,7 @@ declare class ModelerCreatePage {
     clickAdditionalActionsButton(): Promise<void>;
     clickDeployMenuItem(): Promise<void>;
     deployDiagram(clusterName: string): Promise<void>;
+    assertDeployAndRunNotPermitted(): Promise<void>;
     clickStartInstanceMainButton(): Promise<void>;
     clickStartInstanceSubButton(): Promise<void>;
     runProcessInstance(clusterName: string, variables?: string, formVariables?: {

package/dist/pages/8.8/ModelerCreatePage.js

@@ -115,6 +115,8 @@ class ModelerCreatePage {
     timerValue;
     eighthPlacedElement;
     deployAndRunMainButton;
+    deployRunActions;
+    deployAndRunMenuItem;
     deployAndRunSubButton;
     dialog;
     backupDeployButton;
@@ -160,6 +162,13 @@ class ModelerCreatePage {
             name: 'Deploy & run',
             exact: true,
         });
+        // camunda-hub deploy-run-combo-action: both the Carbon ComboButton and
+        // the design-system SplitButton carry this test id.
+        this.deployRunActions = page.getByTestId('deploy-run-actions');
+        this.deployAndRunMenuItem = page.getByRole('menuitem', {
+            name: 'Deploy & run',
+            exact: true,
+        });
         this.deployAndRunSubButton = this.dialog.getByRole('button', {
             name: 'Deploy & run',
             exact: true,
@@ -674,6 +683,22 @@ class ModelerCreatePage {
         await (0, test_1.expect)(this.viewProcessLink).toBeVisible({ timeout: 30000 });
         await (0, test_1.expect)(this.viewProcessLink).toBeHidden({ timeout: 30000 });
     }
+    // For a user whose org role lacks instance/workflow create permissions,
+    // Hub's checkIfAllowedToRun is false: the split button's primary action
+    // becomes "Deploy" and "Deploy & run" moves into its menu, disabled
+    // (camunda-hub BPMNDeployAndRunButtonsDs.tsx, deploy-run-permission.saas.ts).
+    // The Console-era expectation of a deploy that is attempted and then fails
+    // cannot happen, so assert the gate itself.
+    async assertDeployAndRunNotPermitted() {
+        await (0, test_1.expect)(this.deployRunActions.getByRole('button', { name: 'Deploy', exact: true })).toBeVisible({ timeout: 60000 });
+        await (0, test_1.expect)(this.deployAndRunMainButton).toHaveCount(0);
+        await this.deployRunActions
+            .getByRole('button', { name: 'Additional actions' })
+            .click({ timeout: 30000 });
+        await (0, test_1.expect)(this.deployAndRunMenuItem).toBeVisible({ timeout: 30000 });
+        await (0, test_1.expect)(this.deployAndRunMenuItem).toBeDisabled();
+        await this.page.keyboard.press('Escape');
+    }
     async clickStartInstanceMainButton() {
         // ensureStageCluster runs immediately before this on every runProcessInstance
         // attempt and navigates twice, so the diagram's action bar may belong to a

package/dist/pages/8.8/UtilitiesPage.js

@@ -83,8 +83,13 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
             // for the tab's whole lifetime; without clearing it here alongside
             // cookies/storage, a flow that logs a different user into the same
             // page could have getUserToken() return the PREVIOUS user's token.
-            (0, consoleApiHelpers_1.resetHubBearerToken)(page);
+            // Listen from before Hub loads: an API helper called later on an idle
+            // Hub page would otherwise find no request carrying the token.
+            (0, consoleApiHelpers_1.observeBearerTokens)(page);
             await page.goto('about:blank');
+            // After about:blank: until then the previous user's Hub page can still
+            // send a request, and its token must not count for the new session.
+            (0, consoleApiHelpers_1.resetHubBearerToken)(page);
             await page
                 .evaluate(() => {
                 try {
@@ -409,24 +414,36 @@ async function enableAuthorizations(clusterName, homePage, clusterPage, clusterD
 }
 exports.enableAuthorizations = enableAuthorizations;
 async function assertLatestAlertEmail(id, mailSlurp, processName, alertText) {
-    const maxRetries = 3;
-    for (let retries = 0; retries < maxRetries; retries++) {
-        try {
-            const email = await mailSlurp.waitForLatestEmail(id, 120000);
-            if (email && email.body) {
-                (0, test_1.expect)(email.body).toContain(processName);
-                (0, test_1.expect)(email.body).toContain(alertText);
-                return email.body;
-            }
-            else {
-                throw new Error('Email or email body is null or undefined.');
+    // Search the whole inbox for an email carrying alertText rather than asking
+    // for the "latest" one. waitForLatestEmail is documented as returning the
+    // last received email immediately when the inbox is NOT empty ("If you need
+    // to wait for an email for a non-empty inbox see the other receive methods"
+    // -- mailslurp-client's own JSDoc), and the alert flow calls this twice on
+    // the same inbox: the second call kept resolving to the first alert's mail
+    // ("New Incidents: 1") and failed its "New Incidents: 2" assertion on every
+    // retry, since retrying re-read the same already-delivered email. Matching
+    // on content also tolerates the alert sending more mails than the two this
+    // flow asserts on, and ordering between them.
+    let body;
+    await (0, test_1.expect)(async () => {
+        // minCount/retryTimeout make the server itself hold the request open until
+        // the inbox has grown, so this does not busy-poll between attempts.
+        const previews = await mailSlurp.getEmails(id, {
+            minCount: 1,
+            retryTimeout: 60000,
+        });
+        for (const preview of previews) {
+            const email = await mailSlurp.getEmail(preview.id);
+            if (email?.body?.includes(processName) &&
+                email.body.includes(alertText)) {
+                body = email.body;
+                return;
             }
         }
-        catch (error) {
-            console.warn(`Click attempt ${retries + 1} failed: ${error}`);
-        }
-    }
-    throw new Error(`Failed to get latest alert (${processName}) email for ${id} after ${maxRetries} attempts.`);
+        throw new Error(`No alert email for "${processName}" containing "${alertText}" in ` +
+            `inbox ${id} yet (${previews.length} mail(s) present)`);
+    }).toPass({ timeout: 360000, intervals: [5000, 10000, 20000] });
+    return body;
 }
 exports.assertLatestAlertEmail = assertLatestAlertEmail;
 async function clickInvitationLinkInEmail(page, id, mailSlurp) {

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

@@ -10,6 +10,7 @@ declare class WorkspaceMembersPage {
     constructor(page: Page);
     showAllWorkspaces(): Promise<void>;
     openManageMembers(workspaceName: string): Promise<void>;
+    workspaceId(): string;
     private memberRow;
     isMember(email: string): Promise<boolean>;
     addMember(email: string, role: WorkspaceRole): Promise<void>;

package/dist/pages/8.8/WorkspaceMembersPage.js

@@ -106,6 +106,14 @@ class WorkspaceMembersPage {
             await this.membersTab.click({ timeout: 30000 });
         }
     }
+    // Valid once openManageMembers has landed on /workspaces/<id>/manage.
+    workspaceId() {
+        const id = this.page.url().match(/\/workspaces\/([^/?#]+)\/manage/)?.[1];
+        if (!id) {
+            throw new Error(`Not on a workspace Manage page, cannot read its id: ${this.page.url()}`);
+        }
+        return decodeURIComponent(id);
+    }
     memberRow(email) {
         return this.page.getByRole('row').filter({ hasText: email }).first();
     }
@@ -229,12 +237,11 @@ class WorkspaceMembersPage {
             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.
+        // camunda-hub MembersTable.tsx: the row's icon trigger is
+        // aria-label="Actions for <name>", data-test="member-actions-trigger".
         await row
-            .getByRole('button', { name: /(more|actions|options|menu)/i })
-            .or(row.locator('[data-test="member-row-actions"]'))
+            .locator('[data-test="member-actions-trigger"]')
+            .or(row.getByRole('button', { name: /^Actions for / }))
             .first()
             .click({ timeout: 30000 });
         await this.page
@@ -242,11 +249,15 @@ class WorkspaceMembersPage {
             .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 })
+        // RemoveMemberDialog.tsx is a Radix AlertDialog, i.e. role="alertdialog",
+        // which getByRole('dialog') does NOT match -- the confirm button was
+        // unreachable. Prefer its own test id and keep the role lookup as a
+        // fallback.
+        await this.page
+            .locator('[data-test="remove-member-confirm"]')
+            .or(this.page
+            .getByRole('alertdialog', { name: 'Remove member' })
+            .getByRole('button', { name: 'Remove', exact: true }))
             .first()
             .click({ timeout: 30000 });
         await (0, test_1.expect)(row).toBeHidden({ timeout: 60000 });

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

@@ -19,9 +19,13 @@ declare class AppsPage {
     readonly camundaComponentsButton: Locator;
     readonly camundaAppsButton: Locator;
     readonly hubSidebar: Locator;
+    private hubReturnUrl?;
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
+    private expandHubClusterGroup;
+    private showAllWorkspaces;
     private clickHubClusterApp;
+    goBackToHub(): Promise<void>;
     clickModeler(): Promise<void>;
     clickTasklist(clusterName: string): Promise<void>;
     clickAdmin(clusterName: string): Promise<void>;
@@ -35,8 +39,10 @@ declare class AppsPage {
     clickCamundaApps(maxRetries?: number): Promise<void>;
     private dismissBlockingOverlays;
     clickConsoleLink(): Promise<void>;
-    assertOperatePresent(shouldBeVisible?: boolean): Promise<void>;
-    assertTasklistPresent(shouldBeVisible?: boolean): Promise<void>;
-    assertOptimizePresent(shouldBeVisible?: boolean): Promise<void>;
+    private hubClusterAppLink;
+    private assertHubClusterAppPresent;
+    assertOperatePresent(clusterName: string, shouldBeVisible?: boolean): Promise<void>;
+    assertTasklistPresent(clusterName: string, shouldBeVisible?: boolean): Promise<void>;
+    assertOptimizePresent(clusterName: string, shouldBeVisible?: boolean): Promise<void>;
 }
 export { AppsPage };