@camunda/e2e-test-suite 0.0.257 → 0.0.258

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

@@ -0,0 +1,67 @@
+import { Page, Locator } from '@playwright/test';
+declare class OCTenantPage {
+    private page;
+    readonly createTenantMainButton: Locator;
+    readonly enterTenantNameInput: Locator;
+    readonly enterTenantIdInput: Locator;
+    readonly createTenantSubButton: Locator;
+    readonly usersTab: Locator;
+    readonly assignUsersButton: Locator;
+    readonly usernameInput: Locator;
+    readonly assignUserFinalButton: Locator;
+    readonly removeUserButton: Locator;
+    readonly removeButton: Locator;
+    readonly openSidebarButton: Locator;
+    readonly logoutButton: Locator;
+    readonly assignedApplicationsTab: Locator;
+    readonly searchApplicationsInput: Locator;
+    readonly assignApplicationsButtonFinal: Locator;
+    readonly assignApplicationsButton: Locator;
+    readonly tenantDescriptionInput: Locator;
+    readonly modalCloseButton: Locator;
+    readonly rolesTab: Locator;
+    readonly assignRoleButton: Locator;
+    readonly roleIdSearchBox: Locator;
+    readonly assignRoleSubButton: Locator;
+    readonly cancelButton: Locator;
+    readonly gotItButton: Locator;
+    readonly row: (name: string) => Locator;
+    constructor(page: Page);
+    clickCreateTenantMainButton(): Promise<void>;
+    clickCreateTenantSubButton(): Promise<void>;
+    clickEnterTenantNameInput(): Promise<void>;
+    fillEnterTenantNameInput(tenantName: string): Promise<void>;
+    clickEnterTenantIdInput(): Promise<void>;
+    fillEnterTenantIdInput(tenantId: string): Promise<void>;
+    clickUsersTab(): Promise<void>;
+    clickAssignUsersButton(): Promise<void>;
+    clickUsernameInput(): Promise<void>;
+    fillUsernameInput(user: string): Promise<void>;
+    clickAssignUserFinalButton(): Promise<void>;
+    clickRemoveUserButton(): Promise<void>;
+    clickRemoveButton(): Promise<void>;
+    clickTenantDescriptionInput(): Promise<void>;
+    fillTenantDescriptionInput(description: string): Promise<void>;
+    createTenant(tenantName: string): Promise<void>;
+    assertTenantCreated(): Promise<void>;
+    clickCancelButton(): Promise<void>;
+    clickGotItButton(): Promise<void>;
+    clickTenant(tenantName: string): Promise<void>;
+    assignUserToTenant(user: string): Promise<void>;
+    removeUserFromTenant(tenantName: string): Promise<void>;
+    clickOpenSidebarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+    assignClientToTenant(clientName: string): Promise<void>;
+    clickAssignedApplicationsTab(): Promise<void>;
+    clickSearchApplicationsInput(): Promise<void>;
+    fillSearchApplicationsInput(clientName: string): Promise<void>;
+    clickAssignApplicationsFinalButton(): Promise<void>;
+    clickAssignApplicationsButton(): Promise<void>;
+    clickRolesTab(): Promise<void>;
+    clickAssignRoleButton(): Promise<void>;
+    clickRoleIdSearchBox(): Promise<void>;
+    fillRoleIdSearchBox(roleId: string, roleIdentifier: string): Promise<void>;
+    clickAssignRoleSubButton(): Promise<void>;
+    assignRoleToTenant(roleId: string, roleIdentifier: string): Promise<void>;
+}
+export { OCTenantPage };

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

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCTenantPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const findLocatorInPaginatedList_1 = require("../../utils/findLocatorInPaginatedList");
+const expectTextWithPagination_1 = require("../../utils/assertionHelpers/expectTextWithPagination");
+class OCTenantPage {
+    page;
+    createTenantMainButton;
+    enterTenantNameInput;
+    enterTenantIdInput;
+    createTenantSubButton;
+    usersTab;
+    assignUsersButton;
+    usernameInput;
+    assignUserFinalButton;
+    removeUserButton;
+    removeButton;
+    openSidebarButton;
+    logoutButton;
+    assignedApplicationsTab;
+    searchApplicationsInput;
+    assignApplicationsButtonFinal;
+    assignApplicationsButton;
+    tenantDescriptionInput;
+    modalCloseButton;
+    rolesTab;
+    assignRoleButton;
+    roleIdSearchBox;
+    assignRoleSubButton;
+    cancelButton;
+    gotItButton;
+    row;
+    constructor(page) {
+        this.page = page;
+        this.createTenantMainButton = page.getByRole('button', {
+            name: 'Create Tenant',
+        });
+        this.enterTenantNameInput = page.getByPlaceholder('Enter tenant name');
+        this.enterTenantIdInput = page.getByPlaceholder('Enter tenant ID');
+        this.createTenantSubButton = page
+            .getByLabel('Create new tenant')
+            .getByRole('button', { name: 'Create tenant' });
+        this.usersTab = page.getByRole('tab', { name: 'Users' });
+        this.assignUsersButton = page.getByRole('button', { name: 'Assign user' });
+        this.usernameInput = page.getByTitle('Username');
+        this.assignUserFinalButton = page
+            .getByLabel('Assign user')
+            .getByRole('button', { name: 'Assign user' });
+        this.removeUserButton = page.getByRole('button', {
+            name: 'danger Remove user',
+        });
+        this.removeButton = page.getByRole('button', { name: 'danger Remove' });
+        this.openSidebarButton = page.getByLabel('Open User Sidebar');
+        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+        this.assignedApplicationsTab = page.getByRole('tab', {
+            name: 'Assigned applications',
+        });
+        this.searchApplicationsInput = page.getByPlaceholder('Search applications');
+        this.assignApplicationsButtonFinal = page
+            .getByLabel('Assign applications')
+            .getByRole('button', { name: 'Assign applications' });
+        this.assignApplicationsButton = page.getByRole('button', {
+            name: 'Assign applications',
+        });
+        this.tenantDescriptionInput = page.getByTitle('Description');
+        this.modalCloseButton = page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Close' });
+        this.rolesTab = page.getByRole('tab', { name: 'Roles' });
+        this.assignRoleButton = page.getByRole('button', { name: 'Assign role' });
+        this.roleIdSearchBox = page.getByRole('searchbox', {
+            name: 'Search by Role ID',
+        });
+        this.assignRoleSubButton = page
+            .getByLabel('Assign role')
+            .getByRole('button', { name: 'Assign role' });
+        this.cancelButton = page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Cancel' });
+        this.gotItButton = page.getByRole('button', { name: 'Got it' });
+        this.row = (name) => this.page.getByRole('row').filter({ hasText: name }).first();
+    }
+    async clickCreateTenantMainButton() {
+        await this.createTenantMainButton.click({ timeout: 60000 });
+    }
+    async clickCreateTenantSubButton() {
+        await this.createTenantSubButton.click({ timeout: 60000 });
+    }
+    async clickEnterTenantNameInput() {
+        await this.enterTenantNameInput.click();
+    }
+    async fillEnterTenantNameInput(tenantName) {
+        await this.enterTenantNameInput.fill(tenantName);
+    }
+    async clickEnterTenantIdInput() {
+        await this.enterTenantIdInput.click();
+    }
+    async fillEnterTenantIdInput(tenantId) {
+        await this.enterTenantIdInput.fill(tenantId);
+    }
+    async clickUsersTab() {
+        await this.usersTab.click({ timeout: 60000 });
+    }
+    async clickAssignUsersButton() {
+        await this.assignUsersButton.click();
+    }
+    async clickUsernameInput() {
+        await this.usernameInput.click();
+    }
+    async fillUsernameInput(user) {
+        await this.usernameInput.fill(user);
+    }
+    async clickAssignUserFinalButton() {
+        try {
+            await this.assignUserFinalButton.click();
+            await (0, test_1.expect)(this.page.getByRole('dialog')).not.toBeVisible();
+        }
+        catch (e) {
+            if (await this.page.getByText('ALREADY_EXISTS').first().isVisible()) {
+                console.log('User is already assigned to tenant');
+                await this.clickCancelButton();
+            }
+            else {
+                throw new Error('Assigning user to tenant failed' + e);
+            }
+        }
+    }
+    async clickRemoveUserButton() {
+        await this.removeUserButton.click();
+    }
+    async clickRemoveButton() {
+        await this.removeButton.click();
+    }
+    async clickTenantDescriptionInput() {
+        await this.tenantDescriptionInput.click();
+    }
+    async fillTenantDescriptionInput(description) {
+        await this.tenantDescriptionInput.fill(description);
+    }
+    async createTenant(tenantName) {
+        await this.clickCreateTenantMainButton();
+        await this.clickEnterTenantNameInput();
+        await this.fillEnterTenantNameInput(tenantName);
+        await this.clickEnterTenantIdInput();
+        await this.fillEnterTenantIdInput(tenantName);
+        await this.clickTenantDescriptionInput();
+        await this.fillTenantDescriptionInput('This is a test');
+        await this.clickCreateTenantSubButton();
+        await this.assertTenantCreated();
+        await (0, sleep_1.sleep)(30000);
+    }
+    async assertTenantCreated() {
+        try {
+            await (0, test_1.expect)(this.page.getByText('successfully created')).toBeVisible({
+                timeout: 8000,
+            });
+            await this.clickGotItButton();
+        }
+        catch (error) {
+            if (await this.page.getByText('ALREADY_EXISTS').first().isVisible()) {
+                await this.clickCancelButton();
+            }
+            else {
+                throw new Error('Creating tenant failed' + error);
+            }
+        }
+    }
+    async clickCancelButton() {
+        await this.cancelButton.click({ timeout: 30000 });
+    }
+    async clickGotItButton() {
+        await this.gotItButton.click({ timeout: 30000 });
+    }
+    async clickTenant(tenantName) {
+        const maxRetries = 10;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+                const tenant = this.page.getByText(tenantName).first();
+                await (0, findLocatorInPaginatedList_1.findLocatorInPaginatedList)(this.page, tenant);
+                await tenant.click({
+                    timeout: 30000,
+                });
+                return;
+            }
+            catch (error) {
+                console.warn(`Attempt ${attempt} to click tenant '${tenantName}' failed. Retrying...`, error);
+                if (attempt === maxRetries) {
+                    throw new Error(`Failed to click tenant '${tenantName}' after ${maxRetries} attempts.`);
+                }
+            }
+        }
+    }
+    async assignUserToTenant(user) {
+        await this.clickUsersTab();
+        await this.clickAssignUsersButton();
+        await this.clickUsernameInput();
+        await this.fillUsernameInput(user);
+        await this.clickAssignUserFinalButton();
+    }
+    async removeUserFromTenant(tenantName) {
+        await (0, expectTextWithPagination_1.expectTextWithPagination)(this.page, tenantName);
+        await this.page.getByText(tenantName).first().click();
+        await this.clickUsersTab();
+        await this.clickRemoveButton();
+        await this.clickRemoveUserButton();
+        await (0, test_1.expect)(this.page.getByText('Tenant member has been removed.')).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickOpenSidebarButton() {
+        await this.openSidebarButton.click({ timeout: 60000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 60000 });
+    }
+    async assignClientToTenant(clientName) {
+        await this.clickAssignedApplicationsTab();
+        if (await this.page.getByText(clientName, { exact: true }).isVisible()) {
+            return;
+        }
+        else {
+            await this.clickAssignApplicationsButton();
+            await this.clickSearchApplicationsInput();
+            await this.fillSearchApplicationsInput(clientName);
+            await this.page.getByText(clientName, { exact: true }).click();
+            await this.clickAssignApplicationsFinalButton();
+            await (0, test_1.expect)(this.page.getByText('Applications assigned')).toBeVisible({
+                timeout: 60000,
+            });
+        }
+    }
+    async clickAssignedApplicationsTab() {
+        await this.assignedApplicationsTab.click({ timeout: 60000 });
+    }
+    async clickSearchApplicationsInput() {
+        await this.searchApplicationsInput.click({ timeout: 60000 });
+    }
+    async fillSearchApplicationsInput(clientName) {
+        await this.searchApplicationsInput.fill(clientName);
+    }
+    async clickAssignApplicationsFinalButton() {
+        await this.assignApplicationsButtonFinal.click({ timeout: 60000 });
+    }
+    async clickAssignApplicationsButton() {
+        await this.assignApplicationsButton.click({ timeout: 60000 });
+    }
+    async clickRolesTab() {
+        await this.rolesTab.click();
+    }
+    async clickAssignRoleButton() {
+        await this.assignRoleButton.click();
+    }
+    async clickRoleIdSearchBox() {
+        await this.roleIdSearchBox.click();
+    }
+    async fillRoleIdSearchBox(roleId, roleIdentifier) {
+        await this.roleIdSearchBox.fill(roleId);
+        await this.page.getByText(roleIdentifier).click();
+    }
+    async clickAssignRoleSubButton() {
+        await this.assignRoleSubButton.click();
+    }
+    async assignRoleToTenant(roleId, roleIdentifier) {
+        await this.clickRolesTab();
+        await (0, sleep_1.sleep)(1000);
+        if (await this.row(roleId).isVisible()) {
+            console.log(`Role ${roleId} is already assigned to tenant`);
+            return;
+        }
+        await this.clickAssignRoleButton();
+        await this.clickRoleIdSearchBox();
+        await this.fillRoleIdSearchBox(roleId, roleIdentifier);
+        await this.clickAssignRoleSubButton();
+    }
+}
+exports.OCTenantPage = OCTenantPage;

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

