@camunda/e2e-test-suite 0.0.1

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

@@ -0,0 +1,12 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeHomePage {
+    private page;
+    readonly collectionsLink: Locator;
+    readonly dashboardLink: Locator;
+    readonly modalCloseButton: Locator;
+    readonly optimizeBanner: Locator;
+    constructor(page: Page);
+    clickCollectionsLink(): Promise<void>;
+    clickDashboardLink(): Promise<void>;
+}
+export { OptimizeHomePage };

package/dist/pages/8.6/OptimizeHomePage.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeHomePage = void 0;
+class OptimizeHomePage {
+    page;
+    collectionsLink;
+    dashboardLink;
+    modalCloseButton;
+    optimizeBanner;
+    constructor(page) {
+        this.page = page;
+        this.collectionsLink = page.getByRole('link', { name: 'Collections' });
+        this.dashboardLink = page.getByRole('link', { name: 'Dashboard' });
+        this.modalCloseButton = page.locator('button').filter({ hasText: /^Close$/ });
+        this.optimizeBanner = page.getByRole('link', {
+            name: 'Camunda logo Optimize',
+        });
+    }
+    async clickCollectionsLink() {
+        if (await this.modalCloseButton.isVisible({ timeout: 60000 })) {
+            await this.modalCloseButton.click();
+        }
+        await this.collectionsLink.click({ timeout: 60000 });
+    }
+    async clickDashboardLink() {
+        if (await this.modalCloseButton.isVisible({ timeout: 60000 })) {
+            this.modalCloseButton.click();
+        }
+        await this.dashboardLink.click();
+    }
+}
+exports.OptimizeHomePage = OptimizeHomePage;

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

@@ -0,0 +1,48 @@
+import { Page, Locator } from '@playwright/test';
+declare class OptimizeReportPage {
+    private page;
+    readonly processSelectionButton: Locator;
+    readonly userTaskProcess: Locator;
+    readonly versionSelection: Locator;
+    readonly alwaysDisplayLatestSelection: Locator;
+    readonly createReportLink: Locator;
+    readonly durationButton: Locator;
+    readonly countOption: Locator;
+    readonly processInstanceButton: Locator;
+    readonly userTaskOption: Locator;
+    readonly heatMapButton: Locator;
+    readonly numberButton: Locator;
+    readonly tableOption: Locator;
+    readonly reportName: Locator;
+    readonly saveButton: Locator;
+    readonly oneUserTaskInstance: Locator;
+    readonly twoUserTaskInstance: Locator;
+    readonly cancelButton: Locator;
+    readonly createNewButton: Locator;
+    readonly reportOption: Locator;
+    readonly processInstanceCount: Locator;
+    readonly blankReportButton: Locator;
+    readonly selectDropdown: Locator;
+    constructor(page: Page);
+    clickProcessSelectionButton(): Promise<void>;
+    clickUserTaskProcess(processName: string): Promise<void>;
+    clickVersionSelection(): Promise<void>;
+    clickAlwaysDisplayLatestSelection(): Promise<void>;
+    clickCreateReportLink(): Promise<void>;
+    clickDurationButton(): Promise<void>;
+    clickCountOption(): Promise<void>;
+    clickProcessInstanceButton(): Promise<void>;
+    clickUserTaskOption(): Promise<void>;
+    clickHeatMapButton(): Promise<void>;
+    clickNumberButton(): Promise<void>;
+    clickTableOption(): Promise<void>;
+    clickReportName(): Promise<void>;
+    clearReportName(): Promise<void>;
+    fillReportName(name: string): Promise<void>;
+    clickSaveButton(): Promise<void>;
+    waitUntilLocatorIsVisible(locator: Locator, tab: Page): Promise<void>;
+    waitUntilProcessIsVisible(locator: Locator, tab: Page): Promise<void>;
+    clickBlankReportButton(): Promise<void>;
+    clickSelectDropdown(): Promise<void>;
+}
+export { OptimizeReportPage };

