@camunda/e2e-test-suite 0.0.906 → 0.0.908

package/dist/pages/8.8/ClusterSecretsPage.d.ts

@@ -33,12 +33,14 @@ declare class ClusterSecretsPage {
         name: string;
         value: string;
     }[]): Promise<void>;
+    reopenConnectorSecretsTab(cluster: string): Promise<void>;
+    assertSecretsToolbarVisible(cluster: string): Promise<void>;
     assertSecretsOrCreate(cluster: string, secrets: {
         name: string;
         value: string;
     }[]): Promise<void>;
-    clickImportButton(): Promise<void>;
-    bulkImportSecrets(secrets: {
+    clickImportButton(cluster: string): Promise<void>;
+    bulkImportSecrets(cluster: string, secrets: {
         name: string;
         value: string;
     }[]): Promise<void>;

package/dist/pages/8.8/ClusterSecretsPage.js

@@ -169,9 +169,33 @@ class ClusterSecretsPage {
         });
     }
     async createSetOfSecrets(cluster, secrets) {
-        await this.bulkImportSecrets(secrets);
+        await this.bulkImportSecrets(cluster, secrets);
         await this.assertSecretsOrCreate(cluster, secrets);
     }
+    // The Connector Secrets panel renders "Oops ... something went wrong" as soon
+    // as one of its Console API calls is rejected (the org-wide rate limit answers
+    // 429 under the nightly's worker count), and reloading from that state can
+    // land on the Console SPA's global "An error has occurred" page, which never
+    // renders the secrets toolbar again. Re-enter the tab from the Clusters list
+    // instead of reloading in place, so recovery does not depend on the broken
+    // page's own client-side state.
+    async reopenConnectorSecretsTab(cluster) {
+        await this.page.goto('/');
+        await this.clickClusterBanner();
+        await this.clickCluster(cluster);
+        await (0, test_1.expect)(this.clusterSecretTab).toBeVisible({ timeout: 30000 });
+        await this.clusterSecretTab.click({ timeout: 30000 });
+    }
+    async assertSecretsToolbarVisible(cluster) {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.createNewSecretButton, {
+            visibilityTimeout: 60000,
+            totalTimeout: 300000,
+            maxRetries: 3,
+            postAction: async () => {
+                await this.reopenConnectorSecretsTab(cluster);
+            },
+        });
+    }
     async assertSecretsOrCreate(cluster, secrets) {
         for (const secret of secrets) {
             try {
@@ -189,19 +213,29 @@ class ClusterSecretsPage {
             }
         }
     }
-    async clickImportButton() {
-        await (0, test_1.expect)(this.importButton).toBeVisible({ timeout: 30000 });
+    async clickImportButton(cluster) {
+        // Same broken-panel state as assertSecretsToolbarVisible guards against:
+        // when the secrets panel failed to load, Import is simply absent, and only
+        // re-entering the tab brings it back.
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.importButton, {
+            visibilityTimeout: 30000,
+            totalTimeout: 180000,
+            maxRetries: 3,
+            postAction: async () => {
+                await this.reopenConnectorSecretsTab(cluster);
+            },
+        });
         await this.importButton.click({ timeout: 30000 });
     }
-    async bulkImportSecrets(secrets) {
+    async bulkImportSecrets(cluster, secrets) {
         const mapped = secrets
             .map((secret) => `${secret.name}=${secret.value}`)
             .join('\n');
-        await this.clickImportButton();
+        await this.clickImportButton(cluster);
         if (!(await this.dialog.isVisible())) {
             await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.fromFileButton, {
                 postAction: async () => {
-                    await this.clickImportButton();
+                    await this.clickImportButton(cluster);
                 },
             });
             await this.fromFileButton.click();
@@ -229,9 +263,11 @@ class ClusterSecretsPage {
             await this.page.reload();
             await (0, sleep_1.sleep)(5000);
         }
-        await (0, test_1.expect)(this.createNewSecretButton).toBeVisible({
-            timeout: 60000,
-        });
+        // A single reload is not enough when the panel broke because the Console API
+        // rate-limited it: the reload itself can land on the SPA's global error page
+        // (observed in run 30971320305 for both cluster setups), so keep re-entering
+        // the tab until the toolbar is genuinely rendered.
+        await this.assertSecretsToolbarVisible(cluster);
         await this.page.reload();
         await (0, sleep_1.sleep)(5000);
     }

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

@@ -376,7 +376,9 @@ class ModelerCreatePage {
                     await clusterSelect.click();
                     const escapedClusterName = modelerClusterName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
                     await this.dialog
-                        .getByText(new RegExp(`^${escapedClusterName}(?: \\(|$)`))
+                        .getByRole('option', {
+                        name: new RegExp(`^${escapedClusterName}(?: \\(|$)`),
+                    })
                         .click();
                     await (0, test_1.expect)(clusterSelect).toContainText(modelerClusterName);
                 }

package/dist/utils/consoleApiHelpers.js

@@ -55,19 +55,54 @@ async function getUserToken(page) {
     }
     return token;
 }
+// Console's API sits behind an Envoy local rate limit, which rejects bursts
+// with HTTP 429 "local_rate_limited". The nightly drives a single org from many
+// workers (both Tasklist projects' setups plus one project-folder test per test
+// user), so a cluster call can be rejected while nothing is actually wrong.
+// Retry those — and gateway 5xx — with backoff instead of failing setup on the
+// first rejection.
+const TRANSIENT_API_STATUSES = [429, 500, 502, 503, 504];
+const API_MAX_ATTEMPTS = 5;
+async function clusterApiRequest(page, method, url, data) {
+    let response;
+    for (let attempt = 1; attempt <= API_MAX_ATTEMPTS; attempt++) {
+        const token = await getUserToken(page);
+        response = await page.request.fetch(url, {
+            method,
+            headers: { Authorization: `Bearer ${token}` },
+            ...(data === undefined ? {} : { data }),
+        });
+        if (!TRANSIENT_API_STATUSES.includes(response.status()))
+            return response;
+        console.log(`Console API ${method} ${url} returned HTTP ${response.status()} ` +
+            `(attempt ${attempt}/${API_MAX_ATTEMPTS}), retrying`);
+        if (attempt < API_MAX_ATTEMPTS)
+            await (0, sleep_1.sleep)(attempt * 10000);
+    }
+    return response;
+}
 async function findClusterByName(page, clusterName) {
-    const token = await getUserToken(page);
     const orgId = getOrgId();
-    const response = await page.request.get(`${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters`, { headers: { Authorization: `Bearer ${token}` } });
-    if (response.status() !== 200)
-        return undefined;
+    const response = await clusterApiRequest(page, 'GET', `${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters`);
+    // Never report "not found" for a lookup that did not actually complete.
+    // ensureClusterViaApi treats undefined as "no such cluster yet" and creates
+    // one, so swallowing a rate-limited/failed listing here makes it create a
+    // second cluster with the same name — orphaning the one the sibling project's
+    // setup is already using (and, when the create is rate-limited too, failing
+    // the whole setup with a misleading "Failed to create cluster" error). Only a
+    // successful, parseable listing can prove a cluster is absent.
+    if (response.status() !== 200) {
+        throw new Error(`Failed to list clusters of org ${orgId}: ` +
+            `HTTP ${response.status()} - ${await response.text()}`);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let data;
     try {
         data = await response.json();
     }
     catch {
-        return undefined;
+        throw new Error(`Cluster listing of org ${orgId} was not valid JSON: ` +
+            `${await response.text()}`);
     }
     const clusters = Array.isArray(data)
         ? data
@@ -199,7 +234,6 @@ function requestedGenerationName() {
     return clusterVersion;
 }
 async function createClusterViaApi(page, clusterName, region = 'GCP') {
-    const token = await getUserToken(page);
     const orgId = getOrgId();
     // Some trigger flows (e.g. playwright_saas_pr_trigger_monorepo.yml) create a
     // throwaway cluster generation per run, built from that specific commit's
@@ -234,24 +268,21 @@ async function createClusterViaApi(page, clusterName, region = 'GCP') {
         generationId = resolveGenerationId();
     }
     const k8sContextId = region.toUpperCase() === 'AWS' ? AWS_REGION_ID : GCP_REGION_ID;
-    const createResponse = await page.request.post(`${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters`, {
-        headers: { Authorization: `Bearer ${token}` },
-        data: {
-            name: clusterName,
-            planTypeId: PLAN_TYPE_ID,
-            channelId,
-            generationId,
-            k8sContextId,
-            autoUpdate: true,
-            stageLabel: 'dev',
-            // Upgrading a cluster to Tasklist v2 is a one-way, irreversible switch,
-            // and v2 cannot run job-worker-based user tasks, draft variables, or
-            // public start forms -- all of which the @tasklistV1-tagged suites
-            // exercise. Explicitly request v1 rather than relying on whatever the
-            // Console API defaults new clusters to, since a cluster that ends up
-            // v2-enabled can never be brought back to v1 for the rest of its life.
-            tasklistV2Enabled: false,
-        },
+    const createResponse = await clusterApiRequest(page, 'POST', `${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters`, {
+        name: clusterName,
+        planTypeId: PLAN_TYPE_ID,
+        channelId,
+        generationId,
+        k8sContextId,
+        autoUpdate: true,
+        stageLabel: 'dev',
+        // Upgrading a cluster to Tasklist v2 is a one-way, irreversible switch,
+        // and v2 cannot run job-worker-based user tasks, draft variables, or
+        // public start forms -- all of which the @tasklistV1-tagged suites
+        // exercise. Explicitly request v1 rather than relying on whatever the
+        // Console API defaults new clusters to, since a cluster that ends up
+        // v2-enabled can never be brought back to v1 for the rest of its life.
+        tasklistV2Enabled: false,
     });
     if (createResponse.status() !== 200 && createResponse.status() !== 201) {
         throw new Error(`Failed to create cluster "${clusterName}": ` +

package/package.json

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