@camunda/e2e-test-suite 0.0.166 → 0.0.167

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

@@ -57,6 +57,7 @@ declare class ModelerCreatePage {
     readonly correlationKeyPayloadInput: Locator;
     readonly playTab: Locator;
     readonly continueToPlayButton: Locator;
+    readonly implementTab: Locator;
     readonly candidateUsersInput: Locator;
     readonly assigneeInput: Locator;
     readonly candidateGroupsInput: Locator;
@@ -118,11 +119,15 @@ declare class ModelerCreatePage {
     clickMarketPlaceButton(): Promise<void>;
     completeDeploymentEndpointConfiguration(): Promise<void>;
     completePlayConfiguration(): Promise<void>;
+    clickContinueToPlay(): Promise<void>;
     clickWebhookStartEventConnectorOption(): Promise<void>;
     clickWebhookIdInput(): Promise<void>;
     clearWebhookIdInput(): Promise<void>;
     fillWebhookIdInput(webhookId: string): Promise<void>;
     hoverOnStartEvent(): Promise<void>;
+    switchToImplementTab(): Promise<void>;
+    clickStartEvent(): Promise<void>;
+    assertScenarioNameVisible(scenarioName: string): Promise<void>;
     instanceStartedAssertion(): Promise<void>;
     assertImplementationOption(implementationType: string): Promise<void>;
     chooseImplementationOption(implementationType: string): Promise<void>;

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

@@ -62,6 +62,7 @@ class ModelerCreatePage {
     correlationKeyPayloadInput;
     playTab;
     continueToPlayButton;
+    implementTab;
     candidateUsersInput;
     assigneeInput;
     candidateGroupsInput;
@@ -192,6 +193,7 @@ class ModelerCreatePage {
             .locator('g:nth-child(8) > .djs-element > .djs-hit')
             .first();
         this.processIdSecondLocator = page.getByLabel('Process ID');
+        this.implementTab = page.getByRole('tab', { name: 'Implement' });
         this.bpmnReplaceMenu = page.getByTestId('bpmn-replace');
     }
     async deployProcessInstance() {
@@ -319,6 +321,7 @@ class ModelerCreatePage {
         }
     }
     async clickElemendIdInput() {
+        await this.elemendIdInput.waitFor({ state: 'visible', timeout: 10000 });
         await this.elemendIdInput.click();
     }
     async fillElementIdInput(id) {
@@ -619,6 +622,9 @@ class ModelerCreatePage {
             }
         }
     }
+    async clickContinueToPlay() {
+        await this.continueToPlayButton.click({ timeout: 30000 });
+    }
     async clickWebhookStartEventConnectorOption() {
         const maxRetries = 3;
         for (let retries = 0; retries < maxRetries; retries++) {
@@ -656,6 +662,15 @@ class ModelerCreatePage {
     async hoverOnStartEvent() {
         await this.hoverOnLocator(this.startEventElement, '.djs-context-pad');
     }
+    async switchToImplementTab() {
+        await this.implementTab.click({ timeout: 30000 });
+    }
+    async clickStartEvent() {
+        await this.startEventElement.click({ timeout: 30000 });
+    }
+    async assertScenarioNameVisible(scenarioName) {
+        await (0, test_1.expect)(this.page.getByTestId('instance-header').getByText(scenarioName)).toBeVisible();
+    }
     async instanceStartedAssertion() {
         try {
             await (0, test_1.expect)(this.page.getByText('Instance started!')).toBeVisible({

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

@@ -2,6 +2,19 @@ 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 notifications: Locator;
+    readonly saveScenarioModal: Locator;
     constructor(page: Page);
     waitForCompleteJobButtonToBeAvailable(): Promise<void>;
     clickCompleteJobButton(): Promise<void>;
@@ -10,5 +23,17 @@ declare class PlayPage {
     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.7/PlayPage.js

@@ -2,15 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlayPage = void 0;
 const test_1 = require("@playwright/test");
-const maxWaitTimeSeconds = 120000;
+const sleep_1 = require("../../utils/sleep");
+const maxWaitTimeSeconds = 180000;
 class PlayPage {
     page;
     completeJobButton;
+    saveScenarioButton;
+    viewScenarioButton;
+    runAllScenariosButton;
+    confirmSaveScenarioButton;
+    enterScenarioNameInput;
+    confirmDeleteScenarioButton;
+    viewAllScenariosButton;
+    getScenarioRowByName;
+    getScenarioRow;
+    diagram;
+    startInstanceButton;
+    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 = page.getByTestId('undefined-Start instance');
+        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,14 +59,39 @@ class PlayPage {
         await this.completeJobButton.click();
     }
     async clickStartInstanceButton() {
-        await this.page.getByTestId('diagram').getByLabel('Start instance').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 waitForInstanceDetailsToBeLoaded() {
         const maxRetries = 2;
@@ -57,15 +120,73 @@ class PlayPage {
         });
     }
     async waitForProcessToBeCompleted() {
+        const incidentText = await this.page.getByText(/incident/i).count();
+        if (incidentText > 0) {
+            throw new Error('Process has an incident instead of completing');
+        }
+        await (0, test_1.expect)(this.page.getByText(/completed/i)).toBeVisible({
+            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
-            .getByRole('heading', {
-            name: 'Congratulations, you did it!',
-            exact: true,
-        })
-            .or(this.page.getByRole('heading', {
-            name: 'Scenario recorded!',
-            exact: true,
-        }))).toBeVisible({ timeout: maxWaitTimeSeconds });
+            .locator('tr', { hasText: scenarioName })
+            .locator('text=Completed')).toBeVisible({ timeout: 30000 });
     }
 }
 exports.PlayPage = PlayPage;

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

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const test_1 = require("@playwright/test");
 const SM_8_7_1 = require("../../fixtures/SM-8.7");
 const _setup_1 = require("../../test-setup.js");
+const sleep_1 = require("../../utils/sleep");
 const KeycloakUtils_1 = require("../../pages/SM-8.7/KeycloakUtils");
 const loggingUtils_1 = require("../../utils/loggingUtils");
+SM_8_7_1.test.describe.configure({ mode: 'parallel' });
 SM_8_7_1.test.describe('Deploy and run a process in Play', () => {
     SM_8_7_1.test.beforeEach(async ({ navigationPage, identityPage, identityTenantPage, keycloakLoginPage, keycloakAdminPage, }, testInfo) => {
         (0, loggingUtils_1.setupTestLogging)(testInfo);
@@ -34,36 +36,30 @@ SM_8_7_1.test.describe('Deploy and run a process in Play', () => {
                 timeout: 120000,
             });
             await modelerCreatePage.enterDiagramName(processName);
-            // Add a user task with Job worker implementation (default)
-            await modelerCreatePage.clickAppendElementButton();
-            await modelerCreatePage.clickAppendTaskButton();
-            await modelerCreatePage.clickChangeTypeButton();
-            await modelerCreatePage.clickUserTaskOption();
-            await modelerCreatePage.chooseImplementationOption('jobWorker');
-            await modelerCreatePage.clickGeneralPropertiesPanel();
-            await modelerCreatePage.clickElemendIdInput();
-            await modelerCreatePage.fillElementIdInput('tasklist-user-task' + randomString);
-            // Add a user task with Zeebe user task implementation
+            await (0, sleep_1.sleep)(2000);
             await modelerCreatePage.clickAppendElementButton();
             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);
-            // Add a service task
+            await (0, sleep_1.sleep)(1000);
             await modelerCreatePage.clickAppendElementButton();
             await modelerCreatePage.clickAppendTaskButton();
             await modelerCreatePage.clickChangeTypeButton();
             await modelerCreatePage.clickServiceTaskOption();
+            await modelerCreatePage.clickGeneralPropertiesPanel();
             await modelerCreatePage.clickElemendIdInput();
             await modelerCreatePage.fillElementIdInput('service-task' + randomString);
             await modelerCreatePage.clickTaskDefinitionPropertiesPanel();
             await modelerCreatePage.clickJobTypeInput();
             await modelerCreatePage.fillJobTypeInput('someJob' + randomString);
-            // Add end event
+            await (0, sleep_1.sleep)(1000);
             await modelerCreatePage.clickAppendElementButton();
             await modelerCreatePage.clickAppendEndEventButton();
+            await (0, sleep_1.sleep)(2000);
         });
         await SM_8_7_1.test.step('Open Play', async () => {
             await modelerCreatePage.switchToPlay();
@@ -73,19 +69,93 @@ SM_8_7_1.test.describe('Deploy and run a process in Play', () => {
             await playPage.dismissStartModal();
             await playPage.clickStartInstanceButton();
             await playPage.waitForInstanceDetailsToBeLoaded();
-            // wait for and complete the "tasklist user task"
-            await playPage.waitForNextElementToBeActive('tasklist-user-task' + randomString);
-            await playPage.waitForCompleteJobButtonToBeAvailable();
-            await playPage.clickCompleteJobButton();
-            // wait for and complete the "zeebe user task"
             await playPage.waitForNextElementToBeActive('zeebe-user-task' + randomString);
             await playPage.waitForCompleteJobButtonToBeAvailable();
             await playPage.clickCompleteJobButton();
-            // wait for and complete the "service task"
             await playPage.waitForNextElementToBeActive('service-task' + randomString);
             await playPage.waitForCompleteJobButtonToBeAvailable();
             await playPage.clickCompleteJobButton();
             await playPage.waitForProcessToBeCompleted();
         });
     });
+    (0, SM_8_7_1.test)('Create,update and delete test scenarios in play', async ({ modelerHomePage, modelerCreatePage, playPage, context, navigationPage, page, }) => {
+        SM_8_7_1.test.slow();
+        const randomString = await (0, _setup_1.generateRandomStringAsync)(3);
+        const processName = 'Play_Test_Process' + randomString;
+        await SM_8_7_1.test.step('Open Cross Component Test Project', async () => {
+            await context.clearCookies();
+            await navigationPage.goToModeler();
+            await modelerHomePage.clickCreateNewProjectButton();
+            await modelerHomePage.createCrossComponentProjectFolder();
+        });
+        await SM_8_7_1.test.step('Add A BPMN Template To The Project', async () => {
+            await modelerHomePage.clickDiagramTypeDropdown();
+            await modelerHomePage.clickBpmnTemplateOption();
+        });
+        await SM_8_7_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_7_1.test.step('Open Play', async () => {
+            await modelerCreatePage.switchToPlay();
+            await modelerCreatePage.completePlayConfiguration();
+        });
+        await SM_8_7_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_7_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.clickStartInstanceButton();
+            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_7_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_7_1.test.step('Delete test scenario', async () => {
+            await playPage.deleteScenario('My first scenario');
+            await playPage.confirmDeleteScenario();
+            await (0, test_1.expect)(page
+                .locator('tr')
+                .filter({ has: page.getByText('My first scenario', { exact: true }) })).toHaveCount(0);
+        });
+    });
 });

package/package.json

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