@camunda/e2e-test-suite 0.0.204 → 0.0.206

package/dist/fixtures/c8Run-8.10.d.ts

@@ -0,0 +1,20 @@
+import AxeBuilder from '@axe-core/playwright';
+import { OperateLoginPage } from '../pages/c8Run-8.10/OperateLoginPage';
+import { OperateHomePage } from '../pages/c8Run-8.10/OperateHomePage';
+import { TaskPanelPage } from '../pages/c8Run-8.10/TaskPanelPage';
+import { TaskListLoginPage } from '../pages/c8Run-8.10/TaskListLoginPage';
+import { OperateProcessesPage } from '../pages/c8Run-8.10/OperateProcessesPage';
+import { OperateProcessInstancePage } from '../pages/c8Run-8.10/OperateProcessInstancePage';
+import { TaskDetailsPage } from '../pages/c8Run-8.10/TaskDetailsPage';
+type PlaywrightFixtures = {
+    makeAxeBuilder: () => AxeBuilder;
+    operateLoginPage: OperateLoginPage;
+    operateHomePage: OperateHomePage;
+    taskListLoginPage: TaskListLoginPage;
+    taskPanelPage: TaskPanelPage;
+    operateProcessesPage: OperateProcessesPage;
+    operateProcessInstancePage: OperateProcessInstancePage;
+    taskDetailsPage: TaskDetailsPage;
+};
+declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & PlaywrightFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { test };

package/dist/fixtures/c8Run-8.10.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH under
+ * one or more contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright ownership.
+ * Licensed under the Camunda License 1.0. You may not use this file
+ * except in compliance with the Camunda License 1.0.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const test_1 = require("@playwright/test");
+const playwright_1 = __importDefault(require("@axe-core/playwright"));
+const OperateLoginPage_1 = require("../pages/c8Run-8.10/OperateLoginPage");
+const OperateHomePage_1 = require("../pages/c8Run-8.10/OperateHomePage");
+const TaskPanelPage_1 = require("../pages/c8Run-8.10/TaskPanelPage");
+const TaskListLoginPage_1 = require("../pages/c8Run-8.10/TaskListLoginPage");
+const OperateProcessesPage_1 = require("../pages/c8Run-8.10/OperateProcessesPage");
+const OperateProcessInstancePage_1 = require("../pages/c8Run-8.10/OperateProcessInstancePage");
+const TaskDetailsPage_1 = require("../pages/c8Run-8.10/TaskDetailsPage");
+const test = test_1.test.extend({
+    makeAxeBuilder: async ({ page }, use) => {
+        const makeAxeBuilder = () => new playwright_1.default({ page }).withTags([
+            'best-practice',
+            'wcag2a',
+            'wcag2aa',
+            'cat.semantics',
+            'cat.forms',
+        ]);
+        await use(makeAxeBuilder);
+    },
+    operateLoginPage: async ({ page }, use) => {
+        await use(new OperateLoginPage_1.OperateLoginPage(page));
+    },
+    operateHomePage: async ({ page }, use) => {
+        await use(new OperateHomePage_1.OperateHomePage(page));
+    },
+    taskListLoginPage: async ({ page }, use) => {
+        await use(new TaskListLoginPage_1.TaskListLoginPage(page));
+    },
+    taskPanelPage: async ({ page }, use) => {
+        await use(new TaskPanelPage_1.TaskPanelPage(page));
+    },
+    operateProcessesPage: async ({ page }, use) => {
+        await use(new OperateProcessesPage_1.OperateProcessesPage(page));
+    },
+    operateProcessInstancePage: async ({ page }, use) => {
+        await use(new OperateProcessInstancePage_1.OperateProcessInstancePage(page));
+    },
+    taskDetailsPage: async ({ page }, use) => {
+        await use(new TaskDetailsPage_1.TaskDetailsPage(page));
+    },
+});
+exports.test = test;

