@camunda/e2e-test-suite 0.0.202 → 0.0.203

package/dist/pages/8.10/ClusterPage.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+const clickLocatorWithRetry_1 = require("../../utils/assertionHelpers/clickLocatorWithRetry");
+class ClusterPage {
+    page;
+    defaultClusterType = 'G3-Dev';
+    belgiumRegion;
+    londonRegion;
+    finlandRegion;
+    testInfo;
+    createNewClusterButton;
+    clusterNameInput;
+    createClusterButton;
+    clusterCreatingStatusText;
+    clusterHealthyStatusText;
+    clusterHealthyIndicatorSelector;
+    clusterGenerationCompleteMessage;
+    clustersBreadcrumb;
+    deleteClusterButton;
+    confirmDeleteInput;
+    dangerDeleteButton;
+    testClusterLink;
+    connectorSecretsTab;
+    createAClusterButton;
+    clusterVersionOption;
+    g3DevClusterType;
+    alphaTab;
+    devTab;
+    stableTab;
+    qaGenerationsTab;
+    gcpRegion;
+    clustersList;
+    tasklistV1Api;
+    tasklistV2Api;
+    cluster;
+    clusterHealthiness;
+    clusterLink;
+    constructor(page, testInfo) {
+        this.page = page;
+        this.testInfo = testInfo;
+        this.createNewClusterButton = page.getByRole('button', {
+            name: 'Create new Cluster',
+        });
+        this.clusterNameInput = page.getByPlaceholder('Enter a name for the cluster');
+        this.createClusterButton = page.getByRole('button', {
+            name: 'Create cluster',
+        });
+        this.clusterCreatingStatusText = page.getByText('Creating', { exact: true });
+        this.clusterHealthyStatusText = page.getByText('Healthy', { exact: true });
+        this.clusterHealthyIndicatorSelector = '[class="healthy healthIndicator"]';
+        this.clusterGenerationCompleteMessage = page.getByText('Test Cluster is healthy and ready to use');
+        this.clustersBreadcrumb = page
+            .getByLabel('Breadcrumb')
+            .getByText('Clusters', { exact: true });
+        this.deleteClusterButton = page.getByRole('button', { name: 'Delete' });
+        this.confirmDeleteInput = page.getByRole('textbox', {
+            name: 'Type the word DELETE to confirm',
+        });
+        this.dangerDeleteButton = page.getByRole('button', { name: 'danger Delete' });
+        this.testClusterLink = page.getByRole('link', { name: 'Test Cluster' });
+        this.connectorSecretsTab = page.getByRole('tab', {
+            name: 'Connector Secrets',
+        });
+        this.belgiumRegion = page.locator('label').filter({
+            hasText: 'Chaos, Belgium, Europe (europe-west1)',
+        });
+        this.londonRegion = page.locator('label').filter({
+            hasText: 'London, Europe (europe-west2)',
+        });
+        this.finlandRegion = page.locator('label').filter({
+            hasText: 'Finland, Europe (europe-north1)',
+        });
+        this.createAClusterButton = page.getByRole('button', {
+            name: 'Create a Cluster',
+        });
+        this.clusterVersionOption = page.getByText(`${process.env.CLUSTER_VERSION}`, { exact: true });
+        this.g3DevClusterType = page.locator('label').filter({
+            hasText: this.defaultClusterType,
+        });
+        this.alphaTab = page.getByRole('tab', { name: 'Alpha' });
+        this.devTab = page.getByRole('tab', { name: 'Internal Dev' });
+        this.stableTab = page.getByRole('tab', { name: 'Stable' });
+        this.qaGenerationsTab = page.getByRole('tab', { name: 'QA Generations' });
+        this.gcpRegion = page.getByRole('tab', {
+            name: 'GCP',
+        });
+        this.clustersList = page
+            .getByRole('row')
+            .filter({ hasNotText: 'Generation' }); //Filter out header row
+        this.tasklistV1Api = page.getByText('Tasklist API v1 (legacy)');
+        this.tasklistV2Api = page.getByText('Tasklist API v2');
+        this.cluster = (clusterName) => this.clustersList.filter({ hasText: clusterName });
+        this.clusterHealthiness = (clusterName) => this.cluster(clusterName).getByText(`Healthy`, {
+            exact: true,
+        });
+        this.clusterLink = (clusterName) => this.cluster(clusterName).getByRole('link', {
+            name: clusterName,
+        });
+    }
+    async clickClusterBanner() {
+        await this.page
+            .getByRole('banner')
+            .getByRole('link', { name: 'Clusters' })
+            .click({ timeout: 60000 });
+    }
+    async deleteCluster(name) {
+        await this.page.waitForTimeout(1000);
+        const clusterInstance = this.cluster(name).first();
+        if ((await clusterInstance.count()) <= 0) {
+            console.log(`No clusters found with name ${name}, skipping deletion.`);
+            return;
+        }
+        await clusterInstance.waitFor({ timeout: 10000 });
+        let deleteButtons = this.cluster(name).getByRole('button', {
+            name: 'Delete',
+        });
+        while ((await deleteButtons.count()) > 0) {
+            const deleteButton = deleteButtons.nth(0);
+            if (await deleteButton.isVisible()) {
+                try {
+                    await deleteButton.click({ force: true, timeout: 60000 });
+                }
+                catch (error) {
+                    await this.clickClusterBanner();
+                    await (0, test_1.expect)(deleteButton).toBeVisible({ timeout: 60000 });
+                    await deleteButton.click({ force: true, timeout: 60000 });
+                }
+                await this.confirmDeleteInput.click({ force: true, timeout: 60000 });
+                await this.confirmDeleteInput.fill('DELETE', { timeout: 60000 });
+                const dangerDeleteButtons = await this.dangerDeleteButton.all();
+                const lastDangerDeleteButton = dangerDeleteButtons[dangerDeleteButtons.length - 1];
+                await lastDangerDeleteButton.click();
+                await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
+                    timeout: 60000,
+                });
+                // Refresh the list of delete buttons
+                deleteButtons = this.cluster(name).getByRole('button', {
+                    name: 'Delete',
+                });
+            }
+        }
+        await this.page.waitForTimeout(500);
+    }
+    async clickClusterTab() {
+        await Promise.race([
+            this.page.waitForURL(/\/clusters/, {
+                timeout: 60000,
+            }),
+            this.clickClusterBanner(),
+        ]);
+    }
+    async clickCreateNewClusterButton() {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.createNewClusterButton, {
+            visibilityTimeout: 20000,
+            totalTimeout: 80000,
+            postAction: async () => {
+                await this.clickClusterBanner();
+            },
+        });
+    }
+    async clickClusterNameInput() {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.clusterNameInput, {
+            postAction: async () => {
+                await this.clickClusterBanner();
+            },
+        });
+    }
+    async fillClusterNameInput(name) {
+        await this.clusterNameInput.fill(name);
+    }
+    extractClusterIdFromUrl(url) {
+        const clusterIdMatch = url.match(/\/cluster\/([a-f0-9-]+)/);
+        return clusterIdMatch ? clusterIdMatch[1] : null;
+    }
+    async logClusterCreationInfo(clusterName) {
+        try {
+            await this.page.waitForURL(/\/cluster\/[a-f0-9-]+$/, { timeout: 60000 });
+            const currentUrl = this.page.url();
+            const clusterId = this.extractClusterIdFromUrl(currentUrl);
+            console.log(`🎉 Cluster "${clusterName}" created successfully with ID: ${clusterId || 'Unknown'} at ${new Date().toISOString()}`);
+        }
+        catch (error) {
+            console.warn(`⚠️ Could not extract cluster info for "${clusterName}": ${error}`);
+        }
+    }
+    async createCluster(name, region = 'GCP', tasklistV1Api) {
+        await this.clickClusterTab();
+        await this.deleteCluster(name);
+        await this.clickCreateNewClusterButton();
+        await this.clickClusterNameInput();
+        await this.fillClusterNameInput(name);
+        await this.clickClusterType();
+        await this.page.getByRole('tab', { name: region }).click();
+        await this.selectSubRegion(region);
+        await this.clickClusterOption();
+        await this.determineTasklistAPI(tasklistV1Api);
+        await this.clickCreateClusterButton();
+        await this.logClusterCreationInfo(name);
+        await this.clickClustersBreadcrumb(name);
+    }
+    async determineTasklistAPI(tasklistV1Api) {
+        // Determine tasklistV1Api from project name if not explicitly provided
+        if (tasklistV1Api === undefined) {
+            const projectName = this.testInfo?.project.name || '';
+            tasklistV1Api =
+                projectName.includes('v1') || projectName.includes('8.10-v1');
+            console.log(`Auto-detected Tasklist API version from project '${projectName}': ${tasklistV1Api ? 'V1' : 'V2'}`);
+        }
+        if (tasklistV1Api) {
+            await this.clickTasklistV1Api();
+        }
+    }
+    async clickClusterType() {
+        if (process.env.IS_PROD !== 'true') {
+            await (0, test_1.expect)(this.g3DevClusterType).toBeVisible({ timeout: 60000 });
+            await this.g3DevClusterType.click();
+        }
+    }
+    async clickCreateClusterButton() {
+        await this.createClusterButton.click();
+    }
+    async clickClustersBreadcrumb(clusterName) {
+        const creatingCheckRegex = new RegExp(`${clusterName}.*?Creatingdev`);
+        const healthyCheckRegex = new RegExp(`${clusterName}.*?Healthydev`);
+        try {
+            await (0, test_1.expect)(this.clustersBreadcrumb).toBeVisible({ timeout: 60000 });
+            await this.clustersBreadcrumb.click({ timeout: 60000 });
+            await (0, test_1.expect)(this.page.getByText(creatingCheckRegex)).toBeVisible({
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            await this.clickClusterBanner();
+            await (0, test_1.expect)(this.page
+                .getByText(creatingCheckRegex)
+                .or(this.page.getByText(healthyCheckRegex))).toBeVisible({
+                timeout: 30000,
+            });
+        }
+    }
+    async clickClusterLink(name) {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.clusterLink(name), {
+            postAction: async () => {
+                await this.clickClusterBanner();
+            },
+        });
+    }
+    async clickConnectorSecretsTab(clusterName) {
+        await (0, clickLocatorWithRetry_1.clickLocatorWithRetry)(this.page, this.connectorSecretsTab, {
+            postAction: async () => {
+                await this.clickClusterBanner();
+                await this.clickClusterLink(clusterName);
+            },
+        });
+    }
+    async clickClusterOption() {
+        const tabs = [
+            this.clickDevTab,
+            this.clickQAGenerationsTab,
+            this.clickStableTab,
+            this.clickAlphaTab,
+        ];
+        for (const clickTab of tabs) {
+            try {
+                await clickTab.call(this);
+                await this.clusterVersionOption.click({ timeout: 60000 });
+                return;
+            }
+            catch (error) {
+                console.error('Error clicking tab or cluster version option:', error);
+            }
+        }
+        throw new Error('Failed to find cluster generation');
+    }
+    async createClusterIfNotExists(clusterName, region = 'GCP') {
+        await (0, sleep_1.sleep)(15000);
+        if ((await this.cluster(clusterName).isVisible({ timeout: 20000 })) &&
+            (await this.clusterHealthiness(clusterName).isVisible({ timeout: 20000 }))) {
+            console.log(`${clusterName} exists and is healthy.`);
+        }
+        else {
+            await this.createCluster(clusterName, region);
+            await this.assertClusterHealthyStatusWithRetry(clusterName, 120000, 600000);
+        }
+    }
+    async assertClusterHealthyStatusWithRetry(name, visibilityTimeout = 100000, totalTimeout = 500000) {
+        await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.clusterHealthiness(name), {
+            visibilityTimeout: visibilityTimeout,
+            totalTimeout: totalTimeout,
+            maxRetries: 5,
+            preAction: async () => {
+                await this.page.reload();
+                await (0, test_1.expect)(this.cluster(name)).toBeVisible({ timeout: 10000 });
+            },
+        });
+        console.log('Cluster is healthy:', name);
+    }
+    async clickAlphaTab() {
+        await this.alphaTab.click();
+    }
+    async clickDevTab() {
+        await this.devTab.click();
+    }
+    async clickStableTab() {
+        await this.stableTab.click();
+    }
+    async clickQAGenerationsTab() {
+        await this.qaGenerationsTab.click();
+    }
+    async selectSubRegion(region) {
+        if (region === 'GCP') {
+            if (process.env.IS_PROD == 'true') {
+                await (0, test_1.expect)(this.londonRegion).toBeVisible({ timeout: 20000 });
+                await this.londonRegion.click();
+            }
+            else {
+                const regions = [
+                    { name: 'Belgium', locator: this.belgiumRegion },
+                    { name: 'Finland', locator: this.finlandRegion },
+                ];
+                const chosen = regions[Math.floor(Math.random() * regions.length)];
+                console.log(`Selected region: ${chosen.name}`);
+                await (0, test_1.expect)(chosen.locator).toBeVisible({ timeout: 20000 });
+                await chosen.locator.click();
+            }
+        }
+    }
+    async clickGCPRegion() {
+        const regionSelectionEnabled = process.env.REGION_SELECTION === 'true';
+        if (regionSelectionEnabled) {
+            await (0, test_1.expect)(this.gcpRegion).toBeVisible({ timeout: 40000 });
+            await this.gcpRegion.click();
+        }
+    }
+    async clickTasklistV1Api() {
+        try {
+            await (0, test_1.expect)(this.tasklistV1Api).toBeVisible({ timeout: 60000 });
+            await this.tasklistV1Api.click({ timeout: 30000 });
+        }
+        catch {
+            return;
+        }
+    }
+}
+exports.ClusterPage = ClusterPage;

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