package/dist/pages/8.6/OptimizeReportPage.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeReportPage = void 0;
+class OptimizeReportPage {
+    page;
+    processSelectionButton;
+    userTaskProcess;
+    versionSelection;
+    alwaysDisplayLatestSelection;
+    createReportLink;
+    durationButton;
+    countOption;
+    processInstanceButton;
+    userTaskOption;
+    heatMapButton;
+    numberButton;
+    tableOption;
+    reportName;
+    saveButton;
+    oneUserTaskInstance;
+    twoUserTaskInstance;
+    cancelButton;
+    createNewButton;
+    reportOption;
+    processInstanceCount;
+    blankReportButton;
+    selectDropdown;
+    constructor(page) {
+        this.page = page;
+        this.processSelectionButton = page.getByPlaceholder('Select...');
+        this.userTaskProcess = page
+            .getByText('User_Task_Process', { exact: true })
+            .first();
+        this.versionSelection = page.getByLabel('Version');
+        this.alwaysDisplayLatestSelection = page.getByText('Always display latest');
+        this.createReportLink = page.getByRole('link', { name: 'Create Report' });
+        this.durationButton = page.getByRole('button', { name: 'Duration' });
+        this.countOption = page.getByText('Count').first();
+        this.processInstanceButton = page.getByRole('button', {
+            name: 'Process Instance',
+            exact: true,
+        });
+        this.userTaskOption = page.getByRole('menuitemcheckbox', {
+            name: 'User Task',
+        });
+        this.heatMapButton = page.getByRole('button', { name: 'Heatmap Open menu' });
+        this.numberButton = page.getByRole('menuitemcheckbox', { name: 'Number' });
+        this.tableOption = page.getByRole('menuitemcheckbox', { name: 'Table' });
+        this.reportName = page.getByPlaceholder('Report name');
+        this.saveButton = page.getByRole('button', { name: 'Save' });
+        this.oneUserTaskInstance = page.getByRole('cell', { name: '1', exact: true });
+        this.twoUserTaskInstance = page.getByRole('cell', { name: '2', exact: true });
+        this.cancelButton = page.getByRole('button', { name: 'Cancel' });
+        this.createNewButton = page.getByRole('button', {
+            name: 'Create New',
+            exact: true,
+        });
+        this.reportOption = page.getByText('Report', { exact: true });
+        this.processInstanceCount = page.locator('.progressLabel');
+        this.blankReportButton = page.getByRole('button', { name: 'Blank report' });
+        this.selectDropdown = page
+            .getByRole('button', { name: 'Select... Open menu' })
+            .last();
+    }
+    async clickProcessSelectionButton() {
+        await this.processSelectionButton.click();
+    }
+    async clickUserTaskProcess(processName) {
+        await this.page
+            .getByText(processName, { exact: true })
+            .first()
+            .click({ timeout: 90000 });
+    }
+    async clickVersionSelection() {
+        await this.versionSelection.click();
+    }
+    async clickAlwaysDisplayLatestSelection() {
+        await this.alwaysDisplayLatestSelection.click();
+    }
+    async clickCreateReportLink() {
+        await this.createReportLink.click({ timeout: 60000 });
+    }
+    async clickDurationButton() {
+        await this.durationButton.click();
+    }
+    async clickCountOption() {
+        await this.countOption.click();
+    }
+    async clickProcessInstanceButton() {
+        await this.processInstanceButton.click();
+    }
+    async clickUserTaskOption() {
+        await this.userTaskOption.click({ timeout: 60000 });
+    }
+    async clickHeatMapButton() {
+        if (await this.heatMapButton.isVisible()) {
+            await this.heatMapButton.click({ timeout: 60000 });
+        }
+    }
+    async clickNumberButton() {
+        if (await this.numberButton.isVisible()) {
+            await this.numberButton.click();
+        }
+    }
+    async clickTableOption() {
+        await this.tableOption.click();
+    }
+    async clickReportName() {
+        await this.reportName.click();
+    }
+    async clearReportName() {
+        await this.reportName.clear({ force: true });
+    }
+    async fillReportName(name) {
+        await this.reportName.fill(name, { force: true });
+    }
+    async clickSaveButton() {
+        await this.saveButton.click();
+    }
+    async waitUntilLocatorIsVisible(locator, tab) {
+        let elapsedTime = 0;
+        const maxWaitTimeSeconds = 120000;
+        while (elapsedTime < maxWaitTimeSeconds) {
+            const element = await locator;
+            if (await element.isVisible()) {
+                return;
+            }
+            await tab.reload();
+            await tab.waitForTimeout(10 * 1000);
+            // Update the elapsed time
+            elapsedTime += 10000;
+        }
+    }
+    async waitUntilProcessIsVisible(locator, tab) {
+        let elapsedTime = 0;
+        const maxWaitTimeSeconds = 240000;
+        while (elapsedTime < maxWaitTimeSeconds) {
+            const element = await locator;
+            if (await element.isVisible()) {
+                return;
+            }
+            await this.cancelButton.click();
+            await tab.reload();
+            await tab.waitForTimeout(10 * 1000);
+            // Update the elapsed time
+            elapsedTime += 10000;
+            await this.createNewButton.click();
+            await this.reportOption.click();
+            await this.processSelectionButton.click();
+        }
+    }
+    async clickBlankReportButton() {
+        await this.blankReportButton.click();
+    }
+    async clickSelectDropdown() {
+        await this.selectDropdown.click();
+    }
+}
+exports.OptimizeReportPage = OptimizeReportPage;

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

