@camunda/e2e-test-suite 0.0.861 → 0.0.863

package/dist/utils/consoleApiHelpers.js

@@ -5,6 +5,7 @@ const test_1 = require("@playwright/test");
 const sleep_1 = require("./sleep");
 const PLAN_TYPE_ID = '574cde5f-54ae-43c1-851a-e6fb4f03423a';
 const CHANNEL_ID = 'cf355219-cc2d-4266-83e1-2430998ddf30';
+const STABLE_CHANNEL_NAME = 'Stable';
 const GCP_REGION_ID = 'a6fadf1d-b2a0-44ab-b301-2f9aaf6681dc';
 const AWS_REGION_ID = '30fcdd4f-05d7-1c7a-54df-8d9defbd250f';
 const GENERATION_MAP = {
@@ -83,7 +84,7 @@ async function deleteClusterViaApi(page, clusterName) {
     await (0, sleep_1.sleep)(5000);
 }
 exports.deleteClusterViaApi = deleteClusterViaApi;
-async function resolveGenerationId() {
+function resolveMinorVersion() {
     // MINOR_VERSION is always a plain "8.x" string in every trigger flow
     // (run-tests-saas extracts it from the human-readable version input;
     // run-tests-smoke-int sets it straight from c8Version). CLUSTER_VERSION is
@@ -91,34 +92,154 @@ async function resolveGenerationId() {
     // flow (playwright_saas_pr_trigger_monorepo.yml -> run-tests-smoke-int)
     // deliberately puts a random per-PR cluster *generation name* there
     // (openssl rand -hex 6), a pre-existing convention unrelated to this
-    // GENERATION_MAP lookup. Fall back to it only for callers that don't set
-    // MINOR_VERSION.
+    // lookup. Fall back to it only for callers that don't set MINOR_VERSION.
     const rawVersion = process.env.MINOR_VERSION || process.env.CLUSTER_VERSION || '';
-    const minorVersion = rawVersion.match(/^(\d+\.\d+)/)?.[1] ?? rawVersion;
+    return rawVersion.match(/^(\d+\.\d+)/)?.[1] ?? rawVersion;
+}
+function resolveGenerationId() {
+    const minorVersion = resolveMinorVersion();
     const generationId = GENERATION_MAP[minorVersion];
     if (generationId)
         return generationId;
-    throw new Error(`No generation UUID found for MINOR_VERSION/CLUSTER_VERSION="${rawVersion}" ` +
+    throw new Error(`No generation UUID found for MINOR_VERSION/CLUSTER_VERSION=` +
+        `"${process.env.MINOR_VERSION || process.env.CLUSTER_VERSION || ''}" ` +
         `(resolved minor: "${minorVersion}"). ` +
         `Known versions: ${Object.keys(GENERATION_MAP).join(', ')}`);
 }
+// Query the same cluster-parameters endpoint the Console create-cluster dialog
+// uses. Its channels expose their selectable generations under
+// `allowedGenerations`.
+async function fetchClusterChannels(page) {
+    const token = await getUserToken(page);
+    const orgId = getOrgId();
+    const response = await page.request.get(`${getConsoleBaseUrl()}/api/orgs/${orgId}/clusters/parameters`, { headers: { Authorization: `Bearer ${token}` } });
+    if (response.status() !== 200) {
+        throw new Error(`Failed to fetch cluster parameters: ` +
+            `HTTP ${response.status()} - ${await response.text()}`);
+    }
+    const params = (await response.json());
+    return params.channels ?? [];
+}
+// Pick the latest released generation for a minor version from the Stable
+// channel. Migration source clusters must start on a real released generation
+// (e.g. "Camunda 8.7+gen33"), not the "8.x Cross Component Test Suite" snapshot
+// in GENERATION_MAP -- upgrading a snapshot is not a representative path.
+function pickLatestStableTarget(channels, minorVersion) {
+    const stable = channels.find((channel) => channel.name === STABLE_CHANNEL_NAME);
+    if (!stable) {
+        throw new Error(`No "${STABLE_CHANNEL_NAME}" channel found in cluster parameters`);
+    }
+    const escaped = minorVersion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Released generations are named "Camunda <minor>+gen<N>"; pick the highest N.
+    const genPattern = new RegExp(`^Camunda ${escaped}\\+gen(\\d+)`);
+    let best;
+    for (const generation of stable.allowedGenerations ?? []) {
+        const match = generation.name.match(genPattern);
+        if (!match)
+            continue;
+        const gen = Number(match[1]);
+        if (!best || gen > best.gen)
+            best = { uuid: generation.uuid, gen };
+    }
+    if (!best) {
+        throw new Error(`No stable "Camunda ${minorVersion}+gen<N>" generation found in the ` +
+            `"${STABLE_CHANNEL_NAME}" channel`);
+    }
+    console.log(`Resolved latest stable generation for Camunda ${minorVersion}: ` +
+        `gen${best.gen} (${best.uuid})`);
+    return { channelId: stable.uuid, generationId: best.uuid };
+}
+// Resolve an explicitly requested generation (by display name) to its channel
+// and UUID, so a provided Source Generation input is honored as-is.
+function pickGenerationByName(channels, generationName) {
+    for (const channel of channels) {
+        const match = (channel.allowedGenerations ?? []).find((generation) => generation.name === generationName);
+        if (match) {
+            console.log(`Resolved source generation "${generationName}" from channel ` +
+                `"${channel.name}" (${match.uuid})`);
+            return { channelId: channel.uuid, generationId: match.uuid };
+        }
+    }
+    throw new Error(`Source generation "${generationName}" not found in any channel's ` +
+        `allowed generations`);
+}
+// Migration source cluster target: honor an explicit Source Generation (passed
+// via CLUSTER_VERSION) when set; otherwise auto-select the latest stable
+// generation for the source minor version.
+async function resolveMigrationTarget(page) {
+    const channels = await fetchClusterChannels(page);
+    const sourceGeneration = (process.env.CLUSTER_VERSION ?? '').trim();
+    if (sourceGeneration) {
+        return pickGenerationByName(channels, sourceGeneration);
+    }
+    return pickLatestStableTarget(channels, resolveMinorVersion());
+}
+// Snapshot generations mapped in GENERATION_MAP are named
+// "<minor> Cross Component Test Suite" (see .github/c8_versions.json). The
+// regular SaaS nightly passes that name through CLUSTER_VERSION and must keep
+// resolving via the fixed GENERATION_MAP UUID, so it is excluded below.
+const SNAPSHOT_GENERATION_SUFFIX = 'Cross Component Test Suite';
+// The on-demand SaaS manual workflow lets the operator pick an exact cluster
+// generation -- any Console generation name ("Camunda 8.10+gen21", a Release
+// Test name, "my-new-generation", ...) -- and passes it through CLUSTER_VERSION.
+// Treat any such explicit name as a request to resolve that generation live
+// across all channels (pickGenerationByName), instead of the version-keyed
+// GENERATION_MAP snapshot. Two values are NOT explicit generation names and
+// stay on the snapshot lookup: a bare "8.x" minor, and the nightly snapshot
+// name. The monorepo PR-trigger flow sets CLUSTER_GENERATION_ID, which wins
+// earlier, so its random per-PR CLUSTER_VERSION never reaches here.
+function requestedGenerationName() {
+    const clusterVersion = (process.env.CLUSTER_VERSION ?? '').trim();
+    if (!clusterVersion)
+        return undefined;
+    if (/^\d+\.\d+$/.test(clusterVersion))
+        return undefined;
+    if (clusterVersion.endsWith(SNAPSHOT_GENERATION_SUFFIX))
+        return undefined;
+    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
     // component images, and pass its real UUID through as CLUSTER_GENERATION_ID.
-    // That must win over the static GENERATION_MAP lookup -- falling back to a
-    // fixed generation would silently test the wrong (stale) images instead of
-    // failing loudly.
-    const generationId = process.env.CLUSTER_GENERATION_ID || (await resolveGenerationId());
+    // That must win over any other lookup -- falling back to a fixed generation
+    // would silently test the wrong (stale) images instead of failing loudly.
+    //
+    // Migration flows (IS_MIGRATION) create the SOURCE cluster and must start it
+    // on the latest released generation from the Stable channel, resolved live,
+    // rather than the "8.x Cross Component Test Suite" snapshot in GENERATION_MAP.
+    //
+    // On-demand runs (playwright_saas_manual.yml) pass an explicit generation
+    // name via CLUSTER_VERSION; resolve it live across all channels so the
+    // operator's chosen generation is used instead of the version-keyed snapshot.
+    let channelId = CHANNEL_ID;
+    let generationId;
+    const requestedGeneration = requestedGenerationName();
+    if (process.env.CLUSTER_GENERATION_ID) {
+        generationId = process.env.CLUSTER_GENERATION_ID;
+    }
+    else if (process.env.IS_MIGRATION === 'true') {
+        const migrationTarget = await resolveMigrationTarget(page);
+        channelId = migrationTarget.channelId;
+        generationId = migrationTarget.generationId;
+    }
+    else if (requestedGeneration) {
+        const target = pickGenerationByName(await fetchClusterChannels(page), requestedGeneration);
+        channelId = target.channelId;
+        generationId = target.generationId;
+    }
+    else {
+        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: CHANNEL_ID,
+            channelId,
             generationId,
             k8sContextId,
             autoUpdate: true,

package/package.json

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