@@ -0,0 +1,46 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterSecretsPage {
+    private page;
+    readonly createNewSecretButton: Locator;
+    readonly keyInput: Locator;
+    readonly valueInput: Locator;
+    readonly createButton: Locator;
+    readonly optionsButton: Locator;
+    readonly deleteConnectorSecretButton: Locator;
+    readonly deleteConnectorSecretSubButton: Locator;
+    readonly dialog: Locator;
+    readonly importButton: Locator;
+    readonly fromFileButton: Locator;
+    readonly bulkImportTextArea: Locator;
+    readonly dialogImportButton: Locator;
+    readonly secretsSearchBox: Locator;
+    readonly clusterBanner: Locator;
+    readonly clusterLink: (name: string) => Locator;
+    readonly clusterSecretTab: Locator;
+    readonly confirmDeleteInput: Locator;
+    constructor(page: Page);
+    deleteConnectorSecretsIfExist(): Promise<void>;
+    clickCreateNewSecretButton(cluster: string): Promise<void>;
+    clickClusterBanner(): Promise<void>;
+    clickCluster(name: string): Promise<void>;
+    clickKeyInput(): Promise<void>;
+    fillKeyInput(key: string): Promise<void>;
+    clickValueInput(): Promise<void>;
+    fillValueInput(value: string): Promise<void>;
+    clickCreateButton(): Promise<void>;
+    createNewSecret(key: string, value: string, cluster: string): Promise<void>;
+    createSetOfSecrets(cluster: string, secrets: {
+        name: string;
+        value: string;
+    }[]): Promise<void>;
+    assertSecretsOrCreate(cluster: string, secrets: {
+        name: string;
+        value: string;
+    }[]): Promise<void>;
+    clickImportButton(): Promise<void>;
+    bulkImportSecrets(secrets: {
+        name: string;
+        value: string;
+    }[]): Promise<void>;
+}
+export { ClusterSecretsPage };

