@camunda/e2e-test-suite 0.0.1040 → 0.0.1042

package/dist/pages/8.10/UtilitiesPage.js

@@ -100,8 +100,19 @@ async function waitForLoginForm(page, loginPage, totalTimeout = 90000, roundTime
     }
     throw new Error(`Auth0 login form did not render within ${totalTimeout}ms: ${lastState}`);
 }
+// Tracks which worker-derived `timeout` values have already paid the
+// stagger sleep below, so a worker only pays it once per process lifetime
+// rather than on every call -- see the comment at the call site.
+const staggeredWorkerTimeouts = new Set();
 async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5) {
     let lastError;
+    // `timeout` is a stable per-worker identifier (derived from workerIndex),
+    // and a worker is a long-lived process across every test/repeat it runs, so
+    // the stagger below only needs to happen for that worker's first call in
+    // the whole job. A --repeat-each validation pass otherwise pays it on
+    // every repeat instead of just the first (team-test-automation#78).
+    const isWorkersFirstCall = !staggeredWorkerTimeouts.has(timeout);
+    staggeredWorkerTimeouts.add(timeout);
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
             await page.context().clearCookies();
@@ -150,7 +161,9 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
             await page
                 .waitForLoadState('networkidle', { timeout: 30000 })
                 .catch(() => { });
-            await (0, sleep_1.sleep)(timeout);
+            if (isWorkersFirstCall) {
+                await (0, sleep_1.sleep)(timeout);
+            }
             await waitForLoginForm(page, loginPage);
             await loginPage.loginWithTestUser(testUser);
             return;

package/dist/pages/8.7/UtilitiesPage.js

@@ -7,11 +7,28 @@ const HomePage_1 = require("./HomePage");
 const sleep_1 = require("../../utils/sleep");
 const fileUpload_1 = require("../../utils/fileUpload");
 const mailSlurpClient_1 = require("../../utils/mailSlurpClient");
+// Tracks which worker-derived `timeout` values have already paid the
+// pre-flight stagger below, so a worker only pays it once per process
+// lifetime rather than on every call -- see the comment at the call sites.
+const staggeredWorkerTimeouts = new Set();
 async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5, skipOrgAssertion = false) {
+    // Callers derive `timeout` as (workerIndex + 1) * 1000, so it's a stable
+    // per-worker identifier: a Playwright worker is a long-lived process that
+    // calls loginWithRetry once per test/repeat it runs, and this stagger only
+    // needs to happen for that worker's FIRST call in the whole job -- by the
+    // time it calls again, it's no longer starting simultaneously with anyone
+    // else's first call, which is the only scenario the stagger protects
+    // against. Without this, a --repeat-each validation pass pays the full
+    // stagger on every single repeat instead of once, which is pure dead time
+    // on the critical path (team-test-automation#78).
+    const isWorkersFirstCall = !staggeredWorkerTimeouts.has(timeout);
+    staggeredWorkerTimeouts.add(timeout);
     // Pre-flight worker stagger: spread the initial Auth0 hits across parallel
     // workers BEFORE the first goto, otherwise all workers slam the tenant at
     // the same instant and several get throttled into the retry loop.
-    await (0, sleep_1.sleep)(timeout);
+    if (isWorkersFirstCall) {
+        await (0, sleep_1.sleep)(timeout);
+    }
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
             await page.context().clearCookies();
@@ -36,7 +53,9 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
             await page
                 .waitForLoadState('networkidle', { timeout: 30000 })
                 .catch(() => { });
-            await (0, sleep_1.sleep)(timeout);
+            if (isWorkersFirstCall) {
+                await (0, sleep_1.sleep)(timeout);
+            }
             // Always detect SSO re-auth: after a logout + clearCookies, Auth0 may
             // silently log the previous user back in without showing the login form.
             // Force logout until the Auth0 email input appears.

package/dist/pages/8.8/UtilitiesPage.js

@@ -32,14 +32,26 @@ async function forceLogoutIfNeeded(page) {
     }
 }
 exports.forceLogoutIfNeeded = forceLogoutIfNeeded;
