@camunda/e2e-test-suite 0.0.257 → 0.0.258

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

@@ -0,0 +1,44 @@
+import { Page, Locator } from '@playwright/test';
+declare class PlayPage {
+    private page;
+    readonly completeJobButton: Locator;
+    readonly saveScenarioButton: Locator;
+    readonly viewScenarioButton: Locator;
+    readonly runAllScenariosButton: Locator;
+    readonly confirmSaveScenarioButton: Locator;
+    readonly enterScenarioNameInput: 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 notifications: Locator;
+    readonly saveScenarioModal: Locator;
+    readonly loadingInstanceDetailsText: Locator;
+    readonly retryButton: Locator;
+    readonly dialog: 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>;
+    clickSaveScenarioButton(): Promise<void>;
+    clickViewScenarioButton(): Promise<void>;
+    enterScenarioName(scenarioName: string): Promise<void>;
+    updateScenarioName(newScenarioName: string): Promise<void>;
+    clickViewAllScenariosButton(): Promise<void>;
+    confirmSaveScenario(): 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 };

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

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+const maxWaitTimeSeconds = 180000;
+class PlayPage {
+    page;
+    completeJobButton;
+    saveScenarioButton;
+    viewScenarioButton;
+    runAllScenariosButton;
+    confirmSaveScenarioButton;
+    enterScenarioNameInput;
+    confirmDeleteScenarioButton;
+    viewAllScenariosButton;
+    getScenarioRowByName;
+    getScenarioRow;
+    diagram;
+    startInstanceButton;
+    startInstanceWithCachedButton;
+    notifications;
+    saveScenarioModal;
+    loadingInstanceDetailsText;
+    retryButton;
+    dialog;
+    constructor(page) {
+        this.page = page;
+        this.dialog = page.getByRole('dialog');
+        this.completeJobButton = page
+            .getByTestId('diagram')
+            .getByLabel('Complete job');
+        this.saveScenarioButton = page.getByRole('button', { name: 'Save scenario' });
+        this.viewScenarioButton = page.getByRole('button', { name: 'View scenario' });
+        this.runAllScenariosButton = page.getByRole('button', {
+            name: 'Run all scenarios',
+        });
+        this.confirmSaveScenarioButton = page
+            .getByTestId('save-scenario-modal')
+            .getByRole('button', { name: 'Save' });
+        this.enterScenarioNameInput = page
+            .getByTestId('save-scenario-modal')
+            .locator('input#scenario-name')
+            .first();
+        this.confirmDeleteScenarioButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.viewAllScenariosButton = page.getByText('(View all)').last();
+        this.getScenarioRowByName = (scenarioName) => page.locator('tr', { hasText: scenarioName });
+        this.getScenarioRow = (scenarioName) => page.locator('tr', { hasText: scenarioName });
+        this.diagram = page.getByTestId('diagram');
+        this.startInstanceButton = this.diagram.getByLabel('Start instance', {
+            exact: true,
+        });
+        this.startInstanceWithCachedButton = page.getByLabel('Start instance with cached');
+        this.notifications = page.locator('.cds--toast-notification');
+        this.saveScenarioModal = page.getByTestId('save-scenario-modal');
+        this.loadingInstanceDetailsText = this.page.getByText('Loading instance details...');
+        this.retryButton = this.page.getByRole('button', { name: 'Retry' });
+    }
+    async waitForCompleteJobButtonToBeAvailable() {
+        await (0, test_1.expect)(this.completeJobButton).toBeVisible({
+            timeout: maxWaitTimeSeconds,
+        });
+    }
+    async clickCompleteJobButton() {
+        await this.completeJobButton.click();
+    }
+    async clickStartInstanceButton() {
+        const maxRetries = 3;
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            try {
+                await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+                await this.startInstanceButton
+                    .or(this.startInstanceWithCachedButton)
+                    .first()
+                    .click({ timeout: 30000 });
+                await (0, test_1.expect)(this.loadingInstanceDetailsText).toBeVisible();
+                await (0, test_1.expect)(this.loadingInstanceDetailsText).not.toBeVisible({
+                    timeout: 60000,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempts >= maxRetries - 1)
+                    throw error;
+                await this.page.reload();
+                await (0, sleep_1.sleep)(2000);
+                attempts++;
+            }
+        }
+    }
+    async dismissStartModal() {
+        const buttonVariations = [
+            'Start a process instance',
+            'Start another instance',
+            'Start new instance',
+            'Start instance',
+        ];
+        for (const buttonName of buttonVariations) {
+            const button = this.page.getByRole('button', { name: buttonName });
+            const count = await button.count();
+            if (count > 0) {
+                await button.click();
+                return;
+            }
+        }
+        throw new Error('Could not find start instance button with any expected variation');
+    }
+    async clickStartInstanceWithCachedButton() {
+        await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+        await this.startInstanceWithCachedButton.click({ timeout: 30000 });
+    }
+    async waitForInstanceDetailsToBeLoaded() {
+        const maxRetries = 2;
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.page.getByText(/process instance key/i)).toBeVisible({
+                    timeout: maxWaitTimeSeconds,
+                });
+                await (0, test_1.expect)(this.page.getByText(/This process instance has no variables/i)).toBeVisible({
+                    timeout: maxWaitTimeSeconds,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempts >= maxRetries - 1)
+                    throw error;
+                await this.page.reload();
+                attempts++;
+            }
+        }
+    }
+    async waitForNextElementToBeActive(historyItem) {
+        const locator = this.page.getByText(new RegExp(`^${historyItem}`, 'i'));
+        const maxRetries = 6; // ~1 min with the waits below
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(locator.first()).toBeVisible({ timeout: 20000 });
+                return;
+            }
+            catch (e) {
+                if (attempt === maxRetries)
+                    throw e;
+                await this.page.reload();
+                await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+                await this.page.waitForTimeout(5000);
+            }
+        }
+    }
+    async waitForProcessToBeCompleted() {
+        await (0, test_1.expect)(this.page.getByText('Completed')).toBeVisible({
+            timeout: maxWaitTimeSeconds,
+        });
+    }
+    async clickSaveScenarioButton() {
+        await this.notifications
+            .first()
+            .waitFor({ state: 'hidden', timeout: 60000 })
+            .catch(() => { });
+        const isModalVisible = await this.saveScenarioModal
+            .isVisible()
+            .catch(() => false);
+        if (!isModalVisible) {
+            await (0, sleep_1.sleep)(3000);
+            await (0, test_1.expect)(this.saveScenarioButton).toBeVisible({ timeout: 30000 });
+            await (0, test_1.expect)(this.saveScenarioButton).toBeEnabled({ timeout: 30000 });
+            await this.saveScenarioButton.click({ force: true, timeout: 30000 });
+        }
+    }
+    async clickViewScenarioButton() {
+        await this.viewScenarioButton.click();
+    }
+    async enterScenarioName(scenarioName) {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.dialog, {
+            postAction: async () => {
+                await this.saveScenarioButton.click({ timeout: 30000 });
+            },
+        });
+        const input = this.dialog.locator('input#scenario-name');
+        await input.waitFor({ state: 'visible', timeout: 10000 });
+        await input.clear();
+        await input.fill(scenarioName);
+    }
+    async updateScenarioName(newScenarioName) {
+        await this.enterScenarioNameInput.fill(newScenarioName);
+    }
+    async clickViewAllScenariosButton() {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.viewAllScenariosButton);
+        await this.viewAllScenariosButton.click();
+    }
+    async confirmSaveScenario() {
+        await this.confirmSaveScenarioButton.click();
+    }
+    async getDeleteIconForScenario(scenarioName) {
+        const scenarioRow = this.page
+            .locator('tr')
+            .filter({ has: this.page.getByText(scenarioName, { exact: true }) });
+        return scenarioRow.getByLabel('Delete scenario');
+    }
+    async deleteScenario(scenarioName) {
+        const deleteIcon = await this.getDeleteIconForScenario(scenarioName);
+        await deleteIcon.click();
+    }
+    async confirmDeleteScenario() {
+        await this.confirmDeleteScenarioButton.click();
+    }
+    async clickRunAllScenariosButton() {
+        await this.runAllScenariosButton.click();
+    }
+    async clickmessagePublishButton() {
+        await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+        const publishIcon = this.diagram
+            .locator('div.djs-overlays')
+            .getByLabel('Publish message', { exact: true });
+        await publishIcon.click({ timeout: 30000 });
+    }
+    async assertScenarioCompleted(scenarioName) {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.page
+            .locator('tr', { hasText: scenarioName })
+            .locator('text=Completed'), {
+            totalTimeout: 90000,
+            visibilityTimeout: 20000,
+            postAction: async () => {
+                if (await this.retryButton.isVisible()) {
+                    await this.retryButton.click();
+                }
+            },
+        });
+    }
+}
+exports.PlayPage = PlayPage;

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

