@camunda/e2e-test-suite 0.0.1443 → 0.0.1444

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

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayPage = void 0;
+const test_1 = require("@playwright/test");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+const maxWaitTimeSeconds = 180000;
+class PlayPage {
+    page;
+    completeJobButton;
+    viewScenarioButton;
+    runAllScenariosButton;
+    confirmDeleteScenarioButton;
+    viewAllScenariosButton;
+    getScenarioRowByName;
+    getScenarioRow;
+    diagram;
+    startInstanceButton;
+    startInstanceWithCachedButton;
+    configureTestPanel;
+    configureTestPanelStartButton;
+    notifications;
+    scenarioSavedToast;
+    scenarioDetailNameInput;
+    scenarioDetailSaveButton;
+    loadingInstanceDetailsText;
+    retryButton;
+    dialog;
+    inputPanelStartButton;
+    constructor(page) {
+        this.page = page;
+        this.dialog = page.getByRole('dialog');
+        // Test mode labels this button with a <span class="sr-only">Complete job</span>
+        // rather than an aria-label, so getByLabel cannot see it -- its data-testid
+        // is element-scoped ("<elementId>-Complete job"). getByRole reads the
+        // accessible name, which the sr-only text and the legacy aria-label both
+        // supply, so this resolves on either shell.
+        this.completeJobButton = page
+            .getByTestId('diagram')
+            .getByRole('button', { name: 'Complete job' })
+            .first();
+        // Test mode renamed "scenario" to "test case" across this panel
+        // (camunda-hub a90fd06). Each label below accepts both wordings so the
+        // page object works either side of the rename.
+        this.viewScenarioButton = page.getByRole('button', {
+            name: /^View (scenario|test case)$/i,
+        });
+        this.runAllScenariosButton = page.getByRole('button', {
+            name: /^Run all (scenarios|test cases)$/i,
+        });
+        // The Design System confirmation is a Radix AlertDialog, so its role is
+        // "alertdialog" -- a distinct ARIA role that getByRole('dialog') does not
+        // match. Accept either role and identify it by its heading rather than an
+        // accessible name, which the DS dialog does not always expose.
+        this.confirmDeleteScenarioButton = page
+            .getByRole('alertdialog')
+            .or(page.getByRole('dialog'))
+            .filter({
+            has: page.getByRole('heading', {
+                name: /^Delete (scenario|test case)$/i,
+            }),
+        })
+            .getByRole('button', { name: 'Delete', exact: true });
+        // After saving a scenario, the Scenarios panel is in detail-view mode.
+        // To get back to the list (where "Run all test cases" lives in
+        // TestCaseTopBar), click the ghost button at the top of the detail
+        // panel — see TestCaseDetail.tsx Header.
+        // This replaces the legacy bottom-bar `(View all)` link that used to
+        // close the saved-scenario view.
+        // camunda-hub cfaea03 (#28259, "rename play package to test-studio")
+        // relabelled it "Back to all test cases"; the anchored regex below must
+        // keep the optional "all " or it matches nothing on current builds.
+        this.viewAllScenariosButton = page.getByRole('button', {
+            name: /^Back to (all )?(scenarios|test cases)$/i,
+        });
+        this.getScenarioRowByName = (scenarioName) => page.locator('tr', { hasText: scenarioName });
+        this.getScenarioRow = (scenarioName) => page.locator('tr', { hasText: scenarioName });
+        this.diagram = page.getByTestId('diagram');
+        this.startInstanceButton = this.diagram.getByLabel('Start instance', {
+            exact: true,
+        });
+        this.startInstanceWithCachedButton = page.getByLabel('Start instance with cached');
+        this.configureTestPanel = page.getByTestId('configure-test-panel');
+        this.configureTestPanelStartButton = this.configureTestPanel.getByRole('button', { name: /^Start( with .*)?$/, exact: false });
+        this.notifications = page.locator('.cds--toast-notification');
+        // Hub PR #25327 (2026-06-22) removed the standalone "Save scenario" modal
+        // and moved recording into the side panel's detail view. The detail view
+        // renders a TextInput plus a primary "Save test case" button and emits a
+        // "Test case saved" toast via @camunda/c4-notifications — see
+        // TestCasesPanel/TestCases/TestCaseDetail/{index.tsx,use-test-case-editor.ts}.
+        // camunda-hub a90fd06 renamed the input id from "scenario-name" to
+        // "test-case-name"; accept the pre-rename id too.
+        this.scenarioDetailNameInput = page
+            .locator('input#test-case-name')
+            .or(page.locator('input#scenario-name'))
+            .first();
+        this.scenarioDetailSaveButton = page.getByRole('button', {
+            name: /^Save (scenario|test case)$/i,
+        });
+        // c4-notifications wraps Carbon ToastNotification with role="alert" for
+        // non-actionable toasts (see Notification.tsx in @camunda/c4-notifications).
+        // Anchor on the accessible role instead of the Carbon CSS class so the
+        // locator is resilient to Carbon version bumps.
+        // The Design System toast stack is an <ol> of plain <li> items with no
+        // role="alert" (the only alert role in Test mode belongs to the Copilot
+        // panel), so match the text as well as the legacy alert role.
+        this.scenarioSavedToast = page
+            .getByRole('alert')
+            .filter({ hasText: /(Scenario|Test case) saved/i })
+            .or(page.getByText(/(Scenario|Test case) saved/i))
+            .first();
+        this.loadingInstanceDetailsText = this.page.getByText('Loading instance details...');
+        this.retryButton = this.page.getByRole('button', { name: 'Retry' });
+        // New Play UI (8.10+): "Configure scenario" opens an input panel with a plain "Start" button.
+        this.inputPanelStartButton = page.getByRole('button', {
+            name: 'Start',
+            exact: true,
+        });
+    }
+    async waitForCompleteJobButtonToBeAvailable() {
+        await (0, test_1.expect)(this.completeJobButton).toBeVisible({
+            timeout: maxWaitTimeSeconds,
+        });
+    }
+    async clickCompleteJobButton() {
+        await this.completeJobButton.waitFor({ state: 'visible', timeout: 30000 });
+        await this.completeJobButton.click();
+    }
+    async clickStartInstanceButton() {
+        const scenariosRegion = this.page.getByRole('region', {
+            name: /^(Scenarios|Test cases)$/i,
+        });
+        const backToScenariosButton = scenariosRegion.getByRole('button', {
+            name: /^Back to (all )?(scenarios|test cases)$/i,
+        });
+        // TestPanel.tsx labels this `Close ${title} panel`, so match on the
+        // substring rather than the exact accessible name.
+        const closeScenariosButton = scenariosRegion
+            .getByRole('button', {
+            name: 'Close',
+        })
+            .first();
+        // When "Configure test case" is clicked with a prior test case already
+        // saved, the Test Studio UI opens test-case DETAILS (with "Back to all test
+        // cases") instead of the input panel. Close the Test cases panel to reveal
+        // the canvas start controls.
+        const isDetailsView = await backToScenariosButton
+            .waitFor({ state: 'visible', timeout: 3000 })
+            .then(() => true)
+            .catch(() => false);
+        if (isDetailsView) {
+            await closeScenariosButton.click();
+        }
+        const startTrigger = this.configureTestPanelStartButton
+            .or(this.inputPanelStartButton)
+            .or(this.startInstanceButton)
+            .or(this.startInstanceWithCachedButton)
+            .first();
+        // Test Studio's "Setup environment" is an inline accordion whose step 3
+        // ("Configure test case") holds ConfigureTestPanel and its Start button.
+        // The section can collapse again after completePlayConfiguration() returns
+        // (a cluster-change effect re-shows the overlay), in which case the Start
+        // trigger disappears. Re-open the "Configure test case" accordion heading
+        // before an attempt, but only when the panel is not already visible --
+        // clicking the heading while it is open re-shows the overlay and collapses
+        // the panel, so gating on the always-present "Setup environment" heading
+        // would defeat every retry.
+        const configureTestCaseButton = this.page
+            .getByTestId('configure-test-case-button')
+            .or(this.page.getByTestId('play-configuration-configure-scenario-button'))
+            .or(this.page.getByRole('button', {
+            name: /^Configure (test case|scenario)$/,
+        }))
+            .first();
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, startTrigger, {
+            totalTimeout: maxWaitTimeSeconds,
+            visibilityTimeout: 30000,
+            maxRetries: 5,
+            preAction: async () => {
+                const panelVisible = await this.configureTestPanel
+                    .isVisible()
+                    .catch(() => false);
+                if (!panelVisible) {
+                    await configureTestCaseButton.click({ timeout: 30000 });
+                }
+            },
+        });
+    }
+    async dismissStartModal() {
+        const buttonVariations = [
+            'Start a process instance',
+            'Start another instance',
+            'Start new instance',
+            'Start instance',
+        ];
+        // Wait for the page to settle before checking for modal buttons
+        await this.page.waitForLoadState('domcontentloaded');
+        const maxAttempts = 3;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            for (const buttonName of buttonVariations) {
+                const button = this.page.getByRole('button', { name: buttonName });
+                const count = await button.count();
+                if (count > 0) {
+                    await button.waitFor({ state: 'visible', timeout: 10000 });
+                    await button.click();
+                    return;
+                }
+            }
+            if (attempt < maxAttempts - 1) {
+                await this.page.waitForLoadState('load');
+            }
+        }
+        // No modal present — new Play UI skips the modal entirely (Configure scenario
+        // opens the input panel directly without a modal step).
+    }
+    async clickStartInstanceWithCachedButton() {
+        await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+        await this.startInstanceWithCachedButton.click({ timeout: 30000 });
+    }
+    async waitForInstanceDetailsToBeLoaded() {
+        // Do NOT use page.reload() — it destroys Play's embedded context.
+        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,
+        });
+    }
+    async waitForNextElementToBeActive(historyItem) {
+        const locator = this.page.getByText(new RegExp(`^${historyItem}`, 'i'));
+        // Do NOT use page.reload() here — Play is embedded in the modeler and
+        // reloading destroys the Play instance context, making the diagram
+        // permanently invisible. Use a long timeout instead, consistent with
+        // waitForCompleteJobButtonToBeAvailable.
+        await (0, test_1.expect)(locator.first()).toBeVisible({ timeout: maxWaitTimeSeconds });
+    }
+    async waitForProcessToBeCompleted() {
+        // Do NOT use page.reload() — it destroys Play's embedded context.
+        await (0, test_1.expect)(this.page.getByText('Completed')).toBeVisible({
+            timeout: maxWaitTimeSeconds,
+        });
+    }
+    async waitForScenarioRecordPanelReady() {
+        // Hub PR #25327 (2026-06-22) removed the standalone "Save scenario" modal.
+        // Starting a Play run now auto-opens the Scenarios side panel in "record"
+        // mode with the scenario-name input + a primary "Save scenario" button.
+        // This method waits for that record-mode panel to be ready for input.
+        //
+        // `state: 'hidden'` already resolves immediately when the notification is
+        // absent, so no try/catch is needed — letting a real timeout surface is
+        // intentional (it signals a stuck stale toast blocking subsequent input).
+        await this.notifications.first().waitFor({ state: 'hidden', timeout: 60000 });
+        await (0, test_1.expect)(this.scenarioDetailNameInput).toBeVisible({ timeout: 30000 });
+    }
+    async clickViewScenarioButton() {
+        await this.viewScenarioButton.waitFor({ state: 'visible', timeout: 30000 });
+        await this.viewScenarioButton.click();
+    }
+    async enterScenarioName(scenarioName) {
+        // New flow: the name input lives directly inside the auto-opened record
+        // panel — no modal to click open first. Fill and blur so the validation
+        // (canSave = isDirty && !isNameEmpty && !isNameDuplicate) commits before
+        // the Save scenario button is clicked.
+        await this.scenarioDetailNameInput.waitFor({
+            state: 'visible',
+            timeout: 30000,
+        });
+        await this.scenarioDetailNameInput.clear();
+        await this.scenarioDetailNameInput.fill(scenarioName);
+        await this.scenarioDetailNameInput.press('Tab');
+    }
+    async updateScenarioName(newScenarioName) {
+        // Mirror enterScenarioName's blur step so canSave validation commits
+        // before any subsequent Save click.
+        await this.scenarioDetailNameInput.fill(newScenarioName);
+        await this.scenarioDetailNameInput.press('Tab');
+    }
+    async clickViewAllScenariosButton() {
+        // This method's job is to reach the scenario LIST. Saving can already leave
+        // Play there (see assertSavedScenarioNameInPanel), and the "Back to all
+        // test cases" control exists only inside a scenario's detail view -- so on the
+        // list it never renders and waiting for it just burns the retry budget.
+        // "Run all test cases" lives on the list and is what the caller needs next,
+        // so treat it as proof the destination is already reached.
+        if (await this.runAllScenariosButton
+            .isVisible({ timeout: 3000 })
+            .catch(() => false)) {
+            return;
+        }
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.viewAllScenariosButton);
+        await this.viewAllScenariosButton.click();
+    }
+    async confirmSaveScenario() {
+        // Click the in-panel "Save scenario" primary button. It is gated by the
+        // canSave predicate in useScenarioEditor.ts — a non-empty, non-duplicate
+        // name and a completed instance are both required. enterScenarioName()
+        // and waitForProcessToBeCompleted() satisfy those before this is called.
+        await (0, test_1.expect)(this.scenarioDetailSaveButton).toBeVisible({ timeout: 30000 });
+        await (0, test_1.expect)(this.scenarioDetailSaveButton).toBeEnabled({ timeout: 30000 });
+        await this.scenarioDetailSaveButton.click({ timeout: 30000 });
+        // Saving fires a c4-notifications toast with title "Scenario saved".
+        // Wait for it as the success signal that replaces the legacy
+        // modal-hidden assertion.
+        await (0, test_1.expect)(this.scenarioSavedToast).toBeVisible({ timeout: 30000 });
+    }
+    async assertSavedScenarioNameInPanel(scenarioName) {
+        // A successful save tears the detail view down: use-test-case-editor.ts
+        // saveTest() calls resetForm() + testCasesStore.resetTestCaseDetail(),
+        // which clears selectedTestCase and stops recording, so the store's
+        // isTestCaseDetailVisible turns false and the panel falls back to the
+        // saved test-case list. The name therefore lands on one of three
+        // surfaces: a list row, the read-only TestName heading, or (pre-reset
+        // hub builds) the still-editable Name field.
+        const savedName = this.getScenarioRow(scenarioName)
+            .or(this.page.getByRole('heading', { name: scenarioName, exact: true }))
+            .first();
+        const onListOrHeading = await savedName
+            .waitFor({ state: 'visible', timeout: 30000 })
+            .then(() => true)
+            .catch(() => false);
+        if (onListOrHeading) {
+            return;
+        }
+        // Updating an existing test case does NOT always leave the detail view
+        // open: Play can close it and fall back to the "Test cases" list, which is
+        // what it did in run 32105225796 -- the screenshot shows the list with the
+        // updated name present while neither the heading nor the Name field
+        // existed, so the old two-surface check failed on a save that had actually
+        // succeeded (the "Scenario saved" toast had already been asserted). The row
+        // carrying the exact name is the same proof, on the surface Play chose.
+        const listRow = this.page
+            .locator('tr')
+            .filter({ has: this.page.getByText(scenarioName, { exact: true }) })
+            .first();
+        if (await listRow.isVisible({ timeout: 3000 }).catch(() => false)) {
+            return;
+        }
+        await (0, test_1.expect)(this.scenarioDetailNameInput).toHaveValue(scenarioName, {
+            timeout: 30000,
+        });
+    }
+    async getDeleteIconForScenario(scenarioName) {
+        const scenarioRow = this.page
+            .locator('tr')
+            .filter({ has: this.page.getByText(scenarioName, { exact: true }) });
+        return scenarioRow.getByLabel(/^Delete (scenario|test case)$/i);
+    }
+    async deleteScenario(scenarioName) {
+        const deleteIcon = await this.getDeleteIconForScenario(scenarioName);
+        await deleteIcon.waitFor({ state: 'visible', timeout: 10000 });
+        await deleteIcon.click();
+    }
+    async confirmDeleteScenario() {
+        await this.confirmDeleteScenarioButton.waitFor({
+            state: 'visible',
+            timeout: 10000,
+        });
+        await this.confirmDeleteScenarioButton.click();
+    }
+    async clickRunAllScenariosButton() {
+        await this.runAllScenariosButton.waitFor({
+            state: 'visible',
+            timeout: 30000,
+        });
+        await this.runAllScenariosButton.click();
+    }
+    async clickmessagePublishButton() {
+        await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+        const publishIcon = this.diagram
+            .locator('div.djs-overlays')
+            .getByLabel('Publish message', { exact: true });
+        await publishIcon.click({ timeout: 30000 });
+    }
+    async assertScenarioCompleted(scenarioName) {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.page
+            .locator('tr', { hasText: scenarioName })
+            .locator('text=Completed'), {
+            totalTimeout: 120000,
+            visibilityTimeout: 30000,
+            maxRetries: 5,
+            postAction: async () => {
+                if (await this.retryButton.isVisible()) {
+                    await this.retryButton.click();
+                }
+            },
+        });
+    }
+}
+exports.PlayPage = PlayPage;

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

@@ -0,0 +1,35 @@
+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;
+    readonly manageEnvironmentsHeading: Locator;
+    readonly assignedEnvironmentCards: Locator;
+    readonly editEnvironmentsButton: Locator;
+    readonly environmentEditorRegion: Locator;
+    readonly saveEnvironmentsButton: Locator;
+    constructor(page: Page);
+    private pageReady;
+    waitForProcessApplication(timeout?: number): Promise<void>;
+    clickCreateProcessApplicationButton(): Promise<void>;
+    clickCreateProcessApplicationOption(): Promise<void>;
+    nameNewProcessApplication(name: string): Promise<void>;
+    rememberResourceContainer(url: string): void;
+    private workspaceEnvironmentsUrl;
+    ensureStageCluster(clusterName?: string): Promise<void>;
+    assignEnvironmentToWorkspace(workspaceUrl: string, clusterName?: string): Promise<void>;
+    markWorkspaceEnvironmentAssignedByAdmin(workspaceUrl: string): void;
+    private workspaceId;
+    private assignWorkspaceEnvironment;
+    openByName(name: string): Promise<void>;
+}
+export { ProcessApplicationPage };