@camunda/e2e-test-suite 0.0.1

package/dist/pages/8.5/ClusterPage.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class ClusterPage {
+    defaultClusterType = 'G3-Dev';
+    page;
+    createNewClusterButton;
+    clusterNameInput;
+    createClusterButton;
+    clusterCreatingStatusText;
+    clusterHealthyStatusText;
+    clusterHealthyIndicatorSelector;
+    clusterGenerationCompleteMessage;
+    clustersBreadcrumb;
+    deleteClusterButton;
+    confirmDeleteInput;
+    dangerDeleteButton;
+    connectorSecretsTab;
+    createAClusterButton;
+    clusterVersionOption;
+    alphaTab;
+    devTab;
+    stableTab;
+    qaGenerationsTab;
+    gcpRegion;
+    clustersList;
+    g3DevClusterType;
+    constructor(page) {
+        this.page = page;
+        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')
+            .getByRole('link', { name: 'Clusters' });
+        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.connectorSecretsTab = page.getByRole('tab', {
+            name: 'Connector Secrets',
+        });
+        this.createAClusterButton = page.getByRole('button', {
+            name: 'Create a Cluster',
+        });
+        this.clusterVersionOption = page
+            .locator('label')
+            .filter({ hasText: `${process.env.CLUSTER_VERSION}` })
+            .locator('span')
+            .first();
+        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.g3DevClusterType = page.locator('label').filter({
+            hasText: this.defaultClusterType,
+        });
+    }
+    async clickClusterTab() {
+        try {
+            const urlCheckPromise = this.page.waitForURL(/\/clusters/, {
+                timeout: 60000,
+            });
+            await urlCheckPromise;
+        }
+        catch (error) {
+            await this.clickClusterBanner();
+        }
+    }
+    async clickClusterBanner() {
+        await this.page
+            .getByRole('banner')
+            .getByRole('link', { name: 'Clusters' })
+            .click({ timeout: 60000 });
+    }
+    async createCluster(name, region = 'GCP') {
+        await this.clickClusterTab();
+        await this.deleteCluster(name);
+        await this.clickCreateNewClusterButton();
+        await this.clickClusterNameInput();
+        await this.fillClusterNameInput(name);
+        await this.clickClusterType();
+        await this.clickCloudProvider(region);
+        await this.clickClusterOption();
+        await this.clickCreateClusterButton();
+        await this.clickClustersBreadcrumb(name);
+    }
+    async clickCloudProvider(region = 'GCP') {
+        const provider = this.page.getByRole('tab', { name: region });
+        await (0, test_1.expect)(provider).toBeVisible({ timeout: 60000 });
+        await provider.click();
+    }
+    async createClusterIfNotExists(clusterName) {
+        await (0, sleep_1.sleep)(10000);
+        if ((await this.cluster(clusterName).isVisible({ timeout: 20000 })) &&
+            (await this.isClusterHealthy(clusterName))) {
+            console.log(`${clusterName} exists and is healthy.`);
+        }
+        else {
+            await this.createCluster(clusterName);
+            await this.assertClusterHealthyStatusWithRetry(clusterName, 300000);
+        }
+    }
+    async isClusterHealthy(name) {
+        return this.cluster(name)
+            .getByText(`Healthy`, { exact: true })
+            .isVisible({ timeout: 20000 });
+    }
+    async assertClusterHealthyStatusWithRetry(name, timeout = 140000, maxRetries = 3, retryDelay = 20000) {
+        const healthCheck = this.cluster(name).getByText(`Healthy`, { exact: true });
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await (0, test_1.expect)(healthCheck).toBeVisible({
+                    timeout: timeout,
+                });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed. Retrying...`);
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+                else {
+                    throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async deleteCluster(name) {
+        await (0, sleep_1.sleep)(5000);
+        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 (0, sleep_1.sleep)(20000);
+    }
+    cluster(name) {
+        return this.clustersList.filter({ hasText: name });
+    }
+    async clickClusterType() {
+        if (process.env.IS_PROD !== 'true') {
+            await (0, test_1.expect)(this.g3DevClusterType).toBeVisible({ timeout: 60000 });
+            await this.g3DevClusterType.click();
+        }
+    }
+    async clickCreateNewClusterButton() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    await this.createNewClusterButton.click({ timeout: 60000 });
+                }
+                else {
+                    await this.clickClusterBanner();
+                    await this.createNewClusterButton.click({ timeout: 60000 });
+                }
+                return;
+            }
+            catch (error) {
+                console.error(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the create a new cluster button after ${maxRetries} attempts.`);
+    }
+    async clickClusterNameInput() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    await this.clusterNameInput.click({ timeout: 30000 });
+                }
+                else {
+                    await this.clickClusterBanner();
+                    await this.clusterNameInput.click({ timeout: 30000 });
+                }
+                return;
+            }
+            catch (error) {
+                console.error(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the create a new cluster button after ${maxRetries} attempts.`);
+    }
+    async fillClusterNameInput(name) {
+        await this.clusterNameInput.fill(name);
+    }
+    async clickCreateClusterButton() {
+        await this.createClusterButton.click({ timeout: 120000 });
+    }
+    async clickClustersBreadcrumb(clusterName) {
+        const regex = new RegExp(`${clusterName}.*?Creatingdev`);
+        try {
+            await this.clustersBreadcrumb.click({ timeout: 60000 });
+            await (0, test_1.expect)(this.page.getByText(regex)).toBeVisible({
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            const healthyCheckRegex = new RegExp(`${clusterName}.*?Healthydev`);
+            await this.clickClusterBanner();
+            await (0, test_1.expect)(this.page.getByText(healthyCheckRegex)).toBeVisible({
+                timeout: 120000,
+            });
+        }
+    }
+    async clickClusterLink(name) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (retries === 0) {
+                    await this.cluster(name)
+                        .getByRole('link', {
+                        name: name,
+                    })
+                        .click({ timeout: 60000 });
+                }
+                else {
+                    await this.clickClusterBanner();
+                    await this.cluster(name)
+                        .getByRole('link', {
+                        name: name,
+                    })
+                        .click({ timeout: 60000 });
+                }
+                return;
+            }
+            catch (error) {
+                await this.page.reload();
+                console.error(`Click attempt ${retries + 1} failed: ${error}`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+        }
+        throw new Error(`Failed to click the cluster link link after ${maxRetries} attempts.`);
+    }
+    async clickConnectorSecretesTab(clusterName) {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                await this.connectorSecretsTab.click();
+                return;
+            }
+            catch (error) {
+                console.error(`Click attempt ${retries + 1} failed: ${error}`);
+                if (retries === 0) {
+                    try {
+                        await this.clickClusterBanner();
+                        await this.clickClusterLink(clusterName);
+                    }
+                    catch (error) {
+                        console.error(`Camunda apps click attempt failed: ${error}`);
+                    }
+                }
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        throw new Error(`Failed to click the tasklist link after ${maxRetries} attempts.`);
+    }
+    async clickClusterOption() {
+        const tabs = [
+            this.clickStableTab,
+            this.clickDevTab,
+            this.clickQAGenerationsTab,
+            this.clickAlphaTab,
+        ];
+        for (const clickTab of tabs) {
+            try {
+                await clickTab.call(this);
+                await this.clusterVersionOption.click({ timeout: 25000 });
+                return;
+            }
+            catch (error) {
+                console.error('Error clicking tab or cluster version option:', error);
+            }
+        }
+        throw new Error('Failed to find cluster generation');
+    }
+    async clickAlphaTab() {
+        await this.alphaTab.click();
+    }
+    async clickDevTab() {
+        await this.devTab.click();
+    }
+    async clickStableTab() {
+        await this.stableTab.click();
+    }
+    async clickQAGenerationsTab() {
+        await this.qaGenerationsTab.click();
+    }
+}
+exports.ClusterPage = ClusterPage;

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

@@ -0,0 +1,21 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterSecretsPage {
+    private page;
+    readonly createNewSecretButton: Locator;
+    readonly keyInput: Locator;
+    readonly valueInput: Locator;
+    readonly createButton: Locator;
+    readonly operationsButton: Locator;
+    readonly deleteConnectorSecretButton: Locator;
+    readonly deleteConnectorSecretSubButton: Locator;
+    readonly dialog: Locator;
+    constructor(page: Page);
+    clickCreateNewSecretButton(): Promise<void>;
+    deleteConnectorSecretsIfExist(): Promise<void>;
+    clickKeyInput(): Promise<void>;
+    fillKeyInput(key: string): Promise<void>;
+    clickValueInput(): Promise<void>;
+    fillValueInput(value: string): Promise<void>;
+    clickCreateButton(): Promise<void>;
+}
+export { ClusterSecretsPage };

package/dist/pages/8.5/ClusterSecretsPage.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterSecretsPage = void 0;
+const test_1 = require("@playwright/test");
+class ClusterSecretsPage {
+    page;
+    createNewSecretButton;
+    keyInput;
+    valueInput;
+    createButton;
+    operationsButton;
+    deleteConnectorSecretButton;
+    deleteConnectorSecretSubButton;
+    dialog;
+    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.operationsButton = page.getByRole('button', {
+            name: 'operations',
+            exact: true,
+        });
+        this.deleteConnectorSecretButton = page.getByRole('menuitem', {
+            name: 'delete',
+        });
+        this.deleteConnectorSecretSubButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.dialog = page.getByRole('dialog');
+    }
+    async clickCreateNewSecretButton() {
+        try {
+            await this.createNewSecretButton.click({ timeout: 60000 });
+        }
+        catch (error) {
+            await this.page
+                .getByRole('banner')
+                .getByRole('link', { name: 'Clusters' })
+                .click({ timeout: 60000 });
+            await this.page
+                .getByRole('link', { name: 'Test Cluster' })
+                .click({ timeout: 60000 });
+            await this.page
+                .getByRole('tab', {
+                name: 'Connector Secrets',
+            })
+                .click({ timeout: 60000 });
+            await this.createNewSecretButton.click({ timeout: 60000 });
+        }
+    }
+    async deleteConnectorSecretsIfExist() {
+        try {
+            await (0, test_1.expect)(this.operationsButton.first()).toBeVisible({
+                timeout: 10000,
+            });
+        }
+        catch (error) {
+            return; //No Connector Secrets found in the list
+        }
+        try {
+            let operations = await this.operationsButton.all();
+            while (operations.length > 0) {
+                const operationButton = operations[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);
+                operations = await this.operationsButton.all();
+            }
+            await (0, test_1.expect)(this.operationsButton).not.toBeVisible({
+                timeout: 30000,
+            });
+        }
+        catch (error) {
+            console.error('Error during Connector Secrets deletion: ', error);
+        }
+    }
+    async clickKeyInput() {
+        await this.keyInput.click();
+    }
+    async fillKeyInput(key) {
+        await this.keyInput.fill(key);
+    }
+    async clickValueInput() {
+        await this.valueInput.click();
+    }
+    async fillValueInput(value) {
+        await this.valueInput.fill(value);
+    }
+    async clickCreateButton() {
+        await this.createButton.click();
+    }
+}
+exports.ClusterSecretsPage = ClusterSecretsPage;

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

@@ -0,0 +1,18 @@
+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;
+    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.5/ConnectorMarketplacePage.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorMarketplacePage = void 0;
+const test_1 = require("@playwright/test");
+class ConnectorMarketplacePage {
+    page;
+    searchForConnectorTextbox;
+    downloadToProjectButton;
+    snackbar;
+    closeButton;
+    replaceResourceButton;
+    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',
+        });
+    }
+    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() {
+        try {
+            await this.clickDownloadToProjectButton();
+            await (0, test_1.expect)(this.snackbar).toBeVisible({
+                timeout: 90000,
+            });
+            await this.clickSnackbar();
+        }
+        catch {
+            await this.clickReplaceResourceButton();
+            await (0, test_1.expect)(this.snackbar).toBeVisible({
+                timeout: 90000,
+            });
+            await this.clickSnackbar();
+        }
+    }
+}
+exports.ConnectorMarketplacePage = ConnectorMarketplacePage;

package/dist/pages/8.5/ConnectorSettingsPage.d.ts

@@ -0,0 +1,28 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorSettingsPage {
+    private page;
+    readonly urlInput: Locator;
+    readonly resultExpressionInput: Locator;
+    readonly authenticationTypeDropdown: Locator;
+    readonly usernameInput: Locator;
+    readonly passwordInput: Locator;
+    readonly methodTypeDropdown: Locator;
+    readonly resultVariableInput: Locator;
+    readonly bearerTokenInput: Locator;
+    constructor(page: Page);
+    clickUrlInput(): Promise<void>;
+    fillUrlInput(url: string): Promise<void>;
+    clickResultExpressionInput(): Promise<void>;
+    fillResultExpressionInput(resultExpression: string): Promise<void>;
+    selectAuthenticationType(authentication: string): Promise<void>;
+    clickUsernameInput(): Promise<void>;
+    fillUsernameInput(username: string): Promise<void>;
+    clickPasswordInput(): Promise<void>;
+    fillPasswordInput(password: string): Promise<void>;
+    selectMethodType(method: string): Promise<void>;
+    clickResultVariableInput(): Promise<void>;
+    fillResultVariableInput(variable: string): Promise<void>;
+    clickBearerTokenInput(): Promise<void>;
+    fillBearerTokenInput(token: string): Promise<void>;
+}
+export { ConnectorSettingsPage };

package/dist/pages/8.5/ConnectorSettingsPage.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorSettingsPage = void 0;
+class ConnectorSettingsPage {
+    page;
+    urlInput;
+    resultExpressionInput;
+    authenticationTypeDropdown;
+    usernameInput;
+    passwordInput;
+    methodTypeDropdown;
+    resultVariableInput;
+    bearerTokenInput;
+    constructor(page) {
+        this.page = page;
+        this.urlInput = page.getByLabel('URL');
+        this.resultExpressionInput = page.getByRole('textbox', {
+            name: /^Result expression$/,
+        });
+        this.authenticationTypeDropdown = page.getByLabel('Type');
+        this.usernameInput = page.getByLabel('Username');
+        this.passwordInput = page.getByLabel('Password');
+        this.methodTypeDropdown = page.getByLabel('Method');
+        this.resultVariableInput = page.getByLabel('Result variable');
+        this.bearerTokenInput = page.getByLabel('Bearer token');
+    }
+    async clickUrlInput() {
+        await this.urlInput.click({ timeout: 90000 });
+    }
+    async fillUrlInput(url) {
+        await this.urlInput.fill(url, { timeout: 90000 });
+    }
+    async clickResultExpressionInput() {
+        await this.resultExpressionInput.click({ timeout: 90000 });
+    }
+    async fillResultExpressionInput(resultExpression) {
+        await this.resultExpressionInput.fill(resultExpression, {
+            timeout: 120000,
+            force: true,
+        });
+    }
+    async selectAuthenticationType(authentication) {
+        await this.authenticationTypeDropdown.selectOption(authentication, {
+            timeout: 60000,
+        });
+    }
+    async clickUsernameInput() {
+        await this.usernameInput.click({ timeout: 90000 });
+    }
+    async fillUsernameInput(username) {
+        await this.usernameInput.fill(username, { timeout: 60000 });
+    }
+    async clickPasswordInput() {
+        await this.passwordInput.click({ timeout: 60000 });
+    }
+    async fillPasswordInput(password) {
+        await this.passwordInput.fill(password, { timeout: 60000 });
+    }
+    async selectMethodType(method) {
+        await this.methodTypeDropdown.selectOption(method, { timeout: 60000 });
+    }
+    async clickResultVariableInput() {
+        await this.resultVariableInput.click({ timeout: 60000 });
+    }
+    async fillResultVariableInput(variable) {
+        await this.resultVariableInput.fill(variable, { timeout: 90000 });
+    }
+    async clickBearerTokenInput() {
+        await this.bearerTokenInput.click({ timeout: 60000 });
+    }
+    async fillBearerTokenInput(token) {
+        await this.bearerTokenInput.fill(token, { timeout: 60000 });
+    }
+}
+exports.ConnectorSettingsPage = ConnectorSettingsPage;

package/dist/pages/8.5/ConnectorTemplatePage.d.ts

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorTemplatePage {
+    private page;
+    readonly publishToOrgButton: Locator;
+    readonly publishButton: Locator;
+    constructor(page: Page);
+    clickPublishToOrgButton(): Promise<void>;
+    clickPublishButton(): Promise<void>;
+    publishConnector(): Promise<void>;
+}
+export { ConnectorTemplatePage };

package/dist/pages/8.5/ConnectorTemplatePage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorTemplatePage = void 0;
+const test_1 = require("@playwright/test");
+class ConnectorTemplatePage {
+    page;
+    publishToOrgButton;
+    publishButton;
+    constructor(page) {
+        this.page = page;
+        this.publishButton = page.getByRole('button', {
+            name: 'Publish',
+            exact: true,
+        });
+        this.publishToOrgButton = page.locator('[data-test="publish-to-org"]');
+    }
+    async clickPublishToOrgButton() {
+        await this.publishToOrgButton.click({ timeout: 90000 });
+    }
+    async clickPublishButton() {
+        await this.publishButton.click({ timeout: 90000 });
+    }
+    async publishConnector() {
+        try {
+            await (0, test_1.expect)(this.publishToOrgButton).toBeVisible({ timeout: 15000 });
+        }
+        catch (error) {
+            return;
+        }
+        await this.clickPublishToOrgButton();
+        await this.clickPublishButton();
+    }
+}
+exports.ConnectorTemplatePage = ConnectorTemplatePage;