@@ -0,0 +1,24 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateHomePage {
+    private page;
+    readonly operateBanner: Locator;
+    readonly processesTab: Locator;
+    readonly informationDialog: Locator;
+    readonly editVariableButton: Locator;
+    readonly variableValueInput: Locator;
+    readonly saveVariableButton: Locator;
+    readonly editVariableSpinner: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    readonly processPageHeading: 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>;
+    openProcess(processName: string): Promise<void>;
+}
+export { OperateHomePage };

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateHomePage = void 0;
+const test_1 = require("@playwright/test");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+const constants_1 = require("../../utils/constants");
+class OperateHomePage {
+    page;
+    operateBanner;
+    processesTab;
+    informationDialog;
+    editVariableButton;
+    variableValueInput;
+    saveVariableButton;
+    editVariableSpinner;
+    licenseKeyTagNonProduction;
+    licenseKeyTagProduction;
+    processPageHeading;
+    constructor(page) {
+        this.page = page;
+        this.operateBanner = page.getByRole('link', { name: 'Camunda logo 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.licenseKeyTagNonProduction = page
+            .getByText('Non-production license')
+            .first();
+        this.licenseKeyTagProduction = page.getByText('Production license').first();
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByRole('heading', { name: 'Process' });
+    }
+    async clickProcessesTab() {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.processesTab, {
+            totalTimeout: 20000,
+        });
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.processPageHeading, {
+            preAction: async () => {
+                await (0, test_1.expect)(this.processesTab).toBeVisible({
+                    timeout: constants_1._1_SECOND_IN_MS * 4,
+                });
+                await this.processesTab.click({ timeout: constants_1._1_SECOND_IN_MS * 4 });
+            },
+        });
+    }
+    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();
+    }
+    async openProcess(processName) {
+        await this.page.getByText(processName).click();
+    }
+}
+exports.OperateHomePage = OperateHomePage;

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

