@camunda/e2e-test-suite 0.0.1169 → 0.0.1171

package/dist/pages/c8Run-8.10/OperateProcessesPage.d.ts

@@ -17,6 +17,6 @@ declare class OperateProcessesPage {
     clickProcessIncidentsCheckbox(): Promise<void>;
     clickRunningProcessInstancesCheckbox(): Promise<void>;
     clickFinishedProcessInstancesCheckbox(): Promise<void>;
-    clickProcessInstanceLink(processName: string): Promise<void>;
+    clickProcessInstanceLink(processName: string, processInstanceKey?: string): Promise<void>;
 }
 export { OperateProcessesPage };

package/dist/pages/c8Run-8.10/OperateProcessesPage.js

@@ -61,20 +61,33 @@ class OperateProcessesPage {
     async clickFinishedProcessInstancesCheckbox() {
         await this.processFinishedInstancesCheckbox.click({ timeout: 90000 });
     }
-    async clickProcessInstanceLink(processName) {
+    async clickProcessInstanceLink(processName, processInstanceKey) {
+        // Both Operate frontends label the instance-key cell link
+        // "View instance <key>" -- the aria-label in operate/client's
+        // InstancesTable, the operate.processes.instancesTable.viewInstance string
+        // in the orchestration-cluster webapp -- so passing a key pins the click
+        // to one instance. Without a key every row carrying the process name is a
+        // candidate and `.first()` opens an arbitrary instance of that process.
+        // Both frontends sort the list by start date descending, so a
+        // just-created instance is on the first page.
+        const instanceLink = processInstanceKey === undefined
+            ? this.page
+                .getByRole('row')
+                .filter({ hasText: new RegExp(`^(?:Select row)?${processName}\\d+`) })
+                .first()
+                .getByRole('link')
+            : this.page.getByRole('link', {
+                name: `View instance ${processInstanceKey}`,
+                exact: true,
+            });
         let retryCount = 0;
-        const maxRetries = 3;
+        const maxRetries = 4;
         while (retryCount < maxRetries) {
             try {
                 await (0, sleep_1.sleep)(1000);
                 await this.page.reload();
                 await (0, sleep_1.sleep)(1000);
-                await this.page
-                    .getByRole('row')
-                    .filter({ hasText: new RegExp(`^(?:Select row)?${processName}\\d+`) })
-                    .first()
-                    .getByRole('link')
-                    .click({ timeout: 30000 });
+                await instanceLink.click({ timeout: 30000 });
                 await (0, test_1.expect)(this.page.getByText('Instance History').first()).toBeVisible({
                     timeout: 10000,
                 });

package/dist/pages/c8Run-8.10/TaskDetailsPage.js

@@ -220,7 +220,27 @@ class TaskDetailsPage {
         // taskVariablesValueLabel) associated by htmlFor -- the old Carbon input
         // exposed the same string as an HTML title attribute, which getByTitle
         // matched directly; getByLabel is the equivalent for a real <label>.
-        await (0, test_1.expect)(this.page.getByLabel(variableName + ' Value')).toHaveValue(variableValue, { timeout: 60000 });
+        //
+        // The panel fetches the task's variables once, when the task is opened, so
+        // polling the DOM alone can never observe a value that was still being
+        // exported at that moment. Reload between attempts to force a re-fetch --
+        // same retry shape as taskAssertion/priorityAssertion above.
+        const valueInput = this.page.getByLabel(variableName + ' Value');
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await (0, test_1.expect)(valueInput).toHaveValue(variableValue, { timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                if (attempt === maxRetries) {
+                    throw error;
+                }
+                console.log(`Attempt ${attempt} failed. Retrying...`);
+                await this.page.reload();
+                await (0, sleep_1.sleep)(5000);
+            }
+        }
     }
 }
 exports.TaskDetailsPage = TaskDetailsPage;

package/dist/pages/c8Run-8.10/TaskPanelPage.d.ts

@@ -12,7 +12,10 @@ declare class TaskPanelPage {
     assertAssigmentStatus(status: string): Promise<void>;
     assignTaskToMe(): Promise<void>;
     completeATask(): Promise<void>;
-    openTask(name: string, userTaskName?: string): Promise<void>;
+    taskCard(name: string, userTaskName?: string): Locator;
+    revealTaskCard(card: Locator, name: string): Promise<void>;
+    assertTaskVisible(name: string): Promise<void>;
+    openTask(name: string, userTaskName?: string): Promise<string>;
     taskListBannerIsVisible(): Promise<void>;
     asssertUnnassignedTaskEmptyMessage(): Promise<void>;
     filterBy(option: 'All open tasks' | 'Unassigned' | 'Assigned to me' | 'Completed' | 'Custom'): Promise<void>;

package/dist/pages/c8Run-8.10/TaskPanelPage.js

@@ -56,16 +56,62 @@ class TaskPanelPage {
         await this.assignToMeButton.click();
         await this.completeTaskButton.click();
     }
-    async openTask(name, userTaskName = '') {
-        let tasks = this.availableTasks.getByText(name, { exact: true });
+    taskCard(name, userTaskName = '') {
+        let cards = this.availableTasks
+            .getByRole('article')
+            .filter({ has: this.page.getByText(name, { exact: true }) });
         if (userTaskName != '') {
-            tasks = this.availableTasks
-                .getByRole('article')
-                .filter({ hasText: name })
-                .filter({ hasText: userTaskName });
+            cards = cards.filter({ hasText: userTaskName });
         }
-        await (0, test_1.expect)(tasks.nth(0)).toBeVisible({ timeout: 20000 });
-        await tasks.nth(0).click({ timeout: 20000 });
+        return cards.first();
+    }
+    // AvailableTasks.tsx renders the list through @tanstack/react-virtual, so
+    // only the cards inside the scroll window (plus a five-item overscan) are
+    // in the DOM. A task further down the list is not hidden, it is not
+    // rendered at all, so getByText() keeps reporting "element(s) not found"
+    // however long it waits. Page through the list until the card renders,
+    // wrapping back to the top so the layout's 5s refetch can bring in a task
+    // that was still being indexed.
+    async revealTaskCard(card, name) {
+        const scrollableList = this.availableTasks.getByTestId('scrollable-list');
+        await test_1.expect
+            .poll(async () => {
+            if (await card.isVisible()) {
+                return true;
+            }
+            if (await scrollableList.isVisible()) {
+                await scrollableList.evaluate((list) => {
+                    const maxScrollTop = list.scrollHeight - list.clientHeight;
+                    if (list.scrollTop >= maxScrollTop - 1) {
+                        list.scrollTop = 0;
+                        return;
+                    }
+                    list.scrollTop += Math.max(list.clientHeight - 100, 200);
+                });
+            }
+            return false;
+        }, {
+            timeout: 90000,
+            intervals: [500],
+            message: `Task "${name}" never rendered in the task list`,
+        })
+            .toBe(true);
+    }
+    async assertTaskVisible(name) {
+        await this.revealTaskCard(this.taskCard(name), name);
+    }
+    // Returns the opened task's userTaskKey -- the only identifier that tells
+    // two tasks sharing a name apart.
+    async openTask(name, userTaskName = '') {
+        const card = this.taskCard(name, userTaskName);
+        await this.revealTaskCard(card, name);
+        await card.click({ timeout: 20000 });
+        await this.page.waitForURL(/\/tasklist\/\d+/, { timeout: 30000 });
+        const openedTask = /\/tasklist\/(\d+)/.exec(this.page.url());
+        if (openedTask === null) {
+            throw new Error(`Opening task "${name}" did not open a task`);
+        }
+        return openedTask[1];
     }
     async taskListBannerIsVisible() {
         await (0, test_1.expect)(this.taskListPageBanner).toBeVisible({ timeout: 30000 });
@@ -78,23 +124,44 @@ class TaskPanelPage {
         // appears. Unlike the old Carbon sidebar, the trigger is always visible
         // -- there's no separate expand/collapse step, and selecting an option
         // closes the menu on its own.
-        await (0, test_1.expect)(this.filterSelectButton).toBeVisible({ timeout: 10000 });
-        await this.filterSelectButton.click();
+        //
+        // The trigger also carries the active filter's label, so it doubles as
+        // the "selection applied" signal -- the same one camunda/camunda's own
+        // Filters.test.tsx and TasklistIndex.page.ts assert on. It replaces the
+        // heading the old Carbon panel rendered for the active filter, which the
+        // shadcn panel no longer has.
+        //
+        // TasksLayoutPage renders <Filters disabled={isPending} />, so a task
+        // list refetch landing while the menu is open disables the trigger and
+        // tears the menu down before Radix runs the item's onSelect: the menu
+        // closes but the filter never changes. Re-open and pick again rather
+        // than failing on the first dropped selection.
         const menuItem = this.page.getByRole('menuitem', {
             name: option,
             exact: true,
         });
-        await (0, test_1.expect)(menuItem).toBeVisible({ timeout: 10000 });
-        await menuItem.click();
-        await (0, test_1.expect)(menuItem).toBeHidden({ timeout: 10000 });
-        // The trigger renders the active filter's label, so this confirms the
-        // selection was applied -- the same signal camunda/camunda's own
-        // Filters.test.tsx asserts on the trigger. It replaces the heading the
-        // old Carbon panel rendered for the active filter, which the shadcn
-        // panel no longer has.
-        await (0, test_1.expect)(this.filterSelectButton).toContainText(option, {
-            timeout: 10000,
+        const triggerShowingOption = this.filterSelectButton.filter({
+            hasText: new RegExp(`^${option}$`),
         });
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await (0, test_1.expect)(this.filterSelectButton).toBeEnabled({ timeout: 30000 });
+            await this.filterSelectButton.click();
+            await (0, test_1.expect)(menuItem).toBeVisible({ timeout: 10000 });
+            await menuItem.click();
+            const applied = await triggerShowingOption
+                .waitFor({ state: 'visible', timeout: 15000 })
+                .then(() => true)
+                .catch(() => false);
+            if (applied) {
+                return;
+            }
+            console.warn(`Attempt ${attempt} to apply the "${option}" task filter did not ` +
+                'take effect. Retrying...');
+            await this.page.keyboard.press('Escape');
+            await (0, test_1.expect)(this.filterSelectButton).toHaveAttribute('aria-expanded', 'false', { timeout: 10000 });
+        }
+        throw new Error(`Task filter "${option}" was not applied after ${maxAttempts} attempts`);
     }
 }
 exports.TaskPanelPage = TaskPanelPage;

package/dist/pages/c8Run-8.10/UtilitiesPage.d.ts

@@ -1,7 +1,8 @@
-import { Page, Locator } from '@playwright/test';
+import { APIRequestContext, Page, Locator } from '@playwright/test';
 import { TaskPanelPage } from '../c8Run-8.10/TaskPanelPage';
 import { TaskDetailsPage } from '../c8Run-8.10/TaskDetailsPage';
 export declare function navigateToApp(page: Page, appName: string): Promise<void>;
+export declare function openUserTaskOfProcessInstance(page: Page, request: APIRequestContext, processInstanceKey: string, maxRetries?: number, retryDelayMs?: number): Promise<string>;
 export declare function assertLocatorVisibleWithRetry(page: Page, locator: Locator, text: string, timeout?: number, maxRetries?: number): Promise<void>;
 export declare function validateURL(page: Page, URL: RegExp): Promise<void>;
 export declare function completeTaskWithRetry(taskPanelPage: TaskPanelPage, taskDetailsPage: TaskDetailsPage, taskName: string, taskPriority: string, userTaskName?: string, textInput?: string, maxRetries?: number): Promise<void>;

package/dist/pages/c8Run-8.10/UtilitiesPage.js

@@ -7,13 +7,42 @@
  * except in compliance with the Camunda License 1.0.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.completeTaskWithRetry = exports.validateURL = exports.assertLocatorVisibleWithRetry = exports.navigateToApp = void 0;
+exports.completeTaskWithRetry = exports.validateURL = exports.assertLocatorVisibleWithRetry = exports.openUserTaskOfProcessInstance = exports.navigateToApp = void 0;
 const test_1 = require("@playwright/test");
 const sleep_1 = require("../../utils/sleep");
 async function navigateToApp(page, appName) {
     page.goto('/' + appName.toLowerCase() + '/login');
 }
 exports.navigateToApp = navigateToApp;
+async function openUserTaskOfProcessInstance(page, request, processInstanceKey, maxRetries = 30, retryDelayMs = 2000) {
+    // A task card shows only the task and process display names (Task.tsx in
+    // camunda/camunda), so nothing in the Tasklist UI tells two instances of the
+    // same process apart -- opening "the first card named X" lands on whichever
+    // instance happens to sort first. Resolve the user task of THIS instance
+    // over the v2 API instead (c8Run serves it unauthenticated:
+    // camunda.security.authentication.unprotected-api is true in
+    // c8run/configuration/application.yaml, and api-tests-v2.spec.ts calls
+    // /v2/user-tasks/search the same way) and open it at its own route,
+    // /tasklist/{userTaskKey}. Retrying covers the export lag between creating
+    // the instance and its user task becoming searchable.
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        const response = await request.post('/v2/user-tasks/search', {
+            data: { filter: { processInstanceKey } },
+        });
+        if (response.ok()) {
+            const body = await response.json();
+            const userTaskKey = body?.items?.[0]?.userTaskKey;
+            if (userTaskKey != null) {
+                await page.goto('/tasklist/' + userTaskKey);
+                return String(userTaskKey);
+            }
+        }
+        await (0, sleep_1.sleep)(retryDelayMs);
+    }
+    throw new Error(`No user task found for process instance ${processInstanceKey} after ` +
+        `${maxRetries} attempts.`);
+}
+exports.openUserTaskOfProcessInstance = openUserTaskOfProcessInstance;
 async function assertLocatorVisibleWithRetry(page, locator, text, timeout = 20000, maxRetries = 3) {
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
@@ -42,23 +71,32 @@ exports.validateURL = validateURL;
 async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, taskPriority, userTaskName = '', textInput = '', maxRetries = 5) {
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            await taskPanelPage.openTask(taskName, userTaskName);
-            const openTasksWithName = taskPanelPage.availableTasks.getByText(taskName, { exact: true });
-            const openTaskCount = await openTasksWithName.count();
+            const userTaskKey = await taskPanelPage.openTask(taskName, userTaskName);
             await (0, sleep_1.sleep)(500);
             if (!(await taskDetailsPage.assignedToMeText.isVisible())) {
                 await taskDetailsPage.clickAssignToMeButton();
             }
-            await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible();
+            // The details panel is fetched after the task is opened, so the
+            // priority label can lag the click by more than Playwright's 5s
+            // default expect timeout on a loaded c8Run runner. Every other wait
+            // in this helper already carries an explicit, generous timeout.
+            await (0, test_1.expect)(taskDetailsPage.detailsPanel.getByText(taskPriority)).toBeVisible({ timeout: 30000 });
             if (textInput != '') {
                 await taskDetailsPage.clickTextInput();
                 await taskDetailsPage.fillTextInput(textInput);
             }
             await taskDetailsPage.taskCompletedBanner.waitFor({ state: 'hidden' });
             await taskDetailsPage.clickCompleteTaskButton();
-            await (0, test_1.expect)(openTasksWithName).toHaveCount(openTaskCount - 1, {
-                timeout: 60000,
-            });
+            // clickCompleteTaskButton() already waits for the "Task completed"
+            // banner, so the completion itself is confirmed there. Counting the
+            // open cards that share this task's name cannot confirm it: the list
+            // is virtualised, so the count only ever covers the scrolled-in
+            // window, and any concurrently running copy of this spec completes
+            // tasks with the same name -- the count can stay flat or drop by two,
+            // and a false failure here sends the loop round to open and complete
+            // a second task. Wait for this exact card, keyed on its userTaskKey,
+            // to leave the open list instead.
+            await (0, test_1.expect)(taskPanelPage.availableTasks.locator(`[data-testid="task-${userTaskKey}"]`)).toHaveCount(0, { timeout: 60000 });
             return;
         }
         catch (error) {
@@ -67,7 +105,8 @@ async function completeTaskWithRetry(taskPanelPage, taskDetailsPage, taskName, t
             }
             else {
                 console.error(error);
-                throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                throw new Error(`Completing task ${taskName} failed after ${maxRetries} ` +
+                    `attempts: ${error}`);
             }
         }
     }

package/dist/tests/c8Run-8.10/hto-user-flows.spec.js

@@ -6,6 +6,11 @@ const zeebeClient_1 = require("../../utils/zeebeClient");
 const UtilitiesPage_1 = require("../../pages/c8Run-8.10/UtilitiesPage");
 const sleep_1 = require("../../utils/sleep");
 const _setup_1 = require("../../test-setup.js");
+// The key of the User_Task_Editing_Variables instance this run owns. Operate
+// and Tasklist both resolve that instance by key, so a second live instance of
+// the same process -- another worker, a --repeat-each copy, a leftover from an
+// earlier run -- can no longer be picked up by mistake.
+let variableEditingInstanceKey;
 c8Run_8_10_1.test.beforeAll(async () => {
     await Promise.all([
         (0, zeebeClient_1.deploy)('./resources/User_Task_Editing_Variables.bpmn'),
@@ -15,7 +20,7 @@ c8Run_8_10_1.test.beforeAll(async () => {
         (0, zeebeClient_1.deploy)('./resources/Start_Form_Process.bpmn'),
         (0, zeebeClient_1.deploy)('./resources/Zeebe_User_Task_Process_With_Priority.bpmn'),
     ]);
-    await Promise.all([
+    const [, variableEditingInstances] = await Promise.all([
         (0, zeebeClient_1.createInstances)('Zeebe_User_Task', 1, 1),
         (0, zeebeClient_1.createInstances)('User_Task_Editing_Variables', 1, 1, {
             testVariable: 'testValue',
@@ -24,6 +29,7 @@ c8Run_8_10_1.test.beforeAll(async () => {
         (0, zeebeClient_1.createInstances)('Start_Form_Process', 1, 1),
         (0, zeebeClient_1.createInstances)('Zeebe_User_Task_Process_With_Priority', 1, 1),
     ]);
+    variableEditingInstanceKey = String(variableEditingInstances[0].processInstanceKey);
     await (0, sleep_1.sleep)(5000);
 });
 c8Run_8_10_1.test.describe('HTO User Flow Tests', () => {
@@ -36,13 +42,13 @@ c8Run_8_10_1.test.describe('HTO User Flow Tests', () => {
         await (0, _setup_1.captureScreenshot)(page, testInfo);
         await (0, _setup_1.captureFailureVideo)(page, testInfo);
     });
-    (0, c8Run_8_10_1.test)('User Task Editing Variables Flow', async ({ page, operateHomePage, operateProcessesPage, operateProcessInstancePage, taskPanelPage, taskListLoginPage, operateLoginPage, taskDetailsPage, }) => {
+    (0, c8Run_8_10_1.test)('User Task Editing Variables Flow', async ({ page, request, operateHomePage, operateProcessesPage, operateProcessInstancePage, taskPanelPage, taskListLoginPage, operateLoginPage, taskDetailsPage, }) => {
         await c8Run_8_10_1.test.step('View Process Instance in Operate, Edit the Variable & Assert the Variable is Updated in Tasklist', async () => {
             await (0, UtilitiesPage_1.navigateToApp)(page, 'operate');
             await operateLoginPage.login('demo', 'demo');
             await (0, test_1.expect)(operateHomePage.processesTab).toBeVisible({ timeout: 180000 });
             await operateHomePage.clickProcessesTab();
-            await operateProcessesPage.clickProcessInstanceLink('User_Task_Editing_Variables');
+            await operateProcessesPage.clickProcessInstanceLink('User_Task_Editing_Variables', variableEditingInstanceKey);
             await operateProcessInstancePage.activeIconAssertion();
             await (0, test_1.expect)(page.getByText('"testValue"')).toBeVisible({
                 timeout: 120000,
@@ -63,7 +69,8 @@ c8Run_8_10_1.test.describe('HTO User Flow Tests', () => {
             await (0, sleep_1.sleep)(10000);
             await (0, UtilitiesPage_1.navigateToApp)(page, 'tasklist');
             await taskListLoginPage.login('demo', 'demo');
-            await taskPanelPage.openTask('User_Task_Editing_Variables');
+            await taskPanelPage.taskListBannerIsVisible();
+            await (0, UtilitiesPage_1.openUserTaskOfProcessInstance)(page, request, variableEditingInstanceKey);
             await taskDetailsPage.clickAssignToMeButton();
             await (0, test_1.expect)(page.getByText('Assigning...')).not.toBeVisible({
                 timeout: 90000,
@@ -138,10 +145,10 @@ c8Run_8_10_1.test.describe('HTO User Flow Tests', () => {
             // The shadcn task panel no longer renders the active filter as a
             // heading (filterBy asserts it on the Filters trigger instead), so
             // wait for a completed task to actually appear in the list -- that
-            // also covers the indexing lag before the reload below.
-            await (0, test_1.expect)(taskPanelPage.availableTasks
-                .getByText('priorityTest4', { exact: true })
-                .first()).toBeVisible({ timeout: 45000 });
+            // also covers the indexing lag before the reload below. The list is
+            // virtualised, so this has to page through it rather than wait on a
+            // locator that is simply not rendered yet.
+            await taskPanelPage.assertTaskVisible('priorityTest4');
             await page.reload();
             await (0, sleep_1.sleep)(1000);
             await taskPanelPage.openTask('priorityTest4');

package/package.json

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