@camunda/e2e-test-suite 0.0.257 → 0.0.258

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskPanelPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const constants_1 = require("../../utils/constants");
+class TaskPanelPage {
+    page;
+    availableTasks;
+    filterOptions;
+    tasklistBanner;
+    collapseFilter;
+    processesPageTab;
+    tasksTab;
+    assignToMeButton;
+    unassignButton;
+    licenseKeyTagNonProduction;
+    licenseKeyTagProduction;
+    constructor(page) {
+        this.page = page;
+        this.availableTasks = page.getByTitle('Available tasks');
+        this.filterOptions = page
+            .locator('[aria-label="Filter controls"] li')
+            .filter({ hasText: 'Expand to show filters' });
+        this.tasklistBanner = page.getByRole('link', {
+            name: 'Camunda logo Tasklist',
+        });
+        this.collapseFilter = page.locator('button[aria-controls="task-nav-bar"][aria-expanded="true"]');
+        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) {
+        for (let attempt = 1; attempt <= 30; attempt++) {
+            try {
+                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 < 30) {
+                    console.warn(`Attempt ${attempt} failed. Reloading page...`);
+                    await this.page.reload();
+                }
+                else {
+                    throw new Error(`Failed to open task "${name}" after 3 attempts: ${error}`);
+                }
+            }
+        }
+    }
+    async filterBy(option) {
+        await this.filterOptions.click({ timeout: 45000 });
+        await (0, test_1.expect)(this.page.getByRole('link', { name: option })).toBeVisible({
+            timeout: 120000,
+        });
+        await this.page.getByRole('link', { name: option }).click({ timeout: 120000 });
+    }
+    async scrollToLastTask(name) {
+        await this.page.getByText(name).last().scrollIntoViewIfNeeded();
+    }
+    async scrollToFirstTask(name) {
+        await this.page.getByText(name).first().scrollIntoViewIfNeeded();
+    }
+    async clickCollapseFilter() {
+        await this.collapseFilter.click({ timeout: 45000 });
+    }
+    async clickProcessesTab() {
+        await (0, test_1.expect)(this.processesPageTab).toBeVisible();
+        await this.processesPageTab.click();
+    }
+    async taskCount(name) {
+        await (0, sleep_1.sleep)(50000);
+        return this.availableTasks.getByText(name, { exact: true }).count();
+    }
+    async clickTasksTab() {
+        await this.tasksTab.click();
+    }
+}
+exports.TaskPanelPage = TaskPanelPage;

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

