@camunda/e2e-test-suite 0.0.1

package/dist/pages/SM-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: 90000 });
+        }
+        catch (error) {
+            await this.collectionsLink.click({ timeout: 60000 });
+            await this.createNewButton.click({ timeout: 90000 });
+        }
+    }
+    async clickReportOption() {
+        await this.reportOption.click();
+    }
+    async clickMostRecentProcessReport(reportName) {
+        await this.page.getByText(reportName).click({ timeout: 60000 });
+    }
+}
+exports.OptimizeCollectionsPage = OptimizeCollectionsPage;

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

@@ -0,0 +1,15 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeDashboardPage {
+    private page;
+    readonly filterTable: Locator;
+    readonly filterTableSearch: Locator;
+    constructor(page: Page);
+    clickFilterTable(): Promise<void>;
+    fillFilterTable(processName: string): Promise<void>;
+    processAssertion(processName: string, { timeout, not }?: {
+        timeout?: number;
+        not?: boolean;
+    }): Promise<void>;
+    processOwnerNameAssertion(processName: string): Promise<void>;
+}
+export { OptimizeDashboardPage };

package/dist/pages/SM-8.5/OptimizeDashboardPage.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeDashboardPage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeDashboardPage {
+    page;
+    filterTable;
+    filterTableSearch;
+    constructor(page) {
+        this.page = page;
+        this.filterTable = page.getByRole('main').getByRole('button');
+        this.filterTableSearch = page.getByPlaceholder('Type to search....');
+    }
+    async clickFilterTable() {
+        await this.filterTable.click({ timeout: 180000 });
+        await this.filterTableSearch.click();
+    }
+    async fillFilterTable(processName) {
+        await this.filterTableSearch.fill(processName, { timeout: 60000 });
+        await this.filterTableSearch.press('Enter');
+    }
+    async processAssertion(processName, { timeout = 120000, not = false } = {}) {
+        const interval = 60000;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            const locator = this.page.getByText(processName).first();
+            try {
+                if (not) {
+                    await (0, test_1.expect)(locator).not.toBeVisible({ timeout: interval });
+                }
+                else {
+                    await (0, test_1.expect)(locator).toBeVisible({ timeout: interval });
+                }
+                return;
+            }
+            catch (e) {
+                if (Date.now() - start + interval >= timeout) {
+                    throw e;
+                }
+                await this.page.reload();
+            }
+        }
+    }
+    async processOwnerNameAssertion(processName) {
+        try {
+            await this.page.reload();
+            await (0, test_1.expect)(this.page.getByRole('row', {
+                name: processName + ' Process QA Camunda',
+            })).toBeVisible({ timeout: 180000 });
+        }
+        catch {
+            await this.page.reload();
+            await (0, test_1.expect)(this.page.getByRole('row', {
+                name: processName + ' Process QA Camunda',
+            })).toBeVisible({ timeout: 180000 });
+        }
+    }
+}
+exports.OptimizeDashboardPage = OptimizeDashboardPage;

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

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

