@camunda/e2e-test-suite 0.0.916 → 0.0.918

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

@@ -79,6 +79,7 @@ declare class ClusterDetailsPage {
     createAPIClientAndReturnVariables(name: string, setEnvVariables?: boolean): Promise<{
         [key: string]: string;
     }>;
+    private dismissCreateClientDialogIfPresent;
     createAPIClient(name: string): Promise<void>;
     clickEnvVarsButton(): Promise<void>;
     clientCredentialsText(regex: RegExp): Promise<string>;

package/dist/pages/8.8/ClusterDetailsPage.js

@@ -484,21 +484,59 @@ class ClusterDetailsPage {
         }
         return variables;
     }
+    // A rejected POST .../clients leaves the create dialog open with an inline
+    // "Error fetch error" banner instead of closing it. Carbon's modal overlay
+    // then intercepts pointer events for the whole page, so nothing else can be
+    // clicked until the dialog is gone.
+    async dismissCreateClientDialogIfPresent() {
+        const isOpen = await this.createClientCredentialsDialog
+            .isVisible()
+            .catch(() => false);
+        if (!isOpen) {
+            return;
+        }
+        await this.page.keyboard.press('Escape');
+        try {
+            await (0, test_1.expect)(this.createClientCredentialsDialog).not.toBeVisible({
+                timeout: 10000,
+            });
+        }
+        catch {
+            await this.page.reload();
+            await this.page.waitForLoadState('domcontentloaded');
+            await this.clickAPITab();
+        }
+    }
     async createAPIClient(name) {
-        await this.clickCreateClientButton();
-        await (0, test_1.expect)(this.createClientCredentialsDialog).toBeVisible({
-            timeout: 30000,
-        });
-        await this.fillAPIClientName(name);
-        await this.checkOrchestrationClusterCheckbox();
-        await this.checkOptimizeCheckbox();
-        await this.checkSecretsCheckbox();
-        await this.clickCreateButton();
-        // The credentials dialog only renders once POST .../clients resolves, and
-        // that call can take well over 20s on a freshly created cluster.
-        await (0, test_1.expect)(this.clientCredentialsDialog).toBeVisible({
-            timeout: 60000,
-        });
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await this.clickCreateClientButton();
+            await (0, test_1.expect)(this.createClientCredentialsDialog).toBeVisible({
+                timeout: 30000,
+            });
+            await this.fillAPIClientName(name);
+            await this.checkOrchestrationClusterCheckbox();
+            await this.checkOptimizeCheckbox();
+            await this.checkSecretsCheckbox();
+            await this.clickCreateButton();
+            // The credentials dialog only renders once POST .../clients resolves, and
+            // that call can take well over 20s on a freshly created cluster. When the
+            // Console API rejects the call instead, the credentials dialog never
+            // arrives and the create dialog stays open on its error banner, so close
+            // it and retry the create from a clean state rather than leaving the page
+            // wedged behind a modal nobody dismissed.
+            const created = await this.clientCredentialsDialog
+                .waitFor({ state: 'visible', timeout: 60000 })
+                .then(() => true)
+                .catch(() => false);
+            if (created) {
+                break;
+            }
+            await this.dismissCreateClientDialogIfPresent();
+            if (attempt === maxAttempts) {
+                throw new Error(`Client credentials dialog never appeared for API client "${name}" after ${maxAttempts} attempts`);
+            }
+        }
         await (0, test_1.expect)(this.clientCredentialsDialog.getByText('The Client Secret will not be shown again.')).toBeVisible({ timeout: 30000 });
         // The clients table behind the dialog re-fetches after the create, and
         // renders a skeleton (no `row` roles at all) until that GET resolves — so

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

@@ -21,6 +21,8 @@ declare class ClusterSecretsPage {
     constructor(page: Page);
     deleteConnectorSecretsIfExist(): Promise<void>;
     clickCreateNewSecretButton(cluster: string): Promise<void>;
+    private dismissOpenDialogIfPresent;
+    private secretExists;
     clickClusterBanner(): Promise<void>;
     clickCluster(name: string): Promise<void>;
     clickKeyInput(): Promise<void>;

package/dist/pages/8.8/ClusterSecretsPage.js

@@ -107,7 +107,41 @@ class ClusterSecretsPage {
             await this.createNewSecretButton.click({ timeout: 30000 });
         }
     }