+// Tracks which worker-derived `timeout` values have already paid the
+// pre-flight stagger below, so a worker only pays it once per process
+// lifetime rather than on every call -- see the comment at the call site.
+const staggeredWorkerTimeouts = new Set();
 async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5) {
     let lastError;
     // Stagger the first navigation across parallel workers. Without this, every
     // worker's initial page.goto('/') fires within the same second -- with 18+
     // workers logging in at once, that burst is enough to make the navigation
     // itself time out well before any login form ever renders. Retries already
-    // back off via randomSleep below, so this only needs to run once.
-    await (0, sleep_1.sleep)(timeout);
+    // back off via randomSleep below, so this only needs to run once -- and,
+    // since `timeout` is a stable per-worker identifier (derived from
+    // workerIndex) and a worker is a long-lived process across every
+    // test/repeat it runs, "once" means once per worker for the whole job, not
+    // once per call. A --repeat-each validation pass otherwise pays this on
+    // every repeat instead of just the first (team-test-automation#78).
+    if (!staggeredWorkerTimeouts.has(timeout)) {
+        staggeredWorkerTimeouts.add(timeout);
+        await (0, sleep_1.sleep)(timeout);
+    }
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
             await page.context().clearCookies();

package/dist/pages/8.9/UtilitiesPage.js

@@ -8,8 +8,19 @@ const sleep_1 = require("../../utils/sleep");
 const randomSleep_1 = require("../../utils/randomSleep");
 const fileUpload_1 = require("../../utils/fileUpload");
 const mailSlurpClient_1 = require("../../utils/mailSlurpClient");
+// Tracks which worker-derived `timeout` values have already paid the
+// stagger sleep below, so a worker only pays it once per process lifetime
+// rather than on every call -- see the comment at the call site.
+const staggeredWorkerTimeouts = new Set();
 async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5) {
     let lastError;
+    // `timeout` is a stable per-worker identifier (derived from workerIndex),
+    // and a worker is a long-lived process across every test/repeat it runs, so
+    // the stagger below only needs to happen for that worker's first call in
+    // the whole job. A --repeat-each validation pass otherwise pays it on
+    // every repeat instead of just the first (team-test-automation#78).
+    const isWorkersFirstCall = !staggeredWorkerTimeouts.has(timeout);
+    staggeredWorkerTimeouts.add(timeout);
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
             await page.context().clearCookies();
@@ -34,7 +45,9 @@ async function loginWithRetry(page, loginPage, testUser, timeout, maxRetries = 5
             await page
                 .waitForLoadState('networkidle', { timeout: 30000 })
                 .catch(() => { });
-            await (0, sleep_1.sleep)(timeout);
+            if (isWorkersFirstCall) {
+                await (0, sleep_1.sleep)(timeout);
+            }
             // The identity provider occasionally returns a generic error / rate
             // limit page that has none of the usual auth controls. Bail out early
             // when that page is visible so the outer retry can back off.

package/dist/pages/SM-8.10/Authorization.d.ts

@@ -29,6 +29,8 @@ declare class Authorization {
         resourceId: string;
         accessPermissions: string[];
     }): Promise<void>;
+    private expectAuthorizationListed;
+    private filterAuthorizationsByOwner;
     deleteAuthorization(resourceId: string, resourceType: string): Promise<void>;
 }
 export { Authorization };

package/dist/pages/SM-8.10/Authorization.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Authorization = void 0;
 const test_1 = require("@playwright/test");
 const UtilitiesPage_1 = require("../SM-8.10/UtilitiesPage");
