@camunda/e2e-test-suite 0.0.1

package/dist/pages/SM-8.5/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 processesPageTab: Locator;
+    readonly tasksTab: 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>;
+    clickProcessesTab(): Promise<void>;
+    clickTasksTab(): Promise<void>;
+    taskCount(name: string): Promise<number>;
+    processAssertion(processName: string, { timeout, not }?: {
+        timeout?: number;
+        not?: boolean;
+    }): Promise<void>;
+}
+export { TaskPanelPage };

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

@@ -0,0 +1,77 @@
+"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;
+    processesPageTab;
+    tasksTab;
+    constructor(page) {
+        this.page = page;
+        this.availableTasks = page.getByTitle('Available tasks');
+        this.filterOptions = page.getByRole('combobox', { name: 'Filter options' });
+        this.tasklistBanner = page.getByRole('link', {
+            name: 'Camunda logo Tasklist',
+        });
+        this.processesPageTab = page.getByRole('link', { name: 'Processes' });
+        this.tasksTab = page.getByRole('link', { name: 'Tasks', 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('option', { name: option }).getByText(option)).toBeVisible({ timeout: 120000 });
+        await this.page
+            .getByRole('option', { name: option })
+            .getByText(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 clickProcessesTab() {
+        await this.processesPageTab.click();
+    }
+    async clickTasksTab() {
+        await (0, test_1.expect)(this.tasksTab).toBeVisible({ timeout: 60000 });
+        await this.tasksTab.click();
+    }
+    async taskCount(name) {
+        await (0, sleep_1.sleep)(20000);
+        return this.availableTasks.getByText(name, { exact: true }).count();
+    }
+    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();
+            }
+        }
+    }
+}
+exports.TaskPanelPage = TaskPanelPage;

package/dist/pages/SM-8.5/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.5/TaskProcessesPage.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProcessesPage = void 0;
+const test_1 = require("@playwright/test");
+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 });
+        await (0, test_1.expect)(this.page.getByText('Waiting for tasks...')).not.toBeVisible({
+            timeout: 90000,
+        });
+    }
+}
+exports.TaskProcessesPage = TaskProcessesPage;

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

@@ -0,0 +1,21 @@
+import { Page, Locator } from '@playwright/test';
+import { IdentityPage } from '../SM-8.5/IdentityPage';
+import { NavigationPage } from '../SM-8.5/NavigationPage';
+import { ModelerHomePage } from './ModelerHomePage';
+import { ModelerCreatePage } from './ModelerCreatePage';
+import { TaskPanelPage } from '../SM-8.5/TaskPanelPage';
+import { TaskDetailsPage } from '../SM-8.5/TaskDetailsPage';
+import { ConnectorSettingsPage } from '../SM-8.5/ConnectorSettingsPage';
+import { ConnectorMarketplacePage } from '../SM-8.5/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): Promise<void>;
+export declare function createAndRunProcess(page: Page, modelerHomePage: ModelerHomePage, modelerCreatePage: ModelerCreatePage, processName: string): Promise<void>;
+export declare function completeTaskWithRetry(page: Page, taskPanelPage: TaskPanelPage, taskDetailsPage: TaskDetailsPage, taskName: 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.5/UtilitiesPage.js

@@ -0,0 +1,210 @@
+"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) {
+    for (let i = 1; i <= numberOfProcesses; i++) {
+        await createAndRunProcess(page, modelerHomePage, modelerCreatePage, processName + i);
+    }
+}
+exports.runMultipleProcesses = runMultipleProcesses;
+async function createAndRunProcess(page, modelerHomePage, modelerCreatePage, processName) {
+    await modelerHomePage.clickDiagramTypeDropdown();
+    await modelerHomePage.clickBpmnTemplateOption();
+    await modelerCreatePage.modelJobWorkerDiagram(processName);
+    await modelerCreatePage.runProcessInstance();
+    await modelerHomePage.clickProjectBreadcrumb();
+}
+exports.createAndRunProcess = createAndRunProcess;
+async function completeTaskWithRetry(page, taskPanelPage, taskDetailsPage, taskName, 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 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)(15000);
+    await modelerCreatePage.clickCanvas();
+    await modelerCreatePage.clickGeneralPropertiesPanel();
+    await modelerCreatePage.clickIdInput();
+    await modelerCreatePage.fillIdInput(processName);
+    await modelerCreatePage.clickStartEventElement();
+    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.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.clickFirstPlacedElement();
+    await modelerCreatePage.clickGeneralPropertiesPanel();
+    await modelerCreatePage.clickIdInput();
+    await modelerCreatePage.fillIdInput(processName);
+    await (0, sleep_1.sleep)(10000);
+    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.6/ConnectorMarketplacePage.d.ts

