@camunda/e2e-test-suite 0.0.943 → 0.0.945

package/dist/pages/SM-8.10/TaskProcessesPage.js

@@ -28,13 +28,18 @@ class TaskProcessesPage {
             console.log('Popup not present');
         }
     }
+    // Scopes to the tile by walking up from its heading to the closest ancestor
+    // that owns a button: the unified webapp tile carries no test id, and the
+    // wrapper class names are build-hashed CSS modules.
+    processStartButton(name) {
+        return this.page
+            .getByRole('heading', { name, exact: true })
+            .locator('xpath=ancestor::div[.//button][1]')
+            .getByRole('button', { name: 'Start process' });
+    }
     async startProcess(name) {
         const found = await (0, UtilitiesPage_1.findTextWithPagination)(this.page, name, 60000, async () => {
-            await this.page
-                .locator('[data-testid="process-tile"]')
-                .filter({ hasText: name })
-                .getByRole('button', { name: 'Start process' })
-                .click({ timeout: 60000 });
+            await this.processStartButton(name).click({ timeout: 60000 });
         });
         if (!found) {
             throw new Error(`Process "${name}" not found in pagination`);
@@ -44,7 +49,26 @@ class TaskProcessesPage {
         });
     }
     async clickSearchProcessesSearchbox() {
-        await this.searchProcessesSearchbox.click();
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                await this.searchProcessesSearchbox.click({ timeout: 5000 });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxAttempts) {
+                    throw error;
+                }
+                // The app can bounce back to the Tasks tab at any point after a new
+                // task arrives (not just synchronously with the Processes tab click
+                // -- run 31785205047 saw it happen mid-way through the unrelated
+                // 15s wait for a "Continue" popup that wasn't present), leaving
+                // Processes' own searchbox gone by the time this runs. Re-open
+                // Processes and retry rather than trusting we're still on it.
+                console.warn(`Attempt ${attempt} failed to click the Processes searchbox, probably bounced back to Tasks. Re-opening Processes and retrying...`);
+                await this.page.getByRole('link', { name: 'Processes' }).click();
+            }
+        }
     }
     async fillSearchProcessesSearchbox(process) {
         await this.searchProcessesSearchbox.fill(process);

package/dist/pages/SM-8.10/UtilitiesPage.js

@@ -82,7 +82,12 @@ async function completeTaskWithRetry(page, taskPanelPage, taskDetailsPage, taskN
     }
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            await page.waitForLoadState('networkidle');
+            // Tasklist keeps polling for task updates, so 'networkidle' never
+            // settles here. This wait carried no timeout, so it consumed whatever
+            // was left of the 12-minute test budget and the run died inside
+            // waitForLoadState. The task panel rendering is the precondition this
+            // step actually needs, so wait for that instead.
+            await (0, test_1.expect)(taskPanelPage.availableTasks).toBeVisible({ timeout: 60000 });
             const taskLocator = taskPanelPage.availableTasks
                 .getByText(taskName, { exact: true })
                 .first();
@@ -150,7 +155,8 @@ async function completeTaskWithRetry(page, taskPanelPage, taskDetailsPage, taskN
                 catch {
                     await page.reload();
                 }
-                await page.waitForLoadState('networkidle');
+                // No settle wait here either — the goto already waited for
+                // domcontentloaded and the next attempt waits for the task panel.
             }
             else {
                 console.error(`All ${maxRetries} attempts failed for task ${taskName}`);
@@ -343,7 +349,12 @@ async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 3000
                 console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
             }
             else {
-                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                // Keep the cause. Callers branch on the original error to tell a real
+                // failure apart from the test timeout aborting an in-flight wait (see
+                // assertReportWithRefreshes), and a bare attempt count told them
+                // nothing — so they retried into an already-dead test budget and
+                // reported their own generic "after N attempts" instead.
+                throw new Error(`Assertion failed after ${maxRetries} attempts: ${String(error)}`);
             }
         }
     }