package/dist/pages/c8Run-8.10/OperateHomePage.d.ts

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateHomePage {
+    private page;
+    readonly operateBanner: Locator;
+    readonly processesTab: Locator;
+    readonly informationDialog: Locator;
+    readonly editVariableButton: Locator;
+    readonly variableValueInput: Locator;
+    readonly saveVariableButton: Locator;
+    readonly editVariableSpinner: Locator;
+    constructor(page: Page);
+    operateBannerIsVisible(): Promise<void>;
+    clickProcessesTab(): Promise<void>;
+    clickEditVariableButton(variableName: string): Promise<void>;
+    clickVariableValueInput(): Promise<void>;
+    clearVariableValueInput(): Promise<void>;
+    fillVariableValueInput(value: string): Promise<void>;
+    clickSaveVariableButton(): Promise<void>;
+}
+export { OperateHomePage };

package/dist/pages/c8Run-8.10/OperateHomePage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateHomePage = void 0;
+const test_1 = require("@playwright/test");
+class OperateHomePage {
+    page;
+    operateBanner;
+    processesTab;
+    informationDialog;
+    editVariableButton;
+    variableValueInput;
+    saveVariableButton;
+    editVariableSpinner;
+    constructor(page) {
+        this.page = page;
+        this.operateBanner = page.getByRole('link', { name: 'Camunda logo Operate' });
+        this.processesTab = page.getByRole('link', { name: 'Processes' });
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.editVariableButton = page.getByTestId('edit-variable-button');
+        this.variableValueInput = page.getByTestId('edit-variable-value');
+        this.saveVariableButton = page.getByLabel('Save variable');
+        this.editVariableSpinner = page
+            .getByTestId('variable-operation-spinner')
+            .locator('circle')
+            .nth(1);
+    }
+    async operateBannerIsVisible() {
+        await (0, test_1.expect)(this.operateBanner).toBeVisible({ timeout: 30000 });
+    }
+    async clickProcessesTab() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                await (0, test_1.expect)(this.processesTab).toBeVisible({ timeout: 30000 });
+                await this.processesTab.click({ timeout: 30000 });
+                await (0, test_1.expect)(this.page.locator('label').filter({ hasText: 'Completed' }).first()).toBeVisible();
+                return;
+            }
+            catch (error) {
+                console.warn(`Click attempt ${retries + 1} failed: ${error}`);
+            }
+        }
+        throw new Error(`Failed to click the processes tab after ${maxRetries} attempts.`);
+    }
+    async clickEditVariableButton(variableName) {
+        const editVariableButton = 'Edit variable ' + variableName;
+        await this.page.getByLabel(editVariableButton).click();
+    }
+    async clickVariableValueInput() {
+        await this.variableValueInput.click();
+    }
+    async clearVariableValueInput() {
+        await this.variableValueInput.clear();
+    }
+    async fillVariableValueInput(value) {
+        await this.variableValueInput.fill(value);
+    }
+    async clickSaveVariableButton() {
+        await this.saveVariableButton.click();
+    }
+}
+exports.OperateHomePage = OperateHomePage;

package/dist/pages/c8Run-8.10/OperateLoginPage.d.ts

@@ -0,0 +1,14 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateLoginPage {
+    private page;
+    readonly usernameInput: Locator;
+    readonly passwordInput: Locator;
+    readonly loginButton: Locator;
+    constructor(page: Page);
+    fillUsername(username: string): Promise<void>;
+    clickUsername(): Promise<void>;
+    fillPassword(password: string): Promise<void>;
+    clickLoginButton(): Promise<void>;
+    login(username: string, password: string): Promise<void>;
+}
+export { OperateLoginPage };