@@ -0,0 +1,14 @@
+import { Page, Locator } from '@playwright/test';
+declare class PlayPage {
+    private page;
+    readonly completeJobButton: Locator;
+    constructor(page: Page);
+    waitForCompleteJobButtonToBeAvailable(): Promise<void>;
+    clickCompleteJobButton(): Promise<void>;
+    clickStartInstanceButton(): Promise<void>;
+    dismissStartModal(): Promise<void>;
+    waitForInstanceDetailsToBeLoaded(): Promise<void>;
+    waitForNextElementToBeActive(historyItem: string): Promise<void>;
+    waitForProcessToBeCompleted(): Promise<void>;
+}
+export { PlayPage };

package/dist/pages/8.6/PlayPage.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayPage = void 0;
+const test_1 = require("@playwright/test");
+const maxWaitTimeSeconds = 120000;
+class PlayPage {
+    page;
+    completeJobButton;
+    constructor(page) {
+        this.page = page;
+        this.completeJobButton = page
+            .getByTestId('diagram')
+            .getByLabel('Complete job');
+    }
+    async waitForCompleteJobButtonToBeAvailable() {
+        await (0, test_1.expect)(this.completeJobButton).toBeVisible({
+            timeout: maxWaitTimeSeconds,
+        });
+    }
+    async clickCompleteJobButton() {
+        await this.completeJobButton.click();
+    }
+    async clickStartInstanceButton() {
+        await this.page.getByTestId('diagram').getByLabel('Start instance').click();
+    }
+    async dismissStartModal() {
+        await this.page
+            .getByRole('button', {
+            name: 'Start a process instance',
+        })
+            .click();
+    }
+    async waitForInstanceDetailsToBeLoaded() {
+        const maxRetries = 2;
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.page.getByText(/process instance key/i)).toBeVisible({
+                    timeout: maxWaitTimeSeconds,
+                });
+                await (0, test_1.expect)(this.page.getByText(/This process instance has no variables/i)).toBeVisible({
+                    timeout: maxWaitTimeSeconds,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempts >= maxRetries - 1)
+                    throw error;
+                await this.page.reload();
+                attempts++;
+            }
+        }
+    }
+    async waitForNextElementToBeActive(historyItem) {
+        await (0, test_1.expect)(this.page.getByText(new RegExp(`^${historyItem}`, 'i'))).toBeVisible({
+            timeout: maxWaitTimeSeconds,
+        });
+    }
+    async waitForProcessToBeCompleted() {
+        await (0, test_1.expect)(this.page.getByRole('heading', { name: 'Scenario recorded!' })).toBeVisible({ timeout: maxWaitTimeSeconds });
+    }
+}
+exports.PlayPage = PlayPage;

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

