@camunda/e2e-test-suite 0.0.1443 → 0.0.1445

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

@@ -0,0 +1,50 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeReportPage {
+    private page;
+    readonly processSelectionButton: Locator;
+    readonly userTaskProcess: Locator;
+    readonly versionSelection: Locator;
+    readonly alwaysDisplayLatestSelection: Locator;
+    readonly createReportLink: Locator;
+    readonly durationButton: Locator;
+    readonly countOption: Locator;
+    readonly processInstanceButton: Locator;
+    readonly userTaskOption: Locator;
+    readonly heatMapButton: Locator;
+    readonly numberButton: Locator;
+    readonly tableOption: Locator;
+    readonly reportName: Locator;
+    readonly saveButton: Locator;
+    readonly oneUserTaskInstance: Locator;
+    readonly twoUserTaskInstance: Locator;
+    readonly cancelButton: Locator;
+    readonly createNewButton: Locator;
+    readonly reportOption: Locator;
+    readonly processInstanceCount: Locator;
+    readonly blankReportButton: Locator;
+    readonly selectDropdown: Locator;
+    constructor(page: Page);
+    clickProcessSelectionButton(): Promise<void>;
+    clickUserTaskProcess(processName: string): Promise<void>;
+    clickVersionSelection(): Promise<void>;
+    clickAlwaysDisplayLatestSelection(): Promise<void>;
+    clickCreateReportLink(): Promise<void>;
+    clickDurationButton(): Promise<void>;
+    clickCountOption(): Promise<void>;
+    clickProcessInstanceButton(): Promise<void>;
+    clickUserTaskOption(): Promise<void>;
+    clickHeatMapButton(): Promise<void>;
+    clickNumberButton(): Promise<void>;
+    clickTableOption(): Promise<void>;
+    clickReportName(): Promise<void>;
+    clearReportName(): Promise<void>;
+    fillReportName(name: string): Promise<void>;
+    clickSaveButton(): Promise<void>;
+    waitUntilLocatorIsVisible(locator: Locator, tab: Page): Promise<void>;
+    waitUntilProcessIsVisible(locator: Locator, tab: Page): Promise<void>;
+    clickBlankReportButton(): Promise<void>;
+    clickSelectDropdown(): Promise<void>;
+    waitUntilUserTaskProcessIsVisible(processName: string): Promise<void>;
+    clickCancelButton(): Promise<void>;
+}
+export { OptimizeReportPage };

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

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeReportPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class OptimizeReportPage {
+    page;
+    processSelectionButton;
+    userTaskProcess;
+    versionSelection;
+    alwaysDisplayLatestSelection;
+    createReportLink;
+    durationButton;
+    countOption;
+    processInstanceButton;
+    userTaskOption;
+    heatMapButton;
+    numberButton;
+    tableOption;
+    reportName;
+    saveButton;
+    oneUserTaskInstance;
+    twoUserTaskInstance;
+    cancelButton;
+    createNewButton;
+    reportOption;
+    processInstanceCount;
+    blankReportButton;
+    selectDropdown;
+    constructor(page) {
+        this.page = page;
+        this.processSelectionButton = page.getByPlaceholder('Select...');
+        this.userTaskProcess = page.getByText('User_Task_Process', { exact: true });
+        this.versionSelection = page.getByLabel('Version');
+        this.alwaysDisplayLatestSelection = page.getByText('Always display latest');
+        this.createReportLink = page.getByRole('link', { name: 'Create Report' });
+        this.durationButton = page.getByRole('button', { name: 'Duration' });
+        this.countOption = page.getByText('Count').first();
+        this.processInstanceButton = page.getByRole('button', {
+            name: 'Process Instance',
+            exact: true,
+        });
+        this.userTaskOption = page.getByRole('menuitemcheckbox', {
+            name: 'User task',
+        });
+        this.heatMapButton = page.getByRole('button', { name: 'Heatmap' });
+        this.numberButton = page.getByRole('button', { name: 'Number' });
+        this.tableOption = page.getByText('Table');
+        this.reportName = page.getByPlaceholder('Report name');
+        this.saveButton = page.getByRole('button', { name: 'Save' });
+        this.oneUserTaskInstance = page.getByRole('cell', { name: '1', exact: true });
+        this.twoUserTaskInstance = page.getByRole('cell', { name: '2', exact: true });
+        this.cancelButton = page.getByRole('button', { name: 'Cancel' });
+        this.createNewButton = page.getByRole('button', {
+            name: 'Create New',
+            exact: true,
+        });
+        this.reportOption = page.getByText('Report', { exact: true });
+        this.processInstanceCount = page.locator('.progressLabel');
+        this.blankReportButton = page.getByRole('button', { name: 'Blank report' });
+        this.selectDropdown = page
+            .getByRole('button', { name: 'Select... Open menu' })
+            .last();
+    }
+    async clickProcessSelectionButton() {
+        await (0, test_1.expect)(this.processSelectionButton).toBeVisible({ timeout: 180000 });
+        await this.processSelectionButton.click({ timeout: 180000 });
+    }
+    async clickUserTaskProcess(processName) {
+        const processOption = this.page
+            .getByText(processName, { exact: true })
+            .first();
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            await (0, test_1.expect)(processOption).toBeVisible({ timeout: 30000 });
+            await processOption.click();
+            // Optimize keeps refetching the definition list while the modal is open.
+            // A refetch that lands right after the click remounts the version
+            // list-box and drops the selection with it, so Version stays disabled and
+            // the caller's toBeEnabled assertion times out. Confirm the selection
+            // committed and re-pick when a remount swallowed it. Deliberately no
+            // throw here: the caller's assertion stays the gate on this state.
+            try {
+                await (0, test_1.expect)(this.versionSelection).toBeEnabled({ timeout: 15000 });
+                return;
+            }
+            catch (error) {
+                console.warn(`Attempt ${attempt} to select process ${processName} left the version selection disabled, retrying...`, error instanceof Error ? error.message : error);
+            }
+        }
+    }
+    async clickVersionSelection() {
+        await this.versionSelection.click();
+    }
+    async clickAlwaysDisplayLatestSelection() {
+        await this.alwaysDisplayLatestSelection.click();
+    }
+    async clickCreateReportLink() {
+        await this.createReportLink.click();
+    }
+    async clickDurationButton() {
+        await this.durationButton.click();
+    }
+    async clickCountOption() {
+        await this.countOption.click();
+    }
+    async clickProcessInstanceButton() {
+        await this.processInstanceButton.click();
+    }
+    async clickUserTaskOption() {
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                await this.userTaskOption.click();
+                return; // success
+            }
+            catch (error) {
+                if (attempt < 3) {
+                    await this.clickSelectDropdown();
+                }
+                else {
+                    throw new Error(`clickUserTaskOption failed after 3 attempts: ${error}`);
+                }
+            }
+        }
+    }
+    async clickHeatMapButton() {
+        if (await this.heatMapButton.isVisible()) {
+            await this.heatMapButton.click();
+        }
+    }
+    async clickNumberButton() {
+        if (await this.numberButton.isVisible()) {
+            await this.numberButton.click();
+        }
+    }
+    async clickTableOption() {
+        await this.tableOption.click();
+    }
+    async clickReportName() {
+        await this.reportName.click();
+    }
+    async clearReportName() {
+        await this.reportName.clear({ force: true });
+    }
+    async fillReportName(name) {
+        await this.reportName.fill(name, { force: true });
+    }
+    async clickSaveButton() {
+        await this.saveButton.click();
+        // Saving persists the report and leaves edit mode, replacing the report-name
+        // input with the read-only report view. clickSaveButton used to return the
+        // instant the click dispatched, so the caller navigated away while the report
+        // was still dirty and Optimize raised its "Unsaved changes" route-guard modal.
+        // That modal exposes only "Don't save"/"Save changes"/X — none of which the
+        // recovery loop's Close-button dismissal matches — so it intercepted every
+        // subsequent Collections click and burned the whole test budget. Wait for edit
+        // mode to exit here so navigation starts from a clean report; a save that
+        // never persists now fails fast instead of hanging on a blocked recovery loop.
+        await (0, test_1.expect)(this.reportName).toBeHidden({ timeout: 60000 });
+    }
+    async waitUntilLocatorIsVisible(locator, tab) {
+        let elapsedTime = 0;
+        const maxWaitTimeSeconds = 300000;
+        while (elapsedTime < maxWaitTimeSeconds) {
+            const element = await locator;
+            if (await element.isVisible()) {
+                return;
+            }
+            await tab.reload();
+            await tab.waitForTimeout(10 * 1000);
+            // Update the elapsed time
+            elapsedTime += 10000;
+        }
+    }
+    async waitUntilProcessIsVisible(locator, tab) {
+        let elapsedTime = 0;
+        const maxWaitTimeSeconds = 240000;
+        while (elapsedTime < maxWaitTimeSeconds) {
+            const element = await locator;
+            if (await element.isVisible()) {
+                return;
+            }
+            await this.cancelButton.click();
+            await tab.reload();
+            await tab.waitForTimeout(10 * 1000);
+            // Update the elapsed time
+            elapsedTime += 10000;
+            await this.createNewButton.click();
+            await this.reportOption.click();
+            await this.processSelectionButton.click();
+        }
+    }
+    async clickBlankReportButton() {
+        await this.blankReportButton.click();
+    }
+    async clickSelectDropdown() {
+        await this.selectDropdown.click();
+        await (0, sleep_1.sleep)(10000);
+    }
+    async waitUntilUserTaskProcessIsVisible(processName) {
+        await (0, test_1.expect)(this.page.getByText(processName, { exact: true })).toBeVisible({
+            timeout: 1000,
+        });
+    }
+    async clickCancelButton() {
+        await this.cancelButton.click();
+    }
+}
+exports.OptimizeReportPage = OptimizeReportPage;

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

