@camunda/e2e-test-suite 0.0.202 → 0.0.203

package/dist/pages/8.10/ModelerHomePage.d.ts

@@ -0,0 +1,54 @@
+import { Page, Locator } from '@playwright/test';
+declare class ModelerHomePage {
+    private defaultFolderName;
+    private page;
+    readonly modelerPageBanner: Locator;
+    readonly createNewProjectButton: Locator;
+    readonly projectNameInput: Locator;
+    readonly formNameInput: Locator;
+    readonly chooseBpmnTemplateButton: Locator;
+    readonly diagramTypeDropdown: Locator;
+    readonly bpmnTemplateOption: Locator;
+    readonly formTemplateOption: Locator;
+    readonly projectBreadcrumb: Locator;
+    readonly openOrganizationsButton: Locator;
+    readonly manageButton: Locator;
+    readonly crossComponentProjectFolder: Locator;
+    readonly homeBreadcrumb: Locator;
+    readonly rows: Locator;
+    readonly uploadFilesButton: Locator;
+    readonly messageBanner: Locator;
+    readonly idpTemplateOption: Locator;
+    readonly idpApplicationNameInput: Locator;
+    readonly createIdpApplicationButton: Locator;
+    readonly dialog: Locator;
+    readonly closeButton: Locator;
+    readonly optionsButton: Locator;
+    readonly formNameBreadcrumb: (formName: string) => Locator;
+    constructor(page: Page);
+    clickCreateNewProjectButton(): Promise<void>;
+    enterNewProjectName(name: string): Promise<void>;
+    enterIdpApplicationName(name: string): Promise<void>;
+    clickChooseBpmnTemplateButton(): Promise<void>;
+    reload(): Promise<void>;
+    getProjectNames(name: string): Promise<string[]>;
+    clickProcessDiagram(name: string): Promise<void>;
+    clickDiagramTypeDropdown(): Promise<void>;
+    clickBpmnTemplateOption(): Promise<void>;
+    clickFormOption(): Promise<void>;
+    enterFormName(name: string): Promise<void>;
+    clickProjectBreadcrumb(): Promise<void>;
+    clickHomeBreadcrumb(): Promise<void>;
+    clickOpenOrganizationsButton(): Promise<void>;
+    createForm(formName: string): Promise<void>;
+    clickCreateIdpApplicationButton(): Promise<void>;
+    clickCrossComponentProjectFolder(): Promise<void>;
+    createCrossComponentProjectFolder(): Promise<void>;
+    clickManageButton(retries?: number): Promise<void>;
+    clickUploadFilesButton(): Promise<void>;
+    clickMessageBanner(): Promise<void>;
+    selectCluster(clusterName: string): Promise<void>;
+    clickIdpApplicationTemplateOption(): Promise<void>;
+    assertFormBreadcrumbVisible(formName: string): Promise<void>;
+}
+export { ModelerHomePage };

