@camunda/e2e-test-suite 0.0.1276 → 0.0.1278

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

@@ -21,8 +21,12 @@ declare class AppsPage {
     readonly hubSidebar: Locator;
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
+    private expandHubClusterGroup;
+    private showAllWorkspaces;
     private clickHubClusterApp;
+    private isOnHub;
     clickModeler(): Promise<void>;
+    private clickHubModelerHome;
     /**
      * Waits for the Modeler app to actually render, and recovers the one landing
      * state a hostname check cannot see: Modeler's OAuth `/login-callback`

package/dist/pages/8.8/AppsPage.js

@@ -4,6 +4,9 @@ exports.AppsPage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const UtilitiesPage_1 = require("../8.8/UtilitiesPage");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 class AppsPage {
     page;
     modelerLink;
@@ -85,6 +88,165 @@ class AppsPage {
     // up the app link sidebar-wide rather than scoped to a "group" container
     // that doesn't reliably exist. Ported from pages/8.9/AppsPage.ts, where
     // this shape is already nightly-proven.
+    async expandHubClusterGroup(clusterName) {
+        const toggle = this.hubSidebar
+            .getByRole('button', { name: clusterName })
+            .first();
+        // The diagram editor (and other full-screen views reached from it, e.g.
+        // right after runProcessInstance/deployDiagram) has no "Main navigation"
+        // sidebar at all -- confirmed from a nightly trace's DOM snapshot: the
+        // page's only <nav> is aria-label="Context navigation" (the breadcrumb),
+        // and neither "Operate"/"Tasklist"/"Optimize" nor any app-switcher text
+        // appears anywhere on it. clickCamundaApps() is a no-op on Hub (there is
+        // no switcher panel to open), so a caller reaching clickOperate/
+        // clickTasklist/clickOptimize straight from a diagram was left on a page
+        // this sidebar could never resolve on, no matter how the toggle itself
+        // is matched. Navigate home first, the same way clickModeler() does,
+        // whenever the sidebar isn't already there.
+        //
+        // A freshly re-authenticated page can also land on a workspace-agnostic
+        // route (e.g. bare /workspaces right after loginWithTestUser(), which
+        // clickCamundaApps() does nothing to fix -- it is a no-op on Hub) whose
+        // sidebar renders but has not resolved this cluster's own group yet.
+        // Confirmed from a nightly trace: both the getAttribute and click below
+        // timed out (10s each) against this exact toggle while the URL sat on
+        // /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.
+        const sidebarReady = (await this.hubSidebar.isVisible({ timeout: 5000 }).catch(() => false)) &&
+            (await toggle
+                .waitFor({ state: 'visible', timeout: 10000 })
+                .then(() => true)
+                .catch(() => false));
+        if (!sidebarReady) {
+            await this.clickModeler();
+            await (0, test_1.expect)(this.hubSidebar).toBeVisible({ timeout: 30000 });
+            // 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
+        // shape: "the design system splits the group row into a label control
+        // and a chevron control, both labelled by the cluster name; either one
+        // opens it" -- there is no separate "Toggle <name>" control, and the
+        // child links do not exist in the DOM at all until expanded (not merely
+        // hidden), nor are they nested under any container matchable by cluster
+        // name once expanded. So: find the toggle by the cluster's own name
+        // (`.first()` because both controls share that name), click it, then
+        // look up the app link sidebar-wide rather than scoped to a "group"
+        // container that doesn't reliably exist.
+        // Check THIS cluster's own toggle state, not "is any app link with this
+        // name visible anywhere in the sidebar" -- with more than one cluster in
+        // the org, a DIFFERENT cluster's group can already be expanded (left over
+        // from an earlier action on the same page), and that cluster's own
+        // Operate/Tasklist/Optimize link would satisfy an unscoped visibility
+        // check, skipping expansion of the requested cluster entirely and then
+        // clicking the wrong cluster's link. The child links are not nested under
+        // any container matchable by cluster name once expanded (confirmed
+        // against camunda-hub's own nav-shell-ds.spec.saas.tsx), so the toggle's
+        // own aria-expanded is the only reliable per-cluster signal available.
+        // Not exact: the same suite asserts this row with a substring/regex
+        // match (`{name: /Production/}`), not an exact string -- and nightly
+        // traces confirm why: the rendered toggle's accessible name is not
+        // byte-for-byte the bare cluster name (it carries additional content,
+        // e.g. a trailing tag summary), so an exact-match lookup here finds
+        // nothing and the click below times out waiting on a locator that can
+        // never resolve.
+        const alreadyExpanded = (await toggle.getAttribute('aria-expanded').catch(() => null)) === 'true';
+        if (!alreadyExpanded) {
+            // This is the only expansion action in the Hub path -- swallowing its
+            // failure made a broken expansion look successful and left the caller
+            // to burn the full 30s below waiting on an app link that could never
+            // appear, hiding the actionable error (e.g. a toggle that doesn't
+            // exist or isn't clickable) behind an unrelated timeout.
+            await toggle.click({ timeout: 10000 });
+        }
+        // An app link resolved after this is sidebar-wide (see callers below), so
+        // if an EARLIER call in the same test left a different cluster's group
+        // expanded too, two "Operate" (say) links now exist and that becomes a
+        // strict-mode violation. Collapse every other expanded group before
+        // resolving it -- there is no container to scope the link to instead,
+        // since the child links aren't nested under anything matchable by
+        // cluster name once expanded.
+        // hasNotText filters DOM text content, not the accessible name -- the
+        // expanded chevron can be labelled via aria-label with no text content
+        // 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.
+        const otherExpandedToggles = this.hubSidebar.getByRole('button', {
+            expanded: true,
+            name: new RegExp(`^(?!.*${escapeRegExp(clusterName)}).+$`),
+        });
+        for (let i = 0; i < 5 && (await otherExpandedToggles.count()) > 0; i++) {
+            // Let a failed collapse throw rather than swallowing it: the app link
+            // is intentionally sidebar-wide, so a group left expanded here produces
+            // a strict-mode violation (or the wrong cluster's link) below anyway --
+            // failing at the actual cause is more useful than at that symptom.
+            await otherExpandedToggles.first().click({ timeout: 10000 });
+        }
+    }
+    // Widens Hub's Workspaces scope filter to "All workspaces". Duplicated from
+    // ModelerHomePage.showAllWorkspaces() rather than imported: ModelerHomePage
+    // constructs page objects of its own, and pulling it in here would make the
+    // 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.
+    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
+        // organization" -- prefer it. Driving the combobox alone was not enough:
+        // when its accessible name does not match, the probe below simply
+        // returns and the caller waits out its whole timeout on a page that is
+        // still scoped to "My workspaces" (observed live, twice).
+        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: probeTimeout })
+            .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 clickHubClusterApp(clusterName, appName) {
         // When the sidebar is collapsed (the default on a fresh session), the
         // group toggle opens a Radix popover -- a role="dialog" labelled with the
@@ -104,12 +266,12 @@ class AppsPage {
         // multi-cluster org another cluster's group can already be expanded with
         // the same app name, and the click would then fire on the wrong
         // cluster's link.
-        const collapsedToggle = this.hubSidebar
-            .getByRole('button', { name: clusterName, expanded: false })
-            .first();
-        if (await collapsedToggle.isVisible({ timeout: 5000 }).catch(() => false)) {
-            await collapsedToggle.click({ timeout: 10000 });
-        }
+        // Expansion, sidebar recovery and collapsing every OTHER expanded group
+        // all live in the ported helper: with more than one cluster in the org
+        // (this suite creates Test Cluster and AWS Cluster), a sidebar-wide app
+        // link can otherwise resolve to a different cluster's row, or become a
+        // strict-mode violation once two groups are open.
+        await this.expandHubClusterGroup(clusterName);
         await (0, test_1.expect)(appLink).toBeVisible({ timeout: 30000 });
         // Hub's cluster-app links carry target="_blank", so clicking them opens
         // the app in a new tab while every caller keeps asserting on this.page.
@@ -122,6 +284,11 @@ class AppsPage {
         }
         await appLink.click({ timeout: 10000 });
     }
+    // True once the tab is on a Camunda Hub host, where Modeler home is Hub's
+    // own home rather than a modeler.* hostname.
+    isOnHub() {
+        return new URL(this.page.url()).hostname.startsWith('hub.');
+    }
     async clickModeler() {
         // Camunda Hub (hub.*) replaced Console + Web Modeler on SaaS and has no
         // app switcher. Its home is the Modeler/Workspaces home, but a hostname
@@ -132,22 +299,7 @@ class AppsPage {
         // Navigate home through the header logo link instead, same as
         // ModelerHomePage.clickHomeBreadcrumb -- clicking it when already on the
         // Modeler home is a harmless in-SPA no-op.
-        if (new URL(this.page.url()).hostname.startsWith('hub.')) {
-            const header = this.page.locator('header[data-slot="app-header"]');
-            // The href stays literally "/login" until the client's auth state
-            // catches up just after login (camunda-hub NavShellDs.common.tsx) --
-            // clicking it in that window would log the test out instead of
-            // navigating home, so exclude that href and wait for the authenticated
-            // one rather than racing it.
-            const homeLink = header
-                .getByRole('link', { name: 'Camunda Modeler home' })
-                .and(this.page.locator(':not([href$="/login"])'))
-                .or(header
-                .getByRole('link', { name: 'Camunda Hub home' })
-                .and(this.page.locator(':not([href$="/login"])')))
-                .first();
-            await (0, test_1.expect)(homeLink).toBeVisible({ timeout: 30000 });
-            await homeLink.click({ timeout: 30000 });
+        if (await this.clickHubModelerHome()) {
             return;
         }
         const maxRetries = 5;
@@ -160,6 +312,17 @@ class AppsPage {
         }
         for (let retries = 0; retries < maxRetries; retries++) {
             try {
+                // Re-checked every iteration, not once before the loop. A caller can
+                // reach here from a cluster app (Operate/Tasklist/Identity), which is
+                // NOT a hub.* host, so the pre-loop check above takes the legacy
+                // branch -- but the reload in the catch below lands back on Hub, and
+                // the loop's own success signal (a modeler.* hostname) can never come
+                // true there. A nightly trace shows exactly that: every retry
+                // snapshot sits on hub.ultrawombat.com/workspaces, which IS Modeler
+                // home, while the loop kept failing until it ran out of attempts.
+                if (await this.clickHubModelerHome()) {
+                    return;
+                }
                 await this.clickCamundaApps();
                 await (0, test_1.expect)(this.modelerLink).toBeVisible({ timeout: 30000 });
                 await this.modelerLink.click({ timeout: 30000 });
@@ -194,6 +357,30 @@ class AppsPage {
         }
         throw new Error(`Failed to click the modeler link after ${maxRetries} attempts.`);
     }
+    // Navigates to Hub's Modeler home through the header logo link. Returns
+    // false when this tab is not on a Hub host, so the caller falls through to
+    // the legacy Console app-switcher flow.
+    async clickHubModelerHome() {
+        if (!this.isOnHub()) {
+            return false;
+        }
+        const header = this.page.locator('header[data-slot="app-header"]');
+        // The href stays literally "/login" until the client's auth state
+        // catches up just after login (camunda-hub NavShellDs.common.tsx) --
+        // clicking it in that window would log the test out instead of
+        // navigating home, so exclude that href and wait for the authenticated
+        // one rather than racing it.
+        const homeLink = header
+            .getByRole('link', { name: 'Camunda Modeler home' })
+            .and(this.page.locator(':not([href$="/login"])'))
+            .or(header
+            .getByRole('link', { name: 'Camunda Hub home' })
+            .and(this.page.locator(':not([href$="/login"])')))
+            .first();
+        await (0, test_1.expect)(homeLink).toBeVisible({ timeout: 30000 });
+        await homeLink.click({ timeout: 30000 });
+        return true;
+    }
     /**
      * Waits for the Modeler app to actually render, and recovers the one landing
      * state a hostname check cannot see: Modeler's OAuth `/login-callback`

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

@@ -22,8 +22,13 @@ declare class ClusterDetailsPage {
     readonly clientCredentialsDialog: Locator;
     readonly clustersLink: Locator;
     readonly alertsTab: Locator;
+    readonly alertsPanel: Locator;
     readonly activeTabPanel: Locator;
     readonly alertsList: Locator;
+    readonly alertExpandRowButtons: Locator;
+    readonly alertRowActionsButtons: Locator;
+    readonly deleteAlertMenuItem: Locator;
+    readonly deleteAlertConfirmButton: Locator;
     readonly createFirstAlertButton: Locator;
     readonly createNewAlertButton: Locator;
     readonly emailRadioButton: Locator;
@@ -37,6 +42,7 @@ declare class ClusterDetailsPage {
     readonly expandButton: Locator;
     readonly rbaEnabledMessage: Locator;
     readonly authorizationsHeading: Locator;
+    readonly authorizationsSwitch: Locator;
     readonly orchestrationClusterCheckbox: Locator;
     readonly clientCredentialsLink: (clientCredentials: string) => Locator;
     readonly clientRow: (name: string) => Locator;
@@ -64,6 +70,7 @@ declare class ClusterDetailsPage {
     clickCloseModalButton(): Promise<void>;
     clickSettingsTab(): Promise<void>;
     private waitForAuthorizationsSection;
+    private setAuthorizationsViaSwitch;
     enableAuthorizations(): Promise<void>;
     disableAuthorizations(): Promise<void>;
     searchAndClickClientCredentialsLink(name: string): Promise<ClientCredentialsDetailsPage>;
@@ -76,6 +83,8 @@ declare class ClusterDetailsPage {
     selectEmailRadioButton(): Promise<void>;
     clickCreateAlertButton(): Promise<void>;
     deleteAlerts(): Promise<void>;
+    ensureAlertsTabSelected(): Promise<void>;
+    expandAlerts(): Promise<void>;
     private confirmDelete;
     private dismissDeleteDialog;
     private doDelete;

package/dist/pages/8.8/ClusterDetailsPage.js

@@ -28,8 +28,13 @@ class ClusterDetailsPage {
     clientCredentialsDialog;
     clustersLink;
     alertsTab;
+    alertsPanel;
     activeTabPanel;
     alertsList;
+    alertExpandRowButtons;
+    alertRowActionsButtons;
+    deleteAlertMenuItem;
+    deleteAlertConfirmButton;
     createFirstAlertButton;
     createNewAlertButton;
     emailRadioButton;
@@ -43,6 +48,7 @@ class ClusterDetailsPage {
     expandButton;
     rbaEnabledMessage;
     authorizationsHeading;
+    authorizationsSwitch;
     orchestrationClusterCheckbox;
     clientCredentialsLink;
     clientRow;
@@ -123,12 +129,39 @@ class ClusterDetailsPage {
         this.alertsList = this.activeTabPanel
             .getByRole('row')
             .filter({ hasNotText: 'Delivery method' }); //Filter out header row
+        // Hub's Alerts tab is a design-system data table: one summary row per
+        // alert, its detail fields in a sibling expansion row that only exists
+        // once the row's "Expand row" toggle is clicked, and Delete behind the
+        // row's "Row actions" kebab -> "Delete" -> "Delete alert" dialog. A
+        // nightly trace's DOM carries aria-label="Row actions" and no row-level
+        // "Delete" button at all, which is why doDelete() below saw "no items"
+        // and silently deleted nothing. Same shape as pages/8.9, scoped to the
+        // visible tab panel.
+        this.alertExpandRowButtons = this.activeTabPanel.getByRole('button', {
+            name: 'Expand row',
+            exact: true,
+        });
+        this.alertRowActionsButtons = this.activeTabPanel.getByRole('button', {
+            name: 'Row actions',
+            exact: true,
+        });
+        this.deleteAlertMenuItem = page.getByRole('menuitem', {
+            name: 'Delete',
+            exact: true,
+        });
+        this.deleteAlertConfirmButton = page
+            .getByRole('dialog', { name: 'Delete alert' })
+            .getByRole('button', { name: 'Delete', exact: true });
         this.createFirstAlertButton = page.getByRole('button', {
             name: 'Create an alert',
         });
         this.createNewAlertButton = page.getByRole('button', {
             name: 'Create new alert',
         });
+        // The Alerts panel offers "Create an alert" while empty and "Create new
+        // alert" once it holds one, so either proves the panel itself mounted.
+        // Ported from pages/8.9.
+        this.alertsPanel = this.createFirstAlertButton.or(this.createNewAlertButton);
         this.emailRadioButton = page.getByRole('radio', {
             name: 'Email',
         });
@@ -155,6 +188,14 @@ class ClusterDetailsPage {
         });
         this.expandButton = page.locator('button[class="cds--table-expand__button"]');
         this.rbaEnabledMessage = page.getByText('Authorizations enabled');
+        // Hub's design-system Settings tab renders this as
+        // <button role="switch" data-slot="switch" aria-label="Switch Enable
+        // authorizations" aria-checked="true|false">, confirmed from a live
+        // trace. The Carbon `.cds--toggle__*` nodes the old code indexed into do
+        // not exist there at all.
+        this.authorizationsSwitch = this.page.getByRole('switch', {
+            name: /Enable authorizations/i,
+        });
         this.authorizationsHeading = this.page.getByRole('heading', {
             name: 'Authorizations',
         });
@@ -280,9 +321,34 @@ class ClusterDetailsPage {
             },
         });
     }
+    // Drives the design-system Authorizations switch. Returns false when this
+    // shell does not render one, so the caller can fall through to the legacy
+    // Carbon toggle.
+    async setAuthorizationsViaSwitch(enabled) {
+        if (!(await this.authorizationsSwitch.isVisible().catch(() => false))) {
+            return false;
+        }
+        const isOn = (await this.authorizationsSwitch.getAttribute('aria-checked')) === 'true';
+        if (isOn === enabled) {
+            return true;
+        }
+        await this.authorizationsSwitch.click({ timeout: 30000 });
+        if (await this.dialog.isVisible({ timeout: 15000 }).catch(() => false)) {
+            const confirm = enabled ? this.rbaEnableButton : this.rbaDisableButton;
+            if (await confirm.isVisible().catch(() => false)) {
+                await confirm.click({ timeout: 30000 });
+            }
+            await (0, test_1.expect)(this.page.getByText(enabled ? 'Enabling...' : 'Disabling...')).not.toBeVisible({ timeout: 60000 });
+        }
+        await (0, test_1.expect)(this.authorizationsSwitch).toHaveAttribute('aria-checked', String(enabled), { timeout: 120000 });
+        return true;
+    }
     async enableAuthorizations() {
         await (0, sleep_1.sleep)(5000);
         await this.waitForAuthorizationsSection();
+        if (await this.setAuthorizationsViaSwitch(true)) {
+            return;
+        }
         // Locate all elements with class .cds--toggle__text
         const toggleTextElements = await this.page.$$('.cds--toggle__text');
         // Check if toggleTextElements has at least 2 elements
@@ -316,11 +382,22 @@ class ClusterDetailsPage {
             }
         }
         else {
-            console.log('Toggle text elements not found or less than 2.');
+            // Previously a console.log that returned as though the work were done.
+            // Under Hub neither `.cds--toggle__text` nor `.cds--toggle__switch`
+            // exists, so this branch was taken on every run: authorizations were
+            // never enabled, the cluster kept its "Authorizations disabled" badge,
+            // and nothing downstream noticed until a permission assertion failed
+            // somewhere far away.
+            throw new Error('Could not enable authorizations: the Settings tab rendered neither ' +
+                'the design-system "Enable authorizations" switch nor a Carbon ' +
+                'toggle pair.');
         }
     }
     async disableAuthorizations() {
         await this.waitForAuthorizationsSection();
+        if (await this.setAuthorizationsViaSwitch(false)) {
+            return;
+        }
         // Locate all elements with class .cds--toggle__text
         const toggleTextElements = await this.page.$$('.cds--toggle__text');
         // Check if toggleTextElements has at least 2 elements
@@ -354,7 +431,11 @@ class ClusterDetailsPage {
             }
         }
         else {
-            console.log('Toggle text elements not found or less than 2.');
+            // Same silent no-op as enableAuthorizations had: under Hub no Carbon
+            // toggle exists, so this returned as though it had disabled them.
+            throw new Error('Could not disable authorizations: the Settings tab rendered neither ' +
+                'the design-system "Enable authorizations" switch nor a Carbon ' +
+                'toggle pair.');
         }
     }
     async searchAndClickClientCredentialsLink(name) {
@@ -448,7 +529,65 @@ class ClusterDetailsPage {
         });
     }
     async deleteAlerts() {
-        await this.doDelete(this.dialog, 'Alerts');
+        const hasRowActions = await this.alertRowActionsButtons
+            .first()
+            .waitFor({ state: 'visible', timeout: 10000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!hasRowActions) {
+            await this.doDelete(this.dialog, 'Alerts');
+            return;
+        }
+        let remaining = await this.alertRowActionsButtons.count();
+        while (remaining > 0) {
+            // A re-render can detach the menu between opening it and the click, so
+            // open-menu-and-choose-Delete is retried as one unit.
+            await (0, test_1.expect)(async () => {
+                await this.alertRowActionsButtons.first().click({ timeout: 10000 });
+                await this.deleteAlertMenuItem.click({ timeout: 10000 });
+                await (0, test_1.expect)(this.deleteAlertConfirmButton).toBeVisible({
+                    timeout: 10000,
+                });
+            }).toPass({ timeout: 60000 });
+            await this.deleteAlertConfirmButton.click({ timeout: 30000 });
+            await (0, test_1.expect)(this.alertRowActionsButtons).toHaveCount(remaining - 1, {
+                timeout: 60000,
+            });
+            remaining = await this.alertRowActionsButtons.count();
+        }
+    }
+    // Reveals each alert's detail row, where the design-system table keeps the
+    // recipient, creation date and trigger count the callers assert on. A no-op
+    // on the legacy table, whose detail rows are always rendered.
+    // Re-selects the Alerts tab when it is no longer the showing one. A
+    // page.reload() drops the tab selection and the cluster page comes back on
+    // Overview, whose Environments table supplies the very first row -- which
+    // is how `alertsList.nth(0)` came to read "NameAlert Flow Cluster" instead
+    // of "Email" (console-user-flows.spec.ts reloads and then reads the list
+    // straight away). `alertsList` is scoped to whichever tabpanel is visible,
+    // so restoring the tab is what makes those reads address the alerts table.
+    async ensureAlertsTabSelected() {
+        const selected = await this.alertsTab
+            .getAttribute('aria-selected')
+            .catch(() => null);
+        if (selected === 'true') {
+            return;
+        }
+        await this.clickAlertsTab();
+    }
+    async expandAlerts() {
+        await this.ensureAlertsTabSelected();
+        for (let i = 0; i < 10; i++) {
+            const toggle = this.alertExpandRowButtons.first();
+            if (!(await toggle.isVisible().catch(() => false))) {
+                return;
+            }
+            const before = await this.alertExpandRowButtons.count();
+            await toggle.click({ timeout: 10000 });
+            await (0, test_1.expect)(this.alertExpandRowButtons).toHaveCount(before - 1, {
+                timeout: 10000,
+            });
+        }
     }
     // The confirmation modal only closes once the DELETE request resolves. When
     // that call fails the modal stays open on an inline "We're having trouble
@@ -701,6 +840,18 @@ class ClusterDetailsPage {
                     console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
                     await this.page.reload();
                     await (0, sleep_1.sleep)(20000);
+                    // A reload drops the tab selection, so the Alerts panel is no
+                    // longer the visible one -- `alertsList` is scoped to whichever
+                    // tabpanel is showing, which after a reload is Overview, whose
+                    // first non-header row is the cluster-details "Name" row. That is
+                    // exactly what the nightly reported: `Received string:
+                    // "NameAlert Flow Cluster"`, nine times over, while the Email alert
+                    // sat unread on a tab nobody had re-opened. Re-select the tab, wait
+                    // for the panel to mount, and re-expand the detail rows the
+                    // assertions read from.
+                    await this.alertsTab.click({ timeout: 60000 });
+                    await (0, test_1.expect)(this.alertsPanel).toBeVisible({ timeout: 60000 });
+                    await this.expandAlerts();
                 }
                 else {
                     throw new Error(`Assertion failed after ${maxRetries} attempts`);

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

@@ -47,6 +47,7 @@ declare class ClusterPage {
     private extractClusterIdFromUrl;
     private logClusterCreationInfo;
     createCluster(name: string, region?: string, tasklistV1Api?: boolean): Promise<void>;
+    clickProviderOption(region: string): Promise<void>;
     selectSubRegion(region: string): Promise<void>;
     determineTasklistAPI(tasklistV1Api?: boolean): Promise<void>;
     clickClusterType(): Promise<void>;