package/dist/pages/8.10/ClusterSecretsPage.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterSecretsPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const expectLocatorWithRetry_1 = require("../../utils/assertionHelpers/expectLocatorWithRetry");
+class ClusterSecretsPage {
+    page;
+    createNewSecretButton;
+    keyInput;
+    valueInput;
+    createButton;
+    optionsButton;
+    deleteConnectorSecretButton;
+    deleteConnectorSecretSubButton;
+    dialog;
+    importButton;
+    fromFileButton;
+    bulkImportTextArea;
+    dialogImportButton;
+    secretsSearchBox;
+    clusterBanner;
+    clusterLink;
+    clusterSecretTab;
+    confirmDeleteInput;
+    constructor(page) {
+        this.page = page;
+        this.createNewSecretButton = page.getByRole('button', {
+            name: 'Create new secret',
+        });
+        this.keyInput = page.getByLabel('Key');
+        this.valueInput = page.getByLabel('Value', { exact: true });
+        this.createButton = page.getByRole('button', { name: 'Create', exact: true });
+        this.optionsButton = page
+            .getByRole('cell', { name: 'Options' })
+            .getByRole('button');
+        this.deleteConnectorSecretButton = page.getByRole('menuitem', {
+            name: 'Delete',
+            exact: true,
+        });
+        this.deleteConnectorSecretSubButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.dialog = page.getByRole('dialog');
+        this.importButton = page.getByRole('button', { name: 'Import', exact: true });
+        this.fromFileButton = page.getByText('from File', { exact: true });
+        this.bulkImportTextArea = page.locator('[id="env-content-input-secrets-bulk-import"]');
+        this.dialogImportButton = this.page
+            .getByRole('dialog')
+            .getByRole('button', { name: 'Import', exact: true });
+        this.secretsSearchBox = page.getByRole('searchbox', { name: 'Filter table' });
+        this.clusterBanner = this.page
+            .getByRole('banner')
+            .getByRole('link', { name: 'Clusters' });
+        this.clusterLink = (name) => page.getByRole('link', { name: name });
+        this.clusterSecretTab = this.page.getByRole('tab', {
+            name: 'Connector Secrets',
+        });
+        this.confirmDeleteInput = page.getByRole('textbox', {
+            name: 'Type the word DELETE to confirm',
+        });
+    }
+    async deleteConnectorSecretsIfExist() {
+        try {
+            await (0, test_1.expect)(this.optionsButton.first()).toBeVisible({
+                timeout: 10000,
+            });
+        }
+        catch (error) {
+            return; //No Connector Secrets found in the list
+        }
+        try {
+            let options = await this.optionsButton.all();
+            while (options.length > 0) {
+                const operationButton = options[0];
+                if (await operationButton.isVisible()) {
+                    await operationButton.click({ timeout: 60000 });
+                    await this.deleteConnectorSecretButton.click({ timeout: 60000 });
+                    await (0, test_1.expect)(this.dialog).toBeVisible({ timeout: 40000 });
+                    await this.deleteConnectorSecretSubButton.click();
+                    await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
+                        timeout: 60000,
+                    });
+                }
+                const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+                await sleep(3000);
+                options = await this.optionsButton.all();
+            }
+            await (0, test_1.expect)(this.optionsButton).not.toBeVisible({
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            console.error('Error during Connector Secrets deletion: ', error);
+        }
+    }
+    async clickCreateNewSecretButton(cluster) {
+        try {
+            await this.createNewSecretButton.click({ timeout: 60000 });
+        }
+        catch (error) {
+            await this.clickClusterBanner();
+            await this.clickCluster(cluster);
+            await this.clusterSecretTab.click({ timeout: 30000 });
+            await this.createNewSecretButton.click({ timeout: 30000 });
+        }
+    }
+    async clickClusterBanner() {
+        await (0, test_1.expect)(this.clusterBanner).toBeVisible({ timeout: 30000 });
+        await this.clusterBanner.click({ timeout: 60000 });
+    }
+    async clickCluster(name) {
+        await (0, test_1.expect)(this.clusterLink(name)).toBeVisible({ timeout: 30000 });
+        await this.clusterLink(name).click();
+    }
+    async clickKeyInput() {
+        await (0, test_1.expect)(this.keyInput).toBeVisible({ timeout: 60000 });
+        await this.keyInput.click({ timeout: 30000 });
+    }
+    async fillKeyInput(key) {
+        await this.keyInput.fill(key, { timeout: 30000 });
+    }
+    async clickValueInput() {
+        await (0, test_1.expect)(this.valueInput).toBeVisible({ timeout: 60000 });
+        await this.valueInput.click({ timeout: 30000 });
+    }
+    async fillValueInput(value) {
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.valueInput.fill(value, { timeout: 30000 });
+                const inputValue = await this.valueInput.inputValue();
+                if (inputValue === value) {
+                    return;
+                }
+                console.log(`Attempt ${attempt}: Value input not filled correctly. Expected: "${value}", Got: "${inputValue}"`);
+            }
+            catch (error) {
+                console.log(`Attempt ${attempt}: Error filling value input:`, error);
+            }
+            if (attempt < maxRetries) {
+                await this.valueInput.clear();
+                await this.valueInput.click({ timeout: 30000 });
+                await (0, sleep_1.sleep)(1000);
+            }
+        }
+        throw new Error(`Failed to fill value input after ${maxRetries} attempts`);
+    }
+    async clickCreateButton() {
+        await (0, test_1.expect)(this.createButton).toBeVisible({ timeout: 60000 });
+        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,
+        });
+    }
+    async createSetOfSecrets(cluster, secrets) {
+        await this.bulkImportSecrets(secrets);
+        await this.assertSecretsOrCreate(cluster, secrets);
+    }
+    async assertSecretsOrCreate(cluster, secrets) {
+        for (const secret of secrets) {
+            try {
+                await (0, test_1.expect)(this.secretsSearchBox).toBeVisible();
+                await this.secretsSearchBox.click();
+                await this.secretsSearchBox.fill(secret.name);
+                const row = this.page.getByRole('row', {
+                    name: new RegExp(`^${secret.name}\\b`, 'i'),
+                });
+                await (0, test_1.expect)(row).toBeVisible({ timeout: 5000 });
+            }
+            catch (error) {
+                console.error(`Creating secret for ${secret.name}`);
+                await this.createNewSecret(secret.name, secret.value, cluster);
+            }
+        }
+    }
+    async clickImportButton() {
+        await (0, test_1.expect)(this.importButton).toBeVisible({ timeout: 30000 });
+        await this.importButton.click();
+    }
+    async bulkImportSecrets(secrets) {
+        const mapped = secrets
+            .map((secret) => `${secret.name}=${secret.value}`)
+            .join('\n');
+        await this.clickImportButton();
+        if (!(await this.dialog.isVisible())) {
+            await (0, expectLocatorWithRetry_1.expectLocatorWithRetry)(this.page, this.fromFileButton, {
+                postAction: async () => {
+                    await this.clickImportButton();
+                },
+            });
+            await this.fromFileButton.click();
+        }
+        await (0, test_1.expect)(this.dialog).toBeVisible();
+        await this.bulkImportTextArea.click();
+        await this.bulkImportTextArea.fill(mapped);
+        await this.dialogImportButton.click();
+        await (0, test_1.expect)(this.page.getByText('Importing secrets...')).not.toBeVisible({
+            timeout: 60000,
+        });
+        await (0, test_1.expect)(this.createNewSecretButton).toBeVisible({
+            timeout: 60000,
+        });
+    }
+}
+exports.ClusterSecretsPage = ClusterSecretsPage;

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

