@camunda/e2e-test-suite 0.0.1

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

@@ -0,0 +1,217 @@
+"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;
+    taskCompletedBanner;
+    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.taskCompletedBanner = this.page.getByText('Task completed');
+        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.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(`Active icon 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(`Active icon not visible after ${maxRetries} attempts.`);
+    }
+}
+exports.TaskDetailsPage = TaskDetailsPage;

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

@@ -0,0 +1,22 @@
+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 licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    constructor(page: Page);
+    openTask(name: string): 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 };

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskPanelPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class TaskPanelPage {
+    page;
+    availableTasks;
+    filterOptions;
+    tasklistBanner;
+    collapseFilter;
+    processesPageTab;
+    tasksTab;
+    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.licenseKeyTagNonProduction = page.getByText('Non-production license', {
+            exact: true,
+        });
+        this.licenseKeyTagProduction = page.getByText('Production license', {
+            exact: true,
+        });
+    }
+    async openTask(name) {
+        await this.availableTasks
+            .getByText(name, { exact: true })
+            .nth(0)
+            .click({ timeout: 180000 });
+    }
+    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 this.processesPageTab.click();
+    }
+    async taskCount(name) {
+        await (0, sleep_1.sleep)(20000);
+        return this.availableTasks.getByText(name, { exact: true }).count();
+    }
+    async clickTasksTab() {
+        await this.tasksTab.click();
+    }
+}
+exports.TaskPanelPage = TaskPanelPage;

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

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskProcessesPage {
+    private page;
+    readonly popupContinueButton: Locator;
+    readonly popup: Locator;
+    readonly processes: Locator;
+    constructor(page: Page);
+    clickpopupContinueButton(): Promise<void>;
+    startProcess(name: string): Promise<void>;
+}
+export { TaskProcessesPage };

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProcessesPage = void 0;
+class TaskProcessesPage {
+    page;
+    popupContinueButton;
+    popup;
+    processes;
+    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"]');
+    }
+    async clickpopupContinueButton() {
+        try {
+            await this.popupContinueButton.click({ timeout: 60000 });
+        }
+        catch (error) {
+            console.log('Popup not present');
+        }
+    }
+    async startProcess(name) {
+        await this.processes
+            .filter({ hasText: name })
+            .nth(0)
+            .getByRole('button', { name: 'Start process' })
+            .click({ timeout: 60000 });
+    }
+}
+exports.TaskProcessesPage = TaskProcessesPage;

package/dist/pages/SM-8.6/UtlitiesPage.d.ts

@@ -0,0 +1,21 @@
+import { Locator, Page } from '@playwright/test';
+import { IdentityPage } from '../SM-8.6/IdentityPage';
+import { NavigationPage } from '../SM-8.6/NavigationPage';
+import { ModelerHomePage } from './ModelerHomePage';
+import { ModelerCreatePage } from './ModelerCreatePage';
+import { TaskPanelPage } from '../SM-8.6/TaskPanelPage';
+import { TaskDetailsPage } from '../SM-8.6/TaskDetailsPage';
+import { ConnectorSettingsPage } from '../SM-8.6/ConnectorSettingsPage';
+import { ConnectorMarketplacePage } from '../SM-8.6/ConnectorMarketplacePage';
+import { ConnectorTemplatePage } from './ConnectorTemplatePage';
+export declare function deleteAllUserGroups(navigationPage: NavigationPage, identityPage: IdentityPage): Promise<void>;
+export declare function runMultipleProcesses(page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, numberOfProcesses: number, processName: string, processId?: string): 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 assertLocatorVisibleWithRetry(page: Page, locator: Locator, text: string, timeout?: number, maxRetries?: number): 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>;

package/dist/pages/SM-8.6/UtlitiesPage.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelAndRunConnectorsTimerEventDiagram = exports.assertPageTextWithRetry = exports.assertLocatorVisibleWithRetry = exports.modelRestConnector = exports.completeTaskWithRetry = exports.createAndRunProcess = exports.runMultipleProcesses = exports.deleteAllUserGroups = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const fileUpload_1 = require("../../utils/fileUpload");
+async function deleteAllUserGroups(navigationPage, identityPage) {
+    await navigationPage.goToIdentity();
+    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 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 = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await taskPanelPage.openTask(taskName);
+            await (0, sleep_1.sleep)(2000);
+            if (!(await taskDetailsPage.assignedToMeText.isVisible())) {
+                await taskDetailsPage.clickAssignToMeButton();
+            }
+            await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible();
+            await taskDetailsPage.clickCompleteTaskButton();
+            await (0, test_1.expect)(page.getByText('Task completed').first()).toBeVisible({
+                timeout: 200000,
+            });
+            await (0, test_1.expect)(taskPanelPage.availableTasks.getByText(taskName, { exact: true }).first()).not.toBeVisible({ timeout: 10000 });
+            return;
+        }
+        catch (error) {
+            if (attempt < maxRetries - 1) {
+                await page.reload();
+                console.warn(`Attempt ${attempt + 1} failed for completing task ${taskName}. Retrying...`);
+            }
+            else {
+                console.error(error);
+                throw new Error(`Assertion 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)(10000);
+    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.clickChangeTypeButton();
+    }
+    await modelerCreatePage.clickRestConnectorOption();
+    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);
+    if (resultVariable.length > 0) {
+        await (0, test_1.expect)(connectorSettingsPage.resultVariableInput).toBeVisible({
+            timeout: 60000,
+        });
+        await connectorSettingsPage.clickResultVariableInput();
+        await connectorSettingsPage.fillResultVariableInput('result');
+    }
+    await connectorSettingsPage.clickResultExpressionInput();
+    await connectorSettingsPage.fillResultExpressionInput(resultExpression);
+    await modelerCreatePage.clickAppendElementButton();
+    await modelerCreatePage.clickAppendEndEventButton();
+    await (0, sleep_1.sleep)(20000);
+}
+exports.modelRestConnector = modelRestConnector;
+async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 120000, maxRetries = 3) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await page.reload();
+            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 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;

