@camunda/e2e-test-suite 0.0.1443 → 0.0.1444

package/dist/pages/SM-8.11/TaskDetailsPage.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskDetailsPage = void 0;
+const test_1 = require("@playwright/test");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+function cardinalToOrdinal(numberValue) {
+    const realOrderIndex = numberValue.toString();
+    if (['11', '12', '13'].includes(realOrderIndex.slice(-2))) {
+        return `${realOrderIndex}th`;
+    }
+    switch (realOrderIndex.slice(-1)) {
+        case '1':
+            return `${realOrderIndex}st`;
+        case '2':
+            return `${realOrderIndex}nd`;
+        case '3':
+            return `${realOrderIndex}rd`;
+        default:
+            return `${realOrderIndex}th`;
+    }
+}
+class TaskDetailsPage {
+    page;
+    assignToMeButton;
+    completeButton;
+    unassignButton;
+    assignee;
+    completeTaskButton;
+    addVariableButton;
+    detailsPanel;
+    detailsHeader;
+    pendingTaskDescription;
+    pickATaskHeader;
+    emptyTaskMessage;
+    nameInput;
+    addressInput;
+    ageInput;
+    variablesTable;
+    nameColumnHeader;
+    valueColumnHeader;
+    form;
+    numberInput;
+    incrementButton;
+    decrementButton;
+    dateInput;
+    timeInput;
+    checkbox;
+    selectDropdown;
+    tagList;
+    detailsInfo;
+    textInput;
+    taskCompletedBanner;
+    assignedToMeText;
+    noPreviewContainer;
+    previewContainer;
+    constructor(page) {
+        this.page = page;
+        this.assignToMeButton = page.getByRole('button', { name: 'Assign to me' });
+        this.completeButton = page.getByRole('button', { name: 'Complete' });
+        this.unassignButton = page.getByRole('button', { name: 'Unassign' });
+        this.assignee = page.getByTestId('assignee');
+        this.completeTaskButton = page.getByRole('button', { name: 'Complete Task' });
+        this.addVariableButton = page.getByRole('button', { name: 'Add Variable' });
+        this.detailsPanel = this.page.getByRole('complementary', {
+            name: 'Task details right panel',
+        });
+        this.detailsHeader = page.getByTitle('Task details header');
+        this.pendingTaskDescription = page.getByText('Pending task');
+        this.pickATaskHeader = page.getByRole('heading', {
+            name: 'Pick a task to work on',
+        });
+        this.emptyTaskMessage = page.getByRole('heading', {
+            name: /task has no variables/i,
+        });
+        this.nameInput = page.getByLabel('Name*');
+        this.addressInput = page.getByLabel('Address*');
+        this.ageInput = page.getByLabel('Age');
+        this.variablesTable = page.getByTestId('variables-table');
+        this.nameColumnHeader = this.variablesTable.getByRole('columnheader', {
+            name: 'Name',
+        });
+        this.valueColumnHeader = this.variablesTable.getByRole('columnheader', {
+            name: 'Value',
+        });
+        this.form = page.getByTestId('embedded-form');
+        this.numberInput = this.form.getByLabel('Number');
+        this.incrementButton = page.getByRole('button', { name: 'Increment' });
+        this.decrementButton = page.getByRole('button', { name: 'Decrement' });
+        this.dateInput = page.getByPlaceholder('mm/dd/yyyy');
+        this.timeInput = page.getByPlaceholder('hh:mm ?m');
+        this.checkbox = this.form.getByLabel('Checkbox');
+        this.selectDropdown = this.form.getByText('Select').last();
+        this.tagList = page.getByPlaceholder('Search');
+        this.detailsInfo = page.getByTestId('details-info');
+        this.textInput = page.locator('[class="fjs-input"]');
+        this.textInput = page.locator('[class="fjs-input"]');
+        this.taskCompletedBanner = this.page.getByText('Task completed').first();
+        this.assignedToMeText = page
+            .getByTestId('assignee')
+            .getByText('Assigned to me');
+        this.noPreviewContainer = this.page.locator('[class = "fjs-documentPreview-non-preview-item fjs-documentPreview-single-document-container"]');
+        this.previewContainer = this.page.locator('[class = "fjs-documentPreview-single-document-container"]');
+    }
+    async clickAssignToMeButton() {
+        await (0, test_1.expect)(this.assignToMeButton).toBeVisible({ timeout: 60000 });
+        await this.assignToMeButton.click({ timeout: 60000 });
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.assignedToMeText, {
+            // Assignment is a round-trip through the Zeebe user-task backend, which
+            // on a loaded cluster outlasts the default 10s per attempt. Every failure
+            // here aborts the caller's whole task-completion attempt, so it retries
+            // the search, the click and the panel load as well — the run log shows
+            // that churn repeating up to attempt 7.
+            visibilityTimeout: 30000,
+            totalTimeout: 60000,
+            postAction: async () => {
+                await this.page.reload();
+            },
+        });
+    }
+    async clickUnassignButton() {
+        await this.unassignButton.click();
+    }
+    async clickCompleteTaskButton() {
+        await this.completeTaskButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.taskCompletedBanner).toBeVisible({
+            timeout: 200000,
+        });
+    }
+    async clickAddVariableButton() {
+        await this.addVariableButton.click({ timeout: 60000 });
+    }
+    async replaceExistingVariableValue(values) {
+        const { name, value } = values;
+        await this.page.getByTitle(name).clear();
+        await this.page.getByTitle(name).fill(value);
+    }
+    getNthVariableNameInput(nth) {
+        return this.page.getByRole('textbox', {
+            name: `${cardinalToOrdinal(nth)} variable name`,
+        });
+    }
+    getNthVariableValueInput(nth) {
+        return this.page.getByRole('textbox', {
+            name: `${cardinalToOrdinal(nth)} variable value`,
+        });
+    }
+    async addVariable(payload) {
+        const { name, value } = payload;
+        this.clickAddVariableButton();
+        await this.getNthVariableNameInput(1).fill(name);
+        await this.getNthVariableValueInput(1).fill(value);
+    }
+    async fillNumber(number) {
+        await this.numberInput.fill(number);
+    }
+    async clickIncrementButton() {
+        await this.incrementButton.click();
+    }
+    async clickDecrementButton() {
+        await this.decrementButton.click();
+    }
+    async fillDate(date) {
+        await this.dateInput.click();
+        await this.dateInput.fill(date);
+        await this.dateInput.press('Enter');
+    }
+    async enterTime(time) {
+        await this.timeInput.click();
+        await this.page.getByText(time).click();
+    }
+    async checkCheckbox() {
+        await this.checkbox.check();
+    }
+    async selectDropdownValue(value) {
+        await this.selectDropdown.click();
+        await this.page.getByText(value).click();
+    }
+    async clickRadioButton(radioBtnLabel) {
+        await this.page.getByText(radioBtnLabel).click();
+    }
+    async checkChecklistBox(label) {
+        await this.page.getByLabel(label).check();
+    }
+    async enterTwoValuesInTagList(value1, value2) {
+        await this.tagList.click();
+        await this.page.getByText(value1).click();
+        await this.page.getByText(value2, { exact: true }).click();
+    }
+    async clickTextInput() {
+        await this.textInput.click();
+    }
+    async fillTextInput(value) {
+        await this.textInput.fill(value);
+    }
+    async priorityAssertion(priority) {
+        let retryCount = 0;
+        const maxRetries = 2;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.detailsPanel.getByText(priority)).toBeVisible({
+                    timeout: 45000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(10000);
+            }
+        }
+        throw new Error(`Priority not visible after ${maxRetries} attempts.`);
+    }
+    async taskAssertion(name) {
+        let retryCount = 0;
+        const maxRetries = 2;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.detailsInfo.getByText(name)).toBeVisible({
+                    timeout: 45000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(10000);
+            }
+        }
+        throw new Error(`Task not visible after ${maxRetries} attempts.`);
+    }
+    async assertLoadedImage(documentName) {
+        await (0, test_1.expect)(this.page.locator(`img[alt="${documentName}"]`)).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async assertDocumentDownloadButton(documentName) {
+        await (0, test_1.expect)(this.page.locator(`button[aria-label="Download ${documentName}"]`)).toBeVisible({ timeout: 60000 });
+    }
+    async assertPdfPreviewViewerExists() {
+        const containers = this.page.locator('[class="fjs-documentPreview-single-document-container"]');
+        const firstPdfViewer = containers
+            .first()
+            .locator('.fjs-documentPreview-pdf-viewer');
+        const lastPdfViewer = containers
+            .last()
+            .locator('.fjs-documentPreview-pdf-viewer');
+        await (0, test_1.expect)(firstPdfViewer.or(lastPdfViewer)).toBeVisible();
+    }
+    async assertTextIsPresent(expectedText) {
+        const maxAttempts = 3;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            try {
+                await (0, test_1.expect)(this.page.getByText(expectedText).first()).toBeVisible({
+                    timeout: 60000,
+                });
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                await this.page.reload();
+            }
+        }
+    }
+}
+exports.TaskDetailsPage = TaskDetailsPage;