@@ -0,0 +1,12 @@
+import { Page, Locator } from '@playwright/test';
+declare class SettingsPage {
+    private page;
+    readonly openSettingsButton: Locator;
+    readonly logoutButton: Locator;
+    readonly openUserSidebarButton: Locator;
+    constructor(page: Page);
+    clickOpenSettingsButton(): Promise<void>;
+    clickOpenUserSideBarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+}
+export { SettingsPage };

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsPage = void 0;
+class SettingsPage {
+    page;
+    openSettingsButton;
+    logoutButton;
+    openUserSidebarButton;
+    constructor(page) {
+        this.page = page;
+        this.openSettingsButton = page.getByLabel('Open Settings');
+        this.openUserSidebarButton = page.getByLabel('Open User Sidebar');
+        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+    }
+    async clickOpenSettingsButton() {
+        await this.openSettingsButton.click({ timeout: 120000 });
+    }
+    async clickOpenUserSideBarButton() {
+        await this.openUserSidebarButton.click({ timeout: 120000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 30000 });
+    }
+}
+exports.SettingsPage = SettingsPage;

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

@@ -0,0 +1,70 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskDetailsPage {
+    private page;
+    readonly assignToMeButton: Locator;
+    readonly completeButton: Locator;
+    readonly unassignButton: Locator;
+    readonly assignee: Locator;
+    readonly completeTaskButton: Locator;
+    readonly addVariableButton: Locator;
+    readonly detailsPanel: Locator;
+    readonly detailsHeader: Locator;
+    readonly pendingTaskDescription: Locator;
+    readonly pickATaskHeader: Locator;
+    readonly emptyTaskMessage: Locator;
+    readonly nameInput: Locator;
+    readonly addressInput: Locator;
+    readonly ageInput: Locator;
+    readonly variablesTable: Locator;
+    readonly nameColumnHeader: Locator;
+    readonly valueColumnHeader: Locator;
+    readonly form: Locator;
+    readonly numberInput: Locator;
+    readonly incrementButton: Locator;
+    readonly decrementButton: Locator;
+    readonly dateInput: Locator;
+    readonly timeInput: Locator;
+    readonly checkbox: Locator;
+    readonly selectDropdown: Locator;
+    readonly tagList: Locator;
+    readonly detailsInfo: Locator;
+    readonly textInput: Locator;
+    readonly taskCompletedBanner: Locator;
+    readonly assignedToMeText: Locator;
+    readonly noPreviewContainer: Locator;
+    readonly previewContainer: Locator;
+    constructor(page: Page);
+    clickAssignToMeButton(): Promise<void>;
+    clickUnassignButton(): Promise<void>;
+    clickCompleteTaskButton(): Promise<void>;
+    clickAddVariableButton(): Promise<void>;
+    replaceExistingVariableValue(values: {
+        name: string;
+        value: string;
+    }): Promise<void>;
+    getNthVariableNameInput(nth: number): Locator;
+    getNthVariableValueInput(nth: number): Locator;
+    addVariable(payload: {
+        name: string;
+        value: string;
+    }): Promise<void>;
+    fillNumber(number: string): Promise<void>;
+    clickIncrementButton(): Promise<void>;
+    clickDecrementButton(): Promise<void>;
+    fillDate(date: string): Promise<void>;
+    enterTime(time: string): Promise<void>;
+    checkCheckbox(): Promise<void>;
+    selectDropdownValue(value: string): Promise<void>;
+    clickRadioButton(radioBtnLabel: string): Promise<void>;
+    checkChecklistBox(label: string): Promise<void>;
+    enterTwoValuesInTagList(value1: string, value2: string): Promise<void>;
+    clickTextInput(): Promise<void>;
+    fillTextInput(value: string): Promise<void>;
+    priorityAssertion(priority: string): Promise<void>;
+    taskAssertion(name: string): Promise<void>;
+    assertLoadedImage(documentName: string): Promise<void>;
+    assertDocumentDownloadButton(documentName: string): Promise<void>;
+    assertPdfPreviewViewerExists(): Promise<void>;
+    assertTextIsPresent(expectedText: string): Promise<void>;
+}
+export { TaskDetailsPage };

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

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskDetailsPage = void 0;
+const test_1 = require("@playwright/test");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+function cardinalToOrdinal(numberValue) {
+    const realOrderIndex = numberValue.toString();
+    if (['11', '12', '13'].includes(realOrderIndex.slice(-2))) {
+        return `${realOrderIndex}th`;
+    }
+    switch (realOrderIndex.slice(-1)) {
+        case '1':
+            return `${realOrderIndex}st`;
+        case '2':
+            return `${realOrderIndex}nd`;
+        case '3':
+            return `${realOrderIndex}rd`;
+        default:
+            return `${realOrderIndex}th`;
+    }
+}
+class TaskDetailsPage {
+    page;
+    assignToMeButton;
+    completeButton;
+    unassignButton;
+    assignee;
+    completeTaskButton;
+    addVariableButton;
+    detailsPanel;
+    detailsHeader;
+    pendingTaskDescription;
+    pickATaskHeader;
+    emptyTaskMessage;
+    nameInput;
+    addressInput;
+    ageInput;
+    variablesTable;
+    nameColumnHeader;
+    valueColumnHeader;
+    form;
+    numberInput;
+    incrementButton;
+    decrementButton;
+    dateInput;
+    timeInput;
+    checkbox;
+    selectDropdown;
+    tagList;
+    detailsInfo;
+    textInput;
+    taskCompletedBanner;
+    assignedToMeText;
+    noPreviewContainer;
+    previewContainer;
+    constructor(page) {
+        this.page = page;
+        this.assignToMeButton = page.getByRole('button', { name: 'Assign to me' });
+        this.completeButton = page.getByRole('button', { name: 'Complete' });
+        this.unassignButton = page.getByRole('button', { name: 'Unassign' });
+        this.assignee = page.getByTestId('assignee');
+        this.completeTaskButton = page.getByRole('button', { name: 'Complete Task' });
+        this.addVariableButton = page.getByRole('button', { name: 'Add Variable' });
+        this.detailsPanel = this.page.getByRole('complementary', {
+            name: 'Task details right panel',
+        });
+        this.detailsHeader = page.getByTitle('Task details header');
+        this.pendingTaskDescription = page.getByText('Pending task');
+        this.pickATaskHeader = page.getByRole('heading', {
+            name: 'Pick a task to work on',
+        });
+        this.emptyTaskMessage = page.getByRole('heading', {
+            name: /task has no variables/i,
+        });
+        this.nameInput = page.getByLabel('Name*');
+        this.addressInput = page.getByLabel('Address*');
+        this.ageInput = page.getByLabel('Age');
+        this.variablesTable = page.getByTestId('variables-table');
+        this.nameColumnHeader = this.variablesTable.getByRole('columnheader', {
+            name: 'Name',
+        });
+        this.valueColumnHeader = this.variablesTable.getByRole('columnheader', {
+            name: 'Value',
+        });
+        this.form = page.getByTestId('embedded-form');
+        this.numberInput = this.form.getByLabel('Number');
+        this.incrementButton = page.getByRole('button', { name: 'Increment' });
+        this.decrementButton = page.getByRole('button', { name: 'Decrement' });
+        this.dateInput = page.getByPlaceholder('mm/dd/yyyy');
+        this.timeInput = page.getByPlaceholder('hh:mm ?m');
+        this.checkbox = this.form.getByLabel('Checkbox');
+        this.selectDropdown = this.form.getByText('Select').last();
+        this.tagList = page.getByPlaceholder('Search');
+        this.detailsInfo = page.getByTestId('details-info');
+        this.textInput = page.locator('[class="fjs-input"]');
+        this.textInput = page.locator('[class="fjs-input"]');
+        this.taskCompletedBanner = this.page.getByText('Task completed');
+        this.assignedToMeText = page
+            .getByTestId('assignee')
+            .getByText('Assigned to me');
+        this.noPreviewContainer = this.page.locator('[class = "fjs-documentPreview-non-preview-item fjs-documentPreview-single-document-container"]');
+        this.previewContainer = this.page.locator('[class = "fjs-documentPreview-single-document-container"]');
+    }
+    async clickAssignToMeButton() {
+        await (0, test_1.expect)(this.assignToMeButton).toBeVisible({ timeout: 60000 });
+        await this.assignToMeButton.click({ timeout: 60000 });
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.assignedToMeText, {
+            postAction: async () => {
+                await this.page.reload();
+            },
+        });
+    }
+    async clickUnassignButton() {
+        await this.unassignButton.click();
+    }
+    async clickCompleteTaskButton() {
+        await this.completeTaskButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.taskCompletedBanner).toBeVisible({
+            timeout: 200000,
+        });
+    }
+    async clickAddVariableButton() {
+        await this.addVariableButton.click({ timeout: 60000 });
+    }
+    async replaceExistingVariableValue(values) {
+        const { name, value } = values;
+        await this.page.getByTitle(name).clear();
+        await this.page.getByTitle(name).fill(value);
+    }
+    getNthVariableNameInput(nth) {
+        return this.page.getByRole('textbox', {
+            name: `${cardinalToOrdinal(nth)} variable name`,
+        });
+    }
+    getNthVariableValueInput(nth) {
+        return this.page.getByRole('textbox', {
+            name: `${cardinalToOrdinal(nth)} variable value`,
+        });
+    }
+    async addVariable(payload) {
+        const { name, value } = payload;
+        this.clickAddVariableButton();
+        await this.getNthVariableNameInput(1).fill(name);
+        await this.getNthVariableValueInput(1).fill(value);
+    }
+    async fillNumber(number) {
+        await this.numberInput.fill(number);
+    }
+    async clickIncrementButton() {
+        await this.incrementButton.click();
+    }
+    async clickDecrementButton() {
+        await this.decrementButton.click();
+    }
+    async fillDate(date) {
+        await this.dateInput.click();
+        await this.dateInput.fill(date);
+        await this.dateInput.press('Enter');
+    }
+    async enterTime(time) {
+        await this.timeInput.click();
+        await this.page.getByText(time).click();
+    }
+    async checkCheckbox() {
+        await this.checkbox.check();
+    }
+    async selectDropdownValue(value) {
+        await this.selectDropdown.click();
+        await this.page.getByText(value).click();
+    }
+    async clickRadioButton(radioBtnLabel) {
+        await this.page.getByText(radioBtnLabel).click();
+    }
+    async checkChecklistBox(label) {
+        await this.page.getByLabel(label).check();
+    }
+    async enterTwoValuesInTagList(value1, value2) {
+        await this.tagList.click();
+        await this.page.getByText(value1).click();
+        await this.page.getByText(value2, { exact: true }).click();
+    }
+    async clickTextInput() {
+        await this.textInput.click();
+    }
+    async fillTextInput(value) {
+        await this.textInput.fill(value);
+    }
+    async priorityAssertion(priority) {
+        let retryCount = 0;
+        const maxRetries = 2;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.detailsPanel.getByText(priority)).toBeVisible({
+                    timeout: 45000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(10000);
+            }
+        }
+        throw new Error(`Priority not visible after ${maxRetries} attempts.`);
+    }
+    async taskAssertion(name) {
+        let retryCount = 0;
+        const maxRetries = 2;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.detailsInfo.getByText(name)).toBeVisible({
+                    timeout: 45000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(10000);
+            }
+        }
+        throw new Error(`Task not visible after ${maxRetries} attempts.`);
+    }
+    async assertLoadedImage(documentName) {
+        await (0, test_1.expect)(this.page.locator(`img[alt="${documentName}"]`)).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async assertDocumentDownloadButton(documentName) {
+        await (0, test_1.expect)(this.page.locator(`button[aria-label="Download ${documentName}"]`)).toBeVisible({ timeout: 60000 });
+    }
+    async assertPdfPreviewViewerExists() {
+        const containers = this.page.locator('[class="fjs-documentPreview-single-document-container"]');
+        const firstPdfViewer = containers
+            .first()
+            .locator('.fjs-documentPreview-pdf-viewer');
+        const lastPdfViewer = containers
+            .last()
+            .locator('.fjs-documentPreview-pdf-viewer');
+        await (0, test_1.expect)(firstPdfViewer.or(lastPdfViewer)).toBeVisible();
+    }
+    async assertTextIsPresent(expectedText) {
+        const maxAttempts = 3;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            try {
+                await (0, test_1.expect)(this.page.getByText(expectedText)).toBeVisible({
+                    timeout: 60000,
+                });
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                await this.page.reload();
+            }
+        }
+    }
+}
+exports.TaskDetailsPage = TaskDetailsPage;

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

@@ -0,0 +1,24 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskPanelPage {
+    private page;
+    readonly availableTasks: Locator;
+    readonly filterOptions: Locator;
+    readonly tasklistBanner: Locator;
+    readonly collapseFilter: Locator;
+    readonly processesPageTab: Locator;
+    readonly tasksTab: Locator;
+    readonly assignToMeButton: Locator;
+    readonly unassignButton: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    constructor(page: Page);
+    openTask(name: string, assignButton?: boolean): Promise<void>;
+    filterBy(option: 'All open' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
+    scrollToLastTask(name: string): Promise<void>;
+    scrollToFirstTask(name: string): Promise<void>;
+    clickCollapseFilter(): Promise<void>;
+    clickProcessesTab(): Promise<void>;
+    taskCount(name: string): Promise<number>;
+    clickTasksTab(): Promise<void>;
+}
+export { TaskPanelPage };