@camunda/e2e-test-suite 0.0.1

package/dist/pages/8.5/AppsPage.d.ts

@@ -0,0 +1,33 @@
+import { Page, Locator } from '@playwright/test';
+declare class AppsPage {
+    private page;
+    readonly modelerLink: Locator;
+    readonly tasklistLink: Locator;
+    readonly operateLink: Locator;
+    readonly appSwitcherButton: Locator;
+    readonly optimizeLink: Locator;
+    readonly consoleLink: Locator;
+    readonly camundaComponentsButton: Locator;
+    readonly camundaAppsButton: Locator;
+    readonly optimizeButton: Locator;
+    readonly tasklistButton: Locator;
+    readonly operateButton: Locator;
+    readonly operateListItem: Locator;
+    readonly optimizeListItem: Locator;
+    readonly tasklistListItem: Locator;
+    constructor(page: Page);
+    clickModeler(): Promise<void>;
+    clickTasklist(clusterName: string): Promise<void>;
+    private doClickClusterInOperate;
+    private doClickClusterInTasklist;
+    private doClickClusterInOptimize;
+    clickCluster(component: Locator, name: string): Promise<void>;
+    clickOperate(clusterName: string): Promise<void>;
+    clickOptimize(clusterName: string): Promise<void>;
+    clickCamundaApps(maxRetries?: number): Promise<void>;
+    clickConsoleLink(): Promise<void>;
+    assertOperatePresent(shouldBeVisible?: boolean): Promise<void>;
+    assertTasklistPresent(shouldBeVisible?: boolean): Promise<void>;
+    assertOptimizePresent(shouldBeVisible?: boolean): Promise<void>;
+}
+export { AppsPage };