@@ -0,0 +1,10 @@
+import { Page, Locator } from '@playwright/test';
+declare class SettingsPage {
+    private page;
+    readonly openSettingsButton: Locator;
+    readonly logoutButton: Locator;
+    constructor(page: Page);
+    clickOpenSettingsButton(retries?: number): Promise<void>;
+    clickLogoutButton(retries?: number): Promise<void>;
+}
+export { SettingsPage };

package/dist/pages/8.6/SettingsPage.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsPage = void 0;
+class SettingsPage {
+    page;
+    openSettingsButton;
+    logoutButton;
+    constructor(page) {
+        this.page = page;
+        this.openSettingsButton = page.getByLabel('Open Settings');
+        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+    }
+    async clickOpenSettingsButton(retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await this.openSettingsButton.click({ timeout: 180000 });
+                return; // If successful, exit the function
+            }
+            catch (error) {
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(10000);
+            }
+        }
+        throw new Error(`Failed to click button after ${retries} retries`);
+    }
+    async clickLogoutButton(retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await this.logoutButton.click({ timeout: 120000 });
+                return; // Click succeeded, exit the loop
+            }
+            catch (error) {
+                console.error(`Attempt ${i + 1} to click deploy button failed: ${error}`);
+                // Wait for 10 seconds
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(10000);
+                await this.clickOpenSettingsButton();
+            }
+        }
+        throw new Error(`Failed to click deploy button after ${retries} retries`);
+    }
+}
+exports.SettingsPage = SettingsPage;

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

@@ -0,0 +1,44 @@
+import { Page, Locator } from '@playwright/test';
+declare class SignUpPage {
+    private page;
+    readonly firstNameInput: Locator;
+    readonly lastNameInput: Locator;
+    readonly passwordInput: Locator;
+    readonly passwordInputInvitedUser: Locator;
+    readonly signupButton: Locator;
+    readonly emailInput: Locator;
+    readonly companyInput: Locator;
+    readonly createAccountButton: Locator;
+    readonly backgroundDrodownList: Locator;
+    readonly whatDoYouDoDropdownList: Locator;
+    readonly APIClientDropdownList: Locator;
+    readonly levelOfExperienceDropdownList: Locator;
+    readonly nextButton: Locator;
+    readonly runProcessRadioButton: Locator;
+    readonly whyAreYouEvaluatingCamunda: Locator;
+    readonly confirmSaaSTrial: Locator;
+    readonly loginToCamundaButton: Locator;
+    readonly backgroundPageHeading: Locator;
+    readonly useCasePageHeading: Locator;
+    readonly goalPageHeading: Locator;
+    readonly camundaPlansPageHeading: Locator;
+    readonly setPasswordPageHeading: Locator;
+    readonly signUpCompletedPageHeading: Locator;
+    readonly verifyEmailText: Locator;
+    constructor(page: Page);
+    signupToC8(emailAddress: string): Promise<void>;
+    clickFirstNameInput(): Promise<void>;
+    fillFirstNameInput(firstName: string): Promise<void>;
+    clickLastNameInput(): Promise<void>;
+    fillLastNameInput(lastName: string): Promise<void>;
+    clickPasswordInput(): Promise<void>;
+    fillPasswordInput(password: string): Promise<void>;
+    clickPasswordInputInvitedUser(): Promise<void>;
+    fillPasswordInputInvitedUser(password: string): Promise<void>;
+    clickCompanyInput(): Promise<void>;
+    fillCompanyInput(company: string): Promise<void>;
+    clickSignupButton(): Promise<void>;
+    clickEmailInput(): Promise<void>;
+    fillEmailInput(email: string): Promise<void>;
+}
+export { SignUpPage };

