@camunda/e2e-test-suite 0.0.1233 → 0.0.1235

package/dist/pages/8.10/OCIdentityHomePage.d.ts

@@ -12,6 +12,7 @@ declare class OCIdentityHomePage {
     readonly licenseKeyTagCommercial: Locator;
     readonly noPermissionsMessage: Locator;
     constructor(page: Page);
+    private openTab;
     clickAuthorizationsTab(): Promise<void>;
     clickRolesTab(): Promise<void>;
     clickGroupsTab(): Promise<void>;

package/dist/pages/8.10/OCIdentityHomePage.js

@@ -73,21 +73,35 @@ class OCIdentityHomePage {
         this.licenseKeyTagCommercial = page.getByText('Commercial license');
         this.noPermissionsMessage = page.getByText('You don’t have access to this component');
     }
+    // Every caller arrives here from somewhere else in Admin -- a role detail
+    // page that was just reloaded, a freshly dismissed modal -- and the default
+    // retry gives the sidebar three 10s looks with no recovery between them.
+    // That is the whole budget a hand-off has if the SPA is still re-rendering
+    // its shell, and when it runs out the run reports "Failed to assert
+    // visibility locator ... 'Authorizations' ... after 3 attempts" for a nav
+    // that is permanently part of the page. Look longer, and reload between
+    // attempts so a shell that never finished painting gets another chance
+    // instead of being polled in the same broken state three times.
+    async openTab(tab) {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, tab, {
+            visibilityTimeout: 20000,
+            postAction: async () => {
+                await this.page.reload();
+            },
+        });
+        await tab.click({ timeout: 30000 });
+    }
     async clickAuthorizationsTab() {
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.authorizationsTab);
-        await this.authorizationsTab.click({ timeout: 30000 });
+        await this.openTab(this.authorizationsTab);
     }
     async clickRolesTab() {
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.rolesTab);
-        await this.rolesTab.click({ timeout: 30000 });
+        await this.openTab(this.rolesTab);
     }
     async clickGroupsTab() {
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.groupsTab);
-        await this.groupsTab.click({ timeout: 30000 });
+        await this.openTab(this.groupsTab);
     }
     async clickClusterVariablesTab() {
-        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.clusterVariablesTab);
-        await this.clusterVariablesTab.click({ timeout: 30000 });
+        await this.openTab(this.clusterVariablesTab);
     }
 }
 exports.OCIdentityHomePage = OCIdentityHomePage;

package/dist/pages/8.10/OCIdentityRolesPage.d.ts