package/dist/pages/8.5/AppsPage.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppsPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class AppsPage {
+    page;
+    modelerLink;
+    tasklistLink;
+    operateLink;
+    appSwitcherButton;
+    optimizeLink;
+    consoleLink;
+    camundaComponentsButton;
+    camundaAppsButton;
+    optimizeButton;
+    tasklistButton;
+    operateButton;
+    operateListItem;
+    optimizeListItem;
+    tasklistListItem;
+    constructor(page) {
+        this.page = page;
+        this.modelerLink = page.getByRole('link', { name: 'Modeler', exact: true });
+        this.appSwitcherButton = page.getByLabel('App Switcher');
+        this.tasklistLink = page.getByRole('link', { name: 'Tasklist', exact: true });
+        this.operateLink = page.getByRole('link', { name: 'Operate', exact: true });
+        this.optimizeLink = page.getByRole('link', { name: 'Optimize', exact: true });
+        this.consoleLink = page.getByRole('link', { name: 'Console', exact: true });
+        this.camundaComponentsButton = page.getByLabel('Camunda components');
+        this.camundaAppsButton = page.getByLabel('Camunda apps');
+        this.tasklistListItem = this.page
+            .getByRole('listitem')
+            .filter({ hasText: 'Tasklist' });
+        this.optimizeListItem = this.page
+            .getByRole('listitem')
+            .filter({ hasText: 'Optimize' });
+        this.operateListItem = this.page
+            .getByRole('listitem')
+            .filter({ hasText: 'Operate' });
+        this.operateButton = page.getByRole('button', {
+            name: 'Operate',
+            exact: true,
+        });
+        this.optimizeButton = page.getByRole('button', {
+            name: 'Optimize',
+            exact: true,
+        });
+        this.tasklistButton = page.getByRole('button', {
+            name: 'Tasklist',
+            exact: true,
+        });
+    }
+    async clickModeler() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    await (0, test_1.expect)(this.modelerLink).toBeVisible({ timeout: 30000 });
+                    await this.modelerLink.click();
+                }
+                else {
+                    await this.clickCamundaApps();
+                    await (0, test_1.expect)(this.modelerLink).toBeVisible({ timeout: 30000 });
+                    await this.modelerLink.click();
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the modeler link after ${maxRetries} attempts.`);
+    }
+    async clickTasklist(clusterName) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    //Single cluster
+                    if (await this.tasklistLink.isVisible({ timeout: 5000 })) {
+                        await this.tasklistLink.click({ timeout: 10000 });
+                    }
+                    else {
+                        //Multiple clusters
+                        await this.doClickClusterInTasklist(clusterName);
+                    }
+                }
+                else {
+                    await this.clickCamundaApps();
+                    if (await this.tasklistLink.isVisible({ timeout: 5000 })) {
+                        await this.tasklistLink.click({ timeout: 10000 });
+                    }
+                    else {
+                        await this.doClickClusterInTasklist(clusterName);
+                    }
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the tasklist link after ${maxRetries} attempts.`);
+    }
+    async doClickClusterInOperate(clusterName) {
+        if (await this.operateListItem
+            .getByRole('button', {
+            expanded: true,
+        })
+            .isHidden({ timeout: 5000 })) {
+            await this.operateButton.click({ timeout: 10000 });
+        }
+        await this.clickCluster(this.operateListItem, clusterName);
+    }
+    async doClickClusterInTasklist(clusterName) {
+        if (await this.tasklistListItem
+            .getByRole('button', {
+            expanded: true,
+        })
+            .isHidden({ timeout: 5000 })) {
+            await this.tasklistButton.click({ timeout: 10000 });
+        }
+        await this.clickCluster(this.tasklistListItem, clusterName);
+    }
+    async doClickClusterInOptimize(clusterName) {
+        if (await this.optimizeListItem
+            .getByRole('button', {
+            expanded: true,
+        })
+            .isHidden({ timeout: 5000 })) {
+            await this.optimizeButton.click({ timeout: 10000 });
+        }
+        await this.clickCluster(this.optimizeListItem, clusterName);
+    }
+    async clickCluster(component, name) {
+        const cluster = component.getByRole('link', { name: name, exact: true });
+        await (0, test_1.expect)(cluster).toBeVisible({ timeout: 30000 });
+        await cluster.click();
+    }
+    async clickOperate(clusterName) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    if (await this.operateLink.isVisible({ timeout: 5000 })) {
+                        //Single Cluster
+                        await this.operateLink.click({ timeout: 10000 });
+                    }
+                    else {
+                        //Multiple Cluster
+                        await this.doClickClusterInOperate(clusterName);
+                    }
+                }
+                else {
+                    await this.clickCamundaApps();
+                    if (await this.operateLink.isVisible({ timeout: 5000 })) {
+                        await this.operateLink.click({ timeout: 10000 });
+                    }
+                    else {
+                        await this.doClickClusterInOperate(clusterName);
+                    }
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the operate link after ${maxRetries} attempts.`);
+    }
+    async clickOptimize(clusterName) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    if (await this.optimizeLink.isVisible({ timeout: 10000 })) {
+                        //Single cluster
+                        await this.optimizeLink.click({ timeout: 10000 });
+                    }
+                    else {
+                        //Multiple clusters
+                        await this.doClickClusterInOptimize(clusterName);
+                    }
+                }
+                else {
+                    await this.clickCamundaApps();
+                    if (await this.optimizeLink.isVisible({ timeout: 5000 })) {
+                        await this.optimizeLink.click({ timeout: 10000 });
+                    }
+                    else {
+                        await this.doClickClusterInOptimize(clusterName);
+                    }
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the optimize link after ${maxRetries} attempts.`);
+    }
+    async clickCamundaApps(maxRetries = 3) {
+        await (0, sleep_1.sleep)(2000);
+        const appButtons = [
+            this.camundaComponentsButton,
+            this.camundaAppsButton,
+            this.appSwitcherButton,
+        ];
+        for (let retries = 0; retries < maxRetries; retries++) {
+            for (const appButton of appButtons) {
+                if (await appButton.isVisible({ timeout: 20000 })) {
+                    await appButton.click({ timeout: 60000 });
+                    return;
+                }
+            }
+        }
+    }
+    async clickConsoleLink() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    await (0, test_1.expect)(this.consoleLink).toBeVisible({ timeout: 30000 });
+                    await this.consoleLink.click();
+                }
+                else {
+                    await this.clickCamundaApps();
+                    await (0, test_1.expect)(this.consoleLink).toBeVisible({ timeout: 30000 });
+                    await this.consoleLink.click();
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the console link after ${maxRetries} attempts.`);
+    }
+    async assertOperatePresent(shouldBeVisible = true) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                const isVisible = await this.operateLink.isVisible({ timeout: 5000 });
+                if (shouldBeVisible) {
+                    if (isVisible) {
+                        // Single Cluster
+                        await (0, test_1.expect)(this.operateLink).toBeVisible();
+                    }
+                    else if (await this.operateListItem
+                        .getByRole('button', { expanded: true })
+                        .isHidden({ timeout: 5000 })) {
+                        // Multiple Cluster
+                        await (0, test_1.expect)(this.operateButton).toBeVisible();
+                    }
+                }
+                else {
+                    await (0, test_1.expect)(this.operateLink).not.toBeVisible();
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to assert the operate link visibility after ${maxRetries} attempts.`);
+    }
+    async assertTasklistPresent(shouldBeVisible = true) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                const isVisible = await this.tasklistLink.isVisible({ timeout: 5000 });
+                if (shouldBeVisible) {
+                    if (isVisible) {
+                        // Single Cluster
+                        await (0, test_1.expect)(this.tasklistLink).toBeVisible();
+                    }
+                    else if (await this.tasklistListItem
+                        .getByRole('button', { expanded: true })
+                        .isHidden({ timeout: 5000 })) {
+                        // Multiple Cluster
+                        await (0, test_1.expect)(this.tasklistButton).toBeVisible();
+                    }
+                }
+                else {
+                    await (0, test_1.expect)(this.tasklistLink).not.toBeVisible();
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to assert the tasklist link visibility after ${maxRetries} attempts.`);
+    }
+    async assertOptimizePresent(shouldBeVisible = true) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                const isVisible = await this.optimizeLink.isVisible({ timeout: 5000 });
+                if (shouldBeVisible) {
+                    if (isVisible) {
+                        // Single Cluster
+                        await (0, test_1.expect)(this.optimizeLink).toBeVisible();
+                    }
+                    else if (await this.optimizeListItem
+                        .getByRole('button', { expanded: true })
+                        .isHidden({ timeout: 5000 })) {
+                        // Multiple Cluster
+                        await (0, test_1.expect)(this.optimizeButton).toBeVisible();
+                    }
+                }
+                else {
+                    await (0, test_1.expect)(this.optimizeLink).not.toBeVisible();
+                }
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to assert the optimize link visibility after ${maxRetries} attempts.`);
+    }
+}
+exports.AppsPage = AppsPage;

