@camunda/e2e-test-suite 0.0.1

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

@@ -0,0 +1,39 @@
+import { Page, Locator } from '@playwright/test';
+declare class ModelerHomePage {
+    private page;
+    private defaultFolderName;
+    readonly modelerPageBanner: Locator;
+    readonly createNewProjectButton: Locator;
+    readonly projectNameInput: Locator;
+    readonly chooseBpmnTemplateButton: Locator;
+    readonly diagramTypeDropdown: Locator;
+    readonly bpmnTemplateOption: Locator;
+    readonly formTemplateOption: Locator;
+    readonly projectBreadcrumb: Locator;
+    readonly openOrganizationsButton: Locator;
+    readonly manageButton: Locator;
+    readonly rows: Locator;
+    readonly crossComponentProjectFolder: Locator;
+    readonly homeBreadcrumb: Locator;
+    readonly formNameInput: Locator;
+    readonly uploadFilesButton: Locator;
+    constructor(page: Page);
+    clickCreateNewProjectButton(): Promise<void>;
+    reload(): Promise<void>;
+    enterNewProjectName(name: string): Promise<void>;
+    clickChooseBpmnTemplateButton(): Promise<void>;
+    clickHomeBreadcrumb(): Promise<void>;
+    enterFormName(name: string): Promise<void>;
+    clickCrossComponentProjectFolder(): Promise<void>;
+    createForm(formName: string): Promise<void>;
+    createCrossComponentProjectFolder(): Promise<void>;
+    clickProcessDiagram(name: string): Promise<void>;
+    clickDiagramTypeDropdown(): Promise<void>;
+    clickBpmnTemplateOption(): Promise<void>;
+    clickFormOption(): Promise<void>;
+    clickProjectBreadcrumb(): Promise<void>;
+    clickOpenOrganizationsButton(): Promise<void>;
+    clickManageButton(retries?: number): Promise<void>;
+    clickUploadFilesButton(): Promise<void>;
+}
+export { ModelerHomePage };