+    // A rejected Console API call leaves the create/import modal open with an
+    // inline "Error fetch error" banner instead of closing it. Carbon's modal
+    // overlay then intercepts pointer events for the whole page, so nothing else
+    // can be clicked until the dialog is gone.
+    async dismissOpenDialogIfPresent() {
+        const isOpen = await this.dialog.isVisible().catch(() => false);
+        if (!isOpen) {
+            return;
+        }
+        await this.page.keyboard.press('Escape');
+        try {
+            await (0, test_1.expect)(this.dialog).not.toBeVisible({ timeout: 10000 });
+        }
+        catch {
+            await this.page.reload();
+            await (0, test_1.expect)(this.dialog).not.toBeVisible({ timeout: 30000 });
+        }
+    }
+    async secretExists(name) {
+        try {
+            await (0, test_1.expect)(this.secretsSearchBox).toBeVisible({ timeout: 30000 });
+            await this.secretsSearchBox.click();
+            await this.secretsSearchBox.fill(name);
+            await (0, test_1.expect)(this.page.getByRole('row', { name: new RegExp(`^${name}\\b`, 'i') })).toBeVisible({ timeout: 10000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async clickClusterBanner() {
+        // This is the recovery path taken when a click times out, and a leftover
+        // modal overlay is exactly what makes those clicks time out - so the
+        // overlay has to be cleared here or recovery can never succeed either.
+        await this.dismissOpenDialogIfPresent();
         await (0, test_1.expect)(this.clusterBanner).toBeVisible({ timeout: 30000 });
         await this.clusterBanner.click({ timeout: 60000 });
     }
@@ -153,20 +187,41 @@ class ClusterSecretsPage {
         await this.createButton.click({ timeout: 30000 });
     }
     async createNewSecret(key, value, cluster) {
-        await this.clickCreateNewSecretButton(cluster);
-        await this.clickKeyInput();
-        await this.fillKeyInput(key);
-        await (0, sleep_1.sleep)(1000);
-        await this.clickValueInput();
-        await this.fillValueInput(value);
-        await (0, sleep_1.sleep)(1000);
-        await this.clickCreateButton();
-        await (0, test_1.expect)(this.page.getByText('Creating...')).not.toBeVisible({
-            timeout: 60000,
-        });
-        await (0, test_1.expect)(this.createNewSecretButton).toBeVisible({
-            timeout: 60000,
-        });
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await this.clickCreateNewSecretButton(cluster);
+            await this.clickKeyInput();
+            await this.fillKeyInput(key);
+            await (0, sleep_1.sleep)(1000);
+            await this.clickValueInput();
+            await this.fillValueInput(value);
+            await (0, sleep_1.sleep)(1000);
+            await this.clickCreateButton();
+            await (0, test_1.expect)(this.page.getByText('Creating...')).not.toBeVisible({
+                timeout: 60000,
+            });
+            // The dialog closing is the only reliable signal that the create actually
+            // succeeded: when the Console API rejects the POST the dialog stays open
+            // on an inline "Error fetch error" banner, yet createNewSecretButton is
+            // still in the DOM behind the overlay so waiting on it passes regardless.
+            // Returning from there wedged every later interaction on the page, so
+            // dismiss the modal and retry the create instead.
+            const closed = await this.dialog
+                .waitFor({ state: 'hidden', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (closed) {
+                await (0, test_1.expect)(this.createNewSecretButton).toBeVisible({
+                    timeout: 60000,
+                });
+                return;
+            }
+            await this.dismissOpenDialogIfPresent();
+            if (await this.secretExists(key)) {
+                return;
+            }
+        }
+        throw new Error(`Failed to create connector secret "${key}" after ${maxAttempts} attempts`);
     }
     async createSetOfSecrets(cluster, secrets) {
         await this.bulkImportSecrets(cluster, secrets);

package/dist/tests/8.8/hto-user-flows.spec.js

@@ -474,12 +474,11 @@ _8_8_1.test.describe('HTO User Flow Tests', () => {
         const randomString = await (0, _setup_1.generateRandomStringAsync)(3);
         const processName = 'User_Task_Process_With_Public_Form' + randomString;
         const formName = 'Public form' + randomString;
-        // Public start forms are a v1-only feature; the shared "Test Cluster"
-        // used by the rest of this file is deliberately kept on v1 (via
-        // createClusterViaApi's tasklistV2Enabled: false) so job-worker-based
-        // user tasks keep working there. This assertion needs the opposite --
-        // a genuinely v2-upgraded backend -- so it gets its own dedicated
-        // cluster rather than sharing one that can never satisfy both.
+        // This assertion needs a genuinely v2-upgraded backend, and the switch to
+        // v2 is irreversible, so it keeps its own dedicated cluster instead of
+        // relying on the mode of the shared "Test Cluster" (which follows the
+        // Playwright project the setup ran under -- v1 in the chromium-v1 leg, so
+        // that job-worker-based user tasks keep working for the rest of this file).
         const v2ClusterName = 'Public Form V2 Cluster';
         await _8_8_1.test.step('Create Dedicated Tasklist V2 Cluster', async () => {
             const clusterUuid = await (0, consoleApiHelpers_1.ensureClusterViaApi)(page, v2ClusterName);

package/dist/utils/consoleApiHelpers.d.ts

@@ -1,7 +1,7 @@
 import { Page } from '@playwright/test';
 export declare function deleteClusterViaApi(page: Page, clusterName: string): Promise<void>;
-export declare function createClusterViaApi(page: Page, clusterName: string, region?: string): Promise<string>;
-export declare function ensureClusterViaApi(page: Page, clusterName: string, region?: string): Promise<string>;
+export declare function createClusterViaApi(page: Page, clusterName: string, region?: string, tasklistV2Enabled?: boolean): Promise<string>;
+export declare function ensureClusterViaApi(page: Page, clusterName: string, region?: string, tasklistV2Enabled?: boolean): Promise<string>;
 export declare function ensureTasklistV2Enabled(page: Page, clusterUuid: string): Promise<void>;
 export declare function waitForClusterHealthyViaApi(page: Page, clusterUuid: string, timeoutMs?: number): Promise<void>;
 export declare function waitForClusterRestartHealthyViaApi(page: Page, clusterUuid: string, timeoutMs?: number): Promise<void>;

package/dist/utils/consoleApiHelpers.js

@@ -233,7 +233,33 @@ function requestedGenerationName() {
         return undefined;
     return clusterVersion;
 }
-async function createClusterViaApi(page, clusterName, region = 'GCP') {
+// Which Tasklist mode a cluster must be created in is decided by the Playwright
+// project the setup ran under, exactly as the UI path already does it in
+// ClusterPage.determineTasklistAPI(): chromium-v1 selects "Tasklist API v1
+// (legacy)", chromium-v2 leaves the v2 default. Mirror that here so the
+// chromium-v2 leg does not end up driving a v1-mode backend.
+//
+// For generations below 8.10 Console turns this into
+// CAMUNDA_TASKLIST_V2_MODE_ENABLED on Tasklist and the gateway, so 8.8/8.9 are
+// the versions where it changes what is under test; 8.10+ is v2-only and
+// ignores the field, and 8.7 predates the mode entirely (TASKLIST_VERSION is
+// unset there, which resolves to v1 as before).
+function resolveTasklistV2Enabled() {
+    let projectName = '';
+    try {
+        projectName = test_1.test.info().project.name;
+    }
+    catch {
+        // Called outside a running test (no test.info() available); fall back to
+        // the env var the SaaS workflows export from matrix.tasklist_version.
+    }
+    if (projectName.includes('v1'))
+        return false;
+    if (projectName.includes('v2'))
+        return true;
+    return (process.env.TASKLIST_VERSION ?? '').trim().toLowerCase() === 'v2';
+}
+async function createClusterViaApi(page, clusterName, region = 'GCP', tasklistV2Enabled = resolveTasklistV2Enabled()) {
     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
@@ -276,13 +302,14 @@ async function createClusterViaApi(page, clusterName, region = 'GCP') {
         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,
+        // 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,
     });
     if (createResponse.status() !== 200 && createResponse.status() !== 201) {
         throw new Error(`Failed to create cluster "${clusterName}": ` +
@@ -300,11 +327,12 @@ async function createClusterViaApi(page, clusterName, region = 'GCP') {
     if (!clusterId) {
         throw new Error(`Cluster creation response missing UUID: ${JSON.stringify(result)}`);
     }
-    console.log(`Created cluster via API: clusterId=${clusterId} namespace=${clusterId}-zeebe orgId=${orgId} name="${clusterName}"`);
+    console.log(`Created cluster via API: clusterId=${clusterId} namespace=${clusterId}-zeebe ` +
+        `orgId=${orgId} name="${clusterName}" tasklistMode=${tasklistV2Enabled ? 'v2' : 'v1'}`);
     return clusterId;
 }
 exports.createClusterViaApi = createClusterViaApi;
-async function ensureClusterViaApi(page, clusterName, region = 'GCP') {
+async function ensureClusterViaApi(page, clusterName, region = 'GCP', tasklistV2Enabled = resolveTasklistV2Enabled()) {
     // Versions with more than one Tasklist-mode Playwright project (e.g. 8.8,
     // 8.9's chromium-v1/chromium-v2) run test-setup.spec.ts once per project,
     // concurrently, against the same org -- and both target a cluster with
@@ -319,11 +347,15 @@ async function ensureClusterViaApi(page, clusterName, region = 'GCP') {
     // setup already created it. Adopt it instead of destroying it -- whichever
     // project's setup gets here first "wins" and creates it, the other one
     // just reuses it.
+    //
+    // The nightly runs the two Tasklist-mode legs in separate orgs (c8_org_1 for
+    // v1, c8_org_2 for v2), so an adopted cluster always carries the mode this
+    // leg asked for.
     const existing = await findClusterByName(page, clusterName);
     if (existing) {
         return existing.uuid;
     }
-    return createClusterViaApi(page, clusterName, region);
+    return createClusterViaApi(page, clusterName, region, tasklistV2Enabled);
 }
 exports.ensureClusterViaApi = ensureClusterViaApi;
 async function ensureTasklistV2Enabled(page, clusterUuid) {

package/package.json

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