@@ -0,0 +1,14 @@
+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>;
+    startProcess(name: string): Promise<void>;
+    clickSearchProcessesSearchbox(): Promise<void>;
+    fillSearchProcessesSearchbox(process: string): Promise<void>;
+}
+export { TaskProcessesPage };

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProcessesPage = void 0;
+const test_1 = require("@playwright/test");
+const UtilitiesPage_1 = require("./UtilitiesPage");
+class TaskProcessesPage {
+    page;
+    popupContinueButton;
+    popup;
+    processes;
+    searchProcessesSearchbox;
+    constructor(page) {
+        this.page = page;
+        this.popupContinueButton = page.getByRole('button', { name: 'Continue' });
+        this.popup = page.getByLabel('Start your process on demand');
+        this.processes = page.locator('[data-testid="process-tile"]');
+        this.searchProcessesSearchbox = page.getByRole('searchbox', {
+            name: 'Search processes',
+        });
+    }
+    async clickpopupContinueButton() {
+        try {
+            await (0, test_1.expect)(this.popupContinueButton).toBeVisible({ timeout: 15000 });
+            await this.popupContinueButton.click({ timeout: 15000 });
+            await (0, test_1.expect)(this.popupContinueButton).not.toBeVisible({ timeout: 60000 });
+        }
+        catch (error) {
+            console.log('Popup not present');
+        }
+    }
+    async startProcess(name) {
+        const found = await (0, UtilitiesPage_1.findTextWithPagination)(this.page, name, 60000, async () => {
+            await this.page
+                .locator('[data-testid="process-tile"]')
+                .filter({ hasText: name })
+                .getByRole('button', { name: 'Start process' })
+                .click({ timeout: 60000 });
+        });
+        if (!found) {
+            throw new Error(`Process "${name}" not found in pagination`);
+        }
+        await (0, test_1.expect)(this.page.getByText('Waiting for tasks...')).not.toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickSearchProcessesSearchbox() {
+        await this.searchProcessesSearchbox.click();
+    }
+    async fillSearchProcessesSearchbox(process) {
+        await this.searchProcessesSearchbox.fill(process);
+    }
+}
+exports.TaskProcessesPage = TaskProcessesPage;

package/dist/pages/SM-8.10/UtilitiesPage.d.ts

@@ -0,0 +1,34 @@
+import { ModelerHomePage } from './ModelerHomePage';
+import { ModelerCreatePage } from './ModelerCreatePage';
+import { Locator, Page } from '@playwright/test';
+import { TaskDetailsPage } from '../SM-8.10/TaskDetailsPage';
+import { TaskPanelPage } from '../SM-8.10/TaskPanelPage';
+import { ConnectorSettingsPage } from '../SM-8.10/ConnectorSettingsPage';
+import { ConnectorMarketplacePage } from '../SM-8.10/ConnectorMarketplacePage';
+import { ConnectorTemplatePage } from './ConnectorTemplatePage';
+import { NavigationPage } from '../SM-8.10/NavigationPage';
+import { ManagementIdentityPage } from '../SM-8.10/ManagementIdentityPage';
+import { KeycloakLoginPage } from '../SM-8.10/KeycloakLoginPage';
+import { KeycloakAdminPage } from '../SM-8.10/KeycloakAdminPage';
+import { OCIdentityHomePage } from '../SM-8.10/OCIdentityHomePage';
+import { OCIdentityMappingRulesPage } from '../SM-8.10/OCIdentityMappingRulesPage';
+import { OCIdentityRolesPage } from '../SM-8.10/OCIdentityRolesPage';
+import { Serializable } from 'playwright-core/types/structs';
+export declare function deleteAllUserGroups(): Promise<void>;
+export declare function runMultipleProcesses(page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, numberOfProcesses: number, processName: string, processId?: string): Promise<void>;
+export declare function createUserAndAssignToRole(page: Page, navigationPage: NavigationPage, managementIdentityPage: ManagementIdentityPage, keycloakLoginPage: KeycloakLoginPage, keycloakAdminPage: KeycloakAdminPage, ocIdentityHomePage: OCIdentityHomePage, identityMappingRulesPage: OCIdentityMappingRulesPage, identityRolesPage: OCIdentityRolesPage, username: string, password: string, role?: string, testMappings?: Serializable): Promise<void>;
+export declare function assignMappingToRole(page: Page, ocIdentityHomePage: OCIdentityHomePage, ocIdentityRolesPage: OCIdentityRolesPage, role: string, mappingRuleId: string, testMappings?: Serializable): Promise<void>;
+export declare function createAndRunProcess(page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, processName: string, processId?: string): Promise<void>;
+export declare function completeTaskWithRetry(page: Page, taskPanelPage: TaskPanelPage, taskDetailsPage: TaskDetailsPage, taskName: string, taskPriority: string, maxRetries?: number): Promise<void>;
+export declare function modelRestConnector(modelerCreatePage: ModelerCreatePage, connectorSettingsPage: ConnectorSettingsPage, connectorMarketplacePage: ConnectorMarketplacePage, processName: string, url: string, auth: string, resultExpression: string, resultVariable?: string, basicAuthCredentials?: {
+    username: string;
+    password: string;
+}): Promise<void>;
+export declare function assertLocatorVisibleWithPaginated(page: Page, locator: Locator, text: string): Promise<void>;
+export declare function assertLocatorVisibleWithRetry(page: Page, locator: Locator, text: string, timeout?: number, notVisible?: boolean, maxRetries?: number, clickLocator?: Locator): Promise<void>;
+export declare function assertPageTextWithRetry(page: Page, text: string, notVisible?: boolean, timeout?: number, maxRetries?: number): Promise<void>;
+export declare function modelAndRunConnectorsTimerEventDiagram(modelerCreatePage: ModelerCreatePage, modelerHomePage: ModelerHomePage, processName: string, page: Page, connectorMarketplacePage: ConnectorMarketplacePage, connectorTemplatePage: ConnectorTemplatePage): Promise<void>;
+export declare function findTextWithPagination(page: Page, text: string, timeout?: number, action?: (locator: Locator) => Promise<void>): Promise<boolean>;
+export declare function modelDiagramFromFile(page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, processName: string, fileName?: string, nrOfRenamedUserTasks?: number, taskName?: string): Promise<void>;
+export declare function expectTextWithPagination(page: Page, text: string, shouldExist?: boolean, timeout?: number): Promise<void>;
+export declare function modelAndRunConnectorsDocHandlingDiagram(modelerCreatePage: ModelerCreatePage, modelerHomePage: ModelerHomePage, processName: string, page: Page, connectorMarketplacePage: ConnectorMarketplacePage, zeebeUrl: string, zeebeClientId: string, zeebeClientSecret: string, endpoint: string): Promise<void>;

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

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelAndRunConnectorsDocHandlingDiagram = exports.expectTextWithPagination = exports.modelDiagramFromFile = exports.findTextWithPagination = exports.modelAndRunConnectorsTimerEventDiagram = exports.assertPageTextWithRetry = exports.assertLocatorVisibleWithRetry = exports.assertLocatorVisibleWithPaginated = exports.modelRestConnector = exports.completeTaskWithRetry = exports.createAndRunProcess = exports.assignMappingToRole = exports.createUserAndAssignToRole = exports.runMultipleProcesses = exports.deleteAllUserGroups = void 0;
+const sleep_1 = require("../../utils/sleep");
+const test_1 = require("@playwright/test");
+const fileUpload_1 = require("../../utils/fileUpload");
+const findLocatorInPaginatedList_1 = require("../../utils/findLocatorInPaginatedList");
+const KeycloakUtils_1 = require("../SM-8.10/KeycloakUtils");
+const expectLocatorWithPagination_1 = require("../../utils/assertionHelpers/expectLocatorWithPagination");
+// This step will be skipped until new Identity expected flow is confirmed
+async function deleteAllUserGroups() {
+    // await navigationPage.goToOCIdentity();
+    // await identityPage.clickGroupsTab();
+    // await identityPage.deleteAllGroups();
+}
+exports.deleteAllUserGroups = deleteAllUserGroups;
+async function runMultipleProcesses(page, modelerHomePage, modelerCreatePage, numberOfProcesses, processName, processId = '') {
+    for (let i = 1; i <= numberOfProcesses; i++) {
+        await createAndRunProcess(page, modelerHomePage, modelerCreatePage, processName + i, processId.length > 0 ? processId + i : processId);
+    }
+}
+exports.runMultipleProcesses = runMultipleProcesses;
+async function createUserAndAssignToRole(page, navigationPage, managementIdentityPage, keycloakLoginPage, keycloakAdminPage, ocIdentityHomePage, identityMappingRulesPage, identityRolesPage, username, password, role = 'admin', testMappings) {
+    const mappingRuleId = `${username}-user-mapping`;
+    const claimName = 'preferred_username';
+    await (0, KeycloakUtils_1.createUser)(navigationPage, managementIdentityPage, keycloakLoginPage, keycloakAdminPage, username, password);
+    await navigationPage.goToOCIdentity();
+    await ocIdentityHomePage.clickMappingRulesTab();
+    await identityMappingRulesPage.createMappingRule(mappingRuleId, mappingRuleId, claimName, username);
+    await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(page, identityMappingRulesPage.mappingRuleRow(mappingRuleId).first());
+    if (testMappings && mappingRuleId.toLowerCase() != 'demo-user-mapping') {
+        testMappings.mappingIds.push(mappingRuleId);
+    }
+    await assignMappingToRole(page, ocIdentityHomePage, identityRolesPage, role, mappingRuleId, testMappings);
+    await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(page, identityMappingRulesPage
+        .mappingRuleRow(mappingRuleId)
+        .filter({
+        hasText: `${mappingRuleId}${mappingRuleId}${claimName}${username}`,
+    })
+        .first());
+}
+exports.createUserAndAssignToRole = createUserAndAssignToRole;
+async function assignMappingToRole(page, ocIdentityHomePage, ocIdentityRolesPage, role, mappingRuleId, testMappings) {
+    await ocIdentityHomePage.clickRolesTab();
+    try {
+        await (0, test_1.expect)(ocIdentityRolesPage.roleCell(role).first()).toBeVisible({
+            timeout: 20000,
+        });
+    }
+    catch (error) {
+        await ocIdentityRolesPage.createRole({ id: role, name: role });
+        if (testMappings && role.toLowerCase() != 'admin') {
+            testMappings.roleIds.push(role);
+        }
+    }
+    await ocIdentityRolesPage.assignMappingRuleToRole(role, mappingRuleId);
+    await assertLocatorVisibleWithPaginated(page, ocIdentityRolesPage.mappingRuleRow(mappingRuleId).first(), `${mappingRuleId} Mapping Rule`);
+}
+exports.assignMappingToRole = assignMappingToRole;
+async function createAndRunProcess(page, modelerHomePage, modelerCreatePage, processName, processId = '') {
+    await modelerHomePage.clickDiagramTypeDropdown();
+    await modelerHomePage.clickBpmnTemplateOption();
+    await modelerCreatePage.modelCamundaUserTaskDiagram(processName, processId);
+    await modelerCreatePage.runProcessInstance();
+    await modelerHomePage.clickProjectBreadcrumb();
+}
+exports.createAndRunProcess = createAndRunProcess;
+async function completeTaskWithRetry(page, taskPanelPage, taskDetailsPage, taskName, taskPriority, maxRetries = 7) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await page.waitForLoadState('networkidle');
+            await (0, sleep_1.sleep)(500);
+            const taskExists = await taskPanelPage.availableTasks
+                .getByText(taskName, { exact: true })
+                .first()
+                .isVisible({ timeout: 10000 });
+            if (!taskExists) {
+                throw new Error(`Task ${taskName} not found in available tasks`);
+            }
+            await taskPanelPage.openTask(taskName, false);
+            await (0, sleep_1.sleep)(500);
+            await (0, test_1.expect)(taskDetailsPage.detailsPanel).toBeVisible({ timeout: 30000 });
+            if (!(await taskDetailsPage.assignedToMeText.isVisible({ timeout: 5000 }))) {
+                await taskDetailsPage.clickAssignToMeButton();
+            }
+            await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible({ timeout: 30000 });
+            await taskDetailsPage.clickCompleteTaskButton();
+            await (0, test_1.expect)(taskPanelPage.availableTasks.getByText(taskName, { exact: true }).first()).not.toBeVisible({ timeout: 60000 });
+            console.log(`Successfully completed task: ${taskName}`);
+            return;
+        }
+        catch (error) {
+            console.warn(`Attempt ${attempt + 1} failed for completing task ${taskName}:`, error instanceof Error ? error.message : error);
+            if (attempt < maxRetries - 1) {
+                await page.reload();
+                await page.waitForLoadState('networkidle');
+                await (0, sleep_1.sleep)(500);
+            }
+            else {
+                console.error(`All ${maxRetries} attempts failed for task ${taskName}`);
+                throw new Error(`Completion of task ${taskName} failed after ${maxRetries} attempts`);
+            }
+        }
+    }
+}
+exports.completeTaskWithRetry = completeTaskWithRetry;
+async function modelRestConnector(modelerCreatePage, connectorSettingsPage, connectorMarketplacePage, processName, url, auth, resultExpression, resultVariable = '', basicAuthCredentials = {
+    username: '',
+    password: '',
+}) {
+    await (0, test_1.expect)(modelerCreatePage.generalPanel).toBeVisible({
+        timeout: 120000,
+    });
+    await modelerCreatePage.enterDiagramName(processName);
+    await (0, sleep_1.sleep)(1000);
+    await modelerCreatePage.clickCanvas();
+    await modelerCreatePage.clickGeneralPropertiesPanel();
+    await modelerCreatePage.clickIdInput();
+    await modelerCreatePage.fillIdInput(processName);
+    await modelerCreatePage.assertNameInput(processName);
+    await (0, sleep_1.sleep)(1000);
+    await modelerCreatePage.clickStartEventElement();
+    try {
+        await (0, test_1.expect)(modelerCreatePage.appendElementButton).toBeVisible({
+            timeout: 1000,
+        });
+    }
+    catch {
+        await modelerCreatePage.clickStartEventElement();
+    }
+    await modelerCreatePage.clickAppendElementButton();
+    await modelerCreatePage.clickAppendTaskButton();
+    await modelerCreatePage.clickChangeTypeButton();
+    try {
+        await (0, test_1.expect)(modelerCreatePage.restConnectorOption).toBeVisible({
+            timeout: 15000,
+        });
+    }
+    catch (error) {
+        await modelerCreatePage.clickMarketPlaceButton();
+        await connectorMarketplacePage.clickSearchForConnectorTextbox();
+        await connectorMarketplacePage.fillSearchForConnectorTextbox('REST Connector');
+        await (0, sleep_1.sleep)(10000);
+        await connectorMarketplacePage.downloadConnectorToProject();
+    }
+    await modelerCreatePage.clickRestConnectorOption();
+    await connectorSettingsPage.clickAuthenticationTab();
+    await connectorSettingsPage.clickHTTPEndpointTab();
+    if (auth == 'bearer') {
+        await connectorSettingsPage.selectAuthenticationType('bearer');
+        await (0, test_1.expect)(connectorSettingsPage.bearerTokenInput).toBeVisible({
+            timeout: 60000,
+        });
+        await connectorSettingsPage.clickBearerTokenInput();
+        await connectorSettingsPage.fillBearerTokenInput('thisisabearertoken');
+        await (0, test_1.expect)(connectorSettingsPage.methodTypeDropdown).toBeVisible({
+            timeout: 30000,
+        });
+        await connectorSettingsPage.selectMethodType('POST');
+    }
+    else if (auth == 'basic') {
+        await connectorSettingsPage.selectAuthenticationType('basic');
+        await (0, test_1.expect)(connectorSettingsPage.usernameInput).toBeVisible({
+            timeout: 60000,
+        });
+        await connectorSettingsPage.clickUsernameInput();
+        (0, test_1.expect)(basicAuthCredentials['username'].length).toBeGreaterThan(0);
+        (0, test_1.expect)(basicAuthCredentials['password'].length).toBeGreaterThan(0);
+        await connectorSettingsPage.fillUsernameInput(basicAuthCredentials['username']);
+        await connectorSettingsPage.clickPasswordInput();
+        await connectorSettingsPage.fillPasswordInput(basicAuthCredentials['password']);
+        await connectorSettingsPage.selectMethodType('POST');
+    }
+    await connectorSettingsPage.clickUrlInput();
+    await connectorSettingsPage.fillUrlInput(url);
+    await connectorSettingsPage.clickOutputMappingTab();
+    if (resultVariable.length > 0) {
+        await (0, test_1.expect)(connectorSettingsPage.resultVariableInput).toBeVisible({
+            timeout: 60000,
+        });
+        await connectorSettingsPage.clickResultVariableInput();
+        await connectorSettingsPage.fillResultVariableInput('result');
+        await (0, sleep_1.sleep)(5000);
+    }
+    await connectorSettingsPage.clickResultExpressionInput();
+    await connectorSettingsPage.fillResultExpressionInput(resultExpression);
+    await (0, sleep_1.sleep)(5000);
+    await modelerCreatePage.clickAppendElementButton();
+    await modelerCreatePage.clickAppendEndEventButton();
+    await (0, sleep_1.sleep)(10000);
+}
+exports.modelRestConnector = modelRestConnector;
+async function assertLocatorVisibleWithPaginated(page, locator, text) {
+    const maxRetries = 6;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await page.reload();
+            await (0, sleep_1.sleep)(5000);
+            if (attempt > 2) {
+                await (0, findLocatorInPaginatedList_1.findLocatorInPaginatedList)(page, locator);
+            }
+            await (0, test_1.expect)(locator).toBeVisible();
+            return;
+        }
+        catch (error) {
+            if (attempt < maxRetries - 1) {
+                console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
+            }
+            else {
+                throw new Error(`Assertion ${text} failed after ${maxRetries} attempts`);
+            }
+        }
+    }
+}
+exports.assertLocatorVisibleWithPaginated = assertLocatorVisibleWithPaginated;
+async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 120000, notVisible, maxRetries = 3, clickLocator) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await page.reload();
+            if (clickLocator) {
+                await (0, test_1.expect)(clickLocator).toBeVisible({
+                    timeout: 30000,
+                });
+                await clickLocator.click();
+            }
+            if (notVisible == true) {
+                await (0, sleep_1.sleep)(10000);
+                await (0, test_1.expect)(locator.first()).not.toBeVisible({
+                    timeout: timeout,
+                });
+            }
+            else {
+                await (0, test_1.expect)(locator).toBeVisible({
+                    timeout: timeout,
+                });
+            }
+            return;
+        }
+        catch (error) {
+            if (attempt < maxRetries - 1) {
+                console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
+            }
+            else {
+                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+            }
+        }
+    }
+}
+exports.assertLocatorVisibleWithRetry = assertLocatorVisibleWithRetry;
+async function assertPageTextWithRetry(page, text, notVisible, timeout = 120000, maxRetries = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await page.reload();
+            if (notVisible == true) {
+                await (0, sleep_1.sleep)(10000);
+                await (0, test_1.expect)(page.getByText(text, { exact: true }).first()).not.toBeVisible({
+                    timeout: timeout,
+                });
+            }
+            else {
+                await (0, test_1.expect)(page.getByText(text, { exact: true }).first()).toBeVisible({
+                    timeout: timeout,
+                });
+            }
+            return;
+        }
+        catch (error) {
+            if (attempt < maxRetries - 1) {
+                console.warn(`Attempt ${attempt + 1} failed for asserting ${text}. Retrying...`);
+            }
+            else {
+                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+            }
+        }
+    }
+}
+exports.assertPageTextWithRetry = assertPageTextWithRetry;
+async function modelAndRunConnectorsTimerEventDiagram(modelerCreatePage, modelerHomePage, processName, page, connectorMarketplacePage, connectorTemplatePage) {
+    await modelerHomePage.clickCrossComponentProjectFolder();
+    await modelerHomePage.clickDiagramTypeDropdown();
+    await modelerHomePage.clickUploadFilesButton();
+    await (0, fileUpload_1.uploadFile)(page, 'Rest Connector Timer Event.bpmn');
+    await modelerHomePage.clickProcessDiagram('Rest Connector Timer Event');
+    await modelerCreatePage.clickDiagramBreadcrumb();
+    await modelerCreatePage.clickEditDiagramNameButton();
+    await modelerCreatePage.enterDiagramName(processName);
+    await modelerCreatePage.clickStartEventElement();
+    await modelerCreatePage.clickGeneralPropertiesPanel();
+    await modelerCreatePage.clickIdInput();
+    await modelerCreatePage.fillIdInput(processName);
+    await (0, sleep_1.sleep)(2000);
+    await page.reload();
+    await modelerCreatePage.clickEighthPlacedElement();
+    await modelerCreatePage.clickChangeTypeButton();
+    await (0, test_1.expect)(modelerCreatePage.marketPlaceButton).toBeVisible({
+        timeout: 120000,
+    });
+    await modelerCreatePage.clickMarketPlaceButton();
+    await connectorMarketplacePage.clickSearchForConnectorTextbox();
+    await connectorMarketplacePage.fillSearchForConnectorTextbox('REST Connector');
+    await (0, sleep_1.sleep)(10000);
+    await (0, test_1.expect)(page.getByText('REST ConnectorBy CamundaConnect, interact, and synchronize processes')).toBeVisible({
+        timeout: 60000,
+    });
+    await connectorMarketplacePage.downloadConnectorToProject();
+    await modelerHomePage.clickProjectBreadcrumb();
+    await modelerHomePage.clickProcessDiagram('REST Outbound Connector');
+    await connectorTemplatePage.publishConnector();
+    await modelerHomePage.clickProjectBreadcrumb();
+    await modelerHomePage.clickProcessDiagram(processName);
+    await (0, sleep_1.sleep)(5000);
+    await page.reload();
+    await (0, sleep_1.sleep)(5000);
+    await modelerCreatePage.runProcessInstance();
+}
+exports.modelAndRunConnectorsTimerEventDiagram = modelAndRunConnectorsTimerEventDiagram;
+async function findTextWithPagination(page, text, timeout = 30000, action) {
+    const maxPages = 10;
+    const startTime = Date.now();
+    for (let pageNum = 0; pageNum < maxPages; pageNum++) {
+        if (Date.now() - startTime > timeout) {
+            console.log(`Overall timeout of ${timeout}ms exceeded`);
+            break;
+        }
+        const locator = page.getByText(text).last();
+        const textExists = await locator
+            .isVisible({ timeout: 2000 })
+            .catch(() => false);
+        if (textExists) {
+            console.log(`Found text "${text}" on page ${pageNum + 1}`);
+            if (action) {
+                await action(locator);
+            }
+            return true;
+        }
+        const loadMoreButton = page
+            .getByRole('button', { name: 'Load more', exact: true })
+            .last();
+        const isVisible = await loadMoreButton
+            .isVisible({ timeout: 1000 })
+            .catch(() => false);
+        const isEnabled = isVisible
+            ? await loadMoreButton.isEnabled().catch(() => false)
+            : false;
+        if (!isVisible || !isEnabled) {
+            console.log(`No more pages available after page ${pageNum + 1} (visible: ${isVisible}, enabled: ${isEnabled})`);
+            break;
+        }
+        console.log(`Text "${text}" not found on page ${pageNum + 1}, going to next page...`);
+        await loadMoreButton.click();
+        await page.waitForTimeout(1000);
+    }
+    return false;
+}
+exports.findTextWithPagination = findTextWithPagination;
+async function modelDiagramFromFile(page, modelerHomePage, modelerCreatePage, processName, fileName = '', nrOfRenamedUserTasks = 0, taskName = '') {
+    await modelerHomePage.clickDiagramTypeDropdown();
+    await modelerHomePage.clickUploadFilesButton();
+    await (0, fileUpload_1.uploadFile)(page, fileName + '.bpmn');
+    await modelerHomePage.clickProcessDiagram(fileName);
+    await modelerCreatePage.clickDiagramBreadcrumb();
+    await modelerCreatePage.clickEditDiagramNameButton();
+    await modelerCreatePage.enterDiagramName(processName);
+    await (0, sleep_1.sleep)(1000);
+    await modelerCreatePage.clickGeneralPropertiesPanel();
+    await modelerCreatePage.clickNameInput();
+    await modelerCreatePage.fillNameInput(processName);
+    await modelerCreatePage.clickIdInput();
+    await modelerCreatePage.fillIdInput(processName);
+    if (nrOfRenamedUserTasks > 0) {
+        for (let i = 1; i <= nrOfRenamedUserTasks; i++) {
+            await modelerCreatePage.clickUserTask('process' + i);
+            await modelerCreatePage.clickNameInput();
+            await modelerCreatePage.fillNameInput(taskName + i);
+            await modelerCreatePage.clickIdInput();
+            await modelerCreatePage.fillIdInput(taskName + i);
+            await modelerCreatePage.clickCanvas();
+        }
+    }
+    await (0, sleep_1.sleep)(10000);
+}
+exports.modelDiagramFromFile = modelDiagramFromFile;
+async function expectTextWithPagination(page, text, shouldExist = true, timeout = 30000) {
+    const found = await findTextWithPagination(page, text, timeout);
+    if (shouldExist && !found) {
+        throw new Error(`Text "${text}" not found on any page within ${timeout}ms`);
+    }
+    if (!shouldExist && found) {
+        throw new Error(`Text "${text}" should not exist but was found`);
+    }
+    if (shouldExist && found) {
+        await (0, test_1.expect)(page.getByText(text).last()).toBeVisible({ timeout: 5000 });
+    }
+}
+exports.expectTextWithPagination = expectTextWithPagination;
+async function modelAndRunConnectorsDocHandlingDiagram(modelerCreatePage, modelerHomePage, processName, page, connectorMarketplacePage, zeebeUrl, zeebeClientId, zeebeClientSecret, endpoint) {
+    await modelerHomePage.clickCrossComponentProjectFolder();
+    await modelerHomePage.clickDiagramTypeDropdown();
+    await modelerHomePage.clickUploadFilesButton();
+    await (0, fileUpload_1.uploadFile)(page, 'SM_Document_Handling_Connectors_User_Flow.bpmn');
+    await modelerHomePage.clickProcessDiagram('SM_Document_Handling_Connectors_User_Flow');
+    await modelerCreatePage.clickDiagramBreadcrumb();
+    await modelerCreatePage.clickEditDiagramNameButton();
+    await modelerCreatePage.enterDiagramName(processName);
+    await modelerCreatePage.clickGeneralPropertiesPanel();
+    await modelerCreatePage.clickNameInput();
+    await modelerCreatePage.fillNameInput(processName);
+    await modelerCreatePage.clickIdInput();
+    await modelerCreatePage.fillIdInput(processName);
+    await (0, sleep_1.sleep)(10000);
+    await modelerCreatePage.clickFirstPlaceRESTConnector();
+    await modelerCreatePage.clickChangeTypeButton();
+    await modelerCreatePage.clickMarketPlaceButton();
+    await connectorMarketplacePage.clickSearchForConnectorTextbox();
+    await connectorMarketplacePage.fillSearchForConnectorTextbox('REST Connector');
+    await connectorMarketplacePage.downloadConnectorToProject();
+    await (0, sleep_1.sleep)(5000);
+    await page.reload();
+    await (0, sleep_1.sleep)(5000);
+    await modelerCreatePage.fillStartEventVariablesForDocHandling(zeebeUrl, zeebeClientId, zeebeClientSecret);
+    await modelerCreatePage.setOAuthTokenEndpoint(page.locator('.djs-hit').first(), endpoint);
+    await (0, sleep_1.sleep)(2000);
+    await modelerCreatePage.setOAuthTokenEndpoint(page.locator('g:nth-child(3) > .djs-element > .djs-hit'), endpoint);
+    await (0, sleep_1.sleep)(2000);
+    await modelerCreatePage.setOAuthTokenEndpoint(page.locator('g:nth-child(6) > .djs-element > .djs-hit'), endpoint);
+    await (0, sleep_1.sleep)(2000);
+    await modelerCreatePage.clickCloseDetailsPanel();
+    await modelerCreatePage.setOAuthTokenEndpoint(page.locator('g:nth-child(7) > .djs-element > .djs-hit'), endpoint, { openPanel: true });
+    await (0, sleep_1.sleep)(2000);
+    await modelerCreatePage.clickCloseDetailsPanel();
+    await modelerCreatePage.setOAuthTokenEndpoint(page.locator('g:nth-child(9) > .djs-element > .djs-hit'), endpoint, { openPanel: true });
+    await (0, sleep_1.sleep)(2000);
+    await modelerCreatePage.runProcessInstance();
+}
+exports.modelAndRunConnectorsDocHandlingDiagram = modelAndRunConnectorsDocHandlingDiagram;

package/dist/pages/SM-8.10/optimizeReportUtils.d.ts

@@ -0,0 +1,6 @@
+import { Locator, Page } from '@playwright/test';
+import { OptimizeCollectionsPage } from '../SM-8.10/OptimizeCollectionsPage';
+import { OptimizeReportPage } from '../SM-8.10/OptimizeReportPage';
+import { OptimizeHomePage } from '../SM-8.10/OptimizeHomePage';
+export declare const createReportForProcess: (optimizeCollectionsPage: OptimizeCollectionsPage, optimizeReportPage: OptimizeReportPage, processName: string) => Promise<void>;
+export declare const assertReportWithRefreshes: (page: Page, optimizeHomePage: OptimizeHomePage, optimizeCollectionsPage: OptimizeCollectionsPage, optimizeReportPage: OptimizeReportPage, reportName: string, locator: Locator, text: string) => Promise<void>;