@camunda/e2e-test-suite 0.0.257 → 0.0.258

package/dist/pages/SM-8.10/LoginPage.d.ts

@@ -0,0 +1,21 @@
+import { Page, Locator } from '@playwright/test';
+declare class LoginPage {
+    private page;
+    readonly usernameInput: Locator;
+    readonly passwordInput: Locator;
+    readonly loginButton: Locator;
+    readonly coreUsernameInput: Locator;
+    readonly corePasswordInput: Locator;
+    readonly coreLoginButton: Locator;
+    readonly keycloakBanner: Locator;
+    private useCore;
+    private useKeycloak;
+    constructor(page: Page);
+    detectLoginForm(): Promise<void>;
+    fillUsername(username: string): Promise<void>;
+    clickUsername(): Promise<void>;
+    fillPassword(password: string): Promise<void>;
+    clickLoginButton(): Promise<void>;
+    login(username: string, password: string): Promise<void>;
+}
+export { LoginPage };

package/dist/pages/SM-8.10/LoginPage.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginPage = void 0;
+const test_1 = require("@playwright/test");
+class LoginPage {
+    page;
+    usernameInput;
+    passwordInput;
+    loginButton;
+    coreUsernameInput;
+    corePasswordInput;
+    coreLoginButton;
+    keycloakBanner;
+    useCore = false;
+    useKeycloak = false;
+    constructor(page) {
+        this.page = page;
+        this.usernameInput = page.getByLabel('Username or email');
+        this.passwordInput = page.getByLabel('Password');
+        this.loginButton = page.getByRole('button', { name: 'Log in' });
+        this.coreUsernameInput = page.getByPlaceholder('Username');
+        this.corePasswordInput = page.getByPlaceholder('Password');
+        this.coreLoginButton = page.getByRole('button', { name: 'Login' });
+        this.keycloakBanner = page.locator('body#keycloak-bg[data-page-id="login-login"]');
+    }
+    // Race logic: call before interacting
+    async detectLoginForm() {
+        const winner = await Promise.race([
+            this.usernameInput.waitFor({ state: 'visible' }).then(() => 'default'),
+            this.coreUsernameInput.waitFor({ state: 'visible' }).then(() => 'core'),
+            this.keycloakBanner.waitFor({ state: 'visible' }).then(() => 'keycloak'),
+        ]);
+        this.useCore = winner === 'core';
+        this.useKeycloak = winner === 'keycloak';
+    }
+    async fillUsername(username) {
+        if (await this.page.locator('#username').isVisible()) {
+            await this.page.fill('#username', username);
+        }
+        else {
+            await (this.useCore
+                ? this.coreUsernameInput.fill(username)
+                : this.usernameInput.fill(username));
+        }
+    }
+    async clickUsername() {
+        if (await this.page.locator('#username').isVisible()) {
+            await this.page.click('#username');
+        }
+        else {
+            await (this.useCore
+                ? this.coreUsernameInput.click({ timeout: 60000 })
+                : this.usernameInput.click({ timeout: 60000 }));
+        }
+    }
+    async fillPassword(password) {
+        if (await this.page.locator('#password').isVisible()) {
+            await this.page.fill('#password', password);
+        }
+        else {
+            await (this.useCore
+                ? this.corePasswordInput.fill(password)
+                : this.passwordInput.fill(password));
+        }
+    }
+    async clickLoginButton() {
+        if (await this.page.locator('button[type="submit"]').isVisible()) {
+            await this.page.click('button[type="submit"]');
+        }
+        else {
+            await (this.useCore
+                ? this.coreLoginButton.click({ timeout: 60000 })
+                : this.loginButton.click({ timeout: 60000 }));
+        }
+    }
+    async login(username, password) {
+        try {
+            await this.detectLoginForm();
+            if (await this.page
+                .locator('body#keycloak-bg[data-page-id="login-login"]')
+                .isVisible()) {
+                await (0, test_1.expect)(this.keycloakBanner).toBeVisible({ timeout: 15000 });
+            }
+            else {
+                const activeLoginButton = this.useCore
+                    ? this.coreLoginButton
+                    : this.loginButton;
+                await (0, test_1.expect)(activeLoginButton).toBeVisible({ timeout: 15000 });
+            }
+        }
+        catch (error) {
+            return;
+        }
+        await this.clickUsername();
+        await this.fillUsername(username);
+        await this.fillPassword(password);
+        await this.clickLoginButton();
+    }
+}
+exports.LoginPage = LoginPage;

package/dist/pages/SM-8.10/ManagementIdentityPage.d.ts

