@camunda/e2e-test-suite 0.0.1066 → 0.0.1068

package/dist/tests/8.10/test-setup.spec.js

@@ -32,8 +32,7 @@ _8_10_1.test.describe('Cluster Setup Tests', () => {
             await clusterPage.assertClusterHealthyStatusWithRetry(clusterName, 120000, 1500000);
         }
         else {
-            await (0, consoleApiHelpers_1.deleteClusterViaApi)(page, clusterName);
-            const clusterUuid = await (0, consoleApiHelpers_1.createClusterViaApi)(page, clusterName);
+            const clusterUuid = await (0, consoleApiHelpers_1.ensureClusterViaApi)(page, clusterName);
             await (0, consoleApiHelpers_1.waitForClusterHealthyViaApi)(page, clusterUuid);
             await homePage.clickClusters();
         }
@@ -63,8 +62,7 @@ _8_10_1.test.describe('Cluster Setup Tests', () => {
         const apiClientName = 'Test_API_Client' + (await (0, _setup_1.generateRandomStringAsync)(3));
         const mcpClientName = 'MCP_Test_API_Client' + (await (0, _setup_1.generateRandomStringAsync)(3));
         await (0, UtilitiesPage_1.loginWithRetry)(page, loginPage, users_1.testUsers.mainUser, (testInfo.workerIndex + 1) * 1000);
-        await (0, consoleApiHelpers_1.deleteClusterViaApi)(page, clusterName);
-        const clusterUuid = await (0, consoleApiHelpers_1.createClusterViaApi)(page, clusterName);
+        const clusterUuid = await (0, consoleApiHelpers_1.ensureClusterViaApi)(page, clusterName);
         await (0, consoleApiHelpers_1.waitForClusterHealthyViaApi)(page, clusterUuid, 1500000);
         await homePage.clickClusters();
         await clusterPage.clickClusterLink(clusterName);
@@ -99,8 +97,7 @@ _8_10_1.test.describe('Cluster Setup Tests', () => {
             await clusterPage.assertClusterHealthyStatusWithRetry(clusterName, 120000, 1500000);
         }
         else {
-            await (0, consoleApiHelpers_1.deleteClusterViaApi)(page, clusterName);
-            const clusterUuid = await (0, consoleApiHelpers_1.createClusterViaApi)(page, clusterName, 'AWS');
+            const clusterUuid = await (0, consoleApiHelpers_1.ensureClusterViaApi)(page, clusterName, 'AWS');
             await (0, consoleApiHelpers_1.waitForClusterHealthyViaApi)(page, clusterUuid, 1500000);
             await homePage.clickClusters();
         }

package/dist/utils/consoleApiHelpers.js

@@ -64,18 +64,42 @@ async function getUserToken(page) {
 const TRANSIENT_API_STATUSES = [429, 500, 502, 503, 504];
 const API_MAX_ATTEMPTS = 5;
 // Overrides the global actionTimeout (10s) for Console API calls only: cluster
-// creation regularly needs longer than that to answer.
-const API_TIMEOUT_MS = 15000;
+// listings answer in tens of milliseconds, so 15s is generous for a read.
+const API_READ_TIMEOUT_MS = 15000;
+// Cluster mutations are an order of magnitude slower than reads on Console:
+// POST /clusters was measured at 8-12s and DELETE at 7-9s against INT. A 15s
+// ceiling sat inside that band, so the client aborted requests the server went
+// on to complete — leaving a cluster nobody was tracking.
+const API_WRITE_TIMEOUT_MS = 45000;
+// POST is the only non-idempotent verb used here: repeating it creates a second
+// cluster under the same name. Let its timeout surface instead, so the caller
+// can recover by looking the cluster up by name (see createClusterViaApi).
+const TIMEOUT_RETRYABLE_METHODS = ['GET', 'PATCH', 'DELETE'];
 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}` },
-            timeout: API_TIMEOUT_MS,
-            ...(data === undefined ? {} : { data }),
-        });
+        try {
+            response = await page.request.fetch(url, {
+                method,
+                headers: { Authorization: `Bearer ${token}` },
+                timeout: method === 'GET' ? API_READ_TIMEOUT_MS : API_WRITE_TIMEOUT_MS,
+                ...(data === undefined ? {} : { data }),
+            });
+        }
+        catch (error) {
+            // A timeout or transport error throws rather than returning a status, so
+            // the status-based retry below never covered it and API_MAX_ATTEMPTS did
+            // not apply to the one failure mode that actually happens.
+            console.log(`Console API ${method} ${url} threw ${error.message} ` +
+                `(attempt ${attempt}/${API_MAX_ATTEMPTS})`);
+            if (!TIMEOUT_RETRYABLE_METHODS.includes(method) ||
+                attempt === API_MAX_ATTEMPTS) {
+                throw error;
+            }
+            await (0, sleep_1.sleep)(attempt * 10000);
+            continue;
+        }
         if (!TRANSIENT_API_STATUSES.includes(response.status()))
             return response;
         console.log(`Console API ${method} ${url} returned HTTP ${response.status()} ` +
@@ -113,8 +137,22 @@ async function findClusterByName(page, clusterName) {
         : data.clusters ?? [];
     return clusters.find((c) => c.name === clusterName);
 }
+// A cluster is not always listable the instant its create lands, so poll a few
+// times before concluding a timed-out create really did not happen.
+const CLUSTER_RECOVERY_ATTEMPTS = 6;
+const CLUSTER_RECOVERY_INTERVAL_MS = 5000;
+async function findClusterByNameWithRetry(page, clusterName) {
+    for (let attempt = 1; attempt <= CLUSTER_RECOVERY_ATTEMPTS; attempt++) {
+        const cluster = await findClusterByName(page, clusterName);
+        if (cluster)
+            return cluster;
+        if (attempt < CLUSTER_RECOVERY_ATTEMPTS) {
+            await (0, sleep_1.sleep)(CLUSTER_RECOVERY_INTERVAL_MS);
+        }
+    }
+    return undefined;
+}
 async function deleteClusterViaApi(page, clusterName) {
-    const token = await getUserToken(page);
     const orgId = getOrgId();
     const deadline = Date.now() + 180000;
     // Re-deleting a cluster that is already terminating can answer 409/400.
@@ -127,8 +165,14 @@ async function deleteClusterViaApi(page, clusterName) {
         if (!cluster)
             return;
         if (!deleteIssued.has(cluster.uuid)) {
-            const response = await page.request.delete(`${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters/${cluster.uuid}`, { headers: { Authorization: `Bearer ${token}` } });
-            if (!response.ok() && response.status() !== 404) {
+            // Routed through clusterApiRequest for the write timeout and retries: a
+            // bare page.request.delete inherits the 10s actionTimeout, which DELETE
+            // /clusters (7-9s at INT) can exceed.
+            const response = await clusterApiRequest(page, 'DELETE', `${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters/${cluster.uuid}`);
+            // 409 is the retry landing on a cluster the first attempt already put
+            // into termination -- the outcome this asked for, not a failure.
+            const alreadyTerminating = [404, 409].includes(response.status());
+            if (!response.ok() && !alreadyTerminating) {
                 throw new Error(`Failed to delete cluster "${clusterName}" (${cluster.uuid}): ` +
                     `HTTP ${response.status()} - ${await response.text()}`);
             }
@@ -315,23 +359,40 @@ async function createClusterViaApi(page, clusterName, region = 'GCP', tasklistV2
         generationId = resolveGenerationId();
     }
     const k8sContextId = region.toUpperCase() === 'AWS' ? AWS_REGION_ID : GCP_REGION_ID;
-    const createResponse = await clusterApiRequest(page, 'POST', `${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters`, {
-        name: clusterName,
-        planTypeId: PLAN_TYPE_ID,
-        channelId,
-        generationId,
-        k8sContextId,
-        autoUpdate: true,
-        stageLabel: 'dev',
-        // Always sent explicitly rather than omitted: Console defaults an unset
-        // field to v2-enabled for any generation >= 8.8, and the switch to v2 is
-        // one-way -- a cluster that ends up v2-enabled can never be brought back
-        // to v1 for the rest of its life. v2 cannot run job-worker-based user
-        // tasks, draft variables, or public start forms, so the v1 leg
-        // (@tasklistV1-tagged suites) depends on this being false, and the v2 leg
-        // equally depends on it being true.
-        tasklistV2Enabled,
-    });
+    let createResponse;
+    try {
+        createResponse = await clusterApiRequest(page, 'POST', `${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters`, {
+            name: clusterName,
+            planTypeId: PLAN_TYPE_ID,
+            channelId,
+            generationId,
+            k8sContextId,
+            autoUpdate: true,
+            stageLabel: 'dev',
+            // Always sent explicitly rather than omitted: Console defaults an unset
+            // field to v2-enabled for any generation >= 8.8, and the switch to v2 is
+            // one-way -- a cluster that ends up v2-enabled can never be brought back
+            // to v1 for the rest of its life. v2 cannot run job-worker-based user
+            // tasks, draft variables, or public start forms, so the v1 leg
+            // (@tasklistV1-tagged suites) depends on this being false, and the v2 leg
+            // equally depends on it being true.
+            tasklistV2Enabled,
+        });
+    }
+    catch (error) {
+        // Console does not cancel the create when the client stops waiting: it
+        // answers /clusters slower than the request timeout while still creating
+        // the cluster. Adopt what the timed-out POST made instead of re-POSTing,
+        // which would leave two clusters under the same name and break
+        // clickClusterLink in strict mode.
+        const recovered = await findClusterByNameWithRetry(page, clusterName);
+        if (!recovered)
+            throw error;
+        console.log(`Cluster "${clusterName}" create timed out but the cluster exists: ` +
+            `clusterId=${recovered.uuid} namespace=${recovered.uuid}-zeebe ` +
+            `orgId=${orgId} tasklistMode=${tasklistV2Enabled ? 'v2' : 'v1'}`);
+        return recovered.uuid;
+    }
     if (createResponse.status() !== 200 && createResponse.status() !== 201) {
         throw new Error(`Failed to create cluster "${clusterName}": ` +
             `HTTP ${createResponse.status()} - ${await createResponse.text()}`);

package/package.json

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