@camunda/e2e-test-suite 0.0.1111 → 0.0.1112

package/dist/pages/8.10/AppsPage.js

@@ -116,7 +116,12 @@ class AppsPage {
         }
     }
     async clickCluster(component, name) {
-        const cluster = component.getByRole('link', { name: name, exact: true });
+        // Cluster names are not unique in an org, so this app's sub-menu can list
+        // the same name twice; pick the first entry (same row the Console cluster
+        // list resolves to) rather than strict-mode failing on the hand-off.
+        const cluster = component
+            .getByRole('link', { name: name, exact: true })
+            .first();
         await (0, test_1.expect)(cluster).toBeVisible({ timeout: 30000 });
         await cluster.click();
     }
@@ -555,7 +560,17 @@ class AppsPage {
             }
             catch (error) {
                 console.warn(`Click attempt ${retries + 1} failed: ${error}`);
-                await new Promise((resolve) => setTimeout(resolve, 10000));
+                // The other three app hand-offs (`clickTasklist`, `clickOperate`,
+                // `clickOptimize`) all reload here; this one only slept, and a slept
+                // retry re-opens the very same apps menu that just failed to list
+                // Console. When the shell is the thing that did not finish rendering
+                // -- the tab is still mid SSO hand-off, or `clickCamundaApps` found
+                // none of its four triggers and returned without opening anything --
+                // nothing changes between attempts and all three burn their 30s wait
+                // on an entry that was never going to appear. Re-render the shell
+                // instead, then let the loop re-open the menu.
+                await this.reloadForRecovery('opening Console');
+                await (0, sleep_1.sleep)(10000);
             }
         }
         throw new Error(`Failed to click the console link after ${maxRetries} attempts.`);

package/dist/pages/8.10/Authorization.js

@@ -103,8 +103,16 @@ class Authorization {
                 name: /delete authorization/i,
             });
     }
+    // The authorizations table paginates, and the RBA clusters these flows run
+    // against are long-lived: every night's run leaves more process-definition
+    // authorizations behind, so the row being asserted is regularly not on the
+    // page currently displayed. Scoping the assertion to the rendered rows then
+    // reports a row that exists as missing. Walk the pages -- the assertion is
+    // unchanged, it is only no longer limited to the first page, and the helper
+    // reloads between attempts so a row the product has not finished
+    // provisioning yet is still given time to appear.
     async assertAuthorization(auth) {
-        await (0, test_1.expect)(this.authorizationsList.getByRole('row').filter({ hasText: auth }).first()).toBeVisible({ timeout: 30000 });
+        await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, this.authorizationsList.getByRole('row').filter({ hasText: auth }).first());
     }
     async createAuthorization(authorization) {
         await this.createAuthorizationButton.click();

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

@@ -66,6 +66,7 @@ declare class ClusterDetailsPage {
     assertAPIClientScopes(name: string): Promise<void>;
     filterClientsList(name: string): Promise<void>;
     clickSettingsTab(): Promise<void>;
+    private waitForAuthorizationsSection;
     enableAuthorizations(): Promise<void>;
     disableAuthorizations(): Promise<void>;
     searchAndClickClientCredentialsLink(name: string): Promise<ClientCredentialsDetailsPage>;

package/dist/pages/8.10/ClusterDetailsPage.js

@@ -294,9 +294,30 @@ class ClusterDetailsPage {
             });
         }).toPass({ timeout: 120000, intervals: [1000, 2000, 5000] });
     }