@@ -371,7 +382,7 @@ async function assertPageTextWithRetry(page, text, notVisible, timeout = 30000,
                 console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
             }
             else {
-                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                throw new Error(`Assertion failed after ${maxRetries} attempts: ${String(error)}`);
             }
         }
     }

package/dist/pages/SM-8.10/optimizeReportUtils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertReportWithRefreshes = exports.createReportForProcess = void 0;
 const UtilitiesPage_1 = require("../SM-8.10/UtilitiesPage");
 const UtilitiesPage_2 = require("../SM-8.10/UtilitiesPage");
+const constants_1 = require("../../utils/constants");
 const createReportForProcess = async (optimizeCollectionsPage, optimizeReportPage, processName) => {
     const maxRetries = 30;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
@@ -34,18 +35,43 @@ const assertReportWithRefreshes = async (page, optimizeHomePage, optimizeCollect
     // refresh cycles for Optimize to catch up has a bigger underlying
     // problem worth surfacing.
     const maxRetries = 10;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
+    // Playwright treats a 0 timeout as "no timeout", so passing 0 here made the
+    // visibility wait poll one already-rendered report view until the 720s test
+    // timeout killed the test. Optimize report views do not live-refresh, so that
+    // single wait could never observe the batch import landing, and it consumed
+    // every cycle this loop exists to spread out — the reason the failure surfaces
+    // as a bare "Test timeout of 720000ms exceeded". Bound each cycle instead, so
+    // the reload between cycles actually refetches. 60s (rather than the 90s the
+    // identical assertion gets in optimize-user-flows.spec.ts) keeps several
+    // cycles inside the smoke test's shared budget.
+    const attemptTimeout = constants_1._1_SECOND_IN_MS * 60;
+    // Stop starting cycles in time to throw the error below, instead of being
+    // killed mid-cycle by the test timeout, which reports no cause at all.
+    const deadline = Date.now() + constants_1._1_MINUTE_IN_MS * 6;
+    let attempts = 0;
+    let lastError;
+    while (attempts < maxRetries && Date.now() < deadline) {
+        attempts++;
         try {
             await optimizeHomePage.clickCollectionsLink();
             await (0, UtilitiesPage_1.assertPageTextWithRetry)(page, reportName, false);
             await optimizeCollectionsPage.clickMostRecentProcessReport(reportName);
-            await (0, UtilitiesPage_2.assertLocatorVisibleWithRetry)(page, locator, text, 0);
+            await (0, UtilitiesPage_2.assertLocatorVisibleWithRetry)(page, locator, text, attemptTimeout);
             return;
         }
         catch (error) {
-            // nothing to do. Just loop back to the collections
+            lastError = error;
+            // Once the test budget is gone (or the page is closed) every remaining
+            // attempt rejects instantly, so this loop used to spin out and report
+            // "after 10 attempts" for a failure that happened somewhere else
+            // entirely. Surface the real error instead of retrying into it.
+            if (page.isClosed() || String(error).includes('Test timeout')) {
+                throw error;
+            }
+            // otherwise nothing to do. Just loop back to the collections
         }
     }
-    throw new Error(`Failed to assert report ${reportName} after ${maxRetries} attempts`);
+    throw new Error(`Failed to assert report ${reportName} after ${attempts} attempts: ` +
+        String(lastError));
 };
 exports.assertReportWithRefreshes = assertReportWithRefreshes;

package/dist/tests/8.10/smoke-tests.spec.js

@@ -35,21 +35,35 @@ _8_10_1.test.describe('Smoke Tests', () => {
         const userTaskName = 'zeebeUserTaskWithForm' + randomString;
         const reportName = await (0, _setup_1.generateRandomStringAsync)(5);
         let appTab;
+        // One wall-clock deadline for the whole flow. The per-hop budgets below
+        // (2 x 8 min Operate import, 10 min Tasklist, 10 x 2 min Optimize import)
+        // sum to well over this test's own 36 min timeout, so a run where several
+        // hops were merely slow could be killed by the harness mid-wait and
+        // reported as a bare "Test timeout of 2160000ms exceeded" — no failing
+        // assertion, no named hop, and no screenshot. Clamping each hop to the time
+        // actually left makes the slow hop fail with its own diagnostic instead.
+        // The reserve covers the login already spent in `beforeEach` plus the
+        // afterEach screenshot/video capture, which is what the on-call reads.
+        // In a healthy run nothing is clamped: each wait resolves long before the
+        // deadline, so `flowBudget` returns the full budget it was asked for.
+        const flowDeadline = Date.now() + _8_10_1.test.info().timeout - 120000;
+        const flowBudget = (wanted) => Math.max(30000, Math.min(wanted, flowDeadline - Date.now()));
         await _8_10_1.test.step('Navigate to Web Modeler', async () => {
             await (0, test_1.expect)(homePage.camundaComponentsButton).toBeVisible({
                 timeout: constants_1.TIMEOUT.medium,
             });
-            await appsPage.clickCamundaApps();
-            await appsPage.clickModeler();
-            await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
-                timeout: constants_1.TIMEOUT.navigation,
-            });
+            await appsPage.openModelerWithRetry(modelerHomePage.modelerPageBanner, constants_1.TIMEOUT.navigation);
         });
         await _8_10_1.test.step('Create form to be linked for Zeebe user task', async () => {
-            await modelerHomePage.clickCrossComponentProjectFolder();
+            // Ensure the per-user project exists before using it: the shared
+            // test-setup project creates it, but if that per-user setup step is
+            // absent/flaky the folder is missing and clicking it hangs forever.
+            // createCrossComponentProjectFolder clicks into the folder when present
+            // (the normal path) and creates it only when it is genuinely missing.
+            await modelerHomePage.createCrossComponentProjectFolder();
             await modelerHomePage.clickDiagramTypeDropdown();
             await modelerHomePage.clickFormOption();
-            await modelerHomePage.enterFormName(formName);
+            await modelerHomePage.enterFormNameWithRetry(formName);
             await modelerHomePage.assertFormBreadcrumbVisible(formName);
             await formJsPage.deployForm(CLUSTER_NAME);
             // Wait for the form to propagate to the cluster before it can be embedded
@@ -91,52 +105,152 @@ _8_10_1.test.describe('Smoke Tests', () => {
             });
         });
         await _8_10_1.test.step('Open process instance in Operate and verify it is active', async () => {
-            await modelerCreatePage.clickViewProcessInstanceLink();
-            appTab = await page.waitForEvent('popup', { timeout: constants_1.TIMEOUT.navigation });
+            // Start latching the Operate deep link on the CONTEXT before clicking.
+            // Playwright raises `popup` only once the popup's initial navigation
+            // response has started loading, so a listener attached to the popup page
+            // afterwards can never see the deep-link request -- and the auth redirect
+            // chain of a session-less tab drops that path, so nothing else observes it
+            // either. Missing it leaves the retry loop below polling the Operate app
+            // root for the whole budget (see OperateProcessInstancePage).
+            const watchedInstanceUrl = (0, OperateProcessInstancePage_1.watchOperateInstanceUrl)(page.context());
+            // Open the Operate tab through the retrying helper: it registers the
+            // popup wait before each click (`waitForEvent` only sees events raised
+            // after it is called, and the tab opens while the click is still
+            // resolving) and re-clicks when a click resolved without opening a tab,
+            // which is how this step used to sit out its whole 60s budget.
+            appTab = await (0, UtilitiesPage_1.openAppTabWithRetry)(page, modelerCreatePage.viewProcessInstanceLink, constants_1.TIMEOUT.navigation);
             const appTabProcessInstancePage = new OperateProcessInstancePage_1.OperateProcessInstancePage(appTab);
-            // Reload between attempts so a lagging Operate import is picked up —
-            // a single fixed wait never recovers if the instance page renders
-            // before the instance is imported on a fresh SaaS cluster.
-            await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(appTabProcessInstancePage, appTabProcessInstancePage.activeIcon, 'active icon in Operate', constants_1.TIMEOUT.navigation);
-            await appTabProcessInstancePage.closePopOverIfVisible();
+            // Capture the deep link first: when the instance is not imported yet
+            // Operate 404s and replaces the URL with the processes list, so the
+            // retry loop has to re-navigate to this URL instead of reloading the
+            // list page (see OperateProcessInstancePage).
+            await appTabProcessInstancePage.rememberInstanceUrl(constants_1.TIMEOUT.navigation, watchedInstanceUrl);
+            // Poll the instance deep link rather than the page Operate bounced us
+            // to: while the Zeebe -> Operate import lags, the deep link 404s and
+            // Operate replaces the URL with the processes list, where the instance
+            // header can never render. The previous loop spent most of its ~11 min
+            // idling on that list page; this re-asks Operate instead.
+            //
+            // `processImport`, the same budget the COMPLETED-icon gate below uses:
+            // both wait on the identical Zeebe -> Operate import, so the shorter
+            // `processActive` (300s) made this the first place a lagging import ran
+            // out of road ("active icon in Operate timed out after 300000ms" with the
+            // instance header never rendering). This does not lengthen the test in
+            // practice -- the import lag is paid once, so time spent here is time the
+            // COMPLETED-icon gate no longer needs.
+            await appTabProcessInstancePage.waitForInstanceLocator(appTabProcessInstancePage.activeIcon, 'active icon', flowBudget(constants_1.TIMEOUT.processImport));
+            // The active-icon wait above already proves the instance page rendered,
+            // so only the "what's new" popup is left to dismiss. Re-polling for the
+            // "Instance History" panel here would spend a second 8 min budget on a
+            // weaker version of the same gate.
+            await appTabProcessInstancePage.dismissWhatsNewIfVisible();
         });
         await _8_10_1.test.step('Navigate to Tasklist and complete both user tasks', async () => {
             const appTabAppsPage = new AppsPage_1.AppsPage(appTab);
             const appTabTaskPanelPage = new TaskPanelPage_1.TaskPanelPage(appTab);
             const appTabTaskDetailsPage = new TaskDetailsPage_1.TaskDetailsPage(appTab);
-            await appTabAppsPage.clickCamundaApps();
-            await appTabAppsPage.clickTasklist(CLUSTER_NAME);
-            await (0, UtilitiesPage_1.completeTaskWithRetry)(appTabTaskPanelPage, appTabTaskDetailsPage, `${userTaskName}1`, 'Medium');
-            await (0, UtilitiesPage_1.completeTaskWithRetry)(appTabTaskPanelPage, appTabTaskDetailsPage, `${userTaskName}2`, 'Medium');
+            // Gate the hop on Tasklist's own banner, for the same reason the Operate
+            // hop below is gated: `clickTasklist` returns as soon as its click
+            // resolves, so a hand-off that never landed left this tab on Operate —
+            // and the task poll below then spent its whole budget reloading Operate
+            // looking for a row that can only exist in Tasklist (see
+            // `openTasklistWithRetry`).
+            await appTabAppsPage.openTasklistWithRetry(appTabTaskPanelPage.taskListPageBanner, CLUSTER_NAME, constants_1.TIMEOUT.navigation);
+            // One budget for the whole Tasklist hop. The two tasks are parallel
+            // branches of the same instance, so they are imported together: the
+            // first wait absorbs the importer lag and the rest are already present.
+            // Per-call budgets are what killed this test -- 10 x 120s inside
+            // completeTaskWithRetry's 3 attempts is a 60 min worst case for ONE
+            // task, more than the 36 min test timeout, so a lagging importer ran the
+            // clock out mid-wait and the run reported "Test timeout exceeded" with no
+            // failing assertion instead of naming the task that never arrived.
+            const tasklistDeadline = Date.now() + flowBudget(10 * 60 * 1000);
+            const tasklistBudget = () => Math.max(30000, tasklistDeadline - Date.now());
+            await (0, UtilitiesPage_1.completeTaskWithRetry)(appTabTaskPanelPage, appTabTaskDetailsPage, `${userTaskName}1`, 'Medium', 3, tasklistBudget());
+            await (0, UtilitiesPage_1.completeTaskWithRetry)(appTabTaskPanelPage, appTabTaskDetailsPage, `${userTaskName}2`, 'Medium', 3, tasklistBudget());
+            // Re-select the row between attempts instead of asserting once: the click
+            // in `openTask` can land while the Completed list is still re-rendering
+            // after the filter change, which leaves the details panel on the
+            // previously selected task (or on its empty state) with nothing left to
+            // move it. A single 30s wait then reported
+            // "getByTestId('details-info').getByText('<task>') ... element(s) not
+            // found". Re-clicking the row is what recovers it, so the assertion
+            // itself is unchanged — the details panel must still name the task.
+            const assertTaskDetails = async (taskName) => {
+                await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(appTab, appTabTaskDetailsPage.detailsInfo.getByText(taskName), `${taskName} in the task details panel`, constants_1.TIMEOUT.medium, false, 3, appTabTaskPanelPage.taskInList(taskName));
+            };
             await appTabTaskPanelPage.filterBy('Completed');
-            await appTabTaskPanelPage.openTask(`${userTaskName}1`);
-            await (0, test_1.expect)(appTabTaskDetailsPage.detailsInfo.getByText(`${userTaskName}1`)).toBeVisible({ timeout: constants_1.TIMEOUT.medium });
-            await appTabTaskPanelPage.openTask(`${userTaskName}2`);
-            await (0, test_1.expect)(appTabTaskDetailsPage.detailsInfo.getByText(`${userTaskName}2`)).toBeVisible({ timeout: constants_1.TIMEOUT.medium });
+            await appTabTaskPanelPage.openTask(`${userTaskName}1`, tasklistBudget());
+            await assertTaskDetails(`${userTaskName}1`);
+            await appTabTaskPanelPage.openTask(`${userTaskName}2`, tasklistBudget());
+            await assertTaskDetails(`${userTaskName}2`);
         });
         await _8_10_1.test.step('Assert process completion in Operate', async () => {
             const appTabAppsPage = new AppsPage_1.AppsPage(appTab);
             const appTabHomePage = new OperateHomePage_1.OperateHomePage(appTab);
             const appTabProcessesPage = new OperateProcessesPage_1.OperateProcessesPage(appTab);
             const appTabProcessInstancePage = new OperateProcessInstancePage_1.OperateProcessInstancePage(appTab);
-            await appTabAppsPage.clickCamundaApps();
-            await appTabAppsPage.clickOperate(CLUSTER_NAME);
+            // Gate the hop on Operate's own banner: `clickOperate` returns as soon as
+            // its click resolves, so a hand-off that never landed left the tab on
+            // Tasklist — whose nav also has a "Processes" link, so the next step
+            // clicked THAT and then waited out its budget for Operate's Processes
+            // view (see `openOperateWithRetry`).
+            await appTabAppsPage.openOperateWithRetry(appTabHomePage.operateBanner, CLUSTER_NAME, constants_1.TIMEOUT.navigation);
             await appTabHomePage.clickProcessesTab();
             await (0, test_1.expect)(appTabProcessesPage.processCompletedCheckbox).toBeVisible({
                 timeout: constants_1.TIMEOUT.short,
             });
             await appTabProcessesPage.clickProcessCompletedCheckbox();
             await appTabProcessesPage.clickProcessInstanceLink(processName);
-            await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(appTabProcessInstancePage, appTabProcessInstancePage.completedIcon, 'completed icon in Operate', constants_1.TIMEOUT.processComplete);
+            // Poll the instance deep link for the COMPLETED icon, the same way the
+            // active-icon gate above does. `assertLocatorVisibleWithRetry` is blind
+            // to Operate's 404 bounce: the completed filter also lists still-ACTIVE
+            // instances, so this link is often opened before the import has caught
+            // up, and each of its 6 attempts then idled a full 120s on a page that
+            // could not render the header -- 13 min for only 6 re-asks. This budget
+            // re-asks Operate ~16 times and leaves more of the test's 36 min to the
+            // Optimize import later on.
+            await appTabProcessInstancePage.rememberInstanceUrl(constants_1.TIMEOUT.navigation);
+            await appTabProcessInstancePage.waitForInstanceLocator(appTabProcessInstancePage.completedIcon, 'completed icon', flowBudget(constants_1.TIMEOUT.processImport));
         });
         await _8_10_1.test.step('Assert process imported in Optimize and create user task report', async () => {
             const appTabAppsPage = new AppsPage_1.AppsPage(appTab);
             const optimizeHomePage = new OptimizeHomePage_1.OptimizeHomePage(appTab);
             const optimizeCollectionsPage = new OptimizeCollectionsPage_1.OptimizeCollectionsPage(appTab);
             const optimizeReportPage = new OptimizeReportPage_1.OptimizeReportPage(appTab);
-            await appTabAppsPage.clickCamundaApps();
-            await appTabAppsPage.clickOptimize(CLUSTER_NAME);
-            await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(appTab, appTab.getByRole('link', { name: processName }), `process ${processName} in Optimize`, constants_1.TIMEOUT.optimizeImport);
+            // Gate the hop on Optimize's own banner, for the same reason the Operate
+            // and Tasklist hops above are gated: `clickOptimize` returns as soon as
+            // its click resolves, so a hand-off that never landed left this tab off
+            // Optimize — and the import poll below then spent its whole 20 min
+            // budget reloading a page that can never render a process definition
+            // (see `openOptimizeWithRetry`).
+            await appTabAppsPage.openOptimizeWithRetry(optimizeHomePage.optimizeBanner, CLUSTER_NAME, constants_1.TIMEOUT.navigation);
+            // Reloads for ~10 rounds of the 2 min import window, dismissing the
+            // onboarding modal that reappears on every load and covers the list.
+            // Two extra rounds over the previous 8: the Optimize import is the
+            // slowest hop in this flow and the time comes out of the Operate wait
+            // above, so the test's overall worst case still shrinks.
+            // Rounds are derived from the time the flow has left rather than fixed at
+            // 10, for the same reason the waits above are clamped: 10 x 2 min is 20
+            // min of the test's 36, so on a run that already spent its budget on the
+            // Operate imports these rounds were what pushed it past the harness
+            // timeout. At least 2 rounds are always attempted, and a healthy run
+            // still gets all 10.
+            // Deriving only the ROUND COUNT from `flowBudget` left the wait itself
+            // unclamped: the helper's budget is `timeout * maxRetries`, computed from
+            // the per-round timeout it is handed, so the `max(2, ...)` floor kept at
+            // least 2 x 120s of polling even on a flow with seconds left -- and the
+            // report-creation steps below then ran past the test's own 36 min
+            // timeout. That is the bare "Test timeout of 2160000ms exceeded" with no
+            // failing assertion and no named hop. Splitting the budget across the
+            // rounds makes `timeout * maxRetries` equal the time the flow actually
+            // has, so a lagging Optimize import fails with its own diagnostic
+            // ("process <name> in Optimize failed after ...ms of polling") instead of
+            // being killed by the harness. A healthy run is unchanged: the full
+            // 10 x 120s is still granted whenever the flow has it to give.
+            const optimizeBudget = flowBudget(10 * constants_1.TIMEOUT.optimizeImport);
+            const optimizeRounds = Math.max(2, Math.floor(optimizeBudget / constants_1.TIMEOUT.optimizeImport));
+            await optimizeHomePage.assertProcessImportedWithRetry(processName, Math.floor(optimizeBudget / optimizeRounds), optimizeRounds);
             await optimizeHomePage.clickCollectionsLink();
             await optimizeCollectionsPage.clickCreateNewButtonWithRetry();
             await optimizeCollectionsPage.clickReportOption();
@@ -165,10 +279,17 @@ _8_10_1.test.describe('Smoke Tests', () => {
                 timeout: constants_1.TIMEOUT.medium,
             });
             await optimizeCollectionsPage.clickMostRecentProcessReport(reportName);
-            await optimizeReportPage.waitUntilLocatorIsVisible(optimizeReportPage.oneUserTaskInstance.first(), appTab);
-            await (0, test_1.expect)(optimizeReportPage.oneUserTaskInstance).toHaveCount(2, {
-                timeout: constants_1.TIMEOUT.navigation,
-            });
+            // Poll the row count itself across reloads: the user-task instance data
+            // arrives on a later Optimize import cycle than the definition, so
+            // probing visibility first and then asserting the count once reported
+            // "expected 2, received 0" while the import was still in flight.
+            // Clamped for the same reason as the import wait above: this is the last
+            // hop of the flow and its default 4 x 60s is spent after the slowest
+            // wait in the test, so leaving it unclamped re-opens the same overrun
+            // the budget above closes. The retry count is unchanged -- only the time
+            // each attempt may idle is bounded by what the flow has left.
+            const countRetries = 4;
+            await optimizeReportPage.assertUserTaskInstanceCountWithRetry(2, appTab, countRetries, Math.floor(flowBudget(countRetries * constants_1.TIMEOUT.navigation) / countRetries));
         });
     });
     (0, _8_10_1.test)('Most Common REST Connector User Flow', async ({ page, homePage, modelerHomePage, appsPage, modelerCreatePage, connectorSettingsPage, }) => {
@@ -179,14 +300,12 @@ _8_10_1.test.describe('Smoke Tests', () => {
             await (0, test_1.expect)(homePage.camundaComponentsButton).toBeVisible({
                 timeout: constants_1.TIMEOUT.medium,
             });
-            await appsPage.clickCamundaApps();
-            await appsPage.clickModeler();
-            await (0, test_1.expect)(modelerHomePage.modelerPageBanner).toBeVisible({
-                timeout: constants_1.TIMEOUT.navigation,
-            });
+            await appsPage.openModelerWithRetry(modelerHomePage.modelerPageBanner, constants_1.TIMEOUT.navigation);
         });
         await _8_10_1.test.step('Open Cross Component Test Project and create a BPMN diagram template', async () => {
-            await modelerHomePage.clickCrossComponentProjectFolder();
+            // See note in the flow above: ensure the per-user project exists rather
+            // than hanging on a click when the shared setup did not create it.
+            await modelerHomePage.createCrossComponentProjectFolder();
             await modelerHomePage.clickDiagramTypeDropdown();
             await modelerHomePage.clickBpmnTemplateOption();
         });
@@ -200,13 +319,32 @@ _8_10_1.test.describe('Smoke Tests', () => {
             });
         });
         await _8_10_1.test.step('Assert process completes in Operate and verify connector result', async () => {
-            await modelerCreatePage.clickViewProcessInstanceLink();
-            const operateTab = await page.waitForEvent('popup', {
-                timeout: constants_1.TIMEOUT.navigation,
-            });
+            // Context-level deep-link watcher before the click — same reason as in
+            // the flow above: the popup event fires too late to observe the
+            // deep-link request, so without this the retry loop below can only poll
+            // the Operate app root (see OperateProcessInstancePage).
+            const watchedInstanceUrl = (0, OperateProcessInstancePage_1.watchOperateInstanceUrl)(page.context());
+            // Same retrying open as in the flow above: the listener goes up before
+            // the click, and a click that resolved without opening a tab is retried
+            // instead of being waited out.
+            const operateTab = await (0, UtilitiesPage_1.openAppTabWithRetry)(page, modelerCreatePage.viewProcessInstanceLink, constants_1.TIMEOUT.navigation);
             const operateProcessInstancePage = new OperateProcessInstancePage_1.OperateProcessInstancePage(operateTab);
-            await operateProcessInstancePage.closePopOverIfVisible();
-            await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(operateProcessInstancePage, operateProcessInstancePage.completedIcon, 'completed icon in Operate', constants_1.TIMEOUT.processComplete);
+            // Capture the deep link before Operate can bounce the tab to the
+            // processes list on a not-yet-imported instance (see
+            // OperateProcessInstancePage) — otherwise every retry below reloads
+            // the list page, where the instance header can never render.
+            await operateProcessInstancePage.rememberInstanceUrl(constants_1.TIMEOUT.navigation, watchedInstanceUrl);
+            // Wait for the COMPLETED icon as the single import gate, polling the deep
+            // link so a bounce to the processes list is re-navigated instead of
+            // waited out: this tab is opened seconds after the instance starts, so
+            // the first query almost always 404s. `assertLocatorVisibleWithRetry`
+            // does not know about the bounce and burned 120s per attempt on the list
+            // page, which is what reported "completed icon in Operate failed after 6
+            // attempts" whenever the import lagged. The popup is dismissed
+            // afterwards, once the last re-navigation has settled, so it cannot cover
+            // the variables assertions.
+            await operateProcessInstancePage.waitForInstanceLocator(operateProcessInstancePage.completedIcon, 'completed icon', constants_1.TIMEOUT.processImport);
+            await operateProcessInstancePage.dismissWhatsNewIfVisible();
             await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(operateTab, operateProcessInstancePage.variablesList, 'variable list in Operate', constants_1.TIMEOUT.navigation);
             await (0, test_1.expect)(operateProcessInstancePage.connectorResultVariableName('message')).toBeVisible({ timeout: constants_1.TIMEOUT.navigation });
             await (0, test_1.expect)(operateProcessInstancePage

package/dist/tests/SM-8.10/identity-user-flows.spec.js

@@ -105,7 +105,8 @@ SM_8_10_1.test.describe('Identity User Flow Tests', () => {
             });
         });
     });