+const findLocatorWithPagination_1 = require("../../utils/assertionHelpers/findLocatorWithPagination");
 const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
 const sleep_1 = require("../../utils/sleep");
 class Authorization {
@@ -89,7 +90,13 @@ class Authorization {
             this.deleteAuthorizationModal.getByRole('button', {
                 name: /delete authorization/i,
             });
-        this.tableFilter = page.getByRole('searchbox', { name: 'Filter table' });
+        // Carbon labels the table toolbar search "Filter table"; the
+        // design-system shell the Admin is migrating onto exposes the placeholder
+        // as the accessible name instead. Match either.
+        this.tableFilter = page
+            .getByRole('searchbox', { name: 'Filter table' })
+            .or(page.getByRole('searchbox', { name: 'Search by owner ID' }))
+            .first();
     }
     // Released 8.10 alpha images still render the Carbon combobox that lists
     // every owner, so accept whichever owner field this build shows.
@@ -162,14 +169,81 @@ class Authorization {
         }
         await (0, submitModalWithRetry_1.submitModalWithRetry)(this.createAuthorizationSubmitButton, this.createAuthorizationModal);
         await this.selectResourceTypeTab(authorization.resourceType).click();
-        const item = this.page.getByRole('row').filter({
+        const item = this.page
+            .getByRole('row')
+            .filter({
             hasText: `${authorization.ownerId}${authorization.resourceId}`,
-        });
-        await this.tableFilter.click();
-        await this.tableFilter.fill(authorization.resourceType);
-        await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(this.page, item, authorization.resourceType, 5000, false, 10, this.selectResourceTypeTab(authorization.resourceType));
+        })
+            .first();
+        await this.expectAuthorizationListed(authorization, item);
+    }
+    // The toolbar search filters by owner ID, so filling it with the resource
+    // type narrowed nothing, and the retry helper it fed reloads before it
+    // asserts, which dropped the filter entirely. That left the new row to be
+    // found on page 1 of the unfiltered table - and the authorizations table
+    // paginates, so with the RBA specs creating owners in parallel it is
+    // regularly on a later page. Filter by owner, then page through what is
+    // left; fall back to the unfiltered table for builds whose search has not
+    // caught up with a just-created owner yet.
+    async expectAuthorizationListed(authorization, item) {
+        const deadline = Date.now() + 180000;
+        const budget = (max) => Math.max(5000, Math.min(max, deadline - Date.now()));
+        const maxAttempts = 5;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (attempt > 0 && Date.now() >= deadline) {
+                break;
+            }
+            try {
+                const resourceTab = this.selectResourceTypeTab(authorization.resourceType);
+                await (0, test_1.expect)(resourceTab).toBeVisible({ timeout: budget(30000) });
+                await resourceTab.click({ timeout: budget(30000) });
+                for (const filterValue of [authorization.ownerId, '']) {
+                    await this.filterAuthorizationsByOwner(filterValue);
+                    const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, item, {
+                        timeout: budget(filterValue === '' ? 45000 : 15000),
+                    });
+                    if (found) {
+                        await (0, test_1.expect)(item).toBeVisible({ timeout: 5000 });
+                        return;
+                    }
+                }
+                throw new Error(`No row for owner "${authorization.ownerId}" and resource ` +
+                    `"${authorization.resourceId}" in the ` +
+                    `${authorization.resourceType} table`);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts - 1) {
+                    console.warn(`Attempt ${attempt + 1} did not list the ` +
+                        `${authorization.resourceType} authorization for ` +
+                        `"${authorization.ownerId}". Retrying...`);
+                    await this.page.reload();
+                    await this.page.waitForLoadState('domcontentloaded');
+                }
+            }
+        }
+        throw new Error(`Authorization for "${authorization.ownerId}" on ` +
+            `"${authorization.resourceId}" was not listed: ${String(lastError)}`);
+    }
+    async filterAuthorizationsByOwner(ownerId) {
+        const hasFilter = await this.tableFilter
+            .isVisible({ timeout: 5000 })
+            .catch(() => false);
+        if (!hasFilter) {
+            return;
+        }
+        await this.tableFilter.fill(ownerId);
+        await (0, sleep_1.sleep)(1000);
     }
     async deleteAuthorization(resourceId, resourceType) {
+        // Same paginated table as createAuthorization: the row being deleted is
+        // not necessarily on page 1, and the toolbar search cannot narrow by
+        // resource ID.
+        const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, this.deleteAuthorizationButton(resourceId), { timeout: 60000 });
+        if (!found) {
+            throw new Error(`No ${resourceType} authorization row for resource "${resourceId}"`);
+        }
         await this.deleteAuthorizationButton(resourceId).click();
         await (0, test_1.expect)(this.deleteAuthorizationModal).toBeVisible();
         await this.deleteAuthorizationModalDeleteButton.click();

package/dist/pages/SM-8.10/OCIdentityMappingRulesPage.js

@@ -29,9 +29,14 @@ class OCIdentityMappingRulesPage {
         this.deleteMappingRuleDialog = page.getByRole('dialog', {
             name: 'Delete Mapping rule',
         });
-        this.filterTableSearchbox = page.getByRole('searchbox', {
-            name: 'Filter table',
-        });
+        // The design-system Admin shell replaced Carbon's table toolbar search
+        // (labelled "Filter table") with an input whose aria-label is its
+        // placeholder, so match the new shell first and fall back to the legacy
+        // one - the same dual-shell pattern the Admin nav locators use.
+        this.filterTableSearchbox = page
+            .getByRole('searchbox', { name: 'Search by mapping rule ID' })
+            .or(page.getByRole('searchbox', { name: 'Filter table' }))
+            .first();
         this.deleteMappingRuleButton = this.deleteMappingRuleDialog
             .getByRole('button', {
             name: 'Delete Mapping rule',

package/dist/pages/SM-8.10/OCIdentityRolesPage.js

@@ -172,6 +172,16 @@ class OCIdentityRolesPage {
     async deleteRole(name, options) {
         const { throwError = true } = options || {};
         try {
+            // The roles table paginates at 10 rows and the RBA specs run in
+            // parallel against a cluster that already ships six built-in roles, so
+            // a role created by this test is regularly on page 2 by the time it is
+            // deleted. Without walking the pages the row - and therefore its Delete
+            // button - simply never resolves, which is what the 10s click timeout
+            // reported.
+            const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, this.deleteRoleButton(name), { timeout: 30000 });
+            if (!found) {
+                throw new Error(`Role "${name}" was not found on any page of the roles table`);
+            }
             await this.deleteRoleButton(name).click();
             await (0, test_1.expect)(this.deleteRoleModal).toBeVisible();
             await this.deleteRoleModalDeleteButton.click();

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

@@ -25,6 +25,7 @@ if (node_process_1.default.env.IS_RBA === 'true') {
             await navigationPage.goToOCAdmin();
             const ids = idsToBeDeleted[testInfo.title];
             if (ids['mappingIds'].length > 0) {
+                await ocIdentityHomePage.clickMappingRulesTab();
                 for (const id of ids['mappingIds']) {
                     await ocIdentityMappingRulesPage.deleteMappingRule(id);
                 }

package/package.json

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