@camunda/e2e-test-suite 0.0.1379 → 0.0.1380

package/dist/pages/8.10/ClusterPage.d.ts

@@ -24,6 +24,7 @@ declare class ClusterPage {
     readonly clusterVersionOption: Locator;
     readonly generationSearchInput: Locator;
     readonly g3DevClusterType: Locator;
+    readonly clusterRegion: (clusterName: string, regionText: string) => Locator;
     readonly alphaTab: Locator;
     readonly devTab: Locator;
     readonly stableTab: Locator;
@@ -49,7 +50,7 @@ declare class ClusterPage {
     fillClusterNameInput(name: string): Promise<void>;
     private extractClusterIdFromUrl;
     private logClusterCreationInfo;
-    createCluster(name: string, region?: string, tasklistV1Api?: boolean): Promise<void>;
+    createCluster(name: string, region?: string, tasklistV1Api?: boolean, subRegion?: string): Promise<void>;
     determineTasklistAPI(tasklistV1Api?: boolean): Promise<void>;
     clickClusterType(): Promise<void>;
     clickCreateClusterButton(): Promise<void>;
@@ -89,7 +90,7 @@ declare class ClusterPage {
     clickDevTab(): Promise<void>;
     clickStableTab(): Promise<void>;
     clickQAGenerationsTab(): Promise<void>;
-    selectSubRegion(region: string): Promise<void>;
+    selectSubRegion(region: string, subRegion?: string): Promise<void>;
     clickGCPRegion(): Promise<void>;
     clickTasklistV1Api(): Promise<void>;
 }

package/dist/pages/8.10/ClusterPage.js

@@ -29,6 +29,7 @@ class ClusterPage {
     clusterVersionOption;
     generationSearchInput;
     g3DevClusterType;
+    clusterRegion;
     alphaTab;
     devTab;
     stableTab;
@@ -141,6 +142,7 @@ class ClusterPage {
         });
         this.dialog = page.getByRole('dialog');
         this.clusterVersion = (clusterName, versionText) => this.clusterRow(clusterName).getByText(versionText, { exact: false });
+        this.clusterRegion = (clusterName, regionText) => this.clusterRow(clusterName).getByText(regionText, { exact: false });
     }
     async clickClusterBanner() {
         // Camunda Hub has no `banner` landmark; "Clusters" instead lives in its
@@ -273,7 +275,7 @@ class ClusterPage {
             console.warn(`⚠️ Could not extract cluster info for "${clusterName}": ${error}`);
         }
     }
-    async createCluster(name, region = 'GCP', tasklistV1Api) {
+    async createCluster(name, region = 'GCP', tasklistV1Api, subRegion) {
         await this.clickClusterTab();
         await this.deleteCluster(name);
         await this.clickCreateNewClusterButton();
@@ -288,7 +290,7 @@ class ClusterPage {
             .getByRole('tab', { name: region })
             .or(this.page.getByRole('radio', { name: region, exact: true }))
             .click();
-        await this.selectSubRegion(region);
+        await this.selectSubRegion(region, subRegion);
         await this.clickClusterOption();
         await this.determineTasklistAPI(tasklistV1Api);
         await this.clickCreateClusterButton();
@@ -616,7 +618,29 @@ class ClusterPage {
     async clickQAGenerationsTab() {
         await this.qaGenerationsTab.click();
     }
-    async selectSubRegion(region) {
+    async selectSubRegion(region, subRegion) {
+        // An explicit sub-region makes the choice reproducible. The default below
+        // picks at random, which is right for a test that only needs *a* cluster
+        // but wrong for one that has to know which region the cluster is in --
+        // console-cluster-duplication asserts that an overridden region beat the
+        // carried-over one, and a random source region can collide with the
+        // override and make that assertion vacuous.
+        if (subRegion) {
+            const known = {
+                Belgium: this.belgiumRegion,
+                Finland: this.finlandRegion,
+                London: this.londonRegion,
+                Ohio: this.ohioRegion,
+            };
+            const locator = known[subRegion];
+            if (!locator) {
+                throw new Error(`Unknown sub-region "${subRegion}". Known: ${Object.keys(known).join(', ')}`);
+            }
+            console.log(`Selected region: ${subRegion}`);
+            await (0, test_1.expect)(locator).toBeVisible({ timeout: 20000 });
+            await locator.click();
+            return;
+        }
         if (region === 'GCP') {
             if (process.env.IS_PROD == 'true') {
                 await (0, test_1.expect)(this.londonRegion).toBeVisible({ timeout: 20000 });

package/dist/tests/8.10/console-cluster-duplication.spec.js

@@ -10,6 +10,16 @@ const users_1 = require("../../utils/users");
 // reads C8_USERNAME_TEST, which is not a member of the run's org (and is not
 // exported at all in the nightly test job, so fill() received undefined).
 const testUser = (0, users_1.getTestUser)('mainUser');
+// The two GCP sub-regions a non-prod org can create in. DUP-02 pins the source
+// to one and overrides to the other: left to its default selectSubRegion()
+// picks at random, and a source that lands on the override's region makes
+// "the override won" indistinguishable from "the source value carried over".
+// The strings are the rendered tile labels, not display names -- see the
+// belgiumRegion/finlandRegion locators in pages/8.10/ClusterPage.ts.
+const SOURCE_SUB_REGION = 'Belgium';
+const OVERRIDE_SUB_REGION = 'Finland';
+const SOURCE_REGION_LABEL = 'Chaos, Belgium, Europe (europe-west1)';
+const OVERRIDE_REGION_LABEL = 'Finland, Europe (europe-north1)';
 /**
  * Epic: camunda/product-hub#3824 - Console cluster duplication.
  *
@@ -136,4 +146,95 @@ _8_10_1.test.describe('Console cluster duplication', () => {
             await clusterDetailsPage.assertComponentsHealth();
         });
     });
+    // Scoped to name and region. The epic's case also lists plan type, channel
+    // and generation, but neither is overridable through today's page object:
+    // ClusterPage models exactly one cluster type (defaultClusterType =
+    // 'G3-Dev'), and createCluster() already drives the source through the same
+    // clickClusterOption() the duplicate would use, so both land on the same
+    // generation and an "override" assertion would pass without overriding
+    // anything. Asserting a value the test never set is what the first draft of
+    // this case did. Covering them needs page-object work first.
+    (0, _8_10_1.test)('DUP-02: a name and region overridden on the duplication form win over the carried-over ones', async ({ page, homePage, clusterPage, clusterDetailsPage, clusterSecretsPage, }) => {
+        // Two cluster creations plus health polling - this case is long by nature.
+        _8_10_1.test.setTimeout(60 * 60 * 1000);
+        const randomSuffix = await (0, _setup_1.generateRandomStringAsync)(6);
+        const sourceClusterName = `dup-src-ovr-${randomSuffix}`;
+        const duplicateClusterName = `dup-ovr-${randomSuffix}`;
+        await _8_10_1.test.step('given a healthy source cluster in a known region with its settings populated', async () => {
+            await clusterPage.clickClusterTab();
+            createdClusterNames.push(sourceClusterName);
+            // Pin the source region explicitly: the override below must differ from
+            // it, otherwise "the override won" is indistinguishable from "carried
+            // over". The second argument is the cloud provider, the fourth the
+            // sub-region -- passing a region label as the provider matches no tab.
+            await clusterPage.createCluster(sourceClusterName, 'GCP', undefined, SOURCE_SUB_REGION);
+            await clusterPage.assertClusterHealthyStatusWithRetry(sourceClusterName);
+            // A populated source - against an empty one this case would pass by
+            // copying nothing at all.
+            await clusterSecretsPage.createNewSecret(`DUP_SECRET_${randomSuffix}`, `dup-secret-value-${randomSuffix}`, sourceClusterName);
+        });
+        await _8_10_1.test.step('when I override the name and the region before submitting', async () => {
+            await homePage.clickClusters();
+            await clusterPage.clickClusterLink(sourceClusterName);
+            await clusterDetailsPage.dismissOopsIfPresent();
+            await (0, UtilitiesPage_1.waitForLoadingToFinish)(page);
+            await page.getByRole('button', { name: 'cluster operations' }).click();
+            const duplicateAction = page
+                .getByRole('menuitem', { name: /duplicate/i })
+                .or(page.getByRole('button', { name: /duplicate/i }));
+            await (0, test_1.expect)(duplicateAction).toBeVisible({ timeout: 30000 });
+            await duplicateAction.click();
+            // Every editable field of the duplication form, changed away from the
+            // value the form carried over from the source cluster.
+            await clusterPage.clickClusterNameInput();
+            await clusterPage.fillClusterNameInput(duplicateClusterName);
+            // clickGCPRegion only acts when REGION_SELECTION is set, so the tile
+            // click below is what actually moves the region either way.
+            await clusterPage.clickGCPRegion();
+            await clusterPage.selectSubRegion('GCP', OVERRIDE_SUB_REGION);
+            createdClusterNames.push(duplicateClusterName);
+            const submitDuplicate = page.getByRole('button', {
+                name: 'Duplicate cluster',
+                exact: true,
+            });
+            await (0, test_1.expect)(submitDuplicate).toBeEnabled({ timeout: 30000 });
+            // Same as DUP-01: hold the page until the duplicate POST has answered,
+            // otherwise navigating away aborts the in-flight request.
+            const duplicateResponse = page.waitForResponse((response) => response.request().method() === 'POST' &&
+                /\/clusters\/[^/]+\/duplicate$/.test(new URL(response.url()).pathname), { timeout: 60000 });
+            await submitDuplicate.click();
+            const duplicate = await duplicateResponse;
+            (0, test_1.expect)(duplicate.ok()).toBe(true);
+            const { clusterId } = await duplicate.json();
+            await page.waitForURL(new RegExp(`/cluster/${clusterId}`), {
+                timeout: 60000,
+            });
+        });
+        await _8_10_1.test.step('then the created duplicate carries the overridden values, not the source ones, and is healthy', async () => {
+            await homePage.clickClusters();
+            await (0, UtilitiesPage_1.waitForLoadingToFinish)(page);
+            // The overridden name is what the cluster was actually created with.
+            await (0, test_1.expect)(clusterPage.clusterLink(duplicateClusterName)).toBeVisible({
+                timeout: 60000,
+            });
+            await (0, test_1.expect)(clusterPage.clusterLink(sourceClusterName)).toBeVisible();
+            // The result, not the form state: the row of the cluster that was really
+            // created carries the overridden region. Scoped to that row rather than
+            // read off a page-wide getByText -- the source cluster is still listed
+            // on this same page and carries the region the override had to beat.
+            await (0, test_1.expect)(clusterPage.clusterRegion(duplicateClusterName, OVERRIDE_REGION_LABEL)).toBeVisible({ timeout: 60000 });
+            // ...and not the one it would have inherited from the source. Asserted
+            // after the positive check above, so an empty row cannot pass it.
+            await (0, test_1.expect)(clusterPage.clusterRegion(duplicateClusterName, SOURCE_REGION_LABEL)).toHaveCount(0);
+            // The source kept its own region, which is what makes the two labels
+            // above a real comparison rather than two reads of the same cluster.
+            await (0, test_1.expect)(clusterPage.clusterRegion(sourceClusterName, SOURCE_REGION_LABEL)).toBeVisible();
+            // Completion rule: a duplicate that is created but never healthy is the
+            // failure this epic exists to prevent.
+            await clusterPage.assertClusterHealthyStatusWithRetry(duplicateClusterName);
+            await clusterPage.clickClusterLink(duplicateClusterName);
+            await clusterDetailsPage.dismissOopsIfPresent();
+            await clusterDetailsPage.assertComponentsHealth();
+        });
+    });
 });

package/package.json

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