@@ -0,0 +1,16 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorMarketplacePage {
+    private page;
+    readonly searchForConnectorTextbox: Locator;
+    readonly downloadToProjectButton: Locator;
+    readonly snackbar: Locator;
+    readonly closeButton: Locator;
+    constructor(page: Page);
+    clickSearchForConnectorTextbox(): Promise<void>;
+    fillSearchForConnectorTextbox(connectorName: string): Promise<void>;
+    clickDownloadToProjectButton(): Promise<void>;
+    clickSnackbar(): Promise<void>;
+    clickCloseButton(): Promise<void>;
+    downloadConnectorToProject(): Promise<void>;
+}
+export { ConnectorMarketplacePage };

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorMarketplacePage = void 0;
+const test_1 = require("@playwright/test");
+class ConnectorMarketplacePage {
+    page;
+    searchForConnectorTextbox;
+    downloadToProjectButton;
+    snackbar;
+    closeButton;
+    constructor(page) {
+        this.page = page;
+        this.searchForConnectorTextbox = page.getByPlaceholder('Search for a connector');
+        this.downloadToProjectButton = page
+            .getByRole('button', { name: 'Download to project' })
+            .first();
+        this.snackbar = page.locator('[data-test="snackbar"]');
+        this.closeButton = page.getByRole('button', { name: 'Close' });
+    }
+    async clickSearchForConnectorTextbox() {
+        await this.searchForConnectorTextbox.click({ timeout: 60000 });
+    }
+    async fillSearchForConnectorTextbox(connectorName) {
+        await this.searchForConnectorTextbox.fill(connectorName, { timeout: 60000 });
+    }
+    async clickDownloadToProjectButton() {
+        await this.downloadToProjectButton.click({ timeout: 60000 });
+    }
+    async clickSnackbar() {
+        await this.snackbar.click({ timeout: 120000 });
+    }
+    async clickCloseButton() {
+        await this.closeButton.click({ timeout: 60000 });
+    }
+    async downloadConnectorToProject() {
+        try {
+            await this.clickDownloadToProjectButton();
+            await (0, test_1.expect)(this.snackbar).toBeVisible({
+                timeout: 30000,
+            });
+            await this.clickSnackbar();
+        }
+        catch {
+            await this.clickCloseButton();
+        }
+    }
+}
+exports.ConnectorMarketplacePage = ConnectorMarketplacePage;

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