package/dist/pages/8.6/SignUpPage.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignUpPage = void 0;
+const test_1 = require("@playwright/test");
+class SignUpPage {
+    page;
+    firstNameInput;
+    lastNameInput;
+    passwordInput;
+    passwordInputInvitedUser;
+    signupButton;
+    emailInput;
+    companyInput;
+    createAccountButton;
+    backgroundDrodownList;
+    whatDoYouDoDropdownList;
+    APIClientDropdownList;
+    levelOfExperienceDropdownList;
+    nextButton;
+    runProcessRadioButton;
+    whyAreYouEvaluatingCamunda;
+    confirmSaaSTrial;
+    loginToCamundaButton;
+    backgroundPageHeading;
+    useCasePageHeading;
+    goalPageHeading;
+    camundaPlansPageHeading;
+    setPasswordPageHeading;
+    signUpCompletedPageHeading;
+    verifyEmailText;
+    constructor(page) {
+        this.page = page;
+        this.firstNameInput = page.getByLabel('First Name');
+        this.lastNameInput = page.getByLabel('Last Name');
+        this.passwordInput = page.locator('[id="password"]');
+        this.passwordInputInvitedUser = page.getByLabel('Password (min 12 characters)');
+        this.signupButton = page.getByRole('button', { name: 'Sign up' });
+        this.emailInput = page.getByLabel('Email');
+        this.companyInput = page.getByLabel('Company*');
+        this.createAccountButton = page.getByRole('button', {
+            name: 'Create account',
+        });
+        this.backgroundDrodownList = page.getByLabel('Background*');
+        this.whatDoYouDoDropdownList = page.getByLabel('What do you do?*');
+        this.APIClientDropdownList = page.getByRole('combobox', {
+            name: 'what is your preferred api client?',
+        });
+        this.levelOfExperienceDropdownList = page.getByLabel('what is your level of experience with process design?*');
+        this.nextButton = page.getByRole('button', { name: 'Next' });
+        this.runProcessRadioButton = page.getByRole('radio');
+        this.whyAreYouEvaluatingCamunda = page.getByLabel('Why are you evaluating');
+        this.confirmSaaSTrial = page.getByRole('button', {
+            name: 'Confirm SaaS Trial',
+        });
+        this.loginToCamundaButton = page.getByRole('button', {
+            name: 'log in to camunda',
+        });
+        this.backgroundPageHeading = page.getByRole('heading', {
+            name: 'great! to customize your account, tell us a little about yourself',
+        });
+        this.useCasePageHeading = page.getByRole('heading', {
+            name: 'thank you! how will you use camunda',
+        });
+        this.goalPageHeading = page.getByRole('heading', {
+            name: 'finally, what is your goal with camunda?',
+        });
+        this.camundaPlansPageHeading = page.getByRole('heading', {
+            name: 'Here is your custom recommendation, please confirm your Camunda account below:',
+        });
+        this.setPasswordPageHeading = page.getByRole('heading', {
+            name: 'Finish',
+        });
+        this.signUpCompletedPageHeading = page.getByRole('heading', {
+            name: 'thank you for signing up for camunda',
+        });
+        this.runProcessRadioButton = page.getByRole('radio', { name: 'yes' });
+        this.verifyEmailText = page.getByText('Verify your email');
+    }
+    async signupToC8(emailAddress) {
+        await this.page.goto('https://accounts.ultrawombat.com/signup');
+        await this.clickFirstNameInput();
+        await this.fillFirstNameInput('QA');
+        await this.clickLastNameInput();
+        await this.fillLastNameInput('Camunda');
+        await this.clickEmailInput();
+        await this.fillEmailInput(emailAddress);
+        await this.clickPasswordInput();
+        await this.fillPasswordInput(process.env.C8_PASSWORD);
+        await this.clickSignupButton();
+        await (0, test_1.expect)(this.verifyEmailText.first()).toBeVisible({
+            timeout: 40000,
+        });
+    }
+    async clickFirstNameInput() {
+        await this.firstNameInput.click();
+    }
+    async fillFirstNameInput(firstName) {
+        await this.firstNameInput.fill(firstName);
+    }
+    async clickLastNameInput() {
+        await this.lastNameInput.click();
+    }
+    async fillLastNameInput(lastName) {
+        await this.lastNameInput.fill(lastName);
+    }
+    async clickPasswordInput() {
+        await this.passwordInput.click({ timeout: 30000 });
+    }
+    async fillPasswordInput(password) {
+        await this.passwordInput.fill(password);
+    }
+    async clickPasswordInputInvitedUser() {
+        await this.passwordInputInvitedUser.click({ timeout: 30000 });
+    }
+    async fillPasswordInputInvitedUser(password) {
+        await this.passwordInputInvitedUser.fill(password);
+    }
+    async clickCompanyInput() {
+        await this.companyInput.click();
+    }
+    async fillCompanyInput(company) {
+        await this.companyInput.fill(company);
+    }
+    async clickSignupButton() {
+        await this.signupButton.click();
+    }
+    async clickEmailInput() {
+        await this.emailInput.click();
+    }
+    async fillEmailInput(email) {
+        await this.emailInput.fill(email);
+    }
+}
+exports.SignUpPage = SignUpPage;

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

