@camunda/e2e-test-suite 0.0.1443 → 0.0.1444

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

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessesPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const constants_1 = require("../../utils/constants");
+const env_1 = require("../../utils/env");
+class OperateProcessesPage {
+    page;
+    processResultCount;
+    processActiveCheckbox;
+    processCompletedCheckbox;
+    processRunningInstancesCheckbox;
+    processIncidentsCheckbox;
+    processPageHeading;
+    noMatchingInstancesMessage;
+    processFinishedInstancesCheckbox;
+    moreFiltersButton;
+    processInstanceKeyTextBox;
+    whatsNewPopUp;
+    gotItButton;
+    processesTabLink;
+    constructor(page) {
+        this.page = page;
+        this.processResultCount = page.getByTestId('result-count');
+        this.processesTabLink = page.getByRole('link', { name: 'Processes' });
+        this.processActiveCheckbox = page.locator('input#active');
+        this.processCompletedCheckbox = page.locator('input#completed');
+        this.processRunningInstancesCheckbox = page
+            .getByTestId('filter-running-instances')
+            .getByRole('checkbox');
+        this.processIncidentsCheckbox = page.locator('input#incidents');
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByRole('heading', { name: 'Process' });
+        this.noMatchingInstancesMessage = page.getByText('There are no Instances matching this filter set');
+        this.processFinishedInstancesCheckbox = page
+            .getByTestId('filter-finished-instances')
+            .getByRole('checkbox');
+        this.moreFiltersButton = page.getByRole('button', { name: 'More filters' });
+        this.processInstanceKeyTextBox = page
+            .locator('#processInstanceKey')
+            .or(page.locator('#ids'));
+        this.whatsNewPopUp = page.getByRole('heading', {
+            name: "Here's what moved in Operate",
+        });
+        this.gotItButton = page.getByRole('button', { name: 'Got it' });
+    }
+    // Carbon DS checkboxes are hidden inputs — click the label to trigger React's
+    // synthetic event. Operate's filter sidebar is URL-bound and the URL→state
+    // hydration that runs on mount can revert a click that races with it, so the
+    // setter re-clicks (bounded) when the post-click assertion fails.
+    async setCheckboxState(checkbox, desired) {
+        await checkbox.waitFor({ state: 'attached', timeout: constants_1._1_SECOND_IN_MS * 10 });
+        const checkboxId = await checkbox.getAttribute('id');
+        const MAX_ATTEMPTS = 4;
+        let lastError;
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            if ((await checkbox.isChecked()) !== desired) {
+                if (checkboxId) {
+                    await this.page
+                        .locator(`label[for="${checkboxId}"]`)
+                        .click({ timeout: constants_1._1_SECOND_IN_MS * 10 });
+                }
+                else if (desired) {
+                    await checkbox.check({ force: true, timeout: constants_1._1_SECOND_IN_MS * 10 });
+                }
+                else {
+                    await checkbox.uncheck({ force: true, timeout: constants_1._1_SECOND_IN_MS * 10 });
+                }
+            }
+            try {
+                await (0, test_1.expect)(checkbox).toBeChecked({
+                    checked: desired,
+                    timeout: constants_1._1_SECOND_IN_MS * 5,
+                });
+                return;
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`Checkbox did not settle to checked=${desired} after ${MAX_ATTEMPTS} attempts`);
+    }
+    async checkCheckbox(checkbox) {
+        await this.setCheckboxState(checkbox, true);
+    }
+    async uncheckCheckbox(checkbox) {
+        await this.setCheckboxState(checkbox, false);
+    }
+    async uncheckCompletedCheckbox() {
+        await this.uncheckCheckbox(this.processCompletedCheckbox);
+    }
+    async uncheckActiveCheckbox() {
+        await this.uncheckCheckbox(this.processActiveCheckbox);
+    }
+    async toggleActiveCheckboxOn() {
+        await this.uncheckCompletedCheckbox();
+        // Set — never toggle — the Incidents filter: applyProcessStateFilter is
+        // re-applied after every reload in clickProcessInstanceLink, so a blind
+        // flip oscillates the filter between passes and the lookup never converges.
+        await this.checkCheckbox(this.processIncidentsCheckbox);
+        await this.processActiveCheckbox.waitFor({
+            state: 'attached',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        if (await this.processActiveCheckbox.isChecked({ timeout: constants_1._1_SECOND_IN_MS })) {
+            await this.uncheckCheckbox(this.processActiveCheckbox);
+            await (0, sleep_1.sleep)(200); // Required to skip the debounce protection on the frontend
+            await this.checkCheckbox(this.processActiveCheckbox);
+        }
+        else {
+            await this.checkCheckbox(this.processActiveCheckbox);
+        }
+    }
+    async toggleCompletedCheckbox() {
+        await this.uncheckActiveCheckbox();
+        await this.checkCheckbox(this.processIncidentsCheckbox);
+        await this.processCompletedCheckbox.waitFor({
+            state: 'attached',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        if (await this.processCompletedCheckbox.isChecked({ timeout: constants_1._1_SECOND_IN_MS })) {
+            await this.uncheckCheckbox(this.processCompletedCheckbox);
+            await (0, sleep_1.sleep)(200); // Required to skip the debounce protection on the frontend
+            await this.checkCheckbox(this.processCompletedCheckbox);
+        }
+        else {
+            await this.checkCheckbox(this.processCompletedCheckbox);
+            await (0, sleep_1.sleep)(200);
+        }
+    }
+    async applyProcessStateFilter(type) {
+        if (type === 'active') {
+            await this.toggleActiveCheckboxOn();
+        }
+        else {
+            await this.toggleCompletedCheckbox();
+        }
+    }
+    // Operate raises the "Here's what moved in Operate" modal on a first page
+    // load, and every test here logs in as a freshly created user, so it is up on
+    // the Processes view. Its Carbon overlay swallows clicks on the Processes tab
+    // link and on the filter checkbox labels, which is why a reload-recovery pass
+    // could make no progress at all. Dismiss it before interacting with the view,
+    // not only after an instance page has opened.
+    async dismissWhatsNewPopUp() {
+        // isVisible() returns immediately — Playwright ignores its `timeout`
+        // option — so this probe got none of the 2s grace it reads as having. Right
+        // after a reload Operate has usually not mounted the modal yet, the probe
+        // reported "not open", and the Carbon overlay then intercepted every click
+        // in the recovery loop below until the 720s test timeout. waitFor spends
+        // the 2s the probe was written to spend.
+        const isOpen = await this.whatsNewPopUp
+            .waitFor({ state: 'visible', timeout: constants_1._1_SECOND_IN_MS * 2 })
+            .then(() => true)
+            .catch(() => false);
+        if (!isOpen) {
+            return;
+        }
+        await this.gotItButton.click({ timeout: constants_1._1_SECOND_IN_MS * 10 });
+        await (0, test_1.expect)(this.whatsNewPopUp).toBeHidden({
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+    }
+    async checkTableForProcess(processName) {
+        try {
+            const processTable = this.page.locator('[aria-label="Process Instances Panel"]');
+            await (0, test_1.expect)(processTable).toBeVisible({ timeout: constants_1._1_SECOND_IN_MS * 4 });
+            const timeout = env_1.isOpenSearch ? constants_1._1_MINUTE_IN_MS : constants_1._1_SECOND_IN_MS * 20;
+            const row = this.page.locator(`tr:has-text("${processName}")`).first();
+            await (0, test_1.expect)(row).toBeVisible({ timeout });
+            const link = row.locator('a').first();
+            await (0, test_1.expect)(link).toBeVisible({ timeout: constants_1._1_SECOND_IN_MS * 2 });
+            await link.scrollIntoViewIfNeeded();
+            await link.click({ timeout: constants_1._1_SECOND_IN_MS * 2 });
+            await (0, test_1.expect)(this.page.getByText('Instance History').first()).toBeVisible({ timeout: constants_1._1_SECOND_IN_MS * 10 });
+            await this.dismissWhatsNewPopUp();
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async clickProcessActiveCheckbox() {
+        await this.processActiveCheckbox.waitFor({
+            state: 'attached',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        if (!(await this.processActiveCheckbox.isChecked())) {
+            await this.processActiveCheckbox.check({ force: true, timeout: 120000 });
+            await (0, test_1.expect)(this.processActiveCheckbox).toBeChecked({
+                checked: true,
+                timeout: constants_1._1_SECOND_IN_MS * 5,
+            });
+        }
+    }
+    async clickProcessCompletedCheckbox() {
+        await this.processCompletedCheckbox.waitFor({
+            state: 'attached',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        if (!(await this.processCompletedCheckbox.isChecked())) {
+            await this.processCompletedCheckbox.check({ force: true, timeout: 120000 });
+            await (0, test_1.expect)(this.processCompletedCheckbox).toBeChecked({
+                checked: true,
+                timeout: constants_1._1_SECOND_IN_MS * 5,
+            });
+        }
+    }
+    async clickProcessIncidentsCheckbox() {
+        await this.processIncidentsCheckbox.waitFor({
+            state: 'attached',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        const wasChecked = await this.processIncidentsCheckbox.isChecked();
+        await this.setCheckboxState(this.processIncidentsCheckbox, !wasChecked);
+    }
+    async clickRunningProcessInstancesCheckbox() {
+        await this.processRunningInstancesCheckbox.waitFor({
+            state: 'attached',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        const wasChecked = await this.processRunningInstancesCheckbox.isChecked();
+        if (wasChecked) {
+            await this.processRunningInstancesCheckbox.uncheck({
+                force: true,
+                timeout: 90000,
+            });
+        }
+        else {
+            await this.processRunningInstancesCheckbox.check({
+                force: true,
+                timeout: 90000,
+            });
+        }
+        await (0, test_1.expect)(this.processRunningInstancesCheckbox).toBeChecked({
+            checked: !wasChecked,
+            timeout: constants_1._1_SECOND_IN_MS * 5,
+        });
+    }
+    async clickFinishedProcessInstancesCheckbox() {
+        await this.processFinishedInstancesCheckbox.waitFor({
+            state: 'visible',
+            timeout: constants_1._1_SECOND_IN_MS * 10,
+        });
+        const wasChecked = await this.processFinishedInstancesCheckbox.isChecked();
+        await this.processFinishedInstancesCheckbox.click({ timeout: 90000 });
+        await (0, test_1.expect)(this.processFinishedInstancesCheckbox).toBeChecked({
+            checked: !wasChecked,
+            timeout: constants_1._1_SECOND_IN_MS * 5,
+        });
+    }
+    async clickProcessInstanceLink(processName, type = 'active') {
+        await this.dismissWhatsNewPopUp();
+        await this.applyProcessStateFilter(type);
+        if (await this.checkTableForProcess(processName)) {
+            return;
+        }
+        const MAX_ATTEMPTS = 30;
+        const TOTAL_TIMEOUT_MS = constants_1._1_MINUTE_IN_MS * 10;
+        let attempt = 0;
+        let lastError;
+        const startTime = Date.now();
+        const operateUrl = this.page.url();
+        while (Date.now() - startTime < TOTAL_TIMEOUT_MS &&
+            attempt < MAX_ATTEMPTS) {
+            attempt++;
+            try {
+                if (await this.checkTableForProcess(processName)) {
+                    return;
+                }
+                throw new Error(`Instance "${processName}" not found in table (attempt ${attempt}).`);
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : err;
+                console.log(`clickProcessInstanceLink attempt ${attempt}: ${String(lastError)}`);
+                await (0, sleep_1.sleep)(constants_1._1_SECOND_IN_MS * 3);
+                await this.page
+                    .reload({ timeout: 30000 })
+                    .catch(() => console.log('Page reload timed out, continuing...'));
+                await this.page
+                    .waitForLoadState('networkidle', { timeout: 30000 })
+                    .catch(() => console.log('waitForLoadState networkidle timed out, continuing...'));
+                // After reload, the page may redirect away from Operate
+                if (!this.page.url().includes('/operate')) {
+                    await this.page
+                        .goto(operateUrl, { timeout: 30000 })
+                        .catch(() => console.log('Navigation to Operate timed out, continuing...'));
+                    await this.page
+                        .waitForLoadState('networkidle', { timeout: 30000 })
+                        .catch(() => console.log('waitForLoadState after Operate navigation timed out, continuing...'));
+                }
+                // The reload re-raises the what's-new modal, and its overlay would
+                // otherwise intercept both the Processes tab click and the checkbox
+                // labels below, so no attempt in this loop could ever converge.
+                await this.dismissWhatsNewPopUp();
+                // Operate may land on the Dashboard after reload even when the captured
+                // URL pointed at the Processes view.  The filter checkboxes only exist on
+                // the Processes tab, so navigate there explicitly before applying filters.
+                try {
+                    await this.processesTabLink.waitFor({
+                        state: 'visible',
+                        timeout: constants_1._1_SECOND_IN_MS * 10,
+                    });
+                    await this.processesTabLink.click({ timeout: constants_1._1_SECOND_IN_MS * 10 });
+                    await this.page
+                        .waitForLoadState('networkidle', { timeout: 30000 })
+                        .catch(() => { });
+                }
+                catch (navErr) {
+                    console.log(`Processes tab click failed after reload: ${String(navErr)}`);
+                }
+                // Re-apply checkbox filter lost after reload
+                try {
+                    await this.applyProcessStateFilter(type);
+                }
+                catch (toggleErr) {
+                    console.log(`Checkbox toggle failed after reload: ${String(toggleErr)}`);
+                }
+                // Re-fill Process Instance Key filter if it was previously applied
+                // but its value was cleared by the reload.
+                try {
+                    const isFilterVisible = await this.processInstanceKeyTextBox.isVisible();
+                    if (isFilterVisible) {
+                        const currentValue = await this.processInstanceKeyTextBox.inputValue();
+                        if (!currentValue) {
+                            await this.processInstanceKeyTextBox.fill(processName);
+                        }
+                    }
+                }
+                catch {
+                    // Filter input not available, skip
+                }
+                await (0, sleep_1.sleep)(2000);
+            }
+        }
+        throw new Error(`Failed to open instance "${processName}" after ${attempt} attempts (${Math.round((Date.now() - startTime) / 1000)}s elapsed). Last error: ${String(lastError)}`);
+    }
+    async clickProcessInstanceLinkWithPartialNameMatch(processName) {
+        let retryCount = 0;
+        const maxRetries = 5;
+        while (retryCount < maxRetries) {
+            try {
+                const process = this.page
+                    .locator(`td:right-of(:has-text("${processName}"))`)
+                    .first();
+                await (0, test_1.expect)(process).toBeVisible({ timeout: 60000 });
+                await process.click({ timeout: 60000 });
+                await (0, test_1.expect)(this.page.getByText('Instance History').first()).toBeVisible({
+                    timeout: 30000,
+                });
+                return;
+            }
+            catch (error) {
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+                await this.page.waitForTimeout(10000);
+            }
+        }
+        throw new Error(`Failed to click on process instance link containing "${processName}" after ${maxRetries} attempts.`);
+    }
+    getMoreFilterValueLocator(filter) {
+        switch (filter.trim()) {
+            case 'Process Instance Key(s)':
+                return this.processInstanceKeyTextBox;
+            default:
+                throw new Error(`Unsupported filter: "${filter}". Add a mapping in getMoreFilterValueLocator().`);
+        }
+    }
+    async applyMoreFilters(filter, value) {
+        await this.moreFiltersButton.click();
+        await this.page.getByRole('menuitem', { name: filter }).click();
+        const valueInput = this.getMoreFilterValueLocator(filter);
+        await (0, test_1.expect)(valueInput).toBeVisible({ timeout: 10000 });
+        await valueInput.fill(value);
+        await (0, sleep_1.sleep)(2000);
+    }
+}
+exports.OperateProcessesPage = OperateProcessesPage;

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

@@ -0,0 +1,17 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeCollectionsPage {
+    private page;
+    readonly collectionsPageHeader: Locator;
+    readonly createNewButton: Locator;
+    readonly reportOption: Locator;
+    readonly modalCloseButton: Locator;
+    readonly processReport: Locator;
+    readonly collectionsLink: Locator;
+    readonly reportAuthor: Locator;
+    constructor(page: Page);
+    clickCreateNewButton(): Promise<void>;
+    clickReportOption(): Promise<void>;
+    clickMostRecentProcessReport(reportName: string): Promise<void>;
+    clickFirstProcessReport(): Promise<void>;
+}
+export { OptimizeCollectionsPage };

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeCollectionsPage = void 0;
+class OptimizeCollectionsPage {
+    page;
+    collectionsPageHeader;
+    createNewButton;
+    reportOption;
+    modalCloseButton;
+    processReport;
+    collectionsLink;
+    reportAuthor;
+    constructor(page) {
+        this.page = page;
+        this.collectionsPageHeader = page.getByRole('heading', {
+            name: 'Collections, Dashboards, and Reports',
+        });
+        this.createNewButton = page.getByRole('button', {
+            name: 'Create new',
+            exact: true,
+        });
+        this.reportOption = page.getByText('Report', { exact: true });
+        this.modalCloseButton = page.getByText('Close', { exact: true });
+        this.processReport = page.getByText('Process Report').first();
+        this.collectionsLink = page.getByRole('link', { name: 'Collections' });
+        this.reportAuthor = page.getByRole('cell', { name: 'Demo User' }).first();
+    }
+    async clickCreateNewButton() {
+        if (await this.modalCloseButton.isVisible({ timeout: 2000 })) {
+            await this.modalCloseButton.click();
+        }
+        await this.collectionsLink.click({ timeout: 60000 });
+        await this.createNewButton.click({ timeout: 90000 });
+    }
+    async clickReportOption() {
+        await this.reportOption.click();
+    }
+    async clickMostRecentProcessReport(reportName) {
+        await this.page.getByText(reportName).click({ timeout: 60000 });
+    }
+    async clickFirstProcessReport() {
+        const cells = await this.page
+            .getByRole('cell', { name: /Process report/ })
+            .all();
+        if (cells.length === 0) {
+            throw new Error('No process report cells found');
+        }
+        const cell = cells[0];
+        const text = (await cell.textContent())?.trim();
+        if (!text) {
+            throw new Error('Could not read cell text');
+        }
+        const match = text.match(/^(\S+)\s*Process report$/i);
+        if (!match) {
+            throw new Error(`Unexpected text format: ${text}`);
+        }
+        const dynamicValue = match[1];
+        await cell.click();
+        await this.page.getByRole('link', { name: dynamicValue }).click();
+    }
+}
+exports.OptimizeCollectionsPage = OptimizeCollectionsPage;

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

@@ -0,0 +1,14 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeDashboardPage {
+    private page;
+    readonly filterTable: Locator;
+    constructor(page: Page);
+    clickFilterTable(): Promise<void>;
+    fillFilterTable(processName: string): Promise<void>;
+    processOwnerNameAssertion(processName: string): Promise<void>;
+    processAssertion(processName: string, { timeout, not }?: {
+        timeout?: number;
+        not?: boolean;
+    }): Promise<void>;
+}
+export { OptimizeDashboardPage };

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeDashboardPage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeDashboardPage {
+    page;
+    filterTable;
+    constructor(page) {
+        this.page = page;
+        // Optimize's Design System EntityList replaced the Carbon table toolbar
+        // search (placeholder "Filter table") with a plain input whose placeholder
+        // is the `home.search.name` translation, "Search for name...". Match
+        // either so the filter resolves on both shells.
+        this.filterTable = page
+            .getByPlaceholder(/Search for name/i)
+            .or(page.getByPlaceholder('Filter table'))
+            .first();
+    }
+    async clickFilterTable() {
+        await this.filterTable.click({ timeout: 180000 });
+    }
+    async fillFilterTable(processName) {
+        await this.filterTable.fill(processName, { timeout: 60000 });
+        await this.filterTable.press('Enter');
+    }
+    async processOwnerNameAssertion(processName) {
+        try {
+            await this.page.reload();
+            await (0, test_1.expect)(this.page.getByRole('row', {
+                name: processName + ' Process QA Camunda',
+            })).toBeVisible({ timeout: 180000 });
+        }
+        catch {
+            await this.page.reload();
+            await (0, test_1.expect)(this.page.getByRole('row', {
+                name: processName + ' Process QA Camunda',
+            })).toBeVisible({ timeout: 180000 });
+        }
+    }
+    async processAssertion(processName, { timeout = 180000, not = false } = {}) {
+        const interval = 45000;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            const locator = this.page.getByTitle(processName).first();
+            try {
+                if (not) {
+                    await (0, test_1.expect)(locator).not.toBeVisible({ timeout: interval });
+                }
+                else {
+                    await (0, test_1.expect)(locator).toBeVisible({ timeout: interval });
+                }
+                return;
+            }
+            catch (e) {
+                if (Date.now() - start + interval >= timeout) {
+                    throw e;
+                }
+                await this.page.reload();
+            }
+        }
+    }
+}
+exports.OptimizeDashboardPage = OptimizeDashboardPage;

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

@@ -0,0 +1,19 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeHomePage {
+    private page;
+    readonly collectionsLink: Locator;
+    readonly dashboardLink: Locator;
+    readonly modalCloseButton: Locator;
+    readonly optimizeBanner: Locator;
+    readonly openUserSettingsButton: Locator;
+    readonly logoutButton: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    constructor(page: Page);
+    clickCollectionsLink(): Promise<void>;
+    clickDashboardLink(): Promise<void>;
+    assertProcessHasBeenImported(processId: string): Promise<void>;
+    clickOpenUserSettingsButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+}
+export { OptimizeHomePage };

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeHomePage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeHomePage {
+    page;
+    collectionsLink;
+    dashboardLink;
+    modalCloseButton;
+    optimizeBanner;
+    openUserSettingsButton;
+    logoutButton;
+    licenseKeyTagNonProduction;
+    licenseKeyTagProduction;
+    constructor(page) {
+        this.page = page;
+        // Optimize's Design System navigation moved Dashboards/Collections out of
+        // the top banner into a left sidebar (`<nav aria-label="Main navigation">`),
+        // so a banner-scoped link can no longer resolve. Match either shell.
+        this.collectionsLink = page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Collections' })
+            .or(page.getByRole('banner').getByRole('link', { name: 'Collections' }))
+            .first();
+        this.dashboardLink = page.getByRole('link', { name: 'Dashboard' });
+        this.modalCloseButton = page.getByText('Close', { exact: true });
+        // See NavigationPage.optimizePageBanner: the Design System header renders
+        // the logo as its own anchor labelled "Camunda Optimize", so the legacy
+        // combined "Camunda logo Optimize" name is gone. Match either shell.
+        this.optimizeBanner = page
+            .getByRole('link', { name: 'Camunda logo Optimize' })
+            .or(page.getByRole('link', { name: 'Camunda Optimize', exact: true }))
+            .first();
+        this.openUserSettingsButton = page.getByLabel('Open User');
+        this.logoutButton = page.getByRole('button', { name: 'Logout' });
+        this.licenseKeyTagNonProduction = page
+            .getByText('Non-production license')
+            .first();
+        this.licenseKeyTagProduction = page.getByText('Production license').first();
+    }
+    async clickCollectionsLink() {
+        if (await this.modalCloseButton.isVisible({ timeout: 2000 })) {
+            await this.modalCloseButton.click();
+        }
+        await this.collectionsLink.click();
+    }
+    async clickDashboardLink() {
+        if (await this.modalCloseButton.isVisible({ timeout: 2000 })) {
+            await this.modalCloseButton.click();
+        }
+        await this.dashboardLink.click();
+    }
+    async assertProcessHasBeenImported(processId) {
+        await this.clickDashboardLink();
+        // The process list is paginated, so on a cluster with more than one page
+        // of processes the new one is not rendered until the list is filtered by
+        // name. Import is asynchronous, so reload and re-filter until it appears.
+        const search = this.page
+            .getByPlaceholder(/Search for name/i)
+            .or(this.page.getByPlaceholder('Filter table'))
+            .first();
+        const processLink = this.page.getByRole('link', { name: processId });
+        await (0, test_1.expect)(async () => {
+            await this.page.reload();
+            await search.fill(processId, { timeout: 30000 });
+            await (0, test_1.expect)(processLink).toBeVisible({ timeout: 15000 });
+        }).toPass({ timeout: 180000, intervals: [5000, 10000, 15000] });
+    }
+    async clickOpenUserSettingsButton() {
+        await this.openUserSettingsButton.click();
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click();
+    }
+}
+exports.OptimizeHomePage = OptimizeHomePage;