package/dist/pages/8.5/ClusterDetailsPage.d.ts

@@ -0,0 +1,60 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterDetailsPage {
+    private page;
+    readonly apiTab: Locator;
+    readonly createFirstClientButton: Locator;
+    readonly clientNameTextbox: Locator;
+    readonly tasklistCheckbox: Locator;
+    readonly optimizeCheckbox: Locator;
+    readonly operateCheckbox: Locator;
+    readonly createButton: Locator;
+    readonly closeModalButton: Locator;
+    readonly createClientButton: Locator;
+    readonly settingsTab: Locator;
+    readonly rbaEnableButton: Locator;
+    readonly rbaDisableButton: Locator;
+    readonly dialog: Locator;
+    readonly enableRBADialog: Locator;
+    readonly disableRBADialog: Locator;
+    readonly deleteButton: Locator;
+    readonly deleteSubButton: Locator;
+    readonly createClientCredentialsDialog: Locator;
+    readonly clientCredentialsDialog: Locator;
+    readonly userTaskRestriction: Locator;
+    readonly alertsTab: Locator;
+    readonly alertsList: Locator;
+    readonly createFirstAlertButton: Locator;
+    readonly createNewAlertButton: Locator;
+    readonly emailRadioButton: Locator;
+    readonly createAlertsDialog: Locator;
+    readonly createAlertButton: Locator;
+    readonly secretsCheckbox: Locator;
+    readonly clientsList: Locator;
+    constructor(page: Page);
+    clickAPITab(): Promise<void>;
+    reload(): Promise<void>;
+    clickSecretsCheckbox(): Promise<void>;
+    clickCreateFirstClientButton(): Promise<void>;
+    clickClientNameTextbox(): Promise<void>;
+    fillClientNameTextbox(name: string): Promise<void>;
+    clickTasklistCheckbox(): Promise<void>;
+    clickOperateCheckbox(): Promise<void>;
+    clickOptimizeCheckbox(): Promise<void>;
+    clickCreateButton(): Promise<void>;
+    clickCloseModalButton(): Promise<void>;
+    clickSettingsTab(): Promise<void>;
+    deleteAPIClientsIfExist(): Promise<void>;
+    clickAlertsTab(): Promise<void>;
+    clickCreateFirstAlertButton(): Promise<void>;
+    clickCreateNewAlertButton(): Promise<void>;
+    createAlert(isFirstAlert?: boolean): Promise<void>;
+    selectEmailRadioButton(): Promise<void>;
+    clickCreateAlertButton(): Promise<void>;
+    deleteAlerts(): Promise<void>;
+    private doDelete;
+    enableRBA(): Promise<void>;
+    disableRBA(): Promise<void>;
+    assertComponentsHealth(components?: string[]): Promise<void>;
+    userTaskEnabledAssertion(): Promise<void>;
+}
+export { ClusterDetailsPage };