@@ -0,0 +1,64 @@
+import { Page, Locator } from '@playwright/test';
+declare class TaskDetailsPage {
+    private page;
+    readonly assignToMeButton: Locator;
+    readonly completeButton: Locator;
+    readonly unassignButton: Locator;
+    readonly assignee: Locator;
+    readonly completeTaskButton: Locator;
+    readonly addVariableButton: Locator;
+    readonly detailsPanel: Locator;
+    readonly detailsHeader: Locator;
+    readonly pendingTaskDescription: Locator;
+    readonly pickATaskHeader: Locator;
+    readonly emptyTaskMessage: Locator;
+    readonly nameInput: Locator;
+    readonly addressInput: Locator;
+    readonly ageInput: Locator;
+    readonly variablesTable: Locator;
+    readonly nameColumnHeader: Locator;
+    readonly valueColumnHeader: Locator;
+    readonly form: Locator;
+    readonly numberInput: Locator;
+    readonly incrementButton: Locator;
+    readonly decrementButton: Locator;
+    readonly dateInput: Locator;
+    readonly timeInput: Locator;
+    readonly checkbox: Locator;
+    readonly selectDropdown: Locator;
+    readonly tagList: Locator;
+    readonly detailsInfo: Locator;
+    readonly textInput: Locator;
+    readonly assignedToMeText: Locator;
+    readonly textBox: Locator;
+    constructor(page: Page);
+    clickAssignToMeButton(): Promise<void>;
+    clickUnassignButton(): Promise<void>;
+    clickCompleteTaskButton(): Promise<void>;
+    clickAddVariableButton(): Promise<void>;
+    replaceExistingVariableValue(values: {
+        name: string;
+        value: string;
+    }): Promise<void>;
+    getNthVariableNameInput(nth: number): Locator;
+    getNthVariableValueInput(nth: number): Locator;
+    addVariable(payload: {
+        name: string;
+        value: string;
+    }): Promise<void>;
+    fillNumber(number: string): Promise<void>;
+    clickIncrementButton(): Promise<void>;
+    clickDecrementButton(): Promise<void>;
+    fillDate(date: string): Promise<void>;
+    enterTime(time: string): Promise<void>;
+    checkCheckbox(): Promise<void>;
+    selectDropdownValue(value: string): Promise<void>;
+    clickRadioButton(radioBtnLabel: string): Promise<void>;
+    checkChecklistBox(label: string): Promise<void>;
+    enterTwoValuesInTagList(value1: string, value2: string): Promise<void>;
+    clickTextInput(): Promise<void>;
+    fillTextInput(value: string): Promise<void>;
+    fillTextBox(text: string): Promise<void>;
+    fillName(nameInput: string): Promise<void>;
+}
+export { TaskDetailsPage };