@@ -0,0 +1,46 @@
+import { Page, Locator } from '@playwright/test';
+declare class ManagementIdentityPage {
+    private page;
+    readonly identityBanner: Locator;
+    readonly usersLink: Locator;
+    readonly assignedRolesTab: Locator;
+    readonly demoUser: Locator;
+    readonly confirmDeleteButton: Locator;
+    readonly assignRolesButton: Locator;
+    readonly addButton: Locator;
+    readonly optimizeCheckbox: Locator;
+    readonly modelerCheckbox: Locator;
+    readonly consoleCheckbox: Locator;
+    readonly deleteButton: Locator;
+    readonly deleteSubButton: Locator;
+    readonly tenantTab: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagNonCommercial: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    readonly licenseKeyTagCommercial: Locator;
+    readonly modelerAdminCheckbox: Locator;
+    readonly identityCheckbox: Locator;
+    readonly openSidebarButton: Locator;
+    readonly logoutButton: Locator;
+    readonly orchestrationCheckbox: Locator;
+    constructor(page: Page);
+    clickUsersLink(): Promise<void>;
+    clickUser(username: string): Promise<void>;
+    clickAssignedRolesTab(): Promise<void>;
+    clickDemoUser(): Promise<void>;
+    clickDeleteAccessButton(accessToDelete: string): Promise<void>;
+    clickConfirmDeleteButton(): Promise<void>;
+    clickAssignRolesButton(): Promise<void>;
+    clickAddButton(): Promise<void>;
+    clickOptimizeCheckbox(): Promise<void>;
+    clickModelerCheckbox(): Promise<void>;
+    clickConsoleCheckbox(): Promise<void>;
+    clickIdentityCheckbox(): Promise<void>;
+    clickModelerAdminCheckbox(): Promise<void>;
+    clickUserGroup(name: string): Promise<void>;
+    clickTenantTab(): Promise<void>;
+    clickOpenSidebarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+    clickOrchestrationCheckbox(): Promise<void>;
+}
+export { ManagementIdentityPage };