package/dist/pages/SM-8.11/TaskPanelPage.d.ts

@@ -0,0 +1,29 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskPanelPage {
+    private page;
+    readonly availableTasks: Locator;
+    readonly filterPanelExpandButton: Locator;
+    readonly filterPanelCollapseButton: Locator;
+    readonly filterSelectButton: Locator;
+    readonly filterControls: Locator;
+    readonly tasklistBanner: Locator;
+    readonly processesPageTab: Locator;
+    readonly tasksTab: Locator;
+    readonly assignToMeButton: Locator;
+    readonly unassignButton: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    constructor(page: Page);
+    openTask(name: string, assignButton?: boolean): Promise<void>;
+    filterBy(option: 'All open' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
+    private openFilterControls;
+    private static appliedFilterUrl;
+    activeFilter(option: string): Locator;
+    clickCollapseFilter(): Promise<void>;
+    scrollToLastTask(name: string): Promise<void>;
+    scrollToFirstTask(name: string): Promise<void>;
+    clickProcessesTab(): Promise<void>;
+    taskCount(name: string, waitForStable?: boolean): Promise<number>;
+    clickTasksTab(): Promise<void>;
+}
+export { TaskPanelPage };

package/dist/pages/SM-8.11/TaskPanelPage.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskPanelPage = void 0;
+const test_1 = require("@playwright/test");
+const constants_1 = require("../../utils/constants");
+class TaskPanelPage {
+    page;
+    availableTasks;
+    filterPanelExpandButton;
+    filterPanelCollapseButton;
+    filterSelectButton;
+    filterControls;
+    tasklistBanner;
+    processesPageTab;
+    tasksTab;
+    assignToMeButton;
+    unassignButton;
+    licenseKeyTagNonProduction;
+    licenseKeyTagProduction;
+    constructor(page) {
+        this.page = page;
+        // The task-list wrapper's `title="Available tasks"` was removed on
+        // camunda/camunda `main` (8.11-SNAPSHOT) by #65074 ("truncate long task
+        // card labels instead of overflowing the panel"), so
+        // `getByTitle('Available tasks')` matches nothing on the shell the monorepo
+        // helm e2e deploys, and every openTask/completeTask scoped through it times
+        // out. The `<section aria-label="Tasks side panel">` that wraps the panel
+        // is present on both shells -- it is what the product's own
+        // qa/c8-orchestration-cluster-e2e-test-suite TaskPanelPage now anchors on
+        // -- so this also survives the pending backport of #65074 to stable/8.10,
+        // which will remove the same title from the shell the SM nightly deploys.
+        this.availableTasks = page.getByRole('region', { name: 'Tasks side panel' });
+        // SM-8.10 is tested against two different Tasklist shells, so every filter
+        // locator below has to match either one.
+        //
+        // `stable/8.10` -- which is what the published `8.10-SNAPSHOT` images this
+        // repo's own CI deploys are built from -- still renders the Carbon
+        // `CollapsiblePanel`: a collapsed rail carrying the expand control, an
+        // expanded `<nav id="task-nav-bar">` listing each filter as a `<Link>`,
+        // and an `<h1>` naming the active filter.
+        // camunda/camunda `main` is 8.11.0-SNAPSHOT and has replaced that with the
+        // Design System `FilterSelect`: one always-visible trigger (accessible name
+        // "Filters") opening a menu of `menuitem`s, no expand/collapse control and
+        // no `<h1>`. The monorepo's helm e2e deploys an image built from that
+        // commit, so it is the shell seen there.
+        // Matching only one shell is what made this pair of surfaces trade
+        // failures: targeting the Carbon rail found no expand control on the
+        // monorepo run, and targeting the dropdown found no "Filters" button at
+        // all here (`<element(s) not found>`).
+        this.filterPanelExpandButton = page.locator('button[aria-controls="task-nav-bar"][aria-expanded="false"]');
+        this.filterPanelCollapseButton = page.locator('button[aria-controls="task-nav-bar"][aria-expanded="true"]');
+        this.filterSelectButton = page.getByRole('button', {
+            name: 'Filters',
+            exact: true,
+        });
+        // "the task panel's filter control is on screen", whichever shell renders
+        // it: the Carbon rail shows the expand control when collapsed and the
+        // collapse control when expanded, never both.
+        this.filterControls = this.filterPanelExpandButton
+            .or(this.filterPanelCollapseButton)
+            .or(this.filterSelectButton)
+            .first();
+        // Same Design System header rollout NavigationPage.tasklistPageBanner
+        // covers: "Tasklist" is a breadcrumb link once the Carbon shell is gone,
+        // and "Camunda logo Tasklist" while it is still served.
+        this.tasklistBanner = page
+            .getByRole('navigation', { name: 'Camunda context' })
+            .getByRole('link', { name: 'Tasklist', exact: true })
+            .or(page.getByRole('link', { name: 'Camunda logo Tasklist' }))
+            .first();
+        this.processesPageTab = page.getByRole('link', { name: 'Processes' });
+        this.tasksTab = page.getByRole('link', { name: 'Tasks', exact: true });
+        this.assignToMeButton = page.getByRole('button', { name: 'Assign to me' });
+        this.unassignButton = page.getByRole('button', { name: 'Unassign' });
+        this.licenseKeyTagNonProduction = page.getByText('Non-production license', {
+            exact: true,
+        });
+        this.licenseKeyTagProduction = page.getByText('Production license', {
+            exact: true,
+        });
+    }
+    async openTask(name, assignButton = true) {
+        const maxAttempts = 10;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                // Removed waitForLoadState('networkidle') — Tasklist polls
+                // continuously, so networkidle never fires; the click below
+                // already has a 4s timeout that auto-waits for the locator.
+                await this.availableTasks
+                    .getByText(name, { exact: true })
+                    .nth(0)
+                    .click({ timeout: constants_1._1_SECOND_IN_MS * 4 });
+                if (assignButton) {
+                    await (0, test_1.expect)(this.assignToMeButton).toBeVisible({
+                        timeout: constants_1._1_SECOND_IN_MS * 10,
+                    });
+                }
+                return;
+            }
+            catch (error) {
+                if (attempt < maxAttempts) {
+                    console.warn(`Attempt ${attempt} failed. Reloading page...`);
+                    await this.page.reload();
+                    await this.page.waitForLoadState('domcontentloaded');
+                }
+                else {
+                    throw new Error(`Failed to open task "${name}" after ${maxAttempts} attempts: ${error}`);
+                }
+            }
+        }
+    }
+    async filterBy(option) {
+        // Both shells list the options only once their control is open, so open it
+        // first and then pick from whichever of the two the deployed build renders:
+        // a `<Link>` in the Carbon panel's expanded nav, or a `role="menuitem"` in
+        // the Design System dropdown. The Carbon links are scoped to #task-nav-bar
+        // so "Completed" cannot pick up a custom filter or a task row carrying the
+        // same words. Both shells spell the default filter "All open tasks" while
+        // callers pass "All open".
+        //
+        // The task list refetches every 5s behind a suspense boundary, so a poll
+        // landing on the pick can tear the control down before the router
+        // navigates: it closes but the filter never changes, and the test fails
+        // much later on an assertion that reads the still-unfiltered list. Confirm
+        // the route actually carries the filter, and re-pick if it does not.
+        const optionName = option === 'All open' ? 'All open tasks' : option;
+        const filterOption = this.page
+            .locator('#task-nav-bar')
+            .getByRole('link', { name: optionName, exact: true })
+            .or(this.page.getByRole('menuitem', { name: optionName, exact: true }));
+        const maxAttempts = 3;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                // Only the first attempt waits out a slow first render; later
+                // attempts re-pick from a page that has already rendered once, so
+                // they stay short -- three attempts at the full budget would outlast
+                // the 12-minute test timeout and turn a dropped pick into a timeout
+                // with no retry spent.
+                const renderTimeout = attempt === 1 ? 120000 : 15000;
+                await this.openFilterControls();
+                await (0, test_1.expect)(filterOption).toBeVisible({ timeout: renderTimeout });
+                await filterOption.click({ timeout: renderTimeout });
+                const applied = await this.page
+                    .waitForURL(TaskPanelPage.appliedFilterUrl(option), { timeout: 15000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (applied) {
+                    return;
+                }
+                lastError = new Error(`Filter "${option}" was picked but the URL never carried it`);
+            }
+            catch (error) {
+                // Without this catch, a thrown assertion (the control never appearing,
+                // or the option never rendering) propagated straight out of filterBy()
+                // on attempt 1, so attempts 2 and 3 -- and their shorter,
+                // faster-failing budget -- could never run. maxAttempts was dead code.
+                lastError = error;
+            }
+            if (attempt < maxAttempts) {
+                console.warn(`Attempt ${attempt} did not apply the "${option}" filter. Retrying...`);
+            }
+            // This attempt did not land, which leaves the Design System menu in
+            // whichever state Radix last put it. Clicking that trigger again
+            // toggles, so on a still-open menu the next attempt would *close* it and
+            // then burn its whole budget waiting for an option that is gone. Escape
+            // resets it, and is a no-op on both an already-closed menu and the
+            // Carbon panel (whose expanded state openFilterControls() probes for).
+            // It sits outside the catch so a dead page surfaces as itself rather
+            // than replacing the real failure.
+            await this.page.keyboard.press('Escape');
+        }
+        throw new Error(`Filter "${option}" was not applied after ${maxAttempts} attempts: ${lastError}`);
+    }
+    // The Carbon panel renders either the collapsed rail (which carries the
+    // expand control) or the expanded nav -- never both -- and picking a filter
+    // leaves it expanded, so a retry must not click "expand" a second time. The
+    // Design System dropdown has the opposite need: it closes on select, so it
+    // has to be re-opened every attempt. Probing for the Carbon collapse control
+    // first tells the two apart without branching on a version flag.
+    async openFilterControls() {
+        const alreadyExpanded = await this.filterPanelCollapseButton
+            .waitFor({ state: 'visible', timeout: 2000 })
+            .then(() => true)
+            .catch(() => false);
+        if (alreadyExpanded) {
+            return;
+        }
+        // click() auto-waits for the control, so this budget doubles as the wait
+        // for a slow first render of whichever shell is served.
+        await this.filterPanelExpandButton
+            .or(this.filterSelectButton)
+            .first()
+            .click({ timeout: 60000 });
+    }
+    // Tasklist keeps the active filter in the `filter` search param. "All open"
+    // is the route's default and is stripped from the URL, so it is asserted as
+    // the absence of the param.
+    static appliedFilterUrl(option) {
+        const filterParam = {
+            'All open': undefined,
+            Unassigned: 'unassigned',
+            'Assigned to me': 'assigned-to-me',
+            Completed: 'completed',
+        };
+        const param = filterParam[option];
+        return param === undefined
+            ? /\/tasklist(?:\/[^?]*)?(?:\?(?!.*\bfilter=).*)?$/
+            : new RegExp(`[?&]filter=${param}(?:&|$)`);
+    }
+    // Where each shell shows which filter is currently applied: the Carbon
+    // panel renders an `<h1>` naming it, while the Design System dropdown has no
+    // heading and instead carries the label on the trigger itself.
+    activeFilter(option) {
+        return this.page
+            .getByRole('heading', { name: option })
+            .or(this.filterSelectButton.getByText(option, { exact: true }))
+            .first();
+    }
+    // Picking a filter leaves the Carbon panel expanded, and it floats over the
+    // task list -- callers that go straight to a task row would be clicking
+    // through the overlay. The Design System dropdown closes itself on select
+    // and has no collapse control at all, so this probes rather than clicking
+    // unconditionally: on that shell it is a no-op the callers can keep calling.
+    async clickCollapseFilter() {
+        const expanded = await this.filterPanelCollapseButton
+            .waitFor({ state: 'visible', timeout: 2000 })
+            .then(() => true)
+            .catch(() => false);
+        if (expanded) {
+            await this.filterPanelCollapseButton.click({ timeout: 45000 });
+        }
+    }
+    async scrollToLastTask(name) {
+        await this.page.getByText(name).last().scrollIntoViewIfNeeded();
+    }
+    async scrollToFirstTask(name) {
+        await this.page.getByText(name).first().scrollIntoViewIfNeeded();
+    }
+    async clickProcessesTab() {
+        await (0, test_1.expect)(this.processesPageTab).toBeVisible();
+        // Landing on Processes shows either the process search box or, on the
+        // first visit, the "Start your process on demand" onboarding dialog.
+        // `FirstTimeProcessWarning` renders the Processes content only after
+        // consent, so while that dialog is open the search box is not in the
+        // DOM at all -- confirming via the search box alone would never resolve
+        // on a first visit, and the retry would re-click Processes, which the
+        // dialog's modal overlay now covers. Treat either as proof the Processes
+        // view rendered; the caller dismisses the dialog.
+        const processesReady = this.page
+            .getByRole('searchbox', { name: 'Search processes' })
+            .or(this.page.getByRole('dialog', {
+            name: 'Start your process on demand',
+        }));
+        const maxAttempts = 3;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                await this.processesPageTab.click();
+            }
+            catch (error) {
+                // The click belongs inside the try for the same reason filterBy()'s
+                // assertions do: the onboarding dialog's modal overlay covers the
+                // nav, so a click that lands on it throws once the repo's 10s action
+                // timeout expires. Letting that escape made maxAttempts dead code on
+                // exactly the path that needs it. Fall through to the landing probe
+                // below -- a click that threw may still have navigated.
+                lastError = error;
+            }
+            // A newly-arrived task can bounce the app back to the Tasks tab right
+            // as this click lands (nightly SM-8.10 run 31782502787: the click
+            // itself succeeded but the app ended up back on Tasks with the new
+            // task selected), so confirm the Processes view actually rendered
+            // before returning instead of trusting the click alone.
+            const landedOnProcesses = await processesReady
+                .first()
+                .waitFor({ state: 'visible', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (landedOnProcesses) {
+                return;
+            }
+            if (attempt < maxAttempts) {
+                console.warn(`Attempt ${attempt} landed back on Tasks instead of Processes. Retrying...`);
+            }
+        }
+        throw new Error(`Processes tab did not open after ${maxAttempts} attempts: ${lastError}`);
+    }
+    async taskCount(name, waitForStable = true) {
+        // Removed waitForLoadState('networkidle') — Tasklist polls;
+        // the stability poll below already guarantees readiness.
+        if (waitForStable) {
+            // Wait for the task list to stabilize: poll until count is unchanged for 2s
+            let previousCount = -1;
+            let stableIterations = 0;
+            const maxAttempts = 15; // 15 * 1s = 15s max wait
+            for (let i = 0; i < maxAttempts; i++) {
+                const currentCount = await this.availableTasks
+                    .getByText(name, { exact: true })
+                    .count();
+                if (currentCount === previousCount) {
+                    stableIterations++;
+                    if (stableIterations >= 2) {
+                        return currentCount;
+                    }
+                }
+                else {
+                    stableIterations = 0;
+                    previousCount = currentCount;
+                }
+                await this.page.waitForTimeout(1000);
+            }
+        }
+        return this.availableTasks.getByText(name, { exact: true }).count();
+    }
+    async clickTasksTab() {
+        await this.tasksTab.click();
+    }
+}
+exports.TaskPanelPage = TaskPanelPage;

package/dist/pages/SM-8.11/TaskProcessesPage.d.ts

@@ -0,0 +1,15 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskProcessesPage {
+    private page;
+    readonly popupContinueButton: Locator;
+    readonly popup: Locator;
+    readonly processes: Locator;
+    readonly searchProcessesSearchbox: Locator;
+    constructor(page: Page);
+    clickpopupContinueButton(): Promise<void>;
+    private processStartButton;
+    startProcess(name: string): Promise<void>;
+    clickSearchProcessesSearchbox(): Promise<void>;
+    fillSearchProcessesSearchbox(process: string): Promise<void>;
+}
+export { TaskProcessesPage };