package/dist/pages/8.10/ModelerHomePage.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelerHomePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+class ModelerHomePage {
+    defaultFolderName = 'Cross Component Test Project';
+    page;
+    modelerPageBanner;
+    createNewProjectButton;
+    projectNameInput;
+    formNameInput;
+    chooseBpmnTemplateButton;
+    diagramTypeDropdown;
+    bpmnTemplateOption;
+    formTemplateOption;
+    projectBreadcrumb;
+    openOrganizationsButton;
+    manageButton;
+    crossComponentProjectFolder;
+    homeBreadcrumb;
+    rows;
+    uploadFilesButton;
+    messageBanner;
+    idpTemplateOption;
+    idpApplicationNameInput;
+    createIdpApplicationButton;
+    dialog;
+    closeButton;
+    optionsButton;
+    formNameBreadcrumb;
+    constructor(page) {
+        this.page = page;
+        this.modelerPageBanner = page.getByRole('banner', {
+            name: 'Camunda Modeler',
+        });
+        this.createNewProjectButton = page.getByRole('button', {
+            name: 'New project',
+        });
+        this.projectNameInput = page.locator('[data-test="editable-input"]');
+        this.formNameInput = page.locator('[data-test="editable-input"]');
+        this.idpApplicationNameInput = page.getByPlaceholder('New IDP Application');
+        this.createIdpApplicationButton = page.getByRole('button', {
+            name: 'Create',
+            exact: true,
+        });
+        this.chooseBpmnTemplateButton = page.getByRole('button', {
+            name: 'Choose BPMN template',
+        });
+        this.idpTemplateOption = page
+            .locator('[data-test="create-idp-application"]')
+            .getByText('IDP Application');
+        this.diagramTypeDropdown = page.locator('[data-test="diagram-dropdown"]');
+        this.bpmnTemplateOption = page
+            .locator('[data-test="create-bpmn-diagram"]')
+            .getByText('BPMN Diagram');
+        this.formTemplateOption = page
+            .locator('[data-test="create-form"]')
+            .getByText('Form');
+        this.projectBreadcrumb = page.locator('[data-test="breadcrumb-project"]');
+        this.homeBreadcrumb = page.locator('[data-test="breadcrumb-home"]');
+        this.openOrganizationsButton = page.getByLabel('Open Organizations');
+        this.manageButton = page.getByRole('menuitem', { name: 'Manage' });
+        this.crossComponentProjectFolder = page.getByTitle(this.defaultFolderName, {
+            exact: true,
+        });
+        this.rows = page.getByRole('row');
+        this.uploadFilesButton = page.getByRole('menuitem', { name: 'Upload files' });
+        this.messageBanner = page.locator('[data-test="close-top-banner"]');
+        this.dialog = page.getByRole('dialog');
+        this.closeButton = page.getByRole('button', { name: 'Got it - Dismiss' });
+        this.optionsButton = page.getByRole('button', { name: 'Options' });
+        this.formNameBreadcrumb = (formName) => page.locator('button[data-test="breadcrumb-form"]', {
+            hasText: formName,
+        });
+    }
+    async clickCreateNewProjectButton() {
+        await (0, test_1.expect)(this.createNewProjectButton).toBeVisible({ timeout: 60000 });
+        await (0, test_1.expect)(this.createNewProjectButton).toBeEnabled({ timeout: 60000 });
+        await this.createNewProjectButton.click({ timeout: 90000 });
+    }
+    async enterNewProjectName(name) {
+        await this.projectNameInput.click({ timeout: 60000 });
+        await this.projectNameInput.fill(name);
+        await this.projectNameInput.press('Enter');
+    }
+    async enterIdpApplicationName(name) {
+        await this.idpApplicationNameInput.click({ timeout: 60000 });
+        await this.idpApplicationNameInput.fill(name);
+    }
+    async clickChooseBpmnTemplateButton() {
+        await this.chooseBpmnTemplateButton.click();
+    }
+    async reload() {
+        await this.page.reload();
+    }
+    async getProjectNames(name) {
+        return this.rows
+            .filter({ hasText: name })
+            .getByTitle(name)
+            .evaluateAll((elements) => elements
+            .map((el) => el.textContent || '')
+            .filter((text) => text !== ''));
+    }
+    async clickProcessDiagram(name) {
+        const process = this.rows.filter({ hasText: name }).getByTitle(name).first();
+        await (0, test_1.expect)(process).toBeVisible({ timeout: 90000 });
+        await process.click();
+    }
+    async clickDiagramTypeDropdown() {
+        await (0, test_1.expect)(this.diagramTypeDropdown).toBeVisible({
+            timeout: 15000,
+        });
+        await this.diagramTypeDropdown.click();
+    }
+    async clickBpmnTemplateOption() {
+        await (0, test_1.expect)(this.bpmnTemplateOption).toBeVisible({
+            timeout: 15000,
+        });
+        await this.bpmnTemplateOption.click();
+    }
+    async clickFormOption() {
+        await this.formTemplateOption.click();
+    }
+    async enterFormName(name) {
+        await this.formNameInput.click({ timeout: 60000 });
+        await this.formNameInput.fill(name);
+        await this.formNameInput.press('Enter');
+    }
+    async clickProjectBreadcrumb() {
+        await this.projectBreadcrumb.click({ timeout: 60000 });
+    }
+    async clickHomeBreadcrumb() {
+        try {
+            await this.homeBreadcrumb.click();
+        }
+        catch (error) {
+            await this.page.getByText('Home', { exact: true }).first().click();
+        }
+    }
+    async clickOpenOrganizationsButton() {
+        await (0, sleep_1.sleep)(5000);
+        await (0, test_1.expect)(this.openOrganizationsButton).toBeVisible({
+            timeout: 10000,
+        });
+        await this.openOrganizationsButton.click({ timeout: 30000 });
+    }
+    async createForm(formName) {
+        await this.clickDiagramTypeDropdown();
+        await this.clickFormOption();
+        await this.enterFormName(formName);
+        await (0, sleep_1.sleep)(10000);
+    }
+    async clickCreateIdpApplicationButton() {
+        await this.createIdpApplicationButton.click();
+    }
+    async clickCrossComponentProjectFolder() {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.crossComponentProjectFolder, {
+            preAction: async () => {
+                await this.clickMessageBanner();
+            },
+        });
+    }
+    async createCrossComponentProjectFolder() {
+        await (0, sleep_1.sleep)(15000);
+        await this.clickMessageBanner();
+        if (await this.crossComponentProjectFolder.isVisible()) {
+            console.log('Cross Component Project folder already exists. Clicking into it');
+            await this.clickCrossComponentProjectFolder();
+            return;
+        }
+        await this.clickCreateNewProjectButton();
+        await this.enterNewProjectName(this.defaultFolderName);
+    }
+    async clickManageButton(retries = 3) {
+        await this.optionsButton.click({ timeout: 30000 });
+        for (let i = 0; i < retries; i++) {
+            try {
+                await (0, sleep_1.sleep)(5000);
+                if (await this.manageButton.isVisible({ timeout: 30000 })) {
+                    await this.manageButton.click({ timeout: 10000 });
+                }
+                else {
+                    await this.clickOpenOrganizationsButton();
+                    await this.optionsButton.click({ timeout: 30000 });
+                    await (0, test_1.expect)(this.manageButton).toBeVisible({ timeout: 30000 });
+                    await this.manageButton.click({ timeout: 30000 });
+                }
+                return;
+            }
+            catch (error) {
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Failed to click manage button after ${retries} retries`);
+    }
+    async clickUploadFilesButton() {
+        await this.uploadFilesButton.click({ timeout: 60000 });
+    }
+    async clickMessageBanner() {
+        try {
+            const button = this.messageBanner.or(this.closeButton).first();
+            await (0, test_1.expect)(button).toBeVisible({ timeout: 15000 });
+            await button.click();
+        }
+        catch {
+            console.log('No banner or close button found to click');
+        }
+    }
+    async selectCluster(clusterName) {
+        //Select the correct cluster if multiple exist
+        const baseClusterName = clusterName.split('(')[0].trim();
+        const cluster = this.dialog.getByText(baseClusterName, { exact: false });
+        await (0, test_1.expect)(cluster).toBeVisible({
+            timeout: 30000,
+        });
+        await cluster.click();
+        await (0, test_1.expect)(this.dialog
+            .locator('label')
+            .filter({
+            hasText: clusterName,
+        })
+            .getByRole('switch')).toBeChecked({ timeout: 30000 });
+    }
+    async clickIdpApplicationTemplateOption() {
+        await this.idpTemplateOption.click({ timeout: 120000 });
+    }
+    async assertFormBreadcrumbVisible(formName) {
+        await (0, test_1.expect)(this.formNameBreadcrumb(formName)).toBeVisible({
+            timeout: 120000,
+        });
+    }
+}
+exports.ModelerHomePage = ModelerHomePage;

package/dist/pages/8.10/ModelerUserInvitePage.d.ts

@@ -0,0 +1,29 @@
+import { Page, Locator } from '@playwright/test';
+declare class ModelerUserInvitePage {
+    private page;
+    readonly buttonAddUser: Locator;
+    readonly inputFieldUserEmailAddress: Locator;
+    readonly buttonSendInvitation: Locator;
+    readonly pendingInviteText: Locator;
+    readonly settings: Locator;
+    readonly logout: Locator;
+    readonly buttonSkipCustomization: Locator;
+    readonly buttonCloseHelpCentre: Locator;
+    readonly collaboratorName: Locator;
+    readonly inviteModal: Locator;
+    readonly collaboratorEmail: (email: string) => Locator;
+    constructor(page: Page);
+    clickAddUser(): Promise<void>;
+    clickUserEmailInput(): Promise<void>;
+    fillUserEmailInput(emailAddress: string): Promise<void>;
+    clickSendInviteButton(): Promise<void>;
+    checkPendingInviteText(email: string): Promise<void>;
+    inviteNewUser(email: string): Promise<void>;
+    fillNewUserWithRetry(email: string): Promise<void>;
+    clickSettings(): Promise<void>;
+    clickLogout(): Promise<void>;
+    clickSkipCustomization(): Promise<void>;
+    clickCloseHelpCenter(): Promise<void>;
+    verifyCollaboratorName(): Promise<void>;
+}
+export { ModelerUserInvitePage };

package/dist/pages/8.10/ModelerUserInvitePage.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelerUserInvitePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class ModelerUserInvitePage {
+    page;
+    buttonAddUser;
+    inputFieldUserEmailAddress;
+    buttonSendInvitation;
+    pendingInviteText;
+    settings;
+    logout;
+    buttonSkipCustomization;
+    buttonCloseHelpCentre;
+    collaboratorName;
+    inviteModal;
+    collaboratorEmail;
+    constructor(page) {
+        this.page = page;
+        this.buttonAddUser = page.locator('[data-test="add-collaborator"]');
+        this.inputFieldUserEmailAddress = page.locator('[data-test="multi-select-input"]');
+        this.buttonSendInvitation = page.locator('[data-test="invite-email-button"]');
+        this.pendingInviteText = page.getByText('pending').first();
+        this.settings = page.getByLabel('Open Settings');
+        this.logout = page.getByRole('button', { name: 'Log out' });
+        this.buttonSkipCustomization = page.getByRole('button', {
+            name: 'Skip customization',
+        });
+        this.buttonCloseHelpCentre = page.getByRole('button', { name: 'Close' });
+        this.collaboratorName = page.getByText('QA Camunda');
+        this.collaboratorEmail = (email) => this.page.locator('[data-test="chip"]').filter({ hasText: `${email}` });
+        this.inviteModal = this.page.locator('text="Invite collaborators to"');
+    }
+    async clickAddUser() {
+        if (await this.inviteModal.isVisible({ timeout: 2000 })) {
+            console.log('Invite modal already open, skipping Add user click');
+            return;
+        }
+        await (0, test_1.expect)(this.buttonAddUser).toBeVisible({ timeout: 60000 });
+        try {
+            await this.buttonAddUser.click({ timeout: 10000 });
+        }
+        catch (error) {
+            console.log('Regular click failed, trying force click');
+            await this.buttonAddUser.click({ force: true });
+        }
+    }
+    async clickUserEmailInput() {
+        await (0, test_1.expect)(this.inputFieldUserEmailAddress).toBeVisible({
+            timeout: 60000,
+        });
+        await this.inputFieldUserEmailAddress.click();
+    }
+    async fillUserEmailInput(emailAddress) {
+        await this.inputFieldUserEmailAddress.fill(emailAddress);
+        await (0, test_1.expect)(this.inputFieldUserEmailAddress).toHaveValue(emailAddress);
+        await this.inputFieldUserEmailAddress.press('Enter');
+    }
+    async clickSendInviteButton() {
+        await (0, test_1.expect)(this.buttonSendInvitation).toBeVisible({ timeout: 60000 });
+        await this.buttonSendInvitation.click();
+    }
+    async checkPendingInviteText(email) {
+        const maxRetries = 4;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(this.page.getByRole('row').filter({ hasText: `${email}` })).toContainText('pending', {
+                    timeout: 30000,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempt === 0) {
+                    await this.page.reload();
+                    await (0, sleep_1.sleep)(20000);
+                }
+                else if (attempt === 1 || attempt === 2) {
+                    await this.inviteNewUser(email);
+                }
+                else {
+                    console.error(error);
+                    throw new Error(`Inviting a user failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async inviteNewUser(email) {
+        await this.clickAddUser();
+        await this.clickUserEmailInput();
+        await this.fillUserEmailInput(email);
+        await (0, sleep_1.sleep)(8000);
+        await this.clickSendInviteButton();
+    }
+    async fillNewUserWithRetry(email) {
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.clickUserEmailInput();
+                await this.fillUserEmailInput(email);
+                await (0, test_1.expect)(this.collaboratorEmail(email).first()).toBeVisible({
+                    timeout: 20000,
+                });
+                return;
+            }
+            catch (error) {
+                console.log(`Attempt ${attempt}: Error filling email input:${email}`, error);
+            }
+            if (attempt < maxRetries) {
+                await this.inputFieldUserEmailAddress.clear();
+                await (0, sleep_1.sleep)(1000);
+            }
+        }
+        throw new Error(`Failed to filling email input:${email} after ${maxRetries} attempts`);
+    }
+    async clickSettings() {
+        await (0, test_1.expect)(this.settings).toBeVisible({ timeout: 60000 });
+        await this.settings.click({ timeout: 90000 });
+    }
+    async clickLogout() {
+        await (0, test_1.expect)(this.logout).toBeVisible({ timeout: 60000 });
+        await this.logout.click({ timeout: 50000 });
+    }
+    async clickSkipCustomization() {
+        await (0, test_1.expect)(this.buttonSkipCustomization).toBeVisible({ timeout: 60000 });
+        await this.buttonSkipCustomization.click();
+    }
+    async clickCloseHelpCenter() {
+        await (0, test_1.expect)(this.buttonCloseHelpCentre).toBeVisible({ timeout: 60000 });
+        await this.buttonCloseHelpCentre.click();
+    }
+    async verifyCollaboratorName() {
+        await (0, test_1.expect)(this.collaboratorName).toBeVisible({ timeout: 60000 });
+    }
+}
+exports.ModelerUserInvitePage = ModelerUserInvitePage;

