@camunda/e2e-test-suite 0.0.147 → 0.0.149

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

@@ -70,6 +70,7 @@ declare class ModelerCreatePage {
     readonly additionalActionsButton: Locator;
     readonly closeModalButton: Locator;
     readonly deployErrorMessage: Locator;
+    readonly implementTab: Locator;
     readonly bpmnReplaceMenu: Locator;
     readonly connectorsDocHandlingStartEventElement: Locator;
     readonly startEventVariableInputWithThreeVariables: Locator;
@@ -177,6 +178,10 @@ declare class ModelerCreatePage {
     fillTimerValue(value: string): Promise<void>;
     clickEighthPlacedElement(): Promise<void>;
     assertNameInput(processName: string): Promise<void>;
+    switchToImplementTab(): Promise<void>;
+    clickStartEvent(): Promise<void>;
+    clickContinueToPlay(): Promise<void>;
+    assertScenarioNameVisible(scenarioName: string): Promise<void>;
     fillStartEventVariablesForDocHandling(zeebeUrl: string, zeebeClientId: string, zeebeClientSecret: string): Promise<void>;
     fillZeebeClientId(clientId: string): Promise<void>;
     fillZeebeSecretValue(zeebeSecret: string): Promise<void>;

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

@@ -75,6 +75,7 @@ class ModelerCreatePage {
     additionalActionsButton;
     closeModalButton;
     deployErrorMessage;
+    implementTab;
     bpmnReplaceMenu;
     connectorsDocHandlingStartEventElement;
     startEventVariableInputWithThreeVariables;
@@ -216,6 +217,7 @@ class ModelerCreatePage {
             .getByRole('dialog')
             .getByRole('button', { name: 'Close' });
         this.deployErrorMessage = page.getByText('The diagram failed to deploy & run');
+        this.implementTab = page.getByRole('tab', { name: 'Implement' });
         this.bpmnReplaceMenu = page.getByTestId('bpmn-replace');
         this.connectorsDocHandlingStartEventElement = page.locator('g:nth-child(5) > .djs-element > .djs-hit');
         this.startEventVariableInputWithThreeVariables =
@@ -729,7 +731,12 @@ class ModelerCreatePage {
         (0, test_1.expect)(await this.implementationOptions.inputValue()).toEqual(implementationType);
     }
     async chooseImplementationOption(implementationType) {
-        await this.implementationSection.click();
+        // Wait for implementation section to be attached and stable after task type change
+        await this.implementationSection.waitFor({
+            state: 'attached',
+            timeout: 10000,
+        });
+        await this.implementationSection.click({ timeout: 30000 });
         if ((await this.implementationOptions.inputValue()) == implementationType) {
             console.log(`${implementationType} is already selected.`);
         }
@@ -941,6 +948,18 @@ class ModelerCreatePage {
             await (0, test_1.expect)(this.nameInput).toHaveValue(processName);
         }
     }
+    async switchToImplementTab() {
+        await this.implementTab.click({ timeout: 30000 });
+    }
+    async clickStartEvent() {
+        await this.startEventElement.click({ timeout: 30000 });
+    }
+    async clickContinueToPlay() {
+        await this.continueToPlayButton.click({ timeout: 30000 });
+    }
+    async assertScenarioNameVisible(scenarioName) {
+        await (0, test_1.expect)(this.page.getByTestId('instance-header').getByText(scenarioName)).toBeVisible();
+    }
     async fillStartEventVariablesForDocHandling(zeebeUrl, zeebeClientId, zeebeClientSecret) {
         console.log(`URL: ${zeebeUrl}, ClientId: ${zeebeClientId}, Secret: ${zeebeClientSecret}`);
         (0, test_1.expect)(this.connectorsDocHandlingStartEventElement).toBeVisible({

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

@@ -2,13 +2,40 @@ import { Page, Locator } from '@playwright/test';
 declare class PlayPage {
     private page;
     readonly completeJobButton: Locator;
+    readonly saveScenarioButton: Locator;
+    readonly viewScenarioButton: Locator;
+    readonly runAllScenariosButton: Locator;
+    readonly confirmSaveScenarioButton: Locator;
+    readonly enterScenarioNameInput: Locator;
+    readonly confirmDeleteScenarioButton: Locator;
+    readonly viewAllScenariosButton: Locator;
+    readonly getScenarioRowByName: (scenarioName: string) => Locator;
+    readonly getScenarioRow: (scenarioName: string) => Locator;
+    readonly diagram: Locator;
+    readonly startInstanceButton: Locator;
+    readonly startInstanceWithCachedButton: Locator;
+    readonly notifications: Locator;
+    readonly saveScenarioModal: Locator;
     constructor(page: Page);
     waitForCompleteJobButtonToBeAvailable(): Promise<void>;
     clickCompleteJobButton(): Promise<void>;
     clickStartInstanceButton(): Promise<void>;
     dismissStartModal(): Promise<void>;
+    clickStartInstanceWithCachedButton(): Promise<void>;
     waitForInstanceDetailsToBeLoaded(): Promise<void>;
     waitForNextElementToBeActive(historyItem: string): Promise<void>;
     waitForProcessToBeCompleted(): Promise<void>;
+    clickSaveScenarioButton(): Promise<void>;
+    clickViewScenarioButton(): Promise<void>;
+    enterScenarioName(scenarioName: string): Promise<void>;
+    updateScenarioName(newScenarioName: string): Promise<void>;
+    clickViewAllScenariosButton(): Promise<void>;
+    confirmSaveScenario(): Promise<void>;
+    getDeleteIconForScenario(scenarioName: string): Promise<Locator>;
+    deleteScenario(scenarioName: string): Promise<void>;
+    confirmDeleteScenario(): Promise<void>;
+    clickRunAllScenariosButton(): Promise<void>;
+    clickmessagePublishButton(): Promise<void>;
+    assertScenarioCompleted(scenarioName: string): Promise<void>;
 }
 export { PlayPage };

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

@@ -2,15 +2,57 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlayPage = void 0;
 const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
 const maxWaitTimeSeconds = 180000;
 class PlayPage {
     page;
     completeJobButton;
+    saveScenarioButton;
+    viewScenarioButton;
+    runAllScenariosButton;
+    confirmSaveScenarioButton;
+    enterScenarioNameInput;
+    confirmDeleteScenarioButton;
+    viewAllScenariosButton;
+    getScenarioRowByName;
+    getScenarioRow;
+    diagram;
+    startInstanceButton;
+    startInstanceWithCachedButton;
+    notifications;
+    saveScenarioModal;
     constructor(page) {
         this.page = page;
         this.completeJobButton = page
             .getByTestId('diagram')
             .getByLabel('Complete job');
+        this.saveScenarioButton = page.getByRole('button', { name: 'Save scenario' });
+        this.viewScenarioButton = page.getByRole('button', { name: 'View scenario' });
+        this.runAllScenariosButton = page.getByRole('button', {
+            name: 'Run all scenarios',
+        });
+        this.confirmSaveScenarioButton = page
+            .getByTestId('save-scenario-modal')
+            .getByRole('button', { name: 'Save' });
+        this.enterScenarioNameInput = page
+            .getByTestId('save-scenario-modal')
+            .locator('input#scenario-name')
+            .first();
+        this.confirmDeleteScenarioButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.viewAllScenariosButton = page.getByRole('button', {
+            name: '(View all)',
+        });
+        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.notifications = page.locator('.cds--toast-notification');
+        this.saveScenarioModal = page.getByTestId('save-scenario-modal');
     }
     async waitForCompleteJobButtonToBeAvailable() {
         await (0, test_1.expect)(this.completeJobButton).toBeVisible({
@@ -21,17 +63,43 @@ class PlayPage {
         await this.completeJobButton.click();
     }
     async clickStartInstanceButton() {
-        await this.page
-            .getByTestId('diagram')
-            .getByLabel('Start instance', { exact: true })
-            .click();
+        await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+        const maxRetries = 3;
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            try {
+                await this.startInstanceButton.click({ timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                if (attempts >= maxRetries - 1)
+                    throw error;
+                await this.page.reload();
+                await (0, sleep_1.sleep)(2000);
+                attempts++;
+            }
+        }
     }
     async dismissStartModal() {
-        await this.page
-            .getByRole('button', {
-            name: 'Start a process instance',
-        })
-            .click();
+        const buttonVariations = [
+            'Start a process instance',
+            'Start another instance',
+            'Start new instance',
+            'Start instance',
+        ];
+        for (const buttonName of buttonVariations) {
+            const button = this.page.getByRole('button', { name: buttonName });
+            const count = await button.count();
+            if (count > 0) {
+                await button.click();
+                return;
+            }
+        }
+        throw new Error('Could not find start instance button with any expected variation');
+    }
+    async clickStartInstanceWithCachedButton() {
+        await this.diagram.waitFor({ state: 'visible', timeout: 30000 });
+        await this.startInstanceWithCachedButton.click({ timeout: 30000 });
     }
     async waitForInstanceDetailsToBeLoaded() {
         const maxRetries = 2;
@@ -64,5 +132,65 @@ class PlayPage {
             timeout: maxWaitTimeSeconds,
         });
     }
+    async clickSaveScenarioButton() {
+        await this.notifications
+            .first()
+            .waitFor({ state: 'hidden', timeout: 15000 })
+            .catch(() => { });
+        const isModalVisible = await this.saveScenarioModal
+            .isVisible()
+            .catch(() => false);
+        if (!isModalVisible) {
+            await this.saveScenarioButton.click({ force: true, timeout: 30000 });
+        }
+    }
+    async clickViewScenarioButton() {
+        await this.viewScenarioButton.click();
+    }
+    async enterScenarioName(scenarioName) {
+        const modal = this.page.locator('[data-testid="save-scenario-modal"].is-visible');
+        await modal.waitFor({ state: 'visible', timeout: 10000 });
+        const input = modal.locator('input#scenario-name');
+        await input.waitFor({ state: 'visible', timeout: 10000 });
+        await input.clear();
+        await input.fill(scenarioName);
+    }
+    async updateScenarioName(newScenarioName) {
+        await this.enterScenarioNameInput.fill(newScenarioName);
+    }
+    async clickViewAllScenariosButton() {
+        await this.viewAllScenariosButton.click();
+    }
+    async confirmSaveScenario() {
+        await this.confirmSaveScenarioButton.click();
+    }
+    async getDeleteIconForScenario(scenarioName) {
+        const scenarioRow = this.page
+            .locator('tr')
+            .filter({ has: this.page.getByText(scenarioName, { exact: true }) });
+        return scenarioRow.getByLabel('Delete scenario');
+    }
+    async deleteScenario(scenarioName) {
+        const deleteIcon = await this.getDeleteIconForScenario(scenarioName);
+        await deleteIcon.click();
+    }
+    async confirmDeleteScenario() {
+        await this.confirmDeleteScenarioButton.click();
+    }
+    async clickRunAllScenariosButton() {
+        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, test_1.expect)(this.page
+            .locator('tr', { hasText: scenarioName })
+            .locator('text=Completed')).toBeVisible({ timeout: 30000 });
+    }
 }
 exports.PlayPage = PlayPage;

package/dist/tests/SM-8.9/play.spec.js

@@ -29,7 +29,7 @@ SM_8_9_1.test.describe('Deploy and run a process in Play', () => {
                 timeout: 120000,
             });
             await modelerCreatePage.enterDiagramName(processName);
-            await (0, sleep_1.sleep)(10000);
+            await (0, sleep_1.sleep)(2000);
             // Add a user task with Zeebe user task implementation
             await modelerCreatePage.clickAppendElementButton();
             await modelerCreatePage.clickAppendTaskButton();
@@ -55,7 +55,7 @@ SM_8_9_1.test.describe('Deploy and run a process in Play', () => {
             // Add end event
             await modelerCreatePage.clickAppendElementButton();
             await modelerCreatePage.clickAppendEndEventButton();
-            await (0, sleep_1.sleep)(30000);
+            await (0, sleep_1.sleep)(2000);
         });
         await SM_8_9_1.test.step('Open Play', async () => {
             await modelerCreatePage.switchToPlay();
@@ -74,4 +74,79 @@ SM_8_9_1.test.describe('Deploy and run a process in Play', () => {
             await playPage.waitForProcessToBeCompleted();
         });
     });
+    (0, SM_8_9_1.test)('Create,update and delete test scenarios in play', async ({ modelerHomePage, modelerCreatePage, playPage, }) => {
+        SM_8_9_1.test.slow();
+        const randomString = await (0, _setup_1.generateRandomStringAsync)(3);
+        const processName = 'Play_Test_Process' + randomString;
+        await SM_8_9_1.test.step('Open Cross Component Test Project', async () => {
+            await modelerHomePage.clickCrossComponentProjectFolder();
+        });
+        await SM_8_9_1.test.step('Add A BPMN Template To The Project', async () => {
+            await modelerHomePage.clickDiagramTypeDropdown();
+            await modelerHomePage.clickBpmnTemplateOption();
+        });
+        await SM_8_9_1.test.step('Create a BPMN Diagram with simple start and end event', async () => {
+            await (0, test_1.expect)(modelerCreatePage.generalPanel).toBeVisible({
+                timeout: 120000,
+            });
+            await modelerCreatePage.enterDiagramName(processName);
+            await (0, sleep_1.sleep)(2000);
+            await modelerCreatePage.clickAppendElementButton();
+            await modelerCreatePage.clickAppendEndEventButton();
+            await (0, sleep_1.sleep)(2000);
+        });
+        await SM_8_9_1.test.step('Open Play', async () => {
+            await modelerCreatePage.switchToPlay();
+            await modelerCreatePage.completePlayConfiguration();
+        });
+        await SM_8_9_1.test.step('Start and complete the process instance in Play and save scenario', async () => {
+            await playPage.dismissStartModal();
+            await playPage.clickStartInstanceButton();
+            await playPage.waitForInstanceDetailsToBeLoaded();
+            await playPage.waitForProcessToBeCompleted();
+            await playPage.clickSaveScenarioButton();
+            await playPage.enterScenarioName('My first scenario');
+            await playPage.confirmSaveScenario();
+            await (0, sleep_1.sleep)(2000);
+        });
+        await SM_8_9_1.test.step('Update the saved scenario', async () => {
+            await modelerCreatePage.switchToImplementTab();
+            await (0, sleep_1.sleep)(2000);
+            await modelerCreatePage.clickStartEvent();
+            await modelerCreatePage.hoverOnStartEvent();
+            await modelerCreatePage.clickAppendTaskButton();
+            await modelerCreatePage.clickChangeTypeButton();
+            await modelerCreatePage.clickUserTaskOption();
+            await modelerCreatePage.chooseImplementationOption('zeebeUserTask');
+            await modelerCreatePage.clickGeneralPropertiesPanel();
+            await modelerCreatePage.clickElemendIdInput();
+            await modelerCreatePage.fillElementIdInput('zeebe-user-task' + randomString);
+            await (0, sleep_1.sleep)(2000);
+            await modelerCreatePage.clickAppendElementButton();
+            await modelerCreatePage.clickAppendEndEventButton();
+            await modelerCreatePage.switchToPlay();
+            await modelerCreatePage.clickContinueToPlay();
+            await (0, sleep_1.sleep)(2000);
+            await playPage.clickStartInstanceWithCachedButton();
+            await playPage.waitForNextElementToBeActive('zeebe-user-task' + randomString);
+            await playPage.waitForCompleteJobButtonToBeAvailable();
+            await playPage.clickCompleteJobButton();
+            await playPage.waitForProcessToBeCompleted();
+            await playPage.clickSaveScenarioButton();
+            await playPage.enterScenarioName('My first scenario-updated');
+            await playPage.confirmSaveScenario();
+            await modelerCreatePage.assertScenarioNameVisible('My first scenario-updated');
+        });
+        await SM_8_9_1.test.step('Run all scenarios', async () => {
+            await playPage.clickViewAllScenariosButton();
+            await playPage.clickRunAllScenariosButton();
+            await playPage.assertScenarioCompleted('My first scenario');
+            await playPage.assertScenarioCompleted('My first scenario-updated');
+        });
+        await SM_8_9_1.test.step('Delete test scenario', async () => {
+            await playPage.deleteScenario('My first scenario');
+            await playPage.confirmDeleteScenario();
+            await (0, test_1.expect)(playPage.getScenarioRow('My first scenario')).toHaveCount(0);
+        });
+    });
 });

package/package.json

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