package/dist/pages/SM-8.7/ClusterDetailsPage.d.ts

@@ -0,0 +1,8 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterDetailsPage {
+    private page;
+    readonly customPropertiesHeading: Locator;
+    constructor(page: Page);
+    assertCustomPropertyIsNavigated(linkTitle: string, linkName: string, link: string): Promise<void>;
+}
+export { ClusterDetailsPage };

package/dist/pages/SM-8.7/ClusterDetailsPage.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterDetailsPage = void 0;
+const test_1 = require("@playwright/test");
+class ClusterDetailsPage {
+    page;
+    customPropertiesHeading;
+    constructor(page) {
+        this.page = page;
+        this.customPropertiesHeading = this.page.getByRole('heading', {
+            name: 'Custom properties',
+        });
+    }
+    async assertCustomPropertyIsNavigated(linkTitle, linkName, link) {
+        const pageTabPromise = this.page.waitForEvent('popup', {
+            timeout: 60000,
+        });
+        await this.page
+            .getByRole('row', { name: linkTitle })
+            .getByRole('link', { name: linkName })
+            .click({
+            timeout: 60000,
+        });
+        const camundaPage = await pageTabPromise;
+        await (0, test_1.expect)(camundaPage).toHaveURL(link);
+    }
+}
+exports.ClusterDetailsPage = ClusterDetailsPage;

package/dist/pages/SM-8.7/ClusterPage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterPage {
+    private page;
+    readonly clustersList: Locator;
+    readonly defaultClusterName: string;
+    readonly cluster: Locator;
+    constructor(page: Page);
+    clickClusterLink(): Promise<void>;
+    assertCustomTagsAreVisible(tags: string[]): Promise<void>;
+}
+export { ClusterPage };

package/dist/pages/SM-8.7/ClusterPage.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterPage = void 0;
+const test_1 = require("@playwright/test");
+class ClusterPage {
+    page;
+    clustersList;
+    defaultClusterName = process.env.CLUSTER_NAME ||
+        'you must set the CLUSTER_NAME environment variable';
+    cluster;
+    constructor(page) {
+        this.page = page;
+        this.clustersList = page
+            .getByRole('row')
+            .filter({ hasNotText: 'Generation' }); //Filter out header row
+        this.cluster = this.clustersList.getByText(this.defaultClusterName).first();
+    }
+    async clickClusterLink() {
+        await (0, test_1.expect)(this.cluster).toBeVisible({ timeout: 60000 });
+        await this.cluster.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.page.getByText('Cluster details').first()).toBeVisible({
+            timeout: 10000,
+        });
+    }
+    async assertCustomTagsAreVisible(tags) {
+        for (const tag of tags) {
+            await (0, test_1.expect)(this.clustersList.getByText(tag, { exact: true })).toBeVisible({
+                timeout: 1000,
+            });
+        }
+    }
+}
+exports.ClusterPage = ClusterPage;