package/dist/pages/8.10/OCIdentityAuthorizationsPage.d.ts

@@ -0,0 +1,11 @@
+import { Authorization } from '../8.10/Authorization';
+import { Page } from '@playwright/test';
+declare class OCIdentityAuthorizationsPage extends Authorization {
+    constructor(page: Page);
+    clickProcessDefinitionTab(): Promise<void>;
+    clickAuthorizationTab(): Promise<void>;
+    clickRoleTab(): Promise<void>;
+    clickComponentTab(): Promise<void>;
+    clickResourceTab(): Promise<void>;
+}
+export { OCIdentityAuthorizationsPage };

package/dist/pages/8.10/OCIdentityAuthorizationsPage.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCIdentityAuthorizationsPage = void 0;
+const Authorization_1 = require("../8.10/Authorization");
+const test_1 = require("@playwright/test");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+class OCIdentityAuthorizationsPage extends Authorization_1.Authorization {
+    constructor(page) {
+        super(page);
+    }
+    async clickProcessDefinitionTab() {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.selectResourceTypeTab('PROCESS_DEFINITION'));
+        await this.selectResourceTypeTab('PROCESS_DEFINITION').click();
+    }
+    async clickAuthorizationTab() {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.selectResourceTypeTab('AUTHORIZATION'));
+        await this.selectResourceTypeTab('AUTHORIZATION').click();
+    }
+    async clickRoleTab() {
+        await (0, test_1.expect)(this.selectResourceTypeTab('Role')).toBeVisible();
+        await this.selectResourceTypeTab('Role').click();
+    }
+    async clickComponentTab() {
+        await (0, test_1.expect)(this.selectResourceTypeTab('COMPONENT')).toBeVisible();
+        await this.selectResourceTypeTab('COMPONENT').click();
+    }
+    async clickResourceTab() {
+        await (0, test_1.expect)(this.selectResourceTypeTab('RESOURCE')).toBeVisible();
+        await this.selectResourceTypeTab('RESOURCE').click();
+    }
+}
+exports.OCIdentityAuthorizationsPage = OCIdentityAuthorizationsPage;

