@camunda/e2e-test-suite 0.0.1443 → 0.0.1444

package/dist/pages/SM-8.11/ProcessApplicationPage.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessApplicationPage = void 0;
+const test_1 = require("@playwright/test");
+const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
+// ModelerHomePage creates the container, while ModelerCreatePage later binds
+// its stage. Both page objects share the same Playwright Page.
+const resourceContainers = new WeakMap();
+// Workspace ids whose Environment an org admin assigned from a separate session
+// (see assignEnvironmentToWorkspace), keyed by the non-admin user's Page. That
+// user cannot open the workspace Environments tab, so ensureStageCluster skips it.
+const adminAssignedWorkspaces = new WeakMap();
+// Flag-on Self-Managed 8.10 (camunda-hub#27903: workspaces-enabled=true) renamed
+// the entity hierarchy: the legacy "project folder" is now a Workspace and the
+// legacy "process application" is now a Project (camunda-hub#28005). A Project is
+// the resource container -- files, folders and uploads live directly inside it,
+// there is no separate process-application level to descend into. It is created
+// from the workspace's projects listing via the "Create project" split button +
+// dialog, and the app lands on `/workspace/{wsId}/projects/{projectId}`.
+//
+// camunda-hub#29210 ("Environments phase1") then moved cluster assignment up a
+// level again: a Project no longer has its own "Define stages" dialog or
+// "Connected clusters" card at all. Assignment is now an Environment (backed by
+// a registered cluster) assigned to the whole Workspace via its Environments
+// settings tab (`/workspaces/{wsId}/settings?tab=environments`), shared by every
+// Project inside that Workspace.
+//
+// This page object owns that container's surface (creating a Project) plus the
+// Workspace-level Environment assignment Deploy/Play need. Entering and leaving
+// it is driven from ModelerHomePage so the ~150 existing spec call sites keep
+// working unchanged. Method names are kept from the flag-off era
+// ("...ProcessApplication...", "...StageCluster...") so the callers do not have
+// to change.
+class ProcessApplicationPage {
+    page;
+    // The workspace projects listing's "Create project" split button. exact:true
+    // because the split button has a sibling "Create project options" chevron whose
+    // accessible name substring-matches otherwise (mirrors the hub team's own
+    // WorkspaceProjectsPage.newProjectButton). Falls back to the legacy flag-off
+    // "Create process application" button so a deployment with the flag still off
+    // keeps working.
+    createProcessApplicationButton;
+    // Legacy flag-off fallback only: the "Create new" menu item. Not rendered under
+    // workspaces-enabled, where the split button above is the entry point.
+    createProcessApplicationOption;
+    creationDialog;
+    nameInput;
+    submitButton;
+    cancelButton;
+    breadcrumb;
+    folderExplorer;
+    titleBar;
+    createNewDropdown;
+    inlineNameInput;
+    // Workspace management -> Environments tab (camunda-hub#29210). Page-scoped,
+    // not container-scoped: this tab lives on a different page
+    // (`/workspaces/{wsId}/settings`) than the Project detail these other
+    // locators target.
+    manageEnvironmentsHeading;
+    assignedEnvironmentCards;
+    editEnvironmentsButton;
+    environmentEditorRegion;
+    saveEnvironmentsButton;
+    constructor(page) {
+        this.page = page;
+        this.createProcessApplicationButton = page
+            .getByRole('button', { name: 'Create project', exact: true })
+            .or(page.getByRole('button', { name: 'Create process application' }))
+            .first();
+        this.createProcessApplicationOption = page.locator('[data-test="create-process-application"]');
+        // The workspace-mode create-project dialog carries a "Project name" field and
+        // has no accessible dialog name; scope to it via that field. Keeps the legacy
+        // flag-off "Create a process application" dialog as a fallback.
+        this.creationDialog = page
+            .getByRole('dialog')
+            .filter({ has: page.getByLabel('Project name') })
+            .or(page.getByRole('dialog', { name: 'Create a process application' }))
+            .first();
+        // Deliberately scoped to the dialog: ModelerCreatePage owns an unscoped
+        // getByLabel('Name', {exact: true}) for the properties panel, which would
+        // resolve to two elements while the creation modal is open.
+        this.nameInput = this.creationDialog
+            .getByLabel('Project name')
+            .or(this.creationDialog.getByLabel('Name', { exact: true }))
+            .first();
+        this.submitButton = this.creationDialog
+            .getByRole('button', { name: 'Create project', exact: true })
+            .or(this.creationDialog.getByRole('button', { name: 'Create', exact: true }))
+            .first();
+        this.cancelButton = this.creationDialog.getByRole('button', {
+            name: 'Cancel',
+            exact: true,
+        });
+        // Some shells expose a labelled resources region ("Resources" on the DS
+        // twin, "Folder explorer" on Carbon); the 8.10 flag-on Project detail does
+        // not, so this is only a soft readiness signal, never a required scope.
+        this.folderExplorer = page
+            .getByRole('region', { name: 'Folder explorer' })
+            .or(page.getByRole('region', { name: 'Resources' }))
+            .first();
+        // Proof we are on a Project (resource container) page: the flag-on Project
+        // detail renders this title-bar hook.
+        this.titleBar = page.locator('[data-test="process-application-title-bar"]');
+        // Any Project-detail marker also serves as an "inside the container" probe.
+        this.breadcrumb = this.titleBar.or(this.folderExplorer).first();
+        // The Project detail's "Create new" menu. Flag-on 8.10 renders it as
+        // [data-test="create-action-dropdown"] (aria-label "Create new"); older
+        // shells used [data-test="diagram-dropdown"]. Match either, page-wide,
+        // because the flag-on Project detail exposes no resources region to scope to.
+        this.createNewDropdown = page
+            .locator('[data-test="create-action-dropdown"]')
+            .or(page.locator('[data-test="diagram-dropdown"]'))
+            .or(page.getByRole('button', { name: 'Create new' }))
+            .first();
+        this.inlineNameInput = page.locator('[data-test="editable-input"]');
+        // "Assigned environments" heading: WorkspaceEnvironmentsTab's ready signal
+        // (it only renders once the workspace-scoped read has resolved).
+        this.manageEnvironmentsHeading = page.locator('[data-test="manage-environments-heading"]');
+        this.assignedEnvironmentCards = page.locator('[data-test="environment-card"]');
+        // Reads "Add environments" with none assigned yet, "Edit environments"
+        // otherwise -- same data-test either way.
+        this.editEnvironmentsButton = page.locator('[data-test="edit-environments-button"]');
+        this.environmentEditorRegion = page.getByRole('group', {
+            name: 'Edit assigned environments',
+        });
+        // Page-scoped, not environmentEditorRegion-scoped: Save/Cancel are
+        // rendered in the tab's header row, a SIBLING of the "Edit assigned
+        // environments" group, not a descendant of it.
+        this.saveEnvironmentsButton = page.getByRole('button', {
+            name: 'Save',
+            exact: true,
+        });
+    }
+    // Any one of the title bar, the resource region or the create-new dropdown
+    // proves we are on the Project (resource container) page.
+    pageReady() {
+        return this.titleBar
+            .or(this.createNewDropdown)
+            .or(this.folderExplorer)
+            .first();
+    }
+    async waitForProcessApplication(timeout = 90000) {
+        await (0, test_1.expect)(this.pageReady()).toBeVisible({ timeout });
+    }
+    async clickCreateProcessApplicationButton() {
+        await (0, test_1.expect)(this.createProcessApplicationButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.createProcessApplicationButton.click({ timeout: 60000 });
+    }
+    async clickCreateProcessApplicationOption() {
+        await (0, test_1.expect)(this.createProcessApplicationOption).toBeVisible({
+            timeout: 60000,
+        });
+        await this.createProcessApplicationOption.click({ timeout: 60000 });
+    }
+    // A Project is named up front in the create-project dialog. The inline path is
+    // kept as a fallback for the legacy flag-off "process application" surface.
+    async nameNewProcessApplication(name) {
+        const isModal = await this.creationDialog
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (isModal) {
+            await this.nameInput.click({ timeout: 30000 });
+            await this.nameInput.fill(name);
+            await (0, test_1.expect)(this.nameInput).toHaveValue(name, { timeout: 10000 });
+            await (0, submitModalWithRetry_1.submitModalWithRetry)(this.submitButton, this.creationDialog);
+            // The app navigates to the new Project's own detail page on submit.
+            await this.page
+                .waitForURL(/\/projects\/[^/?#]+/, { timeout: 60000 })
+                .catch(() => { });
+            await this.waitForProcessApplication();
+            return;
+        }
+        await (0, test_1.expect)(this.inlineNameInput).toBeVisible({ timeout: 30000 });
+        await this.inlineNameInput.click({ timeout: 60000 });
+        await this.inlineNameInput.fill(name);
+        await this.inlineNameInput.press('Enter');
+        await this.waitForProcessApplication();
+    }
+    rememberResourceContainer(url) {
+        resourceContainers.set(this.page, { url });
+    }
+    // Derives the shared Workspace's Environments settings URL from a Project
+    // detail URL (".../workspaces/<wsId>/projects/<projectId>[?...]"): the
+    // origin/app-root plus "/workspaces/<wsId>/settings?tab=environments" -- the
+    // same deep link camunda-hub's own useManageEnvironmentsLink builds for the
+    // deploy dialog's "Manage environments" link. Always emits the plural
+    // "workspaces" regardless of which spelling the container URL used
+    // (ModelerHomePage.openWorkspaceTile still tolerates a singular
+    // "/workspace/<id>/projects" from camunda-hub#28928 not yet being merged
+    // everywhere) -- the settings route itself (App.tsx) is plural-only, with no
+    // singular alias, so reusing a singular prefix verbatim would 404.
+    workspaceEnvironmentsUrl(containerUrl) {
+        const match = containerUrl.match(/^(.*)\/workspaces?\/([^/?#]+)\//);
+        if (!match) {
+            throw new Error(`Could not derive the workspace Environments URL from "${containerUrl}": ` +
+                'expected a "/workspaces/<id>/..." segment.');
+        }
+        const [, origin, workspaceId] = match;
+        return `${origin}/workspaces/${workspaceId}/settings?tab=environments`;
+    }
+    // Assigns an Environment to the shared Workspace via its Environments
+    // settings tab, so Deploy/Play (and Play's "Configure environment") find a
+    // usable target instead of rendering "No environments assigned" and staying
+    // disabled -- camunda-hub#29210 moved this out of the Project detail's own
+    // "Define stages" dialog and up to the Workspace, shared by every Project
+    // inside it.
+    //
+    // Checks the read-only "Assigned environments" list before entering edit
+    // mode, so a Workspace another (parallel) test already assigned is left
+    // alone regardless of this Page's own memo flag below -- required because
+    // every test's Project lives in the one shared Workspace. This is a
+    // best-effort check, not a lock: two tests racing to assign at once each
+    // still write their own snapshot of the selected set (Save persists the
+    // whole set, it does not merge), so a genuine concurrent race could still
+    // trigger two writes. It converges correctly here only because every test
+    // targets the one MODELER_CLUSTER_NAME (or, when unset, is happy with
+    // whichever single Environment ends up assigned).
+    async ensureStageCluster(clusterName) {
+        const container = resourceContainers.get(this.page);
+        if (!container ||
+            (container.stageBound && container.developmentCluster === clusterName)) {
+            return;
+        }
+        if (adminAssignedWorkspaces
+            .get(this.page)
+            ?.has(this.workspaceId(container.url))) {
+            container.stageBound = true;
+            container.developmentCluster = clusterName;
+            return;
+        }
+        const returnTo = this.page.url();
+        await this.assignEnvironmentToWorkspace(container.url, clusterName);
+        container.stageBound = true;
+        container.developmentCluster = clusterName;
+        await this.page.goto(returnTo, { waitUntil: 'domcontentloaded' });
+    }
+    // Assigns an Environment to the workspace that `workspaceUrl` (any
+    // "/workspaces/<id>/..." URL) belongs to, driving this Page's own session.
+    async assignEnvironmentToWorkspace(workspaceUrl, clusterName) {
+        const environmentsUrl = this.workspaceEnvironmentsUrl(workspaceUrl);
+        await (0, test_1.expect)(async () => {
+            await this.page.goto(environmentsUrl, { waitUntil: 'domcontentloaded' });
+            await this.assignWorkspaceEnvironment(clusterName);
+        }).toPass({ timeout: 240000, intervals: [1000, 2000, 5000] });
+    }
+    markWorkspaceEnvironmentAssignedByAdmin(workspaceUrl) {
+        const assigned = adminAssignedWorkspaces.get(this.page) ?? new Set();
+        assigned.add(this.workspaceId(workspaceUrl));
+        adminAssignedWorkspaces.set(this.page, assigned);
+    }
+    workspaceId(workspaceUrl) {
+        const match = workspaceUrl.match(/\/workspaces?\/([^/?#]+)\//);
+        if (!match) {
+            throw new Error(`Could not derive the workspace id from "${workspaceUrl}": ` +
+                'expected a "/workspaces/<id>/..." segment.');
+        }
+        return match[1];
+    }
+    async assignWorkspaceEnvironment(clusterName) {
+        const tabReady = await this.manageEnvironmentsHeading
+            .or(this.editEnvironmentsButton)
+            .first()
+            .waitFor({ state: 'visible', timeout: 90000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!tabReady) {
+            // WorkspaceManageBody silently normalises an unrecognised/unusable
+            // "?tab=environments" back to Members -- e.g. isEnvironmentsEnabled()
+            // off, or the current user failing canManageWorkspaceEnvironments
+            // (assigning is stricter than viewing: a plain Editor with no
+            // elevated/DevOps org role cannot assign at all). Name the likely
+            // cause rather than timing out with an opaque "not visible".
+            const onMembersTab = await this.page
+                .locator('[data-test="tab-members"][data-state="active"]')
+                .isVisible()
+                .catch(() => false);
+            throw new Error('The workspace Environments settings tab never rendered' +
+                (onMembersTab ? ' -- landed on the Members tab instead' : '') +
+                '. Either the Environments feature is off for this deployment, or the ' +
+                "current user lacks permission to manage this workspace's environments.");
+        }
+        const alreadyAssigned = clusterName
+            ? this.assignedEnvironmentCards.filter({ hasText: clusterName })
+            : this.assignedEnvironmentCards;
+        if (await alreadyAssigned
+            .first()
+            .isVisible()
+            .catch(() => false)) {
+            return;
+        }
+        await this.editEnvironmentsButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.environmentEditorRegion).toBeVisible({ timeout: 30000 });
+        const escapedClusterName = clusterName?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // A picker card's toggle button is "Select <name> (<clusterName or
+        // clusterId>)" (see camunda-hub EnvironmentPickerCard) -- match the
+        // cluster name in that parenthetical rather than the environment's own
+        // display name, which is a separate, admin-chosen field that need not
+        // match the cluster at all.
+        const targetOption = clusterName
+            ? this.environmentEditorRegion
+                .getByRole('button', {
+                name: new RegExp(`^Select .*\\(${escapedClusterName}\\)`),
+            })
+                .first()
+            : this.environmentEditorRegion
+                .getByRole('button', { name: /^Select / })
+                .first();
+        const optionAppeared = await targetOption
+            .waitFor({ state: 'visible', timeout: 30000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!optionAppeared) {
+            throw new Error(clusterName
+                ? `No Environment backed by cluster "${clusterName}" is available to assign to this ` +
+                    'workspace. Register the cluster (or its Environment) first.'
+                : 'No Environment is available to assign to this workspace: the picker shows "No ' +
+                    'environments available".');
+        }
+        await targetOption.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.saveEnvironmentsButton).toBeEnabled({ timeout: 30000 });
+        await this.saveEnvironmentsButton.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.environmentEditorRegion).toBeHidden({ timeout: 60000 });
+    }
+    async openByName(name) {
+        // Workspace-mode projects table: the whole row is the click target (see the
+        // hub team's WorkspaceProjectsPage). Fall back to the legacy title cell.
+        const projectRow = this.page
+            .getByRole('row', { name })
+            .first()
+            .or(this.page.getByRole('row').filter({ hasText: name }).getByTitle(name))
+            .first();
+        await (0, test_1.expect)(projectRow).toBeVisible({ timeout: 90000 });
+        await projectRow.click({ timeout: 60000 });
+        await this.waitForProcessApplication();
+    }
+}
+exports.ProcessApplicationPage = ProcessApplicationPage;

package/dist/pages/SM-8.11/SettingsPage.d.ts

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

package/dist/pages/SM-8.11/SettingsPage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsPage = void 0;
+class SettingsPage {
+    page;
+    openSettingsButton;
+    logoutButton;
+    openUserSidebarButton;
+    constructor(page) {
+        this.page = page;
+        this.openSettingsButton = page
+            .getByRole('button', { name: /^User menu/ })
+            .or(page.getByLabel('Open Settings'))
+            .first();
+        this.openUserSidebarButton = page
+            .getByRole('button', { name: /^User menu/ })
+            .or(page.getByLabel('Open User Sidebar'))
+            .first();
+        this.logoutButton = page
+            .getByRole('menuitem', { name: /log out/i })
+            .or(page.getByRole('button', { name: 'Log out' }))
+            .first();
+    }
+    async clickOpenSettingsButton() {
+        await this.openSettingsButton.click({ timeout: 120000 });
+    }
+    async clickOpenUserSideBarButton() {
+        await this.openUserSidebarButton.click({ timeout: 120000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 30000 });
+    }
+}
+exports.SettingsPage = SettingsPage;

package/dist/pages/SM-8.11/TaskDetailsPage.d.ts

@@ -0,0 +1,70 @@
+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;
+    readonly noPreviewContainer: Locator;
+    readonly previewContainer: 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>;
+    assertLoadedImage(documentName: string): Promise<void>;
+    assertDocumentDownloadButton(documentName: string): Promise<void>;
+    assertPdfPreviewViewerExists(): Promise<void>;
+    assertTextIsPresent(expectedText: string): Promise<void>;
+}
+export { TaskDetailsPage };