@@ -0,0 +1,24 @@
+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);
+    connectorResultVariableName(name: string): Promise<Locator>;
+    connectorResultVariableValue(variableName: string): Promise<Locator>;
+    completedIconAssertion(): Promise<void>;
+    activeIconAssertion(): Promise<void>;
+    activeUserTaskIconVisibleAssertion(taskName: string): Promise<void>;
+    activeUserTaskIconNotVisibleAssertion(taskName: string): Promise<void>;
+    tenantNameAssertion(name: string): Promise<void>;
+    incidentIconAssertion(): Promise<void>;
+    assertEitherIncidentOrActiveIconVisible(): Promise<string>;
+    assertEitherIncidentOrCompletedIconVisible(): Promise<string>;
+    assertProcessCompleteStatusWithRetry(timeout?: number, maxRetries?: number): Promise<void>;
+    assertProcessVariableContainsText(variableName: string, text: string): Promise<void>;
+    assertActiveTokenIsPresent(): Promise<void>;
+}
+export { OperateProcessInstancePage };

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

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessInstancePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+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 connectorResultVariableName(name) {
+        return await this.page.getByTestId(name);
+    }
+    async connectorResultVariableValue(variableName) {
+        return await this.page.getByTestId(variableName).locator('td').last();
+    }
+    async completedIconAssertion() {
+        let retryCount = 0;
+        const maxRetries = 3;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.completedIcon).toBeVisible({
+                    timeout: 90000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                // If the active icon isn't found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+    }
+    async activeIconAssertion() {
+        let retryCount = 0;
+        const maxRetries = 3;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.activeIcon).toBeVisible({
+                    timeout: 90000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                // If the active icon isn't found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+    }
+    async activeUserTaskIconVisibleAssertion(taskName) {
+        let retryCount = 0;
+        const maxRetries = 3;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.page.getByTestId(taskName)).toBeVisible({
+                    timeout: 90000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                // If the active icon isn't found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+    }
+    async activeUserTaskIconNotVisibleAssertion(taskName) {
+        let retryCount = 0;
+        const maxRetries = 3;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.page.getByTestId(taskName)).not.toBeVisible({
+                    timeout: 90000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                // If the active icon is found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Active icon visible after ${maxRetries} attempts.`);
+    }
+    async tenantNameAssertion(name) {
+        await (0, test_1.expect)(this.page.getByRole('cell', { name: name, exact: true })).toBeVisible({ timeout: 60000 });
+    }
+    async incidentIconAssertion() {
+        await (0, test_1.expect)(this.incidentIcon).toBeVisible({ timeout: 90000 });
+    }
+    async assertEitherIncidentOrActiveIconVisible() {
+        return Promise.race([
+            this.incidentIcon.waitFor({ timeout: 90000 }).then(() => 'incident'),
+            this.activeIcon.waitFor({ timeout: 90000 }).then(() => 'active'),
+        ]);
+    }
+    async assertEitherIncidentOrCompletedIconVisible() {
+        return Promise.race([
+            this.incidentIcon.waitFor({ timeout: 90000 }).then(() => 'incident'),
+            this.completedIcon.waitFor({ timeout: 90000 }).then(() => 'completed'),
+        ]);
+    }
+    async assertProcessCompleteStatusWithRetry(timeout = 60000, maxRetries = 10) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(this.completedIcon).toBeVisible({
+                    timeout: timeout,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Process complete status attempt ${attempt + 1} failed. Retrying...`);
+                    await this.page.reload();
+                    await (0, sleep_1.sleep)(5000);
+                }
+                else {
+                    throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async assertProcessVariableContainsText(variableName, text) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                await (0, test_1.expect)(this.page.getByTestId(`variable-${variableName}`)).toContainText(text, { timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                console.log(`Failed to assert variable ${variableName}` + error);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Failed to assert variable ${variableName} after ${maxRetries} attempts.`);
+    }
+    async assertActiveTokenIsPresent() {
+        await (0, test_1.expect)(this.activeIcon).toBeVisible({ timeout: 60000 });
+    }
+}
+exports.OperateProcessInstancePage = OperateProcessInstancePage;

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

@@ -0,0 +1,32 @@
+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;
+    readonly moreFiltersButton: Locator;
+    readonly processInstanceKeyTextBox: Locator;
+    constructor(page: Page);
+    private checkCheckbox;
+    private uncheckCheckbox;
+    private uncheckCompletedCheckbox;
+    private uncheckActiveCheckbox;
+    private toggleActiveCheckboxOn;
+    private toggleCompletedCheckbox;
+    private checkTableForProcess;
+    clickProcessActiveCheckbox(): Promise<void>;
+    clickProcessCompletedCheckbox(): Promise<void>;
+    clickProcessIncidentsCheckbox(): Promise<void>;
+    clickRunningProcessInstancesCheckbox(): Promise<void>;
+    clickFinishedProcessInstancesCheckbox(): Promise<void>;
+    clickProcessInstanceLink(processName: string, type?: 'active' | 'completed'): Promise<void>;
+    clickProcessInstanceLinkWithPartialNameMatch(processName: string): Promise<void>;
+    private getMoreFilterValueLocator;
+    applyMoreFilters(filter: string, value: string): Promise<void>;
+}
+export { OperateProcessesPage };