@camunda/e2e-test-suite 0.0.714 → 0.0.715

package/dist/pages/8.6/AppsPage.js

@@ -1,337 +0,0 @@
-"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;
-    consoleLink;
-    optimizeLink;
-    camundaComponentsButton;
-    camundaAppsButton;
-    optimizeButton;
-    tasklistButton;
-    operateButton;
-    operateListItem;
-    optimizeListItem;
-    tasklistListItem;
-    constructor(page) {
-        this.page = page;
-        this.modelerLink = page
-            .getByRole('link', { name: 'Modeler', exact: true })
-            .or(page.getByLabel('App Panel').getByLabel('Camunda Modeler'))
-            .first();
-        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.consoleLink = page.getByRole('link', { name: 'Console', exact: true });
-        this.optimizeLink = page.getByRole('link', { name: 'Optimize', 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 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 this.page.waitForLoadState('domcontentloaded');
-                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 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 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 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.6/ClientCredentialsDetailsPage.d.ts

@@ -1,12 +0,0 @@
-import { Page, Locator } from '@playwright/test';
-declare class ClientCredentialsDetailsPage {
-    private page;
-    readonly operateUrlRow: Locator;
-    readonly operateUrlValue: Locator;
-    readonly clientNameHeading: (clientName: string) => Locator;
-    constructor(page: Page);
-    isOpen(clientName: string): Promise<void>;
-    getOperateUrl(): Promise<string>;
-    goBack(): Promise<void>;
-}
-export { ClientCredentialsDetailsPage };

package/dist/pages/8.6/ClientCredentialsDetailsPage.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientCredentialsDetailsPage = void 0;
-const test_1 = require("@playwright/test");
-class ClientCredentialsDetailsPage {
-    page;
-    operateUrlRow;
-    operateUrlValue;
-    clientNameHeading;
-    constructor(page) {
-        this.page = page;
-        this.operateUrlRow = page.getByRole('cell', { name: 'Operate URL' });
-        this.operateUrlValue = this.operateUrlRow.getByRole('textbox');
-        this.clientNameHeading = (clientName) => page.getByRole('heading', { name: clientName });
-    }
-    async isOpen(clientName) {
-        await (0, test_1.expect)(this.clientNameHeading(clientName)).toBeVisible({
-            timeout: 30000,
-        });
-    }
-    async getOperateUrl() {
-        if (await this.operateUrlValue.isVisible({ timeout: 10000 }).catch(() => false)) {
-            return await this.operateUrlValue.inputValue();
-        }
-        const text = await this.page.innerText('body');
-        const match = text.match(/Operate URL\s*([\w:/.-]+\/?)/i);
-        if (!match || !match[1]) {
-            throw new Error('Operate URL not found in client credentials page');
-        }
-        return match[1];
-    }
-    async goBack() {
-        await this.page.goBack();
-    }
-}
-exports.ClientCredentialsDetailsPage = ClientCredentialsDetailsPage;

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

@@ -1,75 +0,0 @@
-import { Page, Locator } from '@playwright/test';
-import { ClientCredentialsDetailsPage } from '../8.6/ClientCredentialsDetailsPage';
-declare class ClusterDetailsPage {
-    private page;
-    readonly apiTab: Locator;
-    readonly createFirstClientButton: Locator;
-    readonly clientNameTextbox: Locator;
-    readonly tasklistCheckbox: Locator;
-    readonly optimizeCheckbox: Locator;
-    readonly secretsCheckbox: Locator;
-    readonly operateCheckbox: Locator;
-    readonly createButton: Locator;
-    readonly closeModalButton: Locator;
-    readonly clientsList: 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 rbaHeading: Locator;
-    readonly rbaEnabledMessage: Locator;
-    readonly clientCredentialsLink: (clientCredentials: string) => Locator;
-    readonly clientRow: (name: string) => Locator;
-    readonly clientRowDeleteButton: (name: string) => Locator;
-    readonly reviewUpdateButton: Locator;
-    readonly updateAvailableDialog: Locator;
-    readonly updateButton: Locator;
-    constructor(page: Page);
-    clickAPITab(): Promise<void>;
-    deleteAPIClientsIfExist(name?: string): 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;
-    clickCreateClientButton(): Promise<void>;
-    clickCreateFirstClientButton(): Promise<void>;
-    reload(): Promise<void>;
-    clickClientNameTextbox(): Promise<void>;
-    fillClientNameTextbox(name: string): Promise<void>;
-    clickTasklistCheckbox(): Promise<void>;
-    clickOperateCheckbox(): Promise<void>;
-    clickOptimizeCheckbox(): Promise<void>;
-    clickSecretsCheckbox(): Promise<void>;
-    clickCreateButton(): Promise<void>;
-    clickCloseModalButton(): Promise<void>;
-    clickSettingsTab(): Promise<void>;
-    createAPIClient(name: string): Promise<void>;
-    searchAndClickClientCredentialsLink(name: string): Promise<ClientCredentialsDetailsPage>;
-    enableRBA(): Promise<void>;
-    disableRBA(): Promise<void>;
-    assertComponentsHealth(components?: string[]): Promise<void>;
-    userTaskEnabledAssertion(): Promise<void>;
-    clickReviewUpdateButton(): Promise<void>;
-    clickUpdateButton(): Promise<void>;
-    performClusterUpdate(): Promise<void>;
-}
-export { ClusterDetailsPage };