package/dist/pages/SM-8.5/OptimizeHomePage.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeHomePage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeHomePage {
+    page;
+    collectionsLink;
+    dashboardLink;
+    modalCloseButton;
+    optimizeBanner;
+    openUserSettingsButton;
+    logoutButton;
+    constructor(page) {
+        this.page = page;
+        this.collectionsLink = page.getByRole('link', { name: 'Collections' });
+        this.dashboardLink = page.getByRole('link', { name: 'Dashboard' });
+        this.modalCloseButton = page.getByText('Close', { exact: true });
+        this.optimizeBanner = page.getByRole('link', {
+            name: 'Camunda logo Optimize',
+        });
+        this.openUserSettingsButton = page.getByLabel('Open User');
+        this.logoutButton = page.getByRole('button', { name: 'Logout' });
+    }
+    async clickCollectionsLink() {
+        try {
+            await this.modalCloseButton.click({ timeout: 90000 });
+            await this.collectionsLink.click({ timeout: 60000 });
+        }
+        catch (error) {
+            await this.collectionsLink.click({ timeout: 90000 });
+        }
+    }
+    async clickDashboardLink() {
+        try {
+            await this.modalCloseButton.click({ timeout: 60000 });
+            await this.dashboardLink.click({ timeout: 60000 });
+        }
+        catch (error) {
+            await this.dashboardLink.click({ timeout: 60000 });
+        }
+    }
+    async assertProcessHasBeenImported(processId) {
+        await this.clickDashboardLink();
+        await this.page.reload();
+        await (0, test_1.expect)(this.page.getByRole('link', { name: processId })).toBeVisible({
+            timeout: 180000,
+        });
+    }
+    async clickOpenUserSettingsButton() {
+        await this.openUserSettingsButton.click();
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click();
+    }
+}
+exports.OptimizeHomePage = OptimizeHomePage;

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

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

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeReportPage = void 0;
+const test_1 = require("@playwright/test");
+class OptimizeReportPage {
+    page;
+    processSelectionButton;
+    userTaskProcess;
+    versionSelection;
+    alwaysDisplayLatestSelection;
+    createReportLink;
+    durationButton;
+    countOption;
+    processInstanceButton;
+    userTaskOption;
+    heatMapButton;
+    numberButton;
+    tableOption;
+    reportName;
+    saveButton;
+    oneUserTaskInstance;
+    twoUserTaskInstance;
+    cancelButton;
+    createNewButton;
+    reportOption;
+    processInstanceCount;
+    blankReportButton;
+    selectDropdown;
+    constructor(page) {
+        this.page = page;
+        this.processSelectionButton = page.getByPlaceholder('Select...');
+        this.userTaskProcess = page.getByText('User_Task_Process', { exact: true });
+        this.versionSelection = page.getByLabel('Version');
+        this.alwaysDisplayLatestSelection = page.getByText('Always display latest');
+        this.createReportLink = page.getByRole('link', { name: 'Create Report' });
+        this.durationButton = page.getByRole('button', { name: 'Duration' });
+        this.countOption = page.getByText('Count').first();
+        this.processInstanceButton = page.getByRole('button', {
+            name: 'Process Instance',
+            exact: true,
+        });
+        this.userTaskOption = page.getByText('User task', { exact: true });
+        this.heatMapButton = page.getByRole('button', { name: 'Heatmap' });
+        this.numberButton = page.getByRole('button', { name: 'Number' });
+        this.tableOption = page.getByText('Table');
+        this.reportName = page.getByPlaceholder('Report name');
+        this.saveButton = page.getByRole('button', { name: 'Save' });
+        this.oneUserTaskInstance = page.getByRole('cell', { name: '1', exact: true });
+        this.twoUserTaskInstance = page.getByRole('cell', { name: '2', exact: true });
+        this.cancelButton = page.getByRole('button', { name: 'Cancel' });
+        this.createNewButton = page.getByRole('button', {
+            name: 'Create New',
+            exact: true,
+        });
+        this.reportOption = page.getByText('Report', { exact: true });
+        this.processInstanceCount = page.locator('.progressLabel');
+        this.blankReportButton = page.getByRole('button', { name: 'Blank report' });
+        this.selectDropdown = page
+            .getByRole('button', { name: 'Select... Open menu' })
+            .last();
+    }
+    async clickProcessSelectionButton() {
+        await (0, test_1.expect)(this.processSelectionButton).toBeVisible({ timeout: 180000 });
+        await this.processSelectionButton.click({ timeout: 180000 });
+    }
+    async clickUserTaskProcess(processName) {
+        await this.page.getByText(processName, { exact: true }).first().click();
+    }
+    async clickVersionSelection() {
+        await this.versionSelection.click();
+    }
+    async clickAlwaysDisplayLatestSelection() {
+        await this.alwaysDisplayLatestSelection.click();
+    }
+    async clickCreateReportLink() {
+        await this.createReportLink.click();
+    }
+    async clickDurationButton() {
+        await this.durationButton.click();
+    }
+    async clickCountOption() {
+        await this.countOption.click();
+    }
+    async clickProcessInstanceButton() {
+        await this.processInstanceButton.click();
+    }
+    async clickUserTaskOption() {
+        await this.userTaskOption.click();
+    }
+    async clickHeatMapButton() {
+        if (await this.heatMapButton.isVisible()) {
+            await this.heatMapButton.click();
+        }
+    }
+    async clickNumberButton() {
+        if (await this.numberButton.isVisible()) {
+            await this.numberButton.click();
+        }
+    }
+    async clickTableOption() {
+        await this.tableOption.click();
+    }
+    async clickReportName() {
+        await this.reportName.click();
+    }
+    async clearReportName() {
+        await this.reportName.clear({ force: true });
+    }
+    async fillReportName(name) {
+        await this.reportName.fill(name, { force: true });
+    }
+    async clickSaveButton() {
+        await this.saveButton.click();
+    }
+    async waitUntilLocatorIsVisible(locator, tab) {
+        let elapsedTime = 0;
+        const maxWaitTimeSeconds = 120000;
+        while (elapsedTime < maxWaitTimeSeconds) {
+            const element = await locator;
+            if (await element.isVisible()) {
+                return;
+            }
+            await tab.reload();
+            await tab.waitForTimeout(10 * 1000);
+            // Update the elapsed time
+            elapsedTime += 10000;
+        }
+    }
+    async waitUntilProcessIsVisible(locator, tab) {
+        let elapsedTime = 0;
+        const maxWaitTimeSeconds = 240000;
+        while (elapsedTime < maxWaitTimeSeconds) {
+            const element = await locator;
+            if (await element.isVisible()) {
+                return;
+            }
+            await this.cancelButton.click();
+            await tab.reload();
+            await tab.waitForTimeout(10 * 1000);
+            // Update the elapsed time
+            elapsedTime += 10000;
+            await this.createNewButton.click();
+            await this.reportOption.click();
+            await this.processSelectionButton.click();
+        }
+    }
+    async clickBlankReportButton() {
+        await this.blankReportButton.click();
+    }
+    async clickSelectDropdown() {
+        await (0, test_1.expect)(this.selectDropdown).toBeVisible({
+            timeout: 60000,
+        });
+        await this.selectDropdown.click();
+    }
+}
+exports.OptimizeReportPage = OptimizeReportPage;

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

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

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

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

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

@@ -0,0 +1,61 @@
+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 assignedToMeText: 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>;
+}
+export { TaskDetailsPage };

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskDetailsPage = void 0;
+const test_1 = require("@playwright/test");
+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;
+    assignedToMeText;
+    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.assignedToMeText = page
+            .getByTestId('assignee')
+            .getByText('Assigned to me');
+    }
+    async clickAssignToMeButton() {
+        await this.assignToMeButton.click();
+    }
+    async clickUnassignButton() {
+        await this.unassignButton.click();
+    }
+    async clickCompleteTaskButton() {
+        await this.completeTaskButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.page.getByText('Task completed')).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);
+    }
+}
+exports.TaskDetailsPage = TaskDetailsPage;