@camunda/e2e-test-suite 0.0.1011 → 0.0.1012

package/dist/pages/SM-8.9/ModelerHomePage.d.ts

@@ -2,11 +2,15 @@ import { Page, Locator } from '@playwright/test';
 declare class ModelerHomePage {
     private page;
     private defaultFolderName;
+    private processApplicationPage;
+    private processApplicationUrl?;
+    private processApplicationName?;
     readonly modelerPageBanner: Locator;
     readonly createNewProjectButton: Locator;
     readonly projectNameInput: Locator;
     readonly chooseBpmnTemplateButton: Locator;
     readonly diagramTypeDropdown: Locator;
+    readonly createIdpApplicationButton: Locator;
     readonly bpmnTemplateOption: Locator;
     readonly formTemplateOption: Locator;
     readonly projectBreadcrumb: Locator;
@@ -34,6 +38,9 @@ declare class ModelerHomePage {
     clickHomeBreadcrumb(): Promise<void>;
     clickChooseBpmnTemplateButton(): Promise<void>;
     clickDiagramTypeDropdown(): Promise<void>;
+    private enterResourceContainer;
+    private clickCreateProcessApplication;
+    private becameVisible;
     clickBpmnTemplateOption(): Promise<void>;
     clickFormOption(): Promise<void>;
     enterFormName(name: string): Promise<void>;

package/dist/pages/SM-8.9/ModelerHomePage.js

@@ -4,14 +4,26 @@ exports.ModelerHomePage = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+const randomName_1 = require("../../utils/randomName");
+const ProcessApplicationPage_1 = require("./ProcessApplicationPage");
 class ModelerHomePage {
     page;
     defaultFolderName = 'Cross Component Test Project';
+    // Only used on hub's own image, where content can live solely inside a
+    // process application (camunda/camunda-hub#27592). The released 8.9 image
+    // still creates resources at the project root and never touches this. The
+    // container is created lazily, the first time a resource is created, and
+    // remembered for the lifetime of this page object (one instance per test,
+    // see fixtures/SM-8.9.ts).
+    processApplicationPage;
+    processApplicationUrl;
+    processApplicationName;
     modelerPageBanner;
     createNewProjectButton;
     projectNameInput;
     chooseBpmnTemplateButton;
     diagramTypeDropdown;
+    createIdpApplicationButton;
     bpmnTemplateOption;
     formTemplateOption;
     projectBreadcrumb;
@@ -31,6 +43,7 @@ class ModelerHomePage {
     modalCloseButton;
     constructor(page) {
         this.page = page;
+        this.processApplicationPage = new ProcessApplicationPage_1.ProcessApplicationPage(page);
         this.modelerPageBanner = page
             .locator('a')
             .filter({ hasText: 'Camunda logoModeler' });
@@ -46,6 +59,14 @@ class ModelerHomePage {
             name: 'Choose BPMN template',
         });
         this.diagramTypeDropdown = page.locator('[data-test="diagram-dropdown"]');
+        // Positive marker of the process-application-only layout (hub's own image,
+        // camunda/camunda-hub#27592): that empty project root surfaces IDP-app
+        // creation as a top-level button. The released 8.9 root has no such button
+        // -- its IDP entry is a menu item inside the "Create new" dropdown -- so
+        // this reliably distinguishes the two layouts.
+        this.createIdpApplicationButton = page.getByRole('button', {
+            name: 'Create IDP application',
+        });
         this.bpmnTemplateOption = page
             .locator('[data-test="create-bpmn-diagram"]')
             .getByText('BPMN Diagram');
@@ -212,7 +233,35 @@ class ModelerHomePage {
         // -- the reload-and-wait retry never actually ran. Bound the recovery wait
         // and widen the budget so all three attempts fit.
         await this.waitForModelerReady();
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.diagramTypeDropdown, {
+        // Two Web Modeler layouts run this suite. The released 8.9 image (the SM
+        // nightly) keeps the create-resource dropdown at the project root. Hub's
+        // own image (this pipeline) only lets content live inside a process
+        // application since camunda/camunda-hub#27592, so the root offers no
+        // dropdown and instead surfaces IDP-application creation as a top-level
+        // button.
+        //
+        // Route on a positive marker of EACH layout, never on the mere absence of
+        // the dropdown: wait for the root dropdown (old layout) OR the IDP button
+        // (new layout). If the released image's root dropdown were itself broken --
+        // the regression the old path exists to catch -- neither marker would
+        // render and this assertion throws, rather than silently taking the
+        // process-application path (whose "Create process application" button exists
+        // on both images).
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.diagramTypeDropdown.first().or(this.createIdpApplicationButton), {
+            visibilityTimeout: 15000,
+            totalTimeout: 180000,
+            postAction: async () => {
+                await this.page.reload();
+                await this.waitForModelerReady(45000);
+            },
+        });
+        if (await this.diagramTypeDropdown.first().isVisible()) {
+            await this.diagramTypeDropdown.first().click();
+            return;
+        }
+        await this.enterResourceContainer();
+        const dropdown = this.processApplicationPage.createNewDropdown;
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, dropdown, {
             visibilityTimeout: 15000,
             totalTimeout: 180000,
             postAction: async () => {
@@ -220,7 +269,53 @@ class ModelerHomePage {
                 await this.waitForModelerReady(45000);
             },
         });
-        await this.diagramTypeDropdown.click();
+        await dropdown.click();
+    }
+    // Creates, once, the process application that holds this test's resources and
+    // leaves the browser inside it. Only reached on hub's process-application-only
+    // layout. Idempotent: re-entered by remembered URL if already created.
+    async enterResourceContainer() {
+        if (this.processApplicationUrl) {
+            const stillInside = await this.becameVisible(this.processApplicationPage.breadcrumb, 5000);
+            if (!stillInside) {
+                await this.page.goto(this.processApplicationUrl, {
+                    waitUntil: 'domcontentloaded',
+                });
+                await this.processApplicationPage.waitForProcessApplication();
+                await this.clickMessageBanner();
+            }
+            return;
+        }
+        this.processApplicationName = await (0, randomName_1.randomNameAgregator)('Cross Component Process Application');
+        await this.clickCreateProcessApplication();
+        await this.processApplicationPage.nameNewProcessApplication(this.processApplicationName);
+        this.processApplicationUrl = this.page.url();
+    }
+    // Which control creates a process application depends on the hub version under
+    // test. Since camunda/camunda-hub#25831 it is a plain primary button on the
+    // workspace root, and the "Create new" menu explicitly hides the item because
+    // a process application is no longer just another resource. Before that change
+    // the menu item was the only way in. Race both entry points so neither version
+    // pays a full timeout, then use whichever one rendered.
+    async clickCreateProcessApplication() {
+        const button = this.processApplicationPage.createProcessApplicationButton;
+        const rootLoaded = await this.becameVisible(button.or(this.diagramTypeDropdown).first(), 60000);
+        if (!rootLoaded) {
+            await this.page.reload();
+            await this.waitForModelerReady(45000);
+        }
+        if (await this.becameVisible(button, 5000)) {
+            await this.processApplicationPage.clickCreateProcessApplicationButton();
+            return;
+        }
+        await this.diagramTypeDropdown.click({ timeout: 60000 });
+        await this.processApplicationPage.clickCreateProcessApplicationOption();
+    }
+    async becameVisible(locator, timeout) {
+        return locator
+            .waitFor({ state: 'visible', timeout })
+            .then(() => true)
+            .catch(() => false);
     }
     async clickBpmnTemplateOption() {
         await (0, test_1.expect)(this.bpmnTemplateOption).toBeVisible({ timeout: 60000 });

package/dist/pages/SM-8.9/ProcessApplicationPage.d.ts

@@ -0,0 +1,22 @@
+import { Locator, Page } from '@playwright/test';
+declare class ProcessApplicationPage {
+    private page;
+    readonly createProcessApplicationButton: Locator;
+    readonly createProcessApplicationOption: Locator;
+    readonly creationDialog: Locator;
+    readonly nameInput: Locator;
+    readonly submitButton: Locator;
+    readonly cancelButton: Locator;
+    readonly breadcrumb: Locator;
+    readonly folderExplorer: Locator;
+    readonly titleBar: Locator;
+    readonly createNewDropdown: Locator;
+    readonly inlineNameInput: Locator;
+    constructor(page: Page);
+    private pageReady;
+    waitForProcessApplication(timeout?: number): Promise<void>;
+    clickCreateProcessApplicationButton(): Promise<void>;
+    clickCreateProcessApplicationOption(): Promise<void>;
+    nameNewProcessApplication(name: string): Promise<void>;
+}
+export { ProcessApplicationPage };

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

@@ -0,0 +1,121 @@
+"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");
+// Since camunda/camunda-hub#27592 a process application is the only container
+// that can hold files and folders; a workspace root ("project" in today's UI)
+// holds nothing but process applications and IDP applications. The released 8.9
+// image still lets resources live at the project root, so this page object is
+// only reached when the newer, process-application-only layout is detected --
+// entering and leaving it is driven from ModelerHomePage so the existing spec
+// call sites keep working unchanged.
+class ProcessApplicationPage {
+    page;
+    // Empty workspace root: a plain primary button rendered next to the "Create
+    // new" menu (hub's EmptyStateActionButtons).
+    createProcessApplicationButton;
+    // Non-empty root: the item inside the "Create new" menu. Hub passes
+    // hideProcessApplication at workspace level, so this is the fallback rather
+    // than the primary path. Kept because the Hub PR is still moving this surface.
+    createProcessApplicationOption;
+    creationDialog;
+    nameInput;
+    submitButton;
+    cancelButton;
+    breadcrumb;
+    folderExplorer;
+    titleBar;
+    createNewDropdown;
+    inlineNameInput;
+    constructor(page) {
+        this.page = page;
+        // .first() defensively only: hub renders exactly one of these today, in the
+        // workspace-root empty state. A future second placement should not turn
+        // every PA-creating test into a strict-mode violation.
+        this.createProcessApplicationButton = page
+            .getByRole('button', { name: 'Create process application' })
+            .first();
+        this.createProcessApplicationOption = page.locator('[data-test="create-process-application"]');
+        this.creationDialog = page.getByRole('dialog', {
+            name: 'Create a process application',
+        });
+        // 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('Name', { exact: true });
+        this.submitButton = this.creationDialog.getByRole('button', {
+            name: 'Create',
+            exact: true,
+        });
+        this.cancelButton = this.creationDialog.getByRole('button', {
+            name: 'Cancel',
+            exact: true,
+        });
+        this.breadcrumb = page.locator('[data-test="breadcrumb-process-application-menu"]');
+        // The Design System shell renames this region "Resources"; the Carbon shell
+        // calls it "Folder explorer". Both hold the resource table and its toolbar,
+        // so matching either keeps createNewDropdown below correctly scoped.
+        this.folderExplorer = page
+            .getByRole('region', { name: 'Folder explorer' })
+            .or(page.getByRole('region', { name: 'Resources' }))
+            .first();
+        // Design System proof that we are on a process application page: the
+        // Carbon-era breadcrumb hook is gone under that shell, the same way
+        // breadcrumb-project is.
+        this.titleBar = page.locator('[data-test="process-application-title-bar"]');
+        // The process application page renders more than one diagram-dropdown
+        // (hub's own unit tests reach for it with getAllByTestId), so the dropdown
+        // has to be resolved inside the folder explorer rather than page-wide.
+        this.createNewDropdown = this.folderExplorer
+            .locator('[data-test="diagram-dropdown"]')
+            .first();
+        this.inlineNameInput = page.locator('[data-test="editable-input"]');
+    }
+    // Any one of the title bar, the resource region or the breadcrumb proves we
+    // are on the process application page. Three branches because the Design
+    // System and Carbon shells expose different subsets: only the title bar is
+    // present under both. .first() because several match once it has rendered.
+    pageReady() {
+        return this.titleBar.or(this.folderExplorer).or(this.breadcrumb).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 });
+    }
+    // Hub creates a process application through a modal today. It used an inline
+    // editable title before, and #27593 is still moving this surface, so the
+    // inline path is kept as a fallback -- this is the one method that has to
+    // change if naming moves back inline.
+    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);
+            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();
+    }
+}
+exports.ProcessApplicationPage = ProcessApplicationPage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1011",
+  "version": "0.0.1012",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",