package/dist/pages/SM-8.10/ManagementIdentityPage.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagementIdentityPage = void 0;
+const test_1 = require("@playwright/test");
+class ManagementIdentityPage {
+    page;
+    identityBanner;
+    usersLink;
+    assignedRolesTab;
+    demoUser;
+    confirmDeleteButton;
+    assignRolesButton;
+    addButton;
+    optimizeCheckbox;
+    modelerCheckbox;
+    consoleCheckbox;
+    deleteButton;
+    deleteSubButton;
+    tenantTab;
+    licenseKeyTagNonProduction;
+    licenseKeyTagNonCommercial;
+    licenseKeyTagProduction;
+    licenseKeyTagCommercial;
+    modelerAdminCheckbox;
+    identityCheckbox;
+    openSidebarButton;
+    logoutButton;
+    orchestrationCheckbox;
+    constructor(page) {
+        this.page = page;
+        this.identityBanner = page.getByRole('link', {
+            name: 'Camunda logo Management Identity',
+        });
+        this.usersLink = page.locator('a').filter({ hasText: 'Users' });
+        this.tenantTab = page.getByRole('link', { name: 'Tenants' });
+        this.assignedRolesTab = page.getByRole('tab', { name: 'Assigned roles' });
+        this.demoUser = page.getByRole('cell', { name: 'demo' }).first();
+        this.confirmDeleteButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.assignRolesButton = page.getByRole('button', { name: 'Assign roles' });
+        this.addButton = page.getByRole('button', { name: 'Add' });
+        this.optimizeCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Optimize (Grants full access to Optimize)' });
+        this.modelerCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Web Modeler (Grants full access to Web Modeler)' });
+        this.consoleCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Console (Grants full access to Console)' });
+        this.identityCheckbox = page.locator('label').filter({
+            hasText: 'ManagementIdentity (Provides full access to Management Identity)',
+        });
+        this.deleteSubButton = page.getByRole('button', { name: 'danger delete' });
+        this.deleteButton = page.locator('button', { hasText: 'danger' });
+        this.licenseKeyTagNonProduction = page
+            .getByText('Non-production license')
+            .first();
+        this.licenseKeyTagNonCommercial = page.getByText('Non-commercial license');
+        this.licenseKeyTagProduction = page.getByText('Production license').first();
+        this.licenseKeyTagCommercial = page.getByText('Commercial license');
+        this.modelerAdminCheckbox = page.locator('label').filter({
+            hasText: 'Web Modeler Admin (Grants elevated access to Web Modeler)',
+        });
+        this.openSidebarButton = page.getByLabel('Open User Sidebar');
+        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+        this.orchestrationCheckbox = page.locator('label').filter({
+            hasText: 'Orchestration (Grants full access to Orchestration)',
+        });
+    }
+    async clickUsersLink() {
+        try {
+            await this.usersLink.click({ timeout: 180000, force: true });
+        }
+        catch {
+            await this.page.reload();
+            await this.usersLink.click({ timeout: 180000, force: true });
+        }
+    }
+    async clickUser(username) {
+        const searchbox = this.page.getByRole('searchbox');
+        await searchbox.click();
+        await searchbox.fill(username);
+        const user = this.page.getByRole('cell', { name: username, exact: true });
+        await (0, test_1.expect)(user).toBeVisible({ timeout: 60000 });
+        await user.click();
+    }
+    async clickAssignedRolesTab() {
+        await (0, test_1.expect)(this.assignedRolesTab).toBeVisible({ timeout: 60000 });
+        await this.assignedRolesTab.click();
+    }
+    async clickDemoUser() {
+        await (0, test_1.expect)(this.demoUser).toBeVisible({ timeout: 60000 });
+        await this.demoUser.click({ timeout: 180000 });
+    }
+    async clickDeleteAccessButton(accessToDelete) {
+        try {
+            await this.page
+                .locator('td:right-of(:text("' + accessToDelete + '"))')
+                .first()
+                .click({ timeout: 60000 });
+        }
+        catch {
+            console.log('Access already deleted');
+        }
+    }
+    async clickConfirmDeleteButton() {
+        try {
+            await this.confirmDeleteButton.click();
+        }
+        catch {
+            console.log('Access already deleted');
+        }
+    }
+    async clickAssignRolesButton() {
+        await this.assignRolesButton.click();
+    }
+    async clickAddButton() {
+        await this.addButton.click();
+    }
+    async clickOptimizeCheckbox() {
+        await this.optimizeCheckbox.click();
+    }
+    async clickModelerCheckbox() {
+        await this.modelerCheckbox.click();
+    }
+    async clickConsoleCheckbox() {
+        await this.consoleCheckbox.click();
+    }
+    async clickIdentityCheckbox() {
+        await this.identityCheckbox.click();
+    }
+    async clickModelerAdminCheckbox() {
+        await this.modelerAdminCheckbox.click();
+    }
+    async clickUserGroup(name) {
+        await this.page.getByRole('cell', { name: name }).click();
+    }
+    async clickTenantTab() {
+        await this.tenantTab.click();
+    }
+    async clickOpenSidebarButton() {
+        await this.openSidebarButton.click({ timeout: 60000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 60000 });
+    }
+    async clickOrchestrationCheckbox() {
+        await this.orchestrationCheckbox.click();
+    }
+}
+exports.ManagementIdentityPage = ManagementIdentityPage;

package/dist/pages/SM-8.10/ModelerCreatePage.d.ts