@@ -0,0 +1,28 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorSettingsPage {
+    private page;
+    readonly urlInput: Locator;
+    readonly resultExpressionInput: Locator;
+    readonly authenticationTypeDropdown: Locator;
+    readonly usernameInput: Locator;
+    readonly passwordInput: Locator;
+    readonly methodTypeDropdown: Locator;
+    readonly resultVariableInput: Locator;
+    readonly bearerTokenInput: Locator;
+    constructor(page: Page);
+    clickUrlInput(): Promise<void>;
+    fillUrlInput(url: string): Promise<void>;
+    clickResultExpressionInput(): Promise<void>;
+    fillResultExpressionInput(resultExpression: string): Promise<void>;
+    selectAuthenticationType(authentication: string): Promise<void>;
+    clickUsernameInput(): Promise<void>;
+    fillUsernameInput(username: string): Promise<void>;
+    clickPasswordInput(): Promise<void>;
+    fillPasswordInput(password: string): Promise<void>;
+    selectMethodType(method: string): Promise<void>;
+    clickResultVariableInput(): Promise<void>;
+    fillResultVariableInput(variable: string): Promise<void>;
+    clickBearerTokenInput(): Promise<void>;
+    fillBearerTokenInput(token: string): Promise<void>;
+}
+export { ConnectorSettingsPage };

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorSettingsPage = void 0;
+const ModelerCreatePage_1 = require("./ModelerCreatePage");
+class ConnectorSettingsPage {
+    page;
+    urlInput;
+    resultExpressionInput;
+    authenticationTypeDropdown;
+    usernameInput;
+    passwordInput;
+    methodTypeDropdown;
+    resultVariableInput;
+    bearerTokenInput;
+    constructor(page) {
+        this.page = page;
+        this.urlInput = page.getByLabel('URL');
+        this.resultExpressionInput = page
+            .locator('div')
+            .filter({ hasText: /^Result expression=Opened in editor$/ })
+            .getByRole('textbox');
+        this.authenticationTypeDropdown = page.getByLabel('Type');
+        this.usernameInput = page.getByLabel('Username');
+        this.passwordInput = page.getByLabel('Password');
+        this.methodTypeDropdown = page.getByLabel('Method');
+        this.resultVariableInput = page.getByLabel('Result variable');
+        this.bearerTokenInput = page.getByLabel('Bearer token');
+    }
+    async clickUrlInput() {
+        try {
+            await this.urlInput.click({ timeout: 60000 });
+        }
+        catch {
+            const modelerCreatePage = new ModelerCreatePage_1.ModelerCreatePage(this.page);
+            await modelerCreatePage.clickStartEventElement();
+            await modelerCreatePage.clickAppendTaskButton();
+            await modelerCreatePage.clickChangeTypeButton();
+            await modelerCreatePage.clickRestConnectorOption();
+            await this.urlInput.click({ timeout: 60000 });
+        }
+    }
+    async fillUrlInput(url) {
+        await this.urlInput.fill(url);
+    }
+    async clickResultExpressionInput() {
+        await this.resultExpressionInput.click();
+    }
+    async fillResultExpressionInput(resultExpression) {
+        await this.resultExpressionInput.fill(resultExpression);
+    }
+    async selectAuthenticationType(authentication) {
+        await this.authenticationTypeDropdown.selectOption(authentication);
+    }
+    async clickUsernameInput() {
+        await this.usernameInput.click({ timeout: 30000 });
+    }
+    async fillUsernameInput(username) {
+        await this.usernameInput.fill(username, { timeout: 30000 });
+    }
+    async clickPasswordInput() {
+        await this.passwordInput.click();
+    }
+    async fillPasswordInput(password) {
+        await this.passwordInput.fill(password);
+    }
+    async selectMethodType(method) {
+        await this.methodTypeDropdown.selectOption(method, { timeout: 60000 });
+    }
+    async clickResultVariableInput() {
+        await this.resultVariableInput.click();
+    }
+    async fillResultVariableInput(variable) {
+        await this.resultVariableInput.fill(variable);
+    }
+    async clickBearerTokenInput() {
+        await this.bearerTokenInput.click({ timeout: 30000 });
+    }
+    async fillBearerTokenInput(token) {
+        await this.bearerTokenInput.fill(token);
+    }
+}
+exports.ConnectorSettingsPage = ConnectorSettingsPage;

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

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorTemplatePage {
+    private page;
+    readonly publishToOrgButton: Locator;
+    readonly publishButton: Locator;
+    constructor(page: Page);
+    clickPublishToOrgButton(): Promise<void>;
+    clickPublishButton(): Promise<void>;
+    publishConnector(): Promise<void>;
+}
+export { ConnectorTemplatePage };

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorTemplatePage = void 0;
+const test_1 = require("@playwright/test");
+class ConnectorTemplatePage {
+    page;
+    publishToOrgButton;
+    publishButton;
+    constructor(page) {
+        this.page = page;
+        this.publishButton = page.getByRole('button', {
+            name: 'Publish',
+            exact: true,
+        });
+        this.publishToOrgButton = page.locator('[data-test="publish-to-org"]');
+    }
+    async clickPublishToOrgButton() {
+        await this.publishToOrgButton.click({ timeout: 90000 });
+    }
+    async clickPublishButton() {
+        await this.publishButton.click({ timeout: 90000 });
+    }
+    async publishConnector() {
+        try {
+            await (0, test_1.expect)(this.publishToOrgButton).toBeVisible({ timeout: 15000 });
+        }
+        catch (error) {
+            return;
+        }
+        await this.clickPublishToOrgButton();
+        await this.clickPublishButton();
+    }
+}
+exports.ConnectorTemplatePage = ConnectorTemplatePage;

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

@@ -0,0 +1,9 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConsoleHomePage {
+    private page;
+    readonly consoleBanner: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    constructor(page: Page);
+}
+export { ConsoleHomePage };

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleHomePage = void 0;
+class ConsoleHomePage {
+    page;
+    consoleBanner;
+    licenseKeyTagNonProduction;
+    licenseKeyTagProduction;
+    constructor(page) {
+        this.page = page;
+        this.consoleBanner = page.getByRole('link', {
+            name: 'Camunda logo Console',
+        });
+        this.licenseKeyTagNonProduction = page.getByText('Non-production license', {
+            exact: true,
+        });
+        this.licenseKeyTagProduction = page.getByText('Production license', {
+            exact: true,
+        });
+    }
+}
+exports.ConsoleHomePage = ConsoleHomePage;

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

@@ -0,0 +1,22 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConsoleOrganizationPage {
+    private page;
+    readonly usersTab: Locator;
+    readonly optionsButton: Locator;
+    readonly editUserMenuItem: Locator;
+    readonly operationsEngineerCheckbox: Locator;
+    readonly developerCheckbox: Locator;
+    readonly analystCheckbox: Locator;
+    readonly confirmButton: Locator;
+    constructor(page: Page);
+    clickUsersTab(): Promise<void>;
+    clickOptionsButton(): Promise<void>;
+    clickEditUserMenuItem(): Promise<void>;
+    clickOperationsEngineerCheckbox(): Promise<void>;
+    checkDeveloperCheckbox(): Promise<void>;
+    uncheckDeveloperCheckbox(): Promise<void>;
+    checkAnalystCheckbox(): Promise<void>;
+    uncheckAnalystCheckbox(): Promise<void>;
+    clickConfirmButton(): Promise<void>;
+}
+export { ConsoleOrganizationPage };