package/dist/pages/c8Run-8.10/OperateLoginPage.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateLoginPage = void 0;
+const test_1 = require("@playwright/test");
+class OperateLoginPage {
+    page;
+    usernameInput;
+    passwordInput;
+    loginButton;
+    constructor(page) {
+        this.page = page;
+        this.usernameInput = page.getByLabel('Username');
+        this.passwordInput = page.getByRole('textbox', { name: 'password' });
+        this.loginButton = page.getByRole('button', { name: 'Login' });
+    }
+    async fillUsername(username) {
+        await this.usernameInput.fill(username);
+    }
+    async clickUsername() {
+        await this.usernameInput.click({ timeout: 60000 });
+    }
+    async fillPassword(password) {
+        await this.passwordInput.fill(password);
+    }
+    async clickLoginButton() {
+        await this.loginButton.click({ timeout: 60000 });
+    }
+    async login(username, password) {
+        await (0, test_1.expect)(this.usernameInput).toBeVisible({ timeout: 180000 });
+        await this.clickUsername();
+        await this.fillUsername(username);
+        await this.fillPassword(password);
+        await (0, test_1.expect)(this.loginButton).toBeVisible({ timeout: 120000 });
+        await this.clickLoginButton();
+    }
+}
+exports.OperateLoginPage = OperateLoginPage;

package/dist/pages/c8Run-8.10/OperateProcessInstancePage.d.ts

@@ -0,0 +1,17 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessInstancePage {
+    private page;
+    readonly diagram: Locator;
+    readonly completedIcon: Locator;
+    readonly diagramSpinner: Locator;
+    readonly activeIcon: Locator;
+    readonly variablesList: Locator;
+    readonly messageVariable: Locator;
+    readonly statusVariable: Locator;
+    constructor(page: Page);
+    connectorResultVariableName(name: string): Promise<Locator>;
+    connectorResultVariableValue(variableName: string): Promise<Locator>;
+    completedIconAssertion(): Promise<void>;
+    activeIconAssertion(): Promise<void>;
+}
+export { OperateProcessInstancePage };