@@ -0,0 +1,199 @@
+import { Page, Locator } from '@playwright/test';
+declare class ModelerCreatePage {
+    private page;
+    readonly generalPanel: Locator;
+    readonly taskDefinitionPanel: Locator;
+    readonly processIdInput: Locator;
+    readonly elemendIdInput: Locator;
+    readonly startEventElement: Locator;
+    readonly appendTaskButton: Locator;
+    readonly changeTypeButton: Locator;
+    readonly userTaskOption: Locator;
+    readonly serviceTaskOption: Locator;
+    readonly appendEndEventButton: Locator;
+    readonly dialog: Locator;
+    readonly startInstanceMainButton: Locator;
+    readonly deployAndRunMainButton: Locator;
+    readonly deployAndRunSubButton: Locator;
+    readonly viewProcessInstanceLink: Locator;
+    readonly nameInput: Locator;
+    readonly jobTypeInput: Locator;
+    readonly diagramBreadcrumb: Locator;
+    readonly renameDiagramNameButton: Locator;
+    readonly diagramNameInput: Locator;
+    readonly variableInput: Locator;
+    readonly embedFormButton: Locator;
+    readonly embedButton: Locator;
+    readonly newForm: Locator;
+    readonly deploySubButton: Locator;
+    readonly cancelButton: Locator;
+    readonly restConnectorOption: Locator;
+    readonly marketPlaceButton: Locator;
+    readonly clientIdTextbox: Locator;
+    readonly clientSecretTextbox: Locator;
+    readonly rememberCredentialsCheckbox: Locator;
+    readonly webhookMessageStartEventConnectorOption: Locator;
+    readonly webhookIdInput: Locator;
+    readonly implementationSection: Locator;
+    readonly implementationOptions: Locator;
+    readonly assignmentSection: Locator;
+    readonly priorityInput: Locator;
+    readonly secondElement: Locator;
+    readonly firstElement: Locator;
+    readonly thirdElement: Locator;
+    readonly appendElementButton: Locator;
+    readonly firstPlacedGateway: Locator;
+    readonly secondPlacedGateway: Locator;
+    readonly secondPlacedElement: Locator;
+    readonly appendPreButton: Locator;
+    readonly appendGatewayButton: Locator;
+    readonly parallelGatewayOption: Locator;
+    readonly connectToOtherElementButton: Locator;
+    readonly canvas: Locator;
+    readonly intermediateBoundaryEvent: Locator;
+    readonly intermediateWebhookConnectorOption: Locator;
+    readonly correlationKeyProcessInput: Locator;
+    readonly correlationKeyPayloadInput: Locator;
+    readonly playTab: Locator;
+    readonly continueToPlayButton: Locator;
+    readonly candidateUsersInput: Locator;
+    readonly assigneeInput: Locator;
+    readonly candidateGroupsInput: Locator;
+    readonly tenantIdInput: Locator;
+    readonly timerEventOption: Locator;
+    readonly timerEventSettings: Locator;
+    readonly timerType: Locator;
+    readonly timerValue: Locator;
+    readonly eighthPlacedElement: Locator;
+    readonly processIdSecondLocator: Locator;
+    readonly deployMenuItem: Locator;
+    readonly additionalActionsButton: Locator;
+    readonly closeModalButton: Locator;
+    readonly deployErrorMessage: Locator;
+    readonly implementTab: Locator;
+    readonly bpmnReplaceMenu: Locator;
+    readonly connectorsDocHandlingStartEventElement: Locator;
+    readonly startEventVariableInputWithThreeVariables: Locator;
+    readonly zeebeRestAddressVariable: Locator;
+    readonly variableAssignmentValueTextbox: Locator;
+    readonly zeebeSecretVariable: Locator;
+    readonly variableAssignmentValueTextboxSecondVariable: Locator;
+    readonly zeebeClientIdVariable: Locator;
+    readonly variableAssignmentValueTextboxThirdVariable: Locator;
+    readonly firstPlaceRESTConnector: Locator;
+    readonly authenticationPanel: Locator;
+    readonly oauthTokenEndpointInput: Locator;
+    readonly closeDetailsPanel: Locator;
+    readonly openDetailsPanel: Locator;
+    constructor(page: Page);
+    deployProcessInstance(): Promise<void>;
+    clickCloseModalButton(): Promise<void>;
+    modelCamundaUserTaskDiagram(processName: string, processId?: string, formName?: string): Promise<void>;
+    modelJobWorkerDiagram(processName: string): Promise<void>;
+    assertThreeElementsVisible(): Promise<void>;
+    clickForm(name: string): Promise<void>;
+    runProcessInstance(variables?: string, tenant?: string): Promise<void>;
+    switchToPlay(): Promise<void>;
+    clickGeneralPropertiesPanel(): Promise<void>;
+    clickIdInput(): Promise<void>;
+    clickTaskDefinitionPropertiesPanel(): Promise<void>;
+    clickProcessIdInput(): Promise<void>;
+    fillIdInput(id: string): Promise<void>;
+    clickElemendIdInput(): Promise<void>;
+    fillElementIdInput(id: string): Promise<void>;
+    clickStartEventElement(): Promise<void>;
+    selectStartEventElement(): Promise<void>;
+    clickAppendTaskButton(): Promise<void>;
+    hoverOnLocator(locator: Locator, selector?: string): Promise<void>;
+    clickAppendGatewayButton(): Promise<void>;
+    clickChangeTypeButton(): Promise<void>;
+    clickUserTaskOption(): Promise<void>;
+    clickServiceTaskOption(): Promise<void>;
+    clickAppendEndEventButton(parentElement?: string): Promise<void>;
+    clickFirstPlacedElement(): Promise<void>;
+    clickSecondPlacedElement(): Promise<void>;
+    clickFirstPlacedGateway(): Promise<void>;
+    clickSecondPlacedGateway(): Promise<void>;
+    clickDeployAndRunMainButton(): Promise<void>;
+    clickDeployAndRunSubButton(): Promise<void>;
+    clickViewProcessInstanceLink(): Promise<void>;
+    clickNameInput(): Promise<void>;
+    clickUserTask(id: string): Promise<void>;
+    fillNameInput(name: string): Promise<void>;
+    clickJobTypeInput(): Promise<void>;
+    fillJobTypeInput(name: string): Promise<void>;
+    clickDiagramBreadcrumb(): Promise<void>;
+    clickEditDiagramNameButton(): Promise<void>;
+    enterDiagramName(name: string): Promise<void>;
+    clickVariableInput(): Promise<void>;
+    fillVariableInput(variable: string): Promise<void>;
+    clickEmbedFormButton(): Promise<void>;
+    clickEmbedButton(): Promise<void>;
+    clickAdditionalActionsButton(): Promise<void>;
+    clickDeployMenuItem(): Promise<void>;
+    clickDeployButton(): Promise<void>;
+    clickDeploySubButton(): Promise<void>;
+    clickCancelButton(): Promise<void>;
+    clickRestConnectorOption(): Promise<void>;
+    clickMarketPlaceButton(): Promise<void>;
+    completeDeploymentEndpointConfiguration(): Promise<void>;
+    completePlayConfiguration(): Promise<void>;
+    clickWebhookMessageStartEventConnectorOption(): Promise<void>;
+    clickWebhookIdInput(): Promise<void>;
+    clearWebhookIdInput(): Promise<void>;
+    fillWebhookIdInput(webhookId: string): Promise<void>;
+    hoverOnStartEvent(): Promise<void>;
+    instanceStartedAssertion(): Promise<void>;
+    assertImplementationOption(implementationType: string): Promise<void>;
+    chooseImplementationOption(implementationType: string): Promise<void>;
+    private expandImplementationOptionIfNecessary;
+    expandAssignmentSection(): Promise<void>;
+    clickAppendElementButton(): Promise<void>;
+    clickParallelGatewayOption(): Promise<void>;
+    clickConnectToOtherElementButton(): Promise<void>;
+    clickPriorityInput(): Promise<void>;
+    fillPriorityInput(priority: string): Promise<void>;
+    clickCanvas(): Promise<void>;
+    addParallelUserTasks(numberOfTasks: number, taskName: string): Promise<void>;
+    setPriority(taskName: string, priority: number, numberOfTasks: number): Promise<void>;
+    clickIntermediateBoundaryEvent(): Promise<void>;
+    clickIntermediateWebhookConnectorOption(): Promise<void>;
+    clickCorrelationKeyProcessInput(): Promise<void>;
+    fillCorrelationKeyProcessInput(correlationKeyProcess: string): Promise<void>;
+    clickCorrelationKeyPayloadInput(): Promise<void>;
+    fillCorrelationKeyPayloadInput(correlationKeyPayload: string): Promise<void>;
+    selectUserTask(userTask: string): Promise<void>;
+    clickCandidateUsersInput(): Promise<void>;
+    fillCandidateUsersInput(candidateUser: string): Promise<void>;
+    clickCandidateGroupsInput(): Promise<void>;
+    fillCandidateGroupsInput(candidateGroup: string): Promise<void>;
+    clickAssigneeInput(): Promise<void>;
+    fillAssigneeInput(name: string): Promise<void>;
+    clickTenantIdInput(): Promise<void>;
+    fillTenantIdInput(tenant: string): Promise<void>;
+    clickTimerEventOption(): Promise<void>;
+    clickTimerEventSettings(): Promise<void>;
+    selectTimerType(type: string): Promise<void>;
+    clickTimerValue(): Promise<void>;
+    fillTimerValue(value: string): Promise<void>;
+    clickEighthPlacedElement(): Promise<void>;
+    assertNameInput(processName: string): Promise<void>;
+    switchToImplementTab(): Promise<void>;
+    clickStartEvent(): Promise<void>;
+    clickContinueToPlay(): Promise<void>;
+    assertScenarioNameVisible(scenarioName: string): Promise<void>;
+    fillStartEventVariablesForDocHandling(zeebeUrl: string, zeebeClientId: string, zeebeClientSecret: string): Promise<void>;
+    fillZeebeClientId(clientId: string): Promise<void>;
+    fillZeebeSecretValue(zeebeSecret: string): Promise<void>;
+    fillZeebeRestValue(zeebeUrl: string): Promise<void>;
+    embedForm(formName: string): Promise<void>;
+    clickFirstPlaceRESTConnector(): Promise<void>;
+    setOAuthTokenEndpoint(elementToClick: Locator, endpoint: string, options?: {
+        retries?: number;
+        settleMs?: number;
+        openPanel?: boolean;
+    }): Promise<void>;
+    clickCloseDetailsPanel(): Promise<void>;
+    clickOpenDetailsPanel(): Promise<void>;
+}
+export { ModelerCreatePage };