@@ -0,0 +1,47 @@
+import { Page, Locator } from '@playwright/test';
+declare class PlayPage {
+    private page;
+    readonly completeJobButton: Locator;
+    readonly viewScenarioButton: Locator;
+    readonly runAllScenariosButton: Locator;
+    readonly confirmDeleteScenarioButton: Locator;
+    readonly viewAllScenariosButton: Locator;
+    readonly getScenarioRowByName: (scenarioName: string) => Locator;
+    readonly getScenarioRow: (scenarioName: string) => Locator;
+    readonly diagram: Locator;
+    readonly startInstanceButton: Locator;
+    readonly startInstanceWithCachedButton: Locator;
+    readonly configureTestPanel: Locator;
+    readonly configureTestPanelStartButton: Locator;
+    readonly notifications: Locator;
+    readonly scenarioSavedToast: Locator;
+    readonly scenarioDetailNameInput: Locator;
+    readonly scenarioDetailSaveButton: Locator;
+    readonly loadingInstanceDetailsText: Locator;
+    readonly retryButton: Locator;
+    readonly dialog: Locator;
+    readonly inputPanelStartButton: Locator;
+    constructor(page: Page);
+    waitForCompleteJobButtonToBeAvailable(): Promise<void>;
+    clickCompleteJobButton(): Promise<void>;
+    clickStartInstanceButton(): Promise<void>;
+    dismissStartModal(): Promise<void>;
+    clickStartInstanceWithCachedButton(): Promise<void>;
+    waitForInstanceDetailsToBeLoaded(): Promise<void>;
+    waitForNextElementToBeActive(historyItem: string): Promise<void>;
+    waitForProcessToBeCompleted(): Promise<void>;
+    waitForScenarioRecordPanelReady(): Promise<void>;
+    clickViewScenarioButton(): Promise<void>;
+    enterScenarioName(scenarioName: string): Promise<void>;
+    updateScenarioName(newScenarioName: string): Promise<void>;
+    clickViewAllScenariosButton(): Promise<void>;
+    confirmSaveScenario(): Promise<void>;
+    assertSavedScenarioNameInPanel(scenarioName: string): Promise<void>;
+    getDeleteIconForScenario(scenarioName: string): Promise<Locator>;
+    deleteScenario(scenarioName: string): Promise<void>;
+    confirmDeleteScenario(): Promise<void>;
+    clickRunAllScenariosButton(): Promise<void>;
+    clickmessagePublishButton(): Promise<void>;
+    assertScenarioCompleted(scenarioName: string): Promise<void>;
+}
+export { PlayPage };