+    // The Settings panel body is fetched separately from the tab list, so a
+    // selected Settings tab does not guarantee the Authorizations section is
+    // there: when that fetch fails -- or Console lands on its hard-crash banner
+    // ("An error has occurred") on the way in -- the section never renders, and
+    // neither state recovers on its own. A flat 60s wait can then only time out.
+    // Reload and re-open Settings between attempts, which is the same recovery
+    // `clickSettingsTab` already applies to the tab itself.
+    async waitForAuthorizationsSection() {
+        await (0, test_1.expect)(async () => {
+            const rendered = await this.authorizationsHeading
+                .waitFor({ state: 'visible', timeout: 60000 })
+                .then(() => true)
+                .catch(() => false);
+            if (rendered) {
+                return;
+            }
+            await this.page.reload({ waitUntil: 'domcontentloaded' });
+            await this.clickSettingsTab();
+            await (0, test_1.expect)(this.authorizationsHeading).toBeVisible({ timeout: 60000 });
+        }).toPass({ timeout: 300000, intervals: [1000, 2000, 5000] });
+    }
     async enableAuthorizations() {
         await (0, sleep_1.sleep)(5000);
-        await (0, test_1.expect)(this.authorizationsHeading).toBeVisible({ timeout: 60000 });
+        await this.waitForAuthorizationsSection();
         // Locate all elements with class .cds--toggle__text
         const toggleTextElements = await this.page.$$('.cds--toggle__text');
         // Check if toggleTextElements has at least 2 elements
@@ -332,7 +353,7 @@ class ClusterDetailsPage {
         }
     }
     async disableAuthorizations() {
-        await (0, test_1.expect)(this.authorizationsHeading).toBeVisible({ timeout: 60000 });
+        await this.waitForAuthorizationsSection();
         // Locate all elements with class .cds--toggle__text
         const toggleTextElements = await this.page.$$('.cds--toggle__text');
         // Check if toggleTextElements has at least 2 elements

package/dist/pages/8.10/ClusterPage.js

@@ -107,6 +107,17 @@ class ClusterPage {
             .filter({ hasNotText: 'Generation' }); //Filter out header row
         this.tasklistV1Api = page.getByText('Tasklist API v1 (legacy)');
         this.tasklistV2Api = page.getByText('Tasklist API v2');
+        // The Console does not enforce unique cluster names, so an org can end up
+        // holding several clusters under the same name (a create that was retried
+        // after the list-fetch race in clickClustersBreadcrumb, or two runs of the
+        // same spec overlapping on the long-lived RBA clusters). Every name-scoped
+        // locator below is derived from this one, so without .first() a single
+        // leftover duplicate turns each of them into a strict-mode violation and
+        // the spec dies in beforeEach instead of reusing the healthy cluster.
+        // Resolving to the first matching row keeps this accessor singular, which
+        // is how every caller already uses it (isVisible/waitFor/click). Callers
+        // that must act on *all* same-named rows (deleteCluster) re-query in a
+        // loop, so they still walk the duplicates one by one.
         this.cluster = (clusterName) => this.clustersList.filter({
             has: page.getByRole('link', { name: clusterName, exact: true }),
         });
@@ -272,12 +283,9 @@ class ClusterPage {
         // matches every ancestor whose combined text spans the name and a status
         // (the whole app shell does, once a second row carries the same name),
         // which turns this wait into a strict-mode violation.
-        const creatingRow = this.clusterRow(clusterName).filter({
-            hasText: 'Creating',
-        });
-        const clusterRowVisible = this.clusterRow(clusterName).filter({
-            hasText: /Creating|Healthy/,
-        });
+        const clusterRow = this.clusterRow(clusterName);
+        const creatingRow = clusterRow.getByText('Creating', { exact: true });
+        const clusterRowVisible = creatingRow.or(clusterRow.getByText('Healthy', { exact: true }));
         try {
             await (0, test_1.expect)(this.clustersBreadcrumb).toBeVisible({ timeout: 60000 });
             await this.clustersBreadcrumb.click({ timeout: 60000 });

package/dist/pages/8.10/ModelerCreatePage.js

@@ -628,11 +628,14 @@ class ModelerCreatePage {
         await this.deployAndRunSubButton.click({ timeout: 30000 });
     }
     async runProcessInstance(clusterName, variables = '', formVariables = {}, textToVisible = '', hasDeploymentPermission = true, businessId = '') {
-        await this.processApplicationPage.ensureStageCluster(clusterName);
         const maxRetries = 10;
         const retryDelayMs = 20000;
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
+                // Inside the loop, not before it: a no-op once bound, but selectCluster
+                // clears the binding when the dialog does not offer the cluster, so the
+                // next attempt rebinds rather than reopening an unchanged dialog.
+                await this.processApplicationPage.ensureStageCluster(clusterName);
                 await this.clickStartInstanceMainButton();
                 await this.selectCluster(clusterName);
                 if (variables.length > 0) {
@@ -714,7 +717,22 @@ class ModelerCreatePage {
             .isVisible()
             .catch(() => false);
         if (!isLegacyDialog) {
-            await (0, test_1.expect)(this.dialog.getByText(clusterName, { exact: false }).first()).toBeVisible({ timeout: 30000 });
+            const offered = await this.dialog
+                .getByText(clusterName, { exact: false })
+                .first()
+                .waitFor({ state: 'visible', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!offered) {
+                // Forget the binding before failing. The dialog lists exactly the
+                // clusters this application's stages point at, so a missing cluster
+                // means the binding did not take -- and no amount of reopening the
+                // dialog will make it appear. Clearing the record lets the caller's
+                // next attempt rebind instead of re-checking an unchanged dialog.
+                this.processApplicationPage.forgetStageCluster();
+                throw new Error(`The deploy dialog does not offer "${clusterName}": its stage ` +
+                    'binding did not take. It will be rebound on the next attempt.');
+            }
             return;
         }
         const healthyRegex = new RegExp(`${clusterName}.*?HealthydevManage`);
@@ -763,7 +781,11 @@ class ModelerCreatePage {
                 .isVisible()
                 .catch(() => false);
             if (!menuOpen) {
-                await this.clickDiagramBreadcrumb();
+                // Bounded well below the loop budget rather than reusing
+                // `clickDiagramBreadcrumb`'s 60s: at 60s a single reopen is the whole
+                // retry window, so the attempt that would have recovered never got to
+                // run and toPass reported the previous attempt's error instead.
+                await this.diagramBreadcrumb.click({ timeout: 20000 });
             }
             // Park the pointer so the breadcrumb's own tooltip gets a chance to
             // unmount -- best effort, because it is not reliably hover-driven, and
@@ -785,7 +807,13 @@ class ModelerCreatePage {
                 await this.renameDiagramNameButton.dispatchEvent('click');
             }
             await (0, test_1.expect)(this.diagramNameInput).toBeVisible({ timeout: 10000 });
-        }).toPass({ timeout: 60000, intervals: [1000, 2000, 5000] });
+            // The menu also closes on its own: `modelDiagramFromFile` opens it right
+            // after the diagram is picked, and when bpmn-js finishes importing it
+            // takes focus, which dismisses the menu that `isVisible` had just seen.
+            // The click then fails with "Rename" gone from the DOM rather than
+            // intercepted. Reopening is what recovers, so the budget has to fit
+            // several whole attempts, not one.
+        }).toPass({ timeout: 180000, intervals: [1000, 2000, 5000] });
     }
     // The rename can silently no-op: camunda-hub's breadcrumb name editor
     // (InlineEditable) resets its input back to the stored diagram name whenever

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

@@ -8,9 +8,11 @@ declare class TaskProcessesPage {
     readonly waitingForTasksText: Locator;
     readonly searchProcessesSearchbox: Locator;
     readonly processesTab: Locator;
+    readonly tasksTab: Locator;
     constructor(page: Page);
     searchForProcess(name: string): Promise<void>;
     clickpopupContinueButton(): Promise<void>;
+    private openTasksView;
     startProcess(name: string): Promise<void>;
 }
 export { TaskProcessesPage };

package/dist/pages/8.10/TaskProcessesPage.js

@@ -13,6 +13,7 @@ class TaskProcessesPage {
     waitingForTasksText;
     searchProcessesSearchbox;
     processesTab;
+    tasksTab;
     constructor(page) {
         this.page = page;
         this.popupContinueButton = page.getByRole('button', { name: 'Continue' });
@@ -24,6 +25,7 @@ class TaskProcessesPage {
             name: 'Search processes',
         });
         this.processesTab = page.getByRole('link', { name: 'Processes' });
+        this.tasksTab = page.getByRole('link', { name: 'Tasks' });
     }
     // Tasklist's process list is an infinite list that asks for only 12 process
     // definitions at a time (`PROCESS_DEFINITIONS_PAGE_SIZE` in the
@@ -71,6 +73,28 @@ class TaskProcessesPage {
         }
         await (0, test_1.expect)(this.popup.first()).not.toBeVisible({ timeout: 10000 });
     }
+    // Starting a process only lands on the Tasks view when Tasklist manages to
+    // resolve the new instance's user task in time. `startProcessMachine.ts` in
+    // camunda/camunda's orchestration-cluster webapp polls
+    // `queryUserTasks({processInstanceKey})` every second under a hard
+    // `TASKS_TIMEOUT: 15000`; when that elapses the machine goes straight to
+    // `Succeeded` and performs no navigation at all, leaving the browser on the
+    // Processes page -- which never renders the "Available tasks" panel. On
+    // these long-lived SaaS RBA clusters the exporter routinely lags past 15s,
+    // so waiting 90s for a redirect the product gave up on after 15 can only
+    // time out. Open the Tasks view ourselves when the redirect did not happen;
+    // the panel still has to appear, which is what this asserts, and the task
+    // count the caller then takes is what the test is actually about.
+    async openTasksView() {
+        const redirected = await this.availableTasks
+            .waitFor({ state: 'visible', timeout: 30000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!redirected) {
+            await this.tasksTab.click({ timeout: 60000 });
+        }
+        await (0, test_1.expect)(this.availableTasks).toBeVisible({ timeout: 90000 });
+    }
     async startProcess(name) {
         if (process.env.TASKLIST_VERSION === 'v2') {
             await this.searchForProcess(name);
@@ -88,9 +112,7 @@ class TaskProcessesPage {
             await (0, test_1.expect)(this.waitingForTasksText).not.toBeVisible({
                 timeout: 60000,
             });
-            await (0, test_1.expect)(this.availableTasks.first()).toBeVisible({
-                timeout: 90000, //redirection to tasks tab
-            });
+            await this.openTasksView();
         }
         else if (process.env.TASKLIST_VERSION === 'v1') {
             const processStartButton = this.processes
@@ -102,9 +124,7 @@ class TaskProcessesPage {
             await (0, test_1.expect)(this.waitingForTasksText).not.toBeVisible({
                 timeout: 60000,
             });
-            await (0, test_1.expect)(this.availableTasks.first()).toBeVisible({
-                timeout: 90000,
-            });
+            await this.openTasksView();
         }
         else {
             throw new Error(`Unknown TASKLIST_VERSION: ${process.env.TASKLIST_VERSION}`);

package/dist/tests/8.10/rba-enabled-v2-user-flows.spec.js

@@ -314,7 +314,15 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
             await appsPage.openModelerWithRetry(modelerHomePage.modelerPageBanner);
         });
         await _8_10_1.test.step('Navigate to Cross Component Test Project', async () => {
-            await modelerHomePage.clickCrossComponentProjectFolder();
+            // The project folder is per Modeler user, and this is the only test in
+            // the block that assumed it was already there: the other three call the
+            // create-if-missing helper. When the setup project did not manage to
+            // create it for this user, clickCrossComponentProjectFolder() burns its
+            // full 240s retry budget on a tile that will never render. Use the same
+            // helper as the sibling tests — it clicks straight into the folder when
+            // it exists (and guards against creating a duplicate), so nothing changes
+            // on the happy path.
+            await modelerHomePage.createCrossComponentProjectFolder();
         });
         await _8_10_1.test.step('Create Two BPMN Diagrams with User Task and Start Process Instance', async () => {
             await (0, UtilitiesPage_1.runMultipleProcesses)(clusterName, page, modelerHomePage, modelerCreatePage, {

package/package.json

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