package/dist/pages/8.10/OCIdentityGroupsPage.d.ts

@@ -0,0 +1,38 @@
+import { Page, Locator } from '@playwright/test';
+export declare class OCIdentityGroupsPage {
+    private page;
+    readonly groupsList: Locator;
+    readonly createGroupButton: Locator;
+    readonly editGroupButton: (rowName?: string) => Locator;
+    readonly deleteGroupButton: (rowName?: string) => Locator;
+    readonly createGroupModal: Locator;
+    readonly closeCreateGroupModal: Locator;
+    readonly createGroupIdField: Locator;
+    readonly createNameField: Locator;
+    readonly createDescriptionField: Locator;
+    readonly createGroupModalCancelButton: Locator;
+    readonly createGroupModalCreateButton: Locator;
+    readonly editGroupModal: Locator;
+    readonly closeEditGroupModal: Locator;
+    readonly editNameField: Locator;
+    readonly editDescriptionField: Locator;
+    readonly editGroupModalCancelButton: Locator;
+    readonly editGroupModalUpdateButton: Locator;
+    readonly deleteGroupModal: Locator;
+    readonly closeDeleteGroupModal: Locator;
+    readonly deleteGroupModalCancelButton: Locator;
+    readonly deleteGroupModalDeleteButton: Locator;
+    readonly emptyState: Locator;
+    readonly assignUserButton: Locator;
+    readonly searchBox: Locator;
+    readonly assignUserButtonModal: Locator;
+    readonly selectGroupRow: (name: string) => Locator;
+    readonly groupCell: (name: string) => Locator;
+    constructor(page: Page);
+    createGroup(groupId: string, groupName: string, description?: string): Promise<void>;
+    editGroup(currentName: string, newName: string, newDescription?: string): Promise<void>;
+    deleteGroup(groupName: string): Promise<void>;
+    assertGroupExists(groupName: string): Promise<void>;
+    clickGroupId(groupName: string): Promise<void>;
+    assignUserToGroup(userName: string): Promise<void>;
+}