package/dist/pages/8.5/ModelerHomePage.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelerHomePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class ModelerHomePage {
+    page;
+    defaultFolderName = 'Cross Component Test Project';
+    modelerPageBanner;
+    createNewProjectButton;
+    projectNameInput;
+    chooseBpmnTemplateButton;
+    diagramTypeDropdown;
+    bpmnTemplateOption;
+    formTemplateOption;
+    projectBreadcrumb;
+    openOrganizationsButton;
+    manageButton;
+    rows;
+    crossComponentProjectFolder;
+    homeBreadcrumb;
+    formNameInput;
+    uploadFilesButton;
+    constructor(page) {
+        this.page = page;
+        this.modelerPageBanner = page.getByRole('banner', {
+            name: 'Camunda Modeler',
+        });
+        this.createNewProjectButton = page.getByRole('button', {
+            name: 'New project',
+        });
+        this.projectNameInput = page.locator('[data-test="editable-input"]');
+        this.chooseBpmnTemplateButton = page.getByRole('button', {
+            name: 'Choose BPMN template',
+        });
+        this.diagramTypeDropdown = page.locator('[data-test="diagram-dropdown"]');
+        this.bpmnTemplateOption = page
+            .locator('[data-test="create-bpmn-diagram"]')
+            .getByText('BPMN Diagram');
+        this.formTemplateOption = page
+            .locator('[data-test="create-form"]')
+            .getByText('Form');
+        this.projectBreadcrumb = page.locator('[data-test="breadcrumb-project"]');
+        this.openOrganizationsButton = page.getByLabel('Open Organizations');
+        this.manageButton = page.getByRole('button', { name: 'Manage' });
+        this.rows = page.getByRole('row');
+        this.formNameInput = page.locator('[data-test="editable-input"]');
+        this.crossComponentProjectFolder = page
+            .getByText(this.defaultFolderName, { exact: true })
+            .first();
+        this.homeBreadcrumb = page.locator('[data-test="breadcrumb-home"]');
+        this.uploadFilesButton = page.getByRole('menuitem', { name: 'Upload files' });
+    }
+    async clickCreateNewProjectButton() {
+        await this.createNewProjectButton.click({ timeout: 30000 });
+    }
+    async reload() {
+        await this.page.reload();
+    }
+    async enterNewProjectName(name) {
+        await this.projectNameInput.click({ timeout: 60000 });
+        await this.projectNameInput.fill(name);
+        await this.projectNameInput.press('Enter');
+    }
+    async clickChooseBpmnTemplateButton() {
+        await this.chooseBpmnTemplateButton.click();
+    }
+    async clickHomeBreadcrumb() {
+        try {
+            await this.homeBreadcrumb.click();
+        }
+        catch (error) {
+            await this.page.getByText('Home', { exact: true }).first().click();
+        }
+    }
+    async enterFormName(name) {
+        await this.formNameInput.click({ timeout: 60000 });
+        await this.formNameInput.fill(name);
+        await this.formNameInput.press('Enter');
+    }
+    async clickCrossComponentProjectFolder() {
+        await (0, test_1.expect)(this.crossComponentProjectFolder).toBeVisible({
+            timeout: 60000,
+        });
+        await this.crossComponentProjectFolder.click();
+    }
+    async createForm(formName) {
+        await this.clickDiagramTypeDropdown();
+        await this.clickFormOption();
+        await this.enterFormName(formName);
+        await (0, sleep_1.sleep)(10000);
+    }
+    async createCrossComponentProjectFolder() {
+        await (0, sleep_1.sleep)(15000);
+        if (await this.crossComponentProjectFolder.isVisible()) {
+            console.log('Cross Component Project folder already exists. Clicking into it');
+            await this.clickCrossComponentProjectFolder();
+            return;
+        }
+        await this.clickCreateNewProjectButton();
+        await this.enterNewProjectName(this.defaultFolderName);
+    }
+    async clickProcessDiagram(name) {
+        const process = this.rows.filter({ hasText: name }).getByTitle(name).first();
+        await (0, test_1.expect)(process).toBeVisible({ timeout: 30000 });
+        await process.click();
+    }
+    async clickDiagramTypeDropdown() {
+        await this.diagramTypeDropdown.click({ timeout: 60000 });
+    }
+    async clickBpmnTemplateOption() {
+        await this.bpmnTemplateOption.click({ timeout: 120000 });
+    }
+    async clickFormOption() {
+        await this.formTemplateOption.click();
+    }
+    async clickProjectBreadcrumb() {
+        await this.projectBreadcrumb.click({ timeout: 60000 });
+    }
+    async clickOpenOrganizationsButton() {
+        await this.openOrganizationsButton.click({ timeout: 90000 });
+    }
+    async clickManageButton(retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await this.manageButton.click({ timeout: 60000 });
+                return; // Click succeeded, exit the loop
+            }
+            catch (error) {
+                console.error(`Attempt ${i + 1} to click manage button failed: ${error}`);
+                await (0, sleep_1.sleep)(10000);
+                await this.clickOpenOrganizationsButton();
+            }
+        }
+        throw new Error(`Failed to click manage button after ${retries} retries`);
+    }
+    async clickUploadFilesButton() {
+        await this.uploadFilesButton.click({ timeout: 60000 });
+    }
+}
+exports.ModelerHomePage = ModelerHomePage;

package/dist/pages/8.5/ModelerUserInvitePage.d.ts