@@ -25,7 +25,9 @@ declare class OCIdentityRolesPage {
     readonly assignUserModal: Locator;
     readonly assignUserModalInputField: Locator;
     readonly assignUserModalAssignButton: Locator;
+    readonly roleSearchBox: Locator;
     constructor(page: Page);
+    private searchForRole;
     clickMappingRulesTab(): Promise<void>;
     clickRole(roleID: string): Promise<void>;
     assignMappingRuleToRole(roleId: string, mappingId: string): Promise<void>;

package/dist/pages/8.10/OCIdentityRolesPage.js

@@ -30,6 +30,7 @@ class OCIdentityRolesPage {
     assignUserModal;
     assignUserModalInputField;
     assignUserModalAssignButton;
+    roleSearchBox;
     constructor(page) {
         this.page = page;
         this.rolesList = page.getByRole('table');
@@ -105,6 +106,25 @@ class OCIdentityRolesPage {
         this.assignUserModalAssignButton = this.assignUserModal.getByRole('button', {
             name: /assign user/i,
         });
+        // Both role-list shapes render this filter with the same placeholder:
+        // camunda/camunda identity/client/src/pages/roles/List.tsx (Carbon
+        // TableToolbarSearch) and ListV2.tsx (design-system SearchInput) each pass
+        // `searchPlaceholder={t("searchByRoleId")}`. Only V2 mirrors it into an
+        // aria-label, so match on the placeholder to cover both.
+        this.roleSearchBox = page.getByPlaceholder('Search by role ID');
+    }
+    // The roles list is server-side paginated at 10 rows per page, and these
+    // long-lived RBA clusters accumulate a role per test run -- the org that
+    // failed was already at "Page 6 of 6". A freshly created role sorts to the
+    // end, so `findLocatorWithPagination` has to walk every page one request at
+    // a time and exhausts its 30s budget before it arrives, reporting a role
+    // that is plainly on screen as missing. Both list shapes pass
+    // `searchKey="roleId"` with the default `eq` operator, so filtering queries
+    // the backend for that exact role and puts it on page 1.
+    async searchForRole(roleId) {
+        await (0, test_1.expect)(this.roleSearchBox).toBeVisible({ timeout: 60000 });
+        await this.roleSearchBox.fill(roleId, { timeout: 30000 });
+        await (0, test_1.expect)(this.roleSearchBox).toHaveValue(roleId, { timeout: 30000 });
     }
     async clickMappingRulesTab() {
         await (0, test_1.expect)(this.selectResourceTypeTab('Mapping Rules')).toBeVisible({
@@ -113,6 +133,7 @@ class OCIdentityRolesPage {
         await this.selectResourceTypeTab('Mapping Rules').click();
     }
     async clickRole(roleID) {
+        await this.searchForRole(roleID);
         await (0, test_1.expect)(this.roleCell(roleID).first()).toBeVisible({ timeout: 60000 });
         await this.roleCell(roleID).first().click();
     }
@@ -149,11 +170,21 @@ class OCIdentityRolesPage {
         await this.createNameField.fill(role.name);
         await this.createRoleModalCreateButton.click();
         await (0, test_1.expect)(this.createRoleModal).not.toBeVisible({ timeout: 30000 });
-        await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, this.rolesList
+        await this.searchForRole(role.id);
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.rolesList
             .getByRole('cell', {
             name: role.name,
         })
-            .first());
+            .first(), {
+            visibilityTimeout: 20000,
+            postAction: async () => {
+                // The filter is component state, not a URL param, so a reload drops
+                // it -- re-apply it or the retry falls back to the page walk this
+                // whole approach exists to avoid.
+                await this.page.reload();
+                await this.searchForRole(role.id);
+            },
+        });
     }
     async assignMappingToRole(role, mappingRuleId) {
         try {
@@ -169,8 +200,12 @@ class OCIdentityRolesPage {
         await (0, test_1.expect)(this.rowValue(mappingRuleId)).toContainText(`${mappingRuleId}`);
     }
     async assignUserToRole(role, email) {
+        // Filter before probing for the role: unfiltered, this only ever sees the
+        // ten rows of page 1, so an existing role further down the list reads as
+        // missing and we try to create it a second time.
+        await this.searchForRole(role);
         try {
-            await (0, test_1.expect)(this.page.getByText(role).first()).toBeVisible({
+            await (0, test_1.expect)(this.roleCell(role).first()).toBeVisible({
                 timeout: 10000,
             });
         }
@@ -186,6 +221,7 @@ class OCIdentityRolesPage {
         });
     }
     async deleteRole(name) {
+        await this.searchForRole(name);
         const locator = this.deleteRoleButton(name);
         await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, locator);
         await locator.click();

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

@@ -17,7 +17,7 @@ declare class TaskPanelPage {
     private openFilterControls;
     private collapseFilterPanel;
     private static appliedFilter;
-    taskCount(name: string): Promise<number>;
+    taskCount(name: string, expectedCount?: number): Promise<number>;
     clickTasksTab(): Promise<void>;
     scrollToLastTask(name: string): Promise<void>;
     scrollToFirstTask(name: string): Promise<void>;

package/dist/pages/8.10/TaskPanelPage.js

@@ -190,9 +190,37 @@ class TaskPanelPage {
         const param = filterParam[option] ?? null;
         return (url) => url.searchParams.get('filter') === param;
     }
-    async taskCount(name) {
-        await (0, sleep_1.sleep)(20000);
-        return this.availableTasks.getByText(name, { exact: true }).count();
+    // `expectedCount` turns the single fixed-delay sample into a poll. Tasklist
+    // only lists a task once the exporter has indexed the instance, and on these
+    // long-lived SaaS RBA clusters that routinely lags past the 20s wait -- the
+    // count then comes back one short and the caller's `toBe(before + 1)` fails
+    // on a task that does arrive moments later. Callers that have no expectation
+    // yet (the baseline read taken before starting a process) still get the
+    // fixed wait. The count returned is always the real one, so a task that
+    // genuinely never appears still fails the caller's assertion.
+    async taskCount(name, expectedCount) {
+        const tasks = this.availableTasks.getByText(name, { exact: true });
+        if (expectedCount === undefined) {
+            await (0, sleep_1.sleep)(20000);
+            return tasks.count();
+        }
+        // Re-reading the same rendered list only finds the new task if the panel
+        // refetches while we wait, and the sample that failed sat on 1 of an
+        // expected 2 for the whole budget -- the instance was started, the
+        // exporter published its task afterwards, and the view never asked again.
+        // Reload between samples so each one is an actual query rather than a
+        // re-count of the DOM we already had. The count returned is still the
+        // real one, so a task that genuinely never arrives still fails the
+        // caller's assertion.
+        const deadline = Date.now() + 180000;
+        let count = await tasks.count();
+        while (count !== expectedCount && Date.now() < deadline) {
+            await (0, sleep_1.sleep)(5000);
+            await this.page.reload();
+            await (0, test_1.expect)(this.availableTasks).toBeVisible({ timeout: 60000 });
+            count = await tasks.count();
+        }
+        return count;
     }
     async clickTasksTab() {
         await (0, test_1.expect)(this.tasksTab).toBeVisible({ timeout: 60000 });

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

@@ -11,6 +11,7 @@ declare class OperateProcessInstancePage {
     constructor(page: Page);
     connectorResultVariableName(name: string): Promise<Locator>;
     connectorResultVariableValue(variableName: string): Promise<Locator>;
+    private assertInstanceStatusIcon;
     completedIconAssertion(): Promise<void>;
     activeIconAssertion(): Promise<void>;
     getProcessVariableValue(variableName: string): Promise<Locator>;

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

@@ -32,45 +32,47 @@ class OperateProcessInstancePage {
     async connectorResultVariableValue(variableName) {
         return await this.page.getByTestId(variableName).locator('td').last();
     }
-    async completedIconAssertion() {
-        let retryCount = 0;
-        const maxRetries = 6;
-        while (retryCount < maxRetries) {
+    // The instance header renders the status the instance had when the page was
+    // loaded, so a status that flips afterwards -- ACTIVE once the instance is
+    // exported, COMPLETED once the last task finishes -- only becomes visible on
+    // a reload. Sitting out a 60-90s per-attempt timeout before reloading
+    // therefore buys nothing: the page under the wait can no longer change. Poll
+    // on a short cadence and reload between polls instead, so the status is
+    // picked up shortly after it lands rather than at the next minute boundary.
+    //
+    // The per-attempt timeout escalates rather than staying at its opening
+    // value: on a loaded c8Run runner the instance page itself can take longer
+    // than the first interval to render, and a fixed short interval would keep
+    // reloading a page that was about to show the icon. `deadlineMs` bounds the
+    // whole assertion, so a status that never arrives still fails after at least
+    // as long as the retry loop this replaces waited.
+    async assertInstanceStatusIcon(icon, status, deadlineMs) {
+        const attemptTimeouts = [15000, 15000, 30000, 30000, 60000];
+        const deadline = Date.now() + deadlineMs;
+        let attempt = 0;
+        let lastError;
+        while (Date.now() < deadline) {
             try {
-                await (0, test_1.expect)(this.completedIcon).toBeVisible({
-                    timeout: 60000,
+                await (0, test_1.expect)(icon).toBeVisible({
+                    timeout: attemptTimeouts[Math.min(attempt, attemptTimeouts.length - 1)],
                 });
-                return; // Exit the function if the expectation is met
+                return;
             }
             catch (error) {
-                // If the active icon isn't found, reload the page and try again
-                retryCount++;
-                console.log(`Attempt ${retryCount} failed. Retrying...`);
+                lastError = error;
+                attempt++;
+                console.log(`${status} icon not visible yet (attempt ${attempt}). Reloading...`);
                 await this.page.reload();
-                await (0, sleep_1.sleep)(10000);
             }
         }
-        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+        throw new Error(`${status} icon not visible after ${deadlineMs}ms and ${attempt} ` +
+            `reload(s): ${String(lastError)}`);
+    }
+    async completedIconAssertion() {
+        await this.assertInstanceStatusIcon(this.completedIcon, 'COMPLETED', 420000);
     }
     async activeIconAssertion() {
-        let retryCount = 0;
-        const maxRetries = 3;
-        while (retryCount < maxRetries) {
-            try {
-                await (0, test_1.expect)(this.activeIcon).toBeVisible({
-                    timeout: 90000,
-                });
-                return; // Exit the function if the expectation is met
-            }
-            catch (error) {
-                // If the active icon isn't found, reload the page and try again
-                retryCount++;
-                console.log(`Attempt ${retryCount} failed. Retrying...`);
-                await this.page.reload();
-                await (0, sleep_1.sleep)(10000);
-            }
-        }
-        throw new Error(`Active icon not visible after ${maxRetries} attempts.`);
+        await this.assertInstanceStatusIcon(this.activeIcon, 'ACTIVE', 300000);
     }
     async getProcessVariableValue(variableName) {
         return await this.page

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

@@ -97,11 +97,10 @@ class OperateProcessesPage {
                 return; // Exit the function if the click is successful
             }
             catch (error) {
-                // If process isn't found, reload the page and try again
+                // The next iteration opens with its own reload, so reloading and
+                // sleeping here only parks the worker for 10s on top of it.
                 retryCount++;
                 console.log(`Attempt ${retryCount} failed. Retrying...`);
-                await this.page.reload();
-                await (0, sleep_1.sleep)(10000);
             }
         }
         throw new Error(`Failed to click on process instance link after ${maxRetries} attempts.`);

package/dist/tests/8.10/rba-enabled-v2-user-flows.spec.js

@@ -39,10 +39,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
         const process1 = processName + '1';
         const process2 = processName + '2';
         const role = `rbaNoPermission${randomString}`;
-        const testUser = {
-            username: process.env.C8_USERNAME_TEST_4,
-            password: process.env.C8_PASSWORD_TEST_4,
-        };
+        const testUser = (0, users_1.requireTestUser)('C8_USERNAME_TEST_4');
         await _8_10_1.test.step('Navigate to OC Identity and Assign User To A Role', async () => {
             await appsPage.clickCamundaApps();
             await appsPage.clickAdmin(clusterName);
@@ -149,10 +146,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
         const process2 = processName + '2';
         const role1 = `rbaOnePerm${randomString}1`;
         const role2 = `rbaOnePerm${randomString}2`;
-        const testUser = {
-            username: process.env.C8_USERNAME_TEST_6,
-            password: process.env.C8_PASSWORD_TEST_6,
-        };
+        const testUser = (0, users_1.requireTestUser)('C8_USERNAME_TEST_6');
         await _8_10_1.test.step('Navigate to OC Identity and Assign User To Two Roles', async () => {
             await appsPage.clickCamundaApps();
             await appsPage.clickAdmin(clusterName);
@@ -365,7 +359,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
             const firstProcessTaskCount = await taskPanelPage.taskCount(process1);
             await taskPanelPage.clickProcessesTab();
             await taskProcessesPage.startProcess(process1);
-            const updatedFirstProcessTaskCount = await taskPanelPage.taskCount(process1);
+            const updatedFirstProcessTaskCount = await taskPanelPage.taskCount(process1, firstProcessTaskCount + 1);
             (0, test_1.expect)(updatedFirstProcessTaskCount).toBe(firstProcessTaskCount + 1);
         });
         await _8_10_1.test.step('Assert Second Process Can Be Started From Tasklist', async () => {
@@ -373,7 +367,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
             const secondProcessTaskCount = await taskPanelPage.taskCount(process2);
             await taskPanelPage.clickProcessesTab();
             await taskProcessesPage.startProcess(process2);
-            const updatedSecondProcessTaskCount = await taskPanelPage.taskCount(process2);
+            const updatedSecondProcessTaskCount = await taskPanelPage.taskCount(process2, secondProcessTaskCount + 1);
             (0, test_1.expect)(updatedSecondProcessTaskCount).toBe(secondProcessTaskCount + 1);
         });
         await _8_10_1.test.step('Navigate to Operate and Assert Both Processes Are Accessible', async () => {
@@ -395,10 +389,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
         const role = `rbaSelectedProcessesPermission${randomString}`;
         const process1 = processName + '1';
         const process2 = processName + '2';
-        const testUser = {
-            username: process.env.C8_USERNAME_TEST_5,
-            password: process.env.C8_PASSWORD_TEST_5,
-        };
+        const testUser = (0, users_1.requireTestUser)('C8_USERNAME_TEST_5');
         await _8_10_1.test.step('Navigate to OC Identity and Assign User To A Role', async () => {
             await appsPage.clickCamundaApps();
             await appsPage.clickAdmin(clusterName);
@@ -470,7 +461,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
             const firstProcessTaskCount = await taskPanelPage.taskCount(process1);
             await taskPanelPage.clickProcessesTab();
             await taskProcessesPage.startProcess(process1);
-            const updatedFirstProcessTaskCount = await taskPanelPage.taskCount(process1);
+            const updatedFirstProcessTaskCount = await taskPanelPage.taskCount(process1, firstProcessTaskCount + 1);
             (0, test_1.expect)(updatedFirstProcessTaskCount).toBe(firstProcessTaskCount + 1);
         });
         await _8_10_1.test.step('Assert Second Process Can Be Started From Tasklist', async () => {
@@ -478,7 +469,7 @@ _8_10_1.test.describe.parallel('RBA Enabled User Flows Test @tasklistV2', () =>
             const secondProcessTaskCount = await taskPanelPage.taskCount(process2);
             await taskPanelPage.clickProcessesTab();
             await taskProcessesPage.startProcess(process2);
-            const updatedSecondProcessTaskCount = await taskPanelPage.taskCount(process2);
+            const updatedSecondProcessTaskCount = await taskPanelPage.taskCount(process2, secondProcessTaskCount + 1);
             (0, test_1.expect)(updatedSecondProcessTaskCount).toBe(secondProcessTaskCount + 1);
         });
         await _8_10_1.test.step('Navigate to Operate and Assert Both Processes Are Accessible', async () => {

package/dist/utils/users.d.ts

@@ -100,3 +100,7 @@ export declare function getTestUsers(): ({
     username: string;
     password: string;
 })[];
+export declare function requireTestUser(usernameVar: string): {
+    username: string;
+    password: string;
+};

package/dist/utils/users.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTestUsers = exports.getTestUser = exports.smokeTestUsers = exports.testUsers = void 0;
+exports.requireTestUser = exports.getTestUsers = exports.getTestUser = exports.smokeTestUsers = exports.testUsers = void 0;
 exports.testUsers = {
     mainUser: {
         username: process.env.C8_USERNAME,
@@ -115,3 +115,37 @@ function getTestUsers() {
     return [exports.testUsers.mainUser];
 }
 exports.getTestUsers = getTestUsers;
+// Specs that exercise a *restricted* user reach for a numbered credential
+// slot directly rather than through getTestUser. The SaaS organisation a run
+// gets is sized by grepping the spec for the slots it names
+// (scripts/flakiness-saas-create-org.sh), so when a slot is missed the
+// variable is simply absent -- and `process.env.C8_USERNAME_TEST_4!` then
+// hands `undefined` to whatever consumes it next. Run 35494241466 spent 150
+// of its 152 repeats that way: roughly twenty minutes each to reach the
+// assign-user modal and die on "locator.fill: value: expected string, got
+// undefined", an error that names neither the slot nor the org that lacks it.
+//
+// Resolve the pair here instead, so a slot the org was never given is
+// reported in one second and by name. Callers pass the username variable as
+// a literal so the org-sizing grep above still sees it in the spec.
+//
+// There is deliberately no fallback to mainUser of the kind getTestUser has:
+// mainUser is the organisation owner, and an RBA flow that runs its
+// "restricted" user as the owner would assert nothing.
+function requireTestUser(usernameVar) {
+    const passwordVar = usernameVar.replace('USERNAME', 'PASSWORD');
+    const username = process.env[usernameVar];
+    const password = process.env[passwordVar];
+    const missing = [
+        username ? null : usernameVar,
+        password ? null : passwordVar,
+    ].filter(Boolean);
+    if (missing.length > 0) {
+        throw new Error(`Test user credentials are not set: ${missing.join(', ')}. The ` +
+            'organisation for this run was created without that user slot -- ' +
+            'see scripts/flakiness-saas-create-org.sh, which sizes the org from ' +
+            'the slots the spec names.');
+    }
+    return { username: username, password: password };
+}
+exports.requireTestUser = requireTestUser;

package/package.json

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