@@ -0,0 +1,19 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorMarketplacePage {
+    private page;
+    readonly searchForConnectorTextbox: Locator;
+    readonly downloadToProjectButton: Locator;
+    readonly snackbar: Locator;
+    readonly closeButton: Locator;
+    readonly replaceResourceButton: Locator;
+    readonly cancelButton: Locator;
+    constructor(page: Page);
+    clickSearchForConnectorTextbox(): Promise<void>;
+    fillSearchForConnectorTextbox(connectorName: string): Promise<void>;
+    clickDownloadToProjectButton(): Promise<void>;
+    clickSnackbar(): Promise<void>;
+    clickCloseButton(): Promise<void>;
+    clickReplaceResourceButton(): Promise<void>;
+    downloadConnectorToProject(): Promise<void>;
+}
+export { ConnectorMarketplacePage };

package/dist/pages/8.10/ConnectorMarketplacePage.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorMarketplacePage = void 0;
+class ConnectorMarketplacePage {
+    page;
+    searchForConnectorTextbox;
+    downloadToProjectButton;
+    snackbar;
+    closeButton;
+    replaceResourceButton;
+    cancelButton;
+    constructor(page) {
+        this.page = page;
+        this.searchForConnectorTextbox = page.getByPlaceholder('Search for a connector');
+        this.downloadToProjectButton = page
+            .getByRole('button', { name: 'Download to project' })
+            .first();
+        this.snackbar = page.locator('[data-test="snackbar"]');
+        this.closeButton = page.getByRole('button', { name: 'Close' });
+        this.replaceResourceButton = page.getByRole('button', {
+            name: 'Replace resource',
+        });
+        this.cancelButton = page.getByRole('button', { name: 'Cancel' });
+    }
+    async clickSearchForConnectorTextbox() {
+        await this.searchForConnectorTextbox.click({ timeout: 60000 });
+    }
+    async fillSearchForConnectorTextbox(connectorName) {
+        await this.searchForConnectorTextbox.fill(connectorName, { timeout: 60000 });
+    }
+    async clickDownloadToProjectButton() {
+        await this.downloadToProjectButton.click({ timeout: 60000 });
+    }
+    async clickSnackbar() {
+        await this.snackbar.click({ timeout: 120000 });
+    }
+    async clickCloseButton() {
+        await this.closeButton.click({ timeout: 60000 });
+    }
+    async clickReplaceResourceButton() {
+        await this.replaceResourceButton.click({ timeout: 60000 });
+    }
+    async downloadConnectorToProject() {
+        await this.clickDownloadToProjectButton();
+        try {
+            await Promise.race([
+                this.replaceResourceButton.click({ timeout: 20000 }),
+                this.cancelButton.click({ timeout: 20000 }),
+            ]);
+        }
+        catch (e) {
+            return;
+        }
+    }
+}
+exports.ConnectorMarketplacePage = ConnectorMarketplacePage;