@@ -0,0 +1,27 @@
+import { Page, Locator } from '@playwright/test';
+declare class ModelerUserInvitePage {
+    private page;
+    private user_name;
+    readonly buttonAddUser: Locator;
+    readonly inputFieldUserEmailAddress: Locator;
+    readonly buttonSendInvitation: Locator;
+    readonly pendingInviteText: Locator;
+    readonly settings: Locator;
+    readonly logout: Locator;
+    readonly buttonSkipCustomization: Locator;
+    readonly buttonCloseHelpCentre: Locator;
+    readonly collaboratorName: Locator;
+    constructor(page: Page);
+    clickAddUser(): Promise<void>;
+    clickUserEmailInput(): Promise<void>;
+    fillUserEmailInput(emailAddress?: string): Promise<void>;
+    clickSendInviteButton(): Promise<void>;
+    checkPendingInviteText(email: string): Promise<void>;
+    inviteNewUser(): Promise<void>;
+    clickSettings(): Promise<void>;
+    clickLogout(): Promise<void>;
+    clickSkipCustomization(retries?: number): Promise<void>;
+    clickCloseHelpCenter(): Promise<void>;
+    verifyCollaboratorName(): Promise<void>;
+}
+export { ModelerUserInvitePage };

package/dist/pages/8.5/ModelerUserInvitePage.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelerUserInvitePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class ModelerUserInvitePage {
+    page;
+    user_name;
+    buttonAddUser;
+    inputFieldUserEmailAddress;
+    buttonSendInvitation;
+    pendingInviteText;
+    settings;
+    logout;
+    buttonSkipCustomization;
+    buttonCloseHelpCentre;
+    collaboratorName;
+    constructor(page) {
+        this.page = page;
+        this.buttonAddUser = page.locator('[data-test="add-collaborator"]');
+        this.inputFieldUserEmailAddress = page.locator('[data-test="multi-select-input"]');
+        this.buttonSendInvitation = page.locator('[data-test="invite-email-button"]');
+        this.pendingInviteText = page.getByText('pending');
+        this.settings = page.getByLabel('Open Settings');
+        this.logout = page.getByRole('button', { name: 'Log out' });
+        this.buttonSkipCustomization = page.getByRole('button', {
+            name: 'Skip customization',
+        });
+        this.buttonCloseHelpCentre = page.getByRole('button', { name: 'Close' });
+        this.collaboratorName = page.getByText('QA Camunda');
+    }
+    async clickAddUser() {
+        await (0, test_1.expect)(this.buttonAddUser).toBeVisible({ timeout: 60000 });
+        await this.buttonAddUser.click({ timeout: 30000 });
+    }
+    async clickUserEmailInput() {
+        await (0, test_1.expect)(this.inputFieldUserEmailAddress).toBeVisible({
+            timeout: 60000,
+        });
+        await this.inputFieldUserEmailAddress.click();
+    }
+    async fillUserEmailInput(emailAddress = this.user_name) {
+        await this.inputFieldUserEmailAddress.fill(emailAddress);
+        await (0, test_1.expect)(this.inputFieldUserEmailAddress).toHaveValue(emailAddress);
+        await this.inputFieldUserEmailAddress.press('Enter');
+    }
+    async clickSendInviteButton() {
+        await (0, test_1.expect)(this.buttonSendInvitation).toBeVisible({ timeout: 60000 });
+        await this.buttonSendInvitation.click();
+    }
+    async checkPendingInviteText(email) {
+        await (0, test_1.expect)(this.page.getByRole('row').filter({ hasText: `${email}` })).toContainText('pending', {
+            timeout: 120000,
+        });
+    }
+    async inviteNewUser() {
+        await this.clickAddUser();
+        await this.clickUserEmailInput();
+        await this.fillUserEmailInput();
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        await sleep(8000);
+        await this.clickSendInviteButton();
+    }
+    async clickSettings() {
+        await (0, test_1.expect)(this.settings).toBeVisible({ timeout: 60000 });
+        await this.settings.click({ timeout: 90000 });
+    }
+    async clickLogout() {
+        await (0, test_1.expect)(this.logout).toBeVisible({ timeout: 60000 });
+        await this.logout.click({ timeout: 50000 });
+    }
+    async clickSkipCustomization(retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await (0, test_1.expect)(this.page.getByText('Personalize your experience')).toBeVisible({
+                    timeout: 60000,
+                });
+                await (0, test_1.expect)(this.buttonSkipCustomization).toBeVisible({
+                    timeout: 60000,
+                });
+                await this.buttonSkipCustomization.click();
+                await (0, test_1.expect)(this.page.getByText('Personalize your experience')).not.toBeVisible({
+                    timeout: 30000,
+                });
+                return;
+            }
+            catch (error) {
+                console.error(`Attempt ${i + 1} to click customization button failed: ${error}`);
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Failed to click customization button after ${retries} retries`);
+    }
+    async clickCloseHelpCenter() {
+        await (0, test_1.expect)(this.buttonCloseHelpCentre).toBeVisible({ timeout: 60000 });
+        await this.buttonCloseHelpCentre.click();
+    }
+    async verifyCollaboratorName() {
+        await (0, test_1.expect)(this.collaboratorName).toBeVisible({ timeout: 60000 });
+    }
+}
+exports.ModelerUserInvitePage = ModelerUserInvitePage;

package/dist/pages/8.5/OperateHomePage.d.ts

@@ -0,0 +1,21 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateHomePage {
+    private page;
+    readonly operateHeader: Locator;
+    readonly processesTab: Locator;
+    readonly informationDialog: Locator;
+    readonly editVariableButton: Locator;
+    readonly variableValueInput: Locator;
+    readonly saveVariableButton: Locator;
+    readonly editVariableSpinner: Locator;
+    readonly operateBanner: Locator;
+    constructor(page: Page);
+    clickProcessesTab(): Promise<void>;
+    closeInformationDialog(): Promise<void>;
+    clickEditVariableButton(variableName: string): Promise<void>;
+    clickVariableValueInput(): Promise<void>;
+    clearVariableValueInput(): Promise<void>;
+    fillVariableValueInput(value: string): Promise<void>;
+    clickSaveVariableButton(): Promise<void>;
+}
+export { OperateHomePage };

package/dist/pages/8.5/OperateHomePage.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateHomePage = void 0;
+class OperateHomePage {
+    page;
+    operateHeader;
+    processesTab;
+    informationDialog;
+    editVariableButton;
+    variableValueInput;
+    saveVariableButton;
+    editVariableSpinner;
+    operateBanner;
+    constructor(page) {
+        this.page = page;
+        this.operateHeader = page.getByRole('link', { name: 'Camunda Operate' });
+        this.processesTab = page.getByRole('link', {
+            name: 'Processes',
+            exact: true,
+        });
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.editVariableButton = page.getByTestId('edit-variable-button');
+        this.variableValueInput = page.getByTestId('edit-variable-value');
+        this.saveVariableButton = page.getByLabel('Save variable');
+        this.editVariableSpinner = page
+            .getByTestId('variable-operation-spinner')
+            .locator('circle')
+            .nth(1);
+        this.operateBanner = page.getByRole('link', { name: 'Camunda logo Operate' });
+    }
+    async clickProcessesTab() {
+        await this.processesTab.click();
+    }
+    async closeInformationDialog() {
+        await this.informationDialog.click();
+    }
+    async clickEditVariableButton(variableName) {
+        const editVariableButton = 'Edit variable ' + variableName;
+        await this.page.getByLabel(editVariableButton).click();
+    }
+    async clickVariableValueInput() {
+        await this.variableValueInput.click();
+    }
+    async clearVariableValueInput() {
+        await this.variableValueInput.clear();
+    }
+    async fillVariableValueInput(value) {
+        await this.variableValueInput.fill(value);
+    }
+    async clickSaveVariableButton() {
+        await this.saveVariableButton.click();
+    }
+}
+exports.OperateHomePage = OperateHomePage;

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

@@ -0,0 +1,14 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessInstancePage {
+    private page;
+    readonly diagram: Locator;
+    readonly completedIcon: Locator;
+    readonly diagramSpinner: Locator;
+    readonly activeIcon: Locator;
+    readonly incidentIcon: Locator;
+    constructor(page: Page);
+    reload(): Promise<void>;
+    connectorResultVariableName(name: string): Promise<Locator>;
+    connectorResultVariableValue(variableName: string): Promise<Locator>;
+}
+export { OperateProcessInstancePage };

package/dist/pages/8.5/OperateProcessInstancePage.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessInstancePage = void 0;
+class OperateProcessInstancePage {
+    page;
+    diagram;
+    completedIcon;
+    diagramSpinner;
+    activeIcon;
+    incidentIcon;
+    constructor(page) {
+        this.page = page;
+        this.diagram = page.getByTestId('diagram');
+        this.completedIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('COMPLETED-icon');
+        this.diagramSpinner = page.getByTestId('diagram-spinner');
+        this.activeIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('ACTIVE-icon');
+        this.incidentIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('INCIDENT-icon');
+    }
+    async reload() {
+        await this.page.reload();
+    }
+    async connectorResultVariableName(name) {
+        return await this.page.getByTestId(name);
+    }
+    async connectorResultVariableValue(variableName) {
+        return await this.page.getByTestId(variableName).locator('td').last();
+    }
+}
+exports.OperateProcessInstancePage = OperateProcessInstancePage;

package/dist/pages/8.5/OperateProcessesPage.d.ts

@@ -0,0 +1,21 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessesPage {
+    private page;
+    readonly processResultCount: Locator;
+    readonly processActiveCheckbox: Locator;
+    readonly processCompletedCheckbox: Locator;
+    readonly processRunningInstancesCheckbox: Locator;
+    readonly processIncidentsCheckbox: Locator;
+    readonly processPageHeading: Locator;
+    readonly noMatchingInstancesMessage: Locator;
+    readonly processFinishedInstancesCheckbox: Locator;
+    constructor(page: Page);
+    clickProcessActiveCheckbox(): Promise<void>;
+    clickProcessCompletedCheckbox(): Promise<void>;
+    clickProcessIncidentsCheckbox(): Promise<void>;
+    clickRunningProcessInstancesCheckbox(): Promise<void>;
+    clickFinishedProcessInstancesCheckbox(): Promise<void>;
+    reload(): Promise<void>;
+    clickProcessInstanceLink(processName: string): Promise<void>;
+}
+export { OperateProcessesPage };

package/dist/pages/8.5/OperateProcessesPage.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessesPage = void 0;
+const test_1 = require("@playwright/test");
+class OperateProcessesPage {
+    page;
+    processResultCount;
+    processActiveCheckbox;
+    processCompletedCheckbox;
+    processRunningInstancesCheckbox;
+    processIncidentsCheckbox;
+    processPageHeading;
+    noMatchingInstancesMessage;
+    processFinishedInstancesCheckbox;
+    constructor(page) {
+        this.page = page;
+        this.processResultCount = page.getByTestId('result-count');
+        this.processActiveCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Active' });
+        this.processCompletedCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Completed' });
+        this.processRunningInstancesCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Running Instances' });
+        this.processIncidentsCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Incidents' });
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByText('Process', { exact: true });
+        this.noMatchingInstancesMessage = page.getByText('There are no Instances matching this filter set');
+        this.processFinishedInstancesCheckbox = page
+            .getByTestId('filter-finished-instances')
+            .getByRole('checkbox');
+    }
+    async clickProcessActiveCheckbox() {
+        await this.processActiveCheckbox.click();
+    }
+    async clickProcessCompletedCheckbox() {
+        await this.processCompletedCheckbox.click({ timeout: 30000 });
+    }
+    async clickProcessIncidentsCheckbox() {
+        await this.processIncidentsCheckbox.click();
+    }
+    async clickRunningProcessInstancesCheckbox() {
+        await this.processRunningInstancesCheckbox.click();
+    }
+    async clickFinishedProcessInstancesCheckbox() {
+        await this.processFinishedInstancesCheckbox.click();
+    }
+    async reload() {
+        await this.page.reload();
+    }
+    async clickProcessInstanceLink(processName) {
+        const maxRetries = 5;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                const process = this.page
+                    .locator('td:right-of(:text("' + processName + '"))')
+                    .first();
+                await (0, test_1.expect)(process).toBeVisible({ timeout: 60000 });
+                await process.click({ timeout: 60000 });
+                return;
+            }
+            catch (error) {
+                console.error(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+                await this.page.reload();
+            }
+        }
+        throw new Error(`Failed to click the link after ${maxRetries} attempts.`);
+    }
+}
+exports.OperateProcessesPage = OperateProcessesPage;

package/dist/pages/8.5/OptimizeCollectionsPage.d.ts

@@ -0,0 +1,15 @@
+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;
+    constructor(page: Page);
+    clickCreateNewButton(): Promise<void>;
+    clickReportOption(): Promise<void>;
+    clickMostRecentProcessReport(reportName: string): Promise<void>;
+}
+export { OptimizeCollectionsPage };

package/dist/pages/8.5/OptimizeCollectionsPage.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeCollectionsPage = void 0;
+class OptimizeCollectionsPage {
+    page;
+    collectionsPageHeader;
+    createNewButton;
+    reportOption;
+    modalCloseButton;
+    processReport;
+    collectionsLink;
+    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' });
+    }
+    async clickCreateNewButton() {
+        try {
+            await this.modalCloseButton.click({ timeout: 60000 });
+            await this.collectionsLink.click({ timeout: 60000 });
+            await this.createNewButton.click({ timeout: 60000 });
+        }
+        catch (error) {
+            await this.collectionsLink.click({ timeout: 60000 });
+            await this.createNewButton.click({ timeout: 60000 });
+        }
+    }
+    async clickReportOption() {
+        await this.reportOption.click();
+    }
+    async clickMostRecentProcessReport(reportName) {
+        await this.page.getByText(reportName).click({ timeout: 60000 });
+    }
+}
+exports.OptimizeCollectionsPage = OptimizeCollectionsPage;

package/dist/pages/8.5/OptimizeDashboardPage.d.ts

@@ -0,0 +1,8 @@
+import { Page } from '@playwright/test';
+declare class OptimizeDashboardPage {
+    private page;
+    constructor(page: Page);
+    processLinkAssertion(processName: string, maxRetries?: number, retryDelay?: number): Promise<void>;
+    processOwnerNameAssertion(processName: string, maxRetries?: number, retryDelay?: number): Promise<void>;
+}
+export { OptimizeDashboardPage };

package/dist/pages/8.5/OptimizeDashboardPage.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeDashboardPage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeDashboardPage {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    async processLinkAssertion(processName, maxRetries = 5, retryDelay = 60000) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await (0, test_1.expect)(this.page.getByRole('link', { name: processName })).toBeVisible({ timeout: 70000 });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed for asserting process link in Optimize. Retrying...`);
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+                else {
+                    throw new Error(`Process link in Optimize assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async processOwnerNameAssertion(processName, maxRetries = 5, retryDelay = 60000) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await (0, test_1.expect)(this.page.getByRole('link', { name: 'Process ' + processName })).toContainText('QA Camunda', { timeout: 60000 });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed for asserting owner name in Optimize.. Retrying...`);
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+                else {
+                    throw new Error(`Owner name assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+}
+exports.OptimizeDashboardPage = OptimizeDashboardPage;

package/dist/pages/8.5/OptimizeHomePage.d.ts

@@ -0,0 +1,12 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeHomePage {
+    private page;
+    readonly collectionsLink: Locator;
+    readonly dashboardLink: Locator;
+    readonly modalCloseButton: Locator;
+    readonly optimizeBanner: Locator;
+    constructor(page: Page);
+    clickCollectionsLink(): Promise<void>;
+    clickDashboardLink(): Promise<void>;
+}
+export { OptimizeHomePage };