-    (0, SM_8_10_1.test)('User Roles User Flow on Orchestration Cluster', async ({ page, navigationPage, ocIdentityMappingRulesPage, ocIdentityHomePage, ocIdentityRolesPage, taskPanelPage, operateHomePage, settingsPage, browser, keycloakLoginPage, keycloakAdminPage, managementIdentityPage, }) => {
+    // Skipped due to bug #60139: https://github.com/camunda/camunda/issues/60139
+    SM_8_10_1.test.skip('User Roles User Flow on Orchestration Cluster', async ({ page, navigationPage, ocIdentityMappingRulesPage, ocIdentityHomePage, ocIdentityRolesPage, taskPanelPage, operateHomePage, settingsPage, browser, keycloakLoginPage, keycloakAdminPage, managementIdentityPage, }) => {
         if (node_process_1.default.env.IS_RBA === 'true' ||
             node_process_1.default.env.IS_MT === 'true' ||
             node_process_1.default.env.IS_LICENSE_KEY === 'true') {

package/dist/utils/constants.d.ts

@@ -20,5 +20,6 @@ export declare const TIMEOUT: {
     navigation: number;
     processActive: number;
     processComplete: number;
+    processImport: number;
     optimizeImport: number;
 };

package/dist/utils/constants.js

@@ -28,5 +28,9 @@ exports.TIMEOUT = {
     navigation: 60000,
     processActive: 300000,
     processComplete: 120000,
+    // Total budget for polling an Operate instance deep link until the
+    // Zeebe -> Operate import has caught up (see `waitForInstanceLocator`).
+    // Spent as ~30s polls that each re-ask Operate, not as one long idle wait.
+    processImport: 480000,
     optimizeImport: 120000,
 };

package/package.json

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