@camunda/e2e-test-suite 0.0.944 → 0.0.945

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

@@ -21,7 +21,12 @@ declare class AppsPage {
     constructor(page: Page);
     clickCluster(component: Locator, name: string): Promise<void>;
     clickModeler(): Promise<void>;
+    private isModelerAuthTransit;
+    openModelerWithRetry(banner: Locator, timeout?: number, maxRetries?: number): Promise<void>;
+    openOperateWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
     clickTasklist(clusterName: string): Promise<void>;
+    openTasklistWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
+    openOptimizeWithRetry(banner: Locator, clusterName: string, timeout?: number, maxRetries?: number): Promise<void>;
     clickAdmin(clusterName: string): Promise<void>;
     private doClickClusterInOperate;
     private doClickClusterInTasklist;

package/dist/pages/8.10/AppsPage.js

@@ -113,6 +113,99 @@ class AppsPage {
         }
         throw new Error(`Failed to click the modeler link after ${maxRetries} attempts.`);
     }
+    // True while the tab is still inside the Modeler's OAuth hand-off rather
+    // than on a Modeler page: `modeler.<host>/login` bounces through the IdP and
+    // commits `/login-callback?code=...` before the app itself renders.
+    isModelerAuthTransit() {
+        try {
+            const { hostname, pathname } = new URL(this.page.url());
+            return (hostname.startsWith('modeler.') &&
+                /^\/login(-callback)?\/?$/.test(pathname));
+        }
+        catch {
+            // Not a parsable URL yet (e.g. a tab still on about:blank).
+            return false;
+        }
+    }
+    // The Modeler OAuth handshake occasionally stalls on
+    // `modeler.<host>/login-callback?code=...`: the tab stays on the callback
+    // URL and the Modeler banner never renders. Reloading cannot recover it —
+    // the `code` is single use — so re-enter through the Camunda apps menu,
+    // which starts a fresh handshake.
+    async openModelerWithRetry(banner, timeout = 60000, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            await this.clickCamundaApps();
+            await this.clickModeler();
+            try {
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                // Never tear down a hand-off that is still in flight. `modeler
+                // .<host>/login` runs an invisible reCAPTCHA before it even reaches
+                // the IdP, so on SaaS the tab routinely leaves `/login` for
+                // `/login-callback?code=...` only just AFTER this window lapses.
+                // Re-entering through the apps menu at that moment aborts an exchange
+                // that was about to finish and starts an identical one, which is then
+                // cut at the very same mark — three attempts, three restarts, and the
+                // banner never renders even though nothing was actually wrong. The
+                // trace of such a run shows `/login` committing `/login-callback`
+                // 60.3s into a 60s wait, three times over. Give a hand-off that is
+                // still in transit one more window to settle before treating the
+                // attempt as failed; a tab that is genuinely wedged spends it and
+                // falls through to the re-entry below exactly as before.
+                if (this.isModelerAuthTransit()) {
+                    try {
+                        await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                        return;
+                    }
+                    catch (settleError) {
+                        console.warn(`Modeler hand-off did not settle within the extra window: ` +
+                            `${settleError}`);
+                    }
+                }
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                console.warn(`Modeler banner not visible on attempt ${attempt + 1}; ` +
+                    're-entering through the apps menu.');
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
+    // The hand-off into Operate can resolve without the app ever coming up:
+    // `clickOperate` returns as soon as its click resolves, so a click that
+    // landed while the apps menu was being torn down — or a cluster hand-off
+    // that stalls on the proxy — leaves the tab on whatever app it started from.
+    // The caller then looks for Operate's nav on a page that is not Operate, and
+    // because Tasklist ships a "Processes" link of its own that lookup can even
+    // SUCCEED: the click goes to Tasklist's Processes tab, and the wait for
+    // Operate's own Processes view (`expanded-panel` > "Process") afterwards can
+    // never resolve. That is what reported "Failed to click locator
+    // getByRole('link', { name: 'Processes', exact: true })" on one hand and
+    // "Failed to assert visibility locator getByTestId('expanded-panel')
+    // .getByText('Process', { exact: true })" on the other. Gate on Operate's
+    // banner and re-enter through the apps menu when it never renders — the same
+    // recovery `openModelerWithRetry` uses for the identical Modeler
+    // `login-callback` stall.
+    async openOperateWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            await this.clickCamundaApps();
+            await this.clickOperate(clusterName);
+            try {
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                console.warn(`Operate banner not visible on attempt ${attempt + 1}; ` +
+                    're-entering through the apps menu.');
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
     async clickTasklist(clusterName) {
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
@@ -157,6 +250,65 @@ class AppsPage {
         }
         throw new Error(`Failed to click the tasklist link after ${maxRetries} attempts.`);
     }
+    // Same hand-off failure `openOperateWithRetry` above exists to catch, on the
+    // other app: `clickTasklist` returns as soon as its click resolves, so a
+    // click that landed while the apps menu was being torn down — or a cluster
+    // hand-off that stalls on the proxy — leaves the tab on the app it started
+    // from. The caller then polls THAT page for a task row which can never be
+    // there, and the reload each polling round performs cannot recover a
+    // hand-off that never happened — it re-renders the same wrong app. That is
+    // what reported `Task <name> did not open from "Available tasks"` on a run
+    // whose instance was already confirmed ACTIVE in Operate one step earlier.
+    // Gate on Tasklist's own banner and re-enter through the apps menu when it
+    // never renders.
+    async openTasklistWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            await this.clickCamundaApps();
+            await this.clickTasklist(clusterName);
+            try {
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                console.warn(`Tasklist banner not visible on attempt ${attempt + 1}; ` +
+                    're-entering through the apps menu.');
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
+    // The third instance of the hand-off failure `openOperateWithRetry` and
+    // `openTasklistWithRetry` above exist to catch — and the only app hop in the
+    // smoke flow that was still ungated. `clickOptimize` returns as soon as its
+    // click resolves, so a hand-off that stalled (or that landed on Optimize's
+    // `/login` SSO bounce rather than the app) leaves the tab somewhere that can
+    // never render a process definition. The caller's import poll then spends
+    // its ENTIRE budget — the longest single wait in the flow, 20 minutes —
+    // reloading that page, and a reload cannot recover a hand-off that never
+    // happened. Gating here fails in 3 x 60s with a diagnostic naming the hop
+    // instead. Every other 8.10 spec already asserts `optimizeBanner` right
+    // after `clickOptimize` for exactly this reason; only the smoke flow did
+    // not.
+    async openOptimizeWithRetry(banner, clusterName, timeout = 60000, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            await this.clickCamundaApps();
+            await this.clickOptimize(clusterName);
+            try {
+                await (0, test_1.expect)(banner).toBeVisible({ timeout });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    throw error;
+                }
+                console.warn(`Optimize banner not visible on attempt ${attempt + 1}; ` +
+                    're-entering through the apps menu.');
+                await this.page.goto('/', { waitUntil: 'domcontentloaded' });
+            }
+        }
+    }
     async clickAdmin(clusterName) {
         const maxRetries = 5;
         for (let retries = 0; retries < maxRetries; retries++) {

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

@@ -38,6 +38,7 @@ declare class ModelerHomePage {
     clickBpmnTemplateOption(): Promise<void>;
     clickFormOption(): Promise<void>;
     enterFormName(name: string): Promise<void>;
+    enterFormNameWithRetry(name: string): Promise<void>;
     clickProjectBreadcrumb(): Promise<void>;
     clickHomeBreadcrumb(): Promise<void>;
     clickOpenOrganizationsButton(): Promise<void>;

package/dist/pages/8.10/ModelerHomePage.js

@@ -62,9 +62,15 @@ class ModelerHomePage {
         this.homeBreadcrumb = page.locator('[data-test="breadcrumb-home"]');
         this.openOrganizationsButton = page.getByLabel('Open Organizations');
         this.manageButton = page.getByRole('menuitem', { name: 'Manage' });
-        this.crossComponentProjectFolder = page.getByTitle(this.defaultFolderName, {
+        // `.first()` keeps this usable in an org that already accumulated more
+        // than one project with this name — an unscoped by-title match throws a
+        // strict-mode violation the moment a duplicate exists, which fails every
+        // later run in that org rather than just the run that created it.
+        this.crossComponentProjectFolder = page
+            .getByTitle(this.defaultFolderName, {
             exact: true,
-        });
+        })
+            .first();
         this.rows = page.getByRole('row');
         this.uploadFilesButton = page.getByRole('menuitem', { name: 'Upload files' });
         this.messageBanner = page.locator('[data-test="close-top-banner"]');
@@ -157,8 +163,13 @@ class ModelerHomePage {
         await process.click();
     }
     async clickDiagramTypeDropdown() {
+        // Navigation-class wait: this is the first control on the project page, so
+        // it is reached right after navigating into the project (or back via the
+        // breadcrumb) and its render waits on the project's resource list. 15s was
+        // short enough that a slow project load failed with
+        // `locator('[data-test="diagram-dropdown"]') ... element(s) not found`.
         await (0, test_1.expect)(this.diagramTypeDropdown).toBeVisible({
-            timeout: 15000,
+            timeout: 60000,
         });
         await this.diagramTypeDropdown.click();
     }
@@ -176,6 +187,33 @@ class ModelerHomePage {
         await this.formNameInput.fill(name);
         await this.formNameInput.press('Enter');
     }
+    // Re-enters the name until the breadcrumb reflects it. Web Modeler mounts
+    // the inline name field as soon as the form editor opens, before it is wired
+    // to the rename mutation, so a fill that lands in that window is silently
+    // discarded: the form keeps its default "New form" name and the breadcrumb
+    // never shows the requested one. Nothing retried that, so a single lost
+    // keystroke made the caller's `assertFormBreadcrumbVisible` wait out its
+    // whole 120s on a form that was never going to be renamed
+    // (`button[data-test="breadcrumb-form"] ... element(s) not found`). Verifying
+    // with a short per-attempt budget turns that into one cheap retry. The
+    // caller's assertion stays the authority: this returns after the last
+    // attempt rather than throwing, so the failure is still reported by the
+    // assertion and not by a helper.
+    async enterFormNameWithRetry(name) {
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            await this.enterFormName(name);
+            const renamed = await this.formNameBreadcrumb(name)
+                .waitFor({ state: 'visible', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (renamed) {
+                return;
+            }
+            console.warn(`Form rename to "${name}" has not reached the breadcrumb ` +
+                `(attempt ${attempt}/${maxRetries}). Re-entering the name.`);
+        }
+    }
     async clickProjectBreadcrumb() {
         await this.projectBreadcrumb.click({ timeout: 60000 });
     }
@@ -233,9 +271,18 @@ class ModelerHomePage {
         });
     }
     async createCrossComponentProjectFolder() {
-        await (0, sleep_1.sleep)(15000);
         await this.dismissOverlays();
-        if (await this.crossComponentProjectFolder.isVisible()) {
+        // The projects list renders asynchronously, so an instantaneous
+        // isVisible() reports "missing" whenever the list is still loading — and
+        // this method then creates a SECOND project with the same name. Those
+        // duplicates are permanent and break every subsequent run for that user,
+        // so wait for the folder to actually show up before concluding it is
+        // absent (this also replaces the blind 15s sleep the check relied on).
+        const folderExists = await this.crossComponentProjectFolder
+            .waitFor({ state: 'visible', timeout: 60000 })
+            .then(() => true)
+            .catch(() => false);
+        if (folderExists) {
             console.log('Cross Component Project folder already exists. Clicking into it');
             await this.clickCrossComponentProjectFolder();
             return;

package/dist/pages/8.10/OperateHomePage.js

@@ -54,12 +54,20 @@ class OperateHomePage {
         this.messageBanner = page.getByRole('button', { name: 'Close' });
     }
     async clickProcessesTab() {
+        // `clickLocatorWithRetry` stops at whichever of `maxRetries` and
+        // `totalTimeout` is reached first. One failing attempt here costs up to
+        // ~47s (the banner pre-action plus the 30s visibility waits), so a 120s
+        // budget cut the 5 configured retries down to 3 — this method is reached
+        // right after switching apps, while the cluster SSO hand-off into Operate
+        // is often still in flight, and it reported "Failed to click locator
+        // getByRole('link', { name: 'Processes', exact: true }) after 3 attempts"
+        // after barely two minutes. Give the configured retries room to run.
         await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.processesTab, {
             preAction: async () => {
                 await this.clickMessageBanner();
             },
             maxRetries: 5,
-            totalTimeout: 120000,
+            totalTimeout: 300000,
             visibilityTimeout: 30000,
         });
         await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.processPageHeading, {
@@ -67,8 +75,21 @@ class OperateHomePage {
                 await (0, test_1.expect)(this.processesTab).toBeVisible({ timeout: 10000 });
                 await this.processesTab.click({ timeout: 10000 });
             },
+            // The Processes view routinely needs longer than this helper's default
+            // 10s per attempt to render on a loaded cluster — the same 30s the tab
+            // click above already assumes for this nav, and what SM-8.10 uses for
+            // this very assertion. With the default, all 5 attempts could expire
+            // inside ~1 min of the 5 min budget and report "Failed to assert
+            // visibility locator getByTestId('expanded-panel').getByText('Process',
+            // { exact: true }) after 5 attempts" while the view was still on its way.
+            visibilityTimeout: 30000,
+            // Re-clicking the tab cannot help a view that never rendered, so reload
+            // between attempts and let each one re-ask Operate for the page.
+            postAction: async () => {
+                await this.page.reload();
+            },
             maxRetries: 5,
-            totalTimeout: 120000,
+            totalTimeout: 300000,
         });
     }
     async closeInformationDialog() {

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

@@ -1,11 +1,15 @@
-import { Page, Locator } from '@playwright/test';
+import { Page, Locator, BrowserContext } from '@playwright/test';
+type InstanceUrlWatcher = () => string | undefined;
+declare function watchOperateInstanceUrl(context: BrowserContext): InstanceUrlWatcher;
 declare class OperateProcessInstancePage {
     private page;
+    private instanceUrl;
     readonly diagram: Locator;
     readonly completedIcon: Locator;
     readonly diagramSpinner: Locator;
     readonly activeIcon: Locator;
     readonly incidentIcon: Locator;
+    readonly incidentsBanner: Locator;
     readonly userTaskOpenTasklistLink: Locator;
     readonly taskDetailsPopOver: Locator;
     readonly connectorResultVariableName: (name: string) => Locator;
@@ -15,8 +19,18 @@ declare class OperateProcessInstancePage {
     readonly gotItButton: Locator;
     constructor(page: Page);
     connectorResultVariableValue(variableName: string): Promise<Locator>;
+    rememberInstanceUrl(timeout?: number, watchedUrl?: InstanceUrlWatcher): Promise<void>;
+    private hasBouncedToList;
+    private waitForAuthToSettle;
+    private isStateIconWait;
+    private describeIncident;
+    private describeRenderedState;
+    waitForInstanceLocator(locator: Locator, description: string, totalTimeout?: number, pollTimeout?: number): Promise<void>;
+    dismissWhatsNewIfVisible(): Promise<void>;
     closePopOverIfVisible(): Promise<void>;
-    reload(): Promise<void>;
+    private clusterHost;
+    private reenterViaConsole;
+    reload(): Promise<boolean>;
     assertProcessCompleteStatusWithRetry(timeout?: number, maxRetries?: number): Promise<void>;
     assertProcessVariableContainsText(variableName: string, text: string): Promise<void>;
     assertProcessVariableHasDocumentCount(variableName: string, count: number, softFail?: boolean): Promise<void>;
@@ -25,4 +39,4 @@ declare class OperateProcessInstancePage {
     assertDetailsPopoverIsVisible(): Promise<void>;
     assertBusinessIdVisible(businessId: string): Promise<void>;
 }
-export { OperateProcessInstancePage };
+export { OperateProcessInstancePage, watchOperateInstanceUrl };