package/dist/pages/c8Run-8.10/OperateProcessInstancePage.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessInstancePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class OperateProcessInstancePage {
+    page;
+    diagram;
+    completedIcon;
+    diagramSpinner;
+    activeIcon;
+    variablesList;
+    messageVariable;
+    statusVariable;
+    constructor(page) {
+        this.page = page;
+        this.diagram = page.getByTestId('diagram');
+        this.completedIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('COMPLETED-icon');
+        this.diagramSpinner = page.getByTestId('diagram-spinner');
+        this.activeIcon = page
+            .getByTestId('instance-header')
+            .getByTestId('ACTIVE-icon');
+        this.variablesList = page.getByTestId('variables-list');
+        this.messageVariable = page.getByTestId('variable-message');
+        this.statusVariable = page.getByTestId('variable-status');
+    }
+    async connectorResultVariableName(name) {
+        return await this.page.getByTestId(name);
+    }
+    async connectorResultVariableValue(variableName) {
+        return await this.page.getByTestId(variableName).locator('td').last();
+    }
+    async completedIconAssertion() {
+        let retryCount = 0;
+        const maxRetries = 6;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.completedIcon).toBeVisible({
+                    timeout: 60000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                // If the active icon isn't found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+    }
+    async activeIconAssertion() {
+        let retryCount = 0;
+        const maxRetries = 3;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, test_1.expect)(this.activeIcon).toBeVisible({
+                    timeout: 90000,
+                });
+                return; // Exit the function if the expectation is met
+            }
+            catch (error) {
+                // If the active icon isn't found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+    }
+}
+exports.OperateProcessInstancePage = OperateProcessInstancePage;

package/dist/pages/c8Run-8.10/OperateProcessesPage.d.ts

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+declare class OperateProcessesPage {
+    private page;
+    readonly processResultCount: Locator;
+    readonly processActiveCheckbox: Locator;
+    readonly processCompletedCheckbox: Locator;
+    readonly processRunningInstancesCheckbox: Locator;
+    readonly processIncidentsCheckbox: Locator;
+    readonly processPageHeading: Locator;
+    readonly noMatchingInstancesMessage: Locator;
+    readonly processFinishedInstancesCheckbox: Locator;
+    constructor(page: Page);
+    clickProcessActiveCheckbox(): Promise<void>;
+    clickProcessCompletedCheckbox(): Promise<void>;
+    clickProcessIncidentsCheckbox(): Promise<void>;
+    clickRunningProcessInstancesCheckbox(): Promise<void>;
+    clickFinishedProcessInstancesCheckbox(): Promise<void>;
+    clickProcessInstanceLink(processName: string): Promise<void>;
+}
+export { OperateProcessesPage };

package/dist/pages/c8Run-8.10/OperateProcessesPage.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperateProcessesPage = void 0;
+const sleep_1 = require("../../utils/sleep");
+class OperateProcessesPage {
+    page;
+    processResultCount;
+    processActiveCheckbox;
+    processCompletedCheckbox;
+    processRunningInstancesCheckbox;
+    processIncidentsCheckbox;
+    processPageHeading;
+    noMatchingInstancesMessage;
+    processFinishedInstancesCheckbox;
+    constructor(page) {
+        this.page = page;
+        this.processResultCount = page.getByTestId('result-count');
+        this.processActiveCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Active' });
+        this.processCompletedCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Completed' });
+        this.processRunningInstancesCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Running Instances' });
+        this.processIncidentsCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Incidents' });
+        this.processPageHeading = page
+            .getByTestId('expanded-panel')
+            .getByRole('heading', { name: 'Process' });
+        this.noMatchingInstancesMessage = page.getByText('There are no Instances matching this filter set');
+        this.processFinishedInstancesCheckbox = page
+            .getByTestId('filter-finished-instances')
+            .getByRole('checkbox');
+    }
+    async clickProcessActiveCheckbox() {
+        await this.processActiveCheckbox.click();
+    }
+    async clickProcessCompletedCheckbox() {
+        await (0, sleep_1.sleep)(5000);
+        if (!(await this.processCompletedCheckbox.isChecked({ timeout: 60000 }))) {
+            await this.processCompletedCheckbox.click({ timeout: 120000 });
+            await (0, sleep_1.sleep)(1000);
+        }
+    }
+    async clickProcessIncidentsCheckbox() {
+        await this.processIncidentsCheckbox.click({ timeout: 90000 });
+    }
+    async clickRunningProcessInstancesCheckbox() {
+        await this.processRunningInstancesCheckbox.click({ timeout: 90000 });
+    }
+    async clickFinishedProcessInstancesCheckbox() {
+        await this.processFinishedInstancesCheckbox.click({ timeout: 90000 });
+    }
+    async clickProcessInstanceLink(processName) {
+        let retryCount = 0;
+        const maxRetries = 3;
+        while (retryCount < maxRetries) {
+            try {
+                await (0, sleep_1.sleep)(1000);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(1000);
+                await this.page
+                    .getByRole('row')
+                    .filter({ hasText: new RegExp(`^Select row${processName}\\d+.*$`) })
+                    .first()
+                    .getByRole('link')
+                    .click({ timeout: 30000 });
+                return; // Exit the function if the click is successful
+            }
+            catch (error) {
+                // If process isn't found, reload the page and try again
+                retryCount++;
+                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(10000);
+            }
+        }
+        throw new Error(`Failed to click on process instance link after ${maxRetries} attempts.`);
+    }
+}
+exports.OperateProcessesPage = OperateProcessesPage;

package/dist/pages/c8Run-8.10/TaskDetailsPage.d.ts

@@ -0,0 +1,65 @@
+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 taskCompletedBanner: Locator;
+    readonly assignedToMeText: 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>;
+    priorityAssertion(priority: string): Promise<void>;
+    taskAssertion(name: string): Promise<void>;
+    assertVariableValue(variableName: string, variableValue: string): Promise<void>;
+}
+export { TaskDetailsPage };