@camunda/e2e-test-suite 0.0.1442 → 0.0.1444

package/dist/pages/SM-8.11/ConnectorMarketplacePage.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorMarketplacePage = void 0;
+const test_1 = require("@playwright/test");
+const BrowseAllConnectorMarketplacePage_1 = require("../BrowseAllConnectorMarketplacePage");
+const sleep_1 = require("../../utils/sleep");
+class ConnectorMarketplacePage {
+    page;
+    browseAllConnectorMarketplacePage;
+    connectorName;
+    legacyMarketplaceDialog;
+    searchForConnectorTextbox;
+    downloadToProjectButton;
+    addToProjectButton;
+    replaceResourceButton;
+    saveAsCopyButton;
+    cancelButton;
+    marketplaceErrorMessage;
+    noResultsMessage;
+    constructor(page) {
+        this.page = page;
+        this.browseAllConnectorMarketplacePage =
+            new BrowseAllConnectorMarketplacePage_1.BrowseAllConnectorMarketplacePage(page);
+        this.searchForConnectorTextbox =
+            this.browseAllConnectorMarketplacePage.searchForConnectorTextbox
+                .or(page.getByPlaceholder('Search for a connector'))
+                .first();
+        this.legacyMarketplaceDialog = page
+            .getByRole('dialog', { name: 'Browse Marketplace connectors' })
+            .or(page.getByRole('dialog', { name: 'Discover Connectors Dialog' }))
+            .first();
+        this.downloadToProjectButton = page
+            .getByRole('button', { name: 'Download to project' })
+            .first();
+        this.cancelButton = page.getByRole('button', { name: 'Cancel' });
+        this.addToProjectButton = page.getByRole('button', {
+            name: 'Add to project',
+        });
+        this.replaceResourceButton = page.getByRole('button', {
+            name: 'Replace resource',
+        });
+        this.saveAsCopyButton = page.getByRole('button', { name: 'Save as copy' });
+        this.marketplaceErrorMessage = page.getByText('an error occurred, please try again later');
+        this.noResultsMessage = page.getByText('find a match for your search phrase');
+    }
+    async clickSearchForConnectorTextbox() {
+        await this.searchForConnectorTextbox.click({ timeout: 60000 });
+        await (0, sleep_1.sleep)(2000);
+    }
+    async fillSearchForConnectorTextbox(connectorName) {
+        this.connectorName = connectorName;
+        await this.searchForConnectorTextbox.fill(connectorName, { timeout: 60000 });
+        await (0, sleep_1.sleep)(2000);
+    }
+    async clickDownloadToProjectButton() {
+        await this.getLegacyDownloadButton().click({ timeout: 60000 });
+    }
+    async clickCancelButton() {
+        await this.cancelButton.click({ timeout: 30000 });
+    }
+    async clickReplaceResourceButton() {
+        await this.replaceResourceButton.click({ timeout: 30000 });
+    }
+    async waitForConnectorSearchResults() {
+        if (await this.browseAllConnectorMarketplacePage.isOpen()) {
+            await this.browseAllConnectorMarketplacePage.waitForConnectorSearchResult(this.connectorName);
+            return;
+        }
+        const MAX_RETRIES = 4;
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            const downloadButton = this.getLegacyDownloadButton();
+            await (0, test_1.expect)(downloadButton
+                .or(this.marketplaceErrorMessage)
+                .or(this.noResultsMessage)).toBeVisible({ timeout: 60000 });
+            if (await downloadButton.isVisible()) {
+                return;
+            }
+            console.log(`Marketplace search attempt ${attempt} of ${MAX_RETRIES} returned an error or no results. Retrying search...`);
+            if (attempt < MAX_RETRIES) {
+                // The marketplace search API returns transient 5xx. Back off for
+                // growing intervals before re-issuing the query so a short outage
+                // self-heals instead of burning all attempts inside a few seconds.
+                await (0, sleep_1.sleep)(attempt * 5000);
+                const searchText = await this.searchForConnectorTextbox.inputValue();
+                await this.searchForConnectorTextbox.clear();
+                await (0, sleep_1.sleep)(2000);
+                await this.searchForConnectorTextbox.fill(searchText);
+                await (0, sleep_1.sleep)(2000);
+            }
+        }
+        throw new Error('Marketplace connector search failed after retries due to persistent error or no matching results');
+    }
+    async downloadConnectorToProject() {
+        if (await this.browseAllConnectorMarketplacePage.isOpen()) {
+            await this.browseAllConnectorMarketplacePage.importConnectorToProject(this.connectorName);
+            return;
+        }
+        await this.clickDownloadToProjectButton();
+        if (await this.confirmImport()) {
+            return;
+        }
+        // The modal is up but rendered none of the known import actions. Dismiss it
+        // so it does not block the next click on the diagram, then fail here:
+        // continuing would leave the diagram's connector template unresolved
+        // ("Template: Not found") and only surface 60s later as a missing
+        // properties-panel group, pointing at the wrong step.
+        if (await this.cancelButton.isVisible().catch(() => false)) {
+            await this.cancelButton.click({ timeout: 20000 });
+            throw new Error('Connector import modal offered no import action ("Add to project", "Replace resource" or "Save as copy"); the import was abandoned.');
+        }
+        // Hub imported without asking for confirmation, so the write is in flight
+        // here too.
+        await this.waitForImportToSettle();
+    }
+    // Hub's import modal labels its primary button after the project state:
+    // "Add to project" when the template is new to the project, "Replace
+    // resource" when the same template is already there, "Save as copy" on a
+    // conflicting version. Probe them in order and click the one actually
+    // rendered; clicking "Cancel" instead abandons the import and leaves the
+    // diagram's connector template unresolved ("Template: Not found"), which
+    // only surfaces much later as a missing properties-panel group.
+    async confirmImport() {
+        const importButtons = [
+            this.addToProjectButton,
+            this.replaceResourceButton,
+            this.saveAsCopyButton,
+        ];
+        // Carbon animates the modal in, so a click issued mid-transition is
+        // rejected ("element is not stable") and by the next Playwright retry the
+        // button can already be gone; keep probing the labels until one click
+        // actually lands instead of burning the whole budget on a single button.
+        const deadline = Date.now() + 45000;
+        do {
+            for (const button of importButtons) {
+                if (!(await button.isVisible().catch(() => false))) {
+                    continue;
+                }
+                // Register the waiter before the click: the write can be acknowledged
+                // before the modal finishes unmounting.
+                const templateWritten = this.page
+                    .waitForResponse((response) => response.request().method() === 'POST' &&
+                    response.url().includes('/internal/files'), { timeout: 30000 })
+                    .catch(() => null);
+                const clicked = await button
+                    .click({ timeout: 5000 })
+                    .then(() => true)
+                    .catch(() => false);
+                if (!clicked) {
+                    continue;
+                }
+                await (0, test_1.expect)(button).toBeHidden({ timeout: 60000 });
+                const written = await templateWritten;
+                // A rejected write leaves the project without the template just like
+                // an aborted one, so surface the status here instead of letting it
+                // resurface 60s later as a missing "Authentication" group in
+                // ModelerCreatePage.
+                if (written && !written.ok()) {
+                    throw new Error(`Connector template import failed: writing it into the project returned HTTP ${written.status()}.`);
+                }
+                await this.waitForImportToSettle();
+                return true;
+            }
+            await (0, sleep_1.sleep)(1000);
+        } while (Date.now() < deadline);
+        return false;
+    }
+    // Hub unmounts the ImportModal as soon as the click is handled, but writes the
+    // template into the project with a POST that is still in flight at that point.
+    // Returning right after the button hides let the caller's `page.reload()`
+    // abort that write ~20ms later, leaving the project's connector-template list
+    // empty and every templated task on the diagram at "Template: Not found" --
+    // the properties panel then never renders the "Authentication" group.
+    async waitForImportToSettle() {
+        await this.page.waitForLoadState('networkidle').catch(() => { });
+    }
+    getLegacyDownloadButton() {
+        if (!this.connectorName) {
+            return this.downloadToProjectButton;
+        }
+        return this.legacyMarketplaceDialog
+            .getByText(this.connectorName, { exact: true })
+            .first()
+            .locator('xpath=ancestor::*[.//button[normalize-space()="Download to project"]][1]')
+            .getByRole('button', { name: 'Download to project' });
+    }
+}
+exports.ConnectorMarketplacePage = ConnectorMarketplacePage;

package/dist/pages/SM-8.11/ConnectorSettingsPage.d.ts

@@ -0,0 +1,41 @@
+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;
+    readonly authenticationTab: Locator;
+    readonly outputMappingTab: Locator;
+    readonly httpEndpointTab: Locator;
+    readonly correlationTab: Locator;
+    readonly inputTab: Locator;
+    readonly webhookConfigurationTab: 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>;
+    private clickTabWithRetry;
+    clickAuthenticationTab(): Promise<void>;
+    clickOutputMappingTab(): Promise<void>;
+    clickHTTPEndpointTab(): Promise<void>;
+    clickCorrelationTab(): Promise<void>;
+    clickInputTab(): Promise<void>;
+    clickWebhookConfigurationTab(): Promise<void>;
+}
+export { ConnectorSettingsPage };

package/dist/pages/SM-8.11/ConnectorSettingsPage.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorSettingsPage = void 0;
+const test_1 = require("@playwright/test");
+class ConnectorSettingsPage {
+    page;
+    urlInput;
+    resultExpressionInput;
+    authenticationTypeDropdown;
+    usernameInput;
+    passwordInput;
+    methodTypeDropdown;
+    resultVariableInput;
+    bearerTokenInput;
+    authenticationTab;
+    outputMappingTab;
+    httpEndpointTab;
+    correlationTab;
+    inputTab;
+    webhookConfigurationTab;
+    constructor(page) {
+        this.page = page;
+        this.urlInput = page.getByLabel('URL');
+        this.resultExpressionInput = page.getByLabel('Result expression');
+        this.authenticationTypeDropdown = page.getByLabel('Type');
+        this.usernameInput = page.getByLabel('Username');
+        this.passwordInput = page.getByLabel('Password', { exact: true });
+        this.methodTypeDropdown = page.getByLabel('Method');
+        this.resultVariableInput = page.getByLabel('Result variable');
+        this.bearerTokenInput = page.getByLabel('Bearer token');
+        this.authenticationTab = page
+            .locator('div')
+            .filter({ hasText: /^Authentication$/ })
+            .first();
+        this.outputMappingTab = page
+            .locator('div')
+            .filter({ hasText: /^Output mapping$/ })
+            .first();
+        this.httpEndpointTab = page
+            .locator('div')
+            .filter({ hasText: /^HTTP endpoint$/ })
+            .first();
+        this.correlationTab = page
+            .locator('div')
+            .filter({ hasText: /^Correlation$/ })
+            .first();
+        this.inputTab = page
+            .locator('div')
+            .filter({ hasText: /^Input$/ })
+            .first();
+        this.webhookConfigurationTab = page
+            .locator('div')
+            .filter({ hasText: /^Webhook configuration$/ })
+            .first();
+    }
+    async clickUrlInput() {
+        try {
+            await this.urlInput.click({ timeout: 60000 });
+        }
+        catch {
+            await this.httpEndpointTab.click();
+            await this.urlInput.click({ timeout: 60000 });
+        }
+    }
+    async fillUrlInput(url) {
+        await this.urlInput.fill(url);
+        await (0, test_1.expect)(this.page.getByText('URL must not be empty.')).not.toBeVisible({ timeout: 30000 });
+    }
+    async clickResultExpressionInput() {
+        try {
+            await this.resultExpressionInput.click();
+        }
+        catch {
+            await this.clickOutputMappingTab();
+            await this.resultExpressionInput.click();
+        }
+    }
+    async fillResultExpressionInput(resultExpression) {
+        await this.resultExpressionInput.fill(resultExpression);
+    }
+    async selectAuthenticationType(authentication) {
+        await this.authenticationTypeDropdown.selectOption(authentication);
+    }
+    async clickUsernameInput() {
+        await this.usernameInput.click({ timeout: 30000 });
+    }
+    async fillUsernameInput(username) {
+        await this.usernameInput.fill(username, { timeout: 30000 });
+        await (0, test_1.expect)(this.page.getByText('Username must not be empty.')).not.toBeVisible({ timeout: 30000 });
+    }
+    async clickPasswordInput() {
+        await this.passwordInput.click();
+    }
+    async fillPasswordInput(password) {
+        await this.passwordInput.fill(password);
+        await (0, test_1.expect)(this.page.getByText('Password must not be empty.')).not.toBeVisible({ timeout: 30000 });
+    }
+    async selectMethodType(method) {
+        await this.methodTypeDropdown.selectOption(method, { timeout: 60000 });
+    }
+    async clickResultVariableInput() {
+        await this.resultVariableInput.click();
+    }
+    async fillResultVariableInput(variable) {
+        await this.resultVariableInput.fill(variable);
+    }
+    async clickBearerTokenInput() {
+        await this.bearerTokenInput.click({ timeout: 30000 });
+    }
+    async fillBearerTokenInput(token) {
+        await this.bearerTokenInput.fill(token);
+        await (0, test_1.expect)(this.page.getByText('Bearer token must not be empty.')).not.toBeVisible({ timeout: 30000 });
+    }
+    // Connector settings tabs can take several seconds to render on slower clusters
+    // after the element type is changed. Each clickXxxTab method retries with a
+    // reload-free wait so a single slow render doesn't cause a hard timeout failure.
+    async clickTabWithRetry(tab, tabName, maxAttempts = 3) {
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                await (0, test_1.expect)(tab).toBeVisible({ timeout: 30000 });
+                await tab.click({ timeout: 30000 });
+                return;
+            }
+            catch (err) {
+                lastError = err;
+                console.warn(`clickTabWithRetry: "${tabName}" attempt ${attempt + 1}/${maxAttempts} failed: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`Tab "${tabName}" not clickable after ${maxAttempts} attempts`);
+    }
+    async clickAuthenticationTab() {
+        await this.clickTabWithRetry(this.authenticationTab, 'Authentication');
+    }
+    async clickOutputMappingTab() {
+        await this.clickTabWithRetry(this.outputMappingTab, 'Output mapping');
+    }
+    async clickHTTPEndpointTab() {
+        await this.clickTabWithRetry(this.httpEndpointTab, 'HTTP endpoint');
+    }
+    async clickCorrelationTab() {
+        await this.clickTabWithRetry(this.correlationTab, 'Correlation');
+    }
+    async clickInputTab() {
+        await this.clickTabWithRetry(this.inputTab, 'Input');
+    }
+    async clickWebhookConfigurationTab() {
+        await this.clickTabWithRetry(this.webhookConfigurationTab, 'Webhook configuration');
+    }
+}
+exports.ConnectorSettingsPage = ConnectorSettingsPage;

package/dist/pages/SM-8.11/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/SM-8.11/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;

package/dist/pages/SM-8.11/FormJsPage.d.ts

@@ -0,0 +1,33 @@
+import { Page, Locator } from '@playwright/test';
+declare class FormJsPage {
+    private page;
+    readonly aiFormGeneratorButton: Locator;
+    readonly formRequestInput: Locator;
+    readonly generateFormButton: Locator;
+    readonly formEditor: Locator;
+    readonly filePicker: Locator;
+    readonly generalPanel: Locator;
+    readonly keyInput: Locator;
+    readonly uploadMultipleFilesToggle: Locator;
+    readonly documentReferenceInput: Locator;
+    readonly documentPreview: Locator;
+    readonly deployDialog: Locator;
+    readonly deployFormButton: Locator;
+    readonly deployModalSubmitButton: Locator;
+    readonly deploySuccessNotification: Locator;
+    constructor(page: Page);
+    clickAIFormGeneratorButton(): Promise<void>;
+    clickFormRequestInput(): Promise<void>;
+    fillFormRequestInput(formRequest: string): Promise<void>;
+    clickGenerateFormButton(): Promise<void>;
+    dragAndDrop(source: Locator, target: Locator): Promise<void>;
+    clickGeneralPropertiesPanel(): Promise<void>;
+    fillKeyInput(key: string): Promise<void>;
+    enableUploadMultipleFiles(): Promise<void>;
+    filldocumentReferenceInput(key: string): Promise<void>;
+    clickDeployFormButton(): Promise<void>;
+    clickDeployModalSubmitButton(): Promise<void>;
+    selectOnlyThisResource(): Promise<void>;
+    deployForm(): Promise<void>;
+}
+export { FormJsPage };

package/dist/pages/SM-8.11/FormJsPage.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormJsPage = void 0;
+const test_1 = require("@playwright/test");
+const modelerCluster_1 = require("../../utils/modelerCluster");
+const hubDeployDialog_1 = require("../../utils/hubDeployDialog");
+class FormJsPage {
+    page;
+    aiFormGeneratorButton;
+    formRequestInput;
+    generateFormButton;
+    formEditor;
+    filePicker;
+    generalPanel;
+    keyInput;
+    uploadMultipleFilesToggle;
+    documentReferenceInput;
+    documentPreview;
+    deployDialog;
+    deployFormButton;
+    deployModalSubmitButton;
+    deploySuccessNotification;
+    constructor(page) {
+        this.page = page;
+        this.aiFormGeneratorButton = page.getByRole('button', {
+            name: 'AI Form Generator',
+        });
+        this.formRequestInput = page.getByPlaceholder('A form for an american standard loan request');
+        this.generateFormButton = page.getByRole('button', { name: 'Generate form' });
+        this.formEditor = page.getByLabel('Form Definition');
+        this.filePicker = page.locator('button[data-field-type="filepicker"]');
+        this.generalPanel = page.locator('[data-group-id="group-general"]').first();
+        this.keyInput = page.getByRole('textbox', { name: 'key' });
+        this.uploadMultipleFilesToggle = page.locator('div[data-entry-id="multiple"] .bio-properties-panel-toggle-switch__switcher');
+        this.documentReferenceInput = page.getByRole('textbox', {
+            name: 'document reference',
+        });
+        this.documentPreview = page.locator('button[data-field-type="documentPreview"]');
+        this.deployDialog = page.getByRole('dialog');
+        // The Design System shell renders none of Carbon's cds-- classes, so the
+        // editor's Deploy button, the dialog's submit and the success toast are all
+        // matched by role and text instead -- which resolves on both shells.
+        // .first(): once the deploy dialog is open its submit carries the same
+        // accessible name; the editor's button is the earlier one in the DOM.
+        this.deployFormButton = page
+            .getByRole('button', { name: 'Deploy', exact: true })
+            .first();
+        this.deployModalSubmitButton = this.deployDialog
+            .getByRole('button', { name: 'Deploy', exact: true })
+            .or(page.locator('button[data-modal-primary-focus="true"][type="submit"]'))
+            .first();
+        this.deploySuccessNotification = page.getByText('Form deployed!').first();
+    }
+    async clickAIFormGeneratorButton() {
+        await this.aiFormGeneratorButton.click();
+    }
+    async clickFormRequestInput() {
+        await this.formRequestInput.click();
+    }
+    async fillFormRequestInput(formRequest) {
+        await this.formRequestInput.fill(formRequest);
+    }
+    async clickGenerateFormButton() {
+        await this.generateFormButton.click();
+    }
+    async dragAndDrop(source, target) {
+        await source.waitFor();
+        await target.waitFor();
+        await source.dragTo(target);
+    }
+    async clickGeneralPropertiesPanel() {
+        await this.generalPanel.click({ timeout: 60000 });
+    }
+    async fillKeyInput(key) {
+        await this.keyInput.fill(key, { timeout: 60000 });
+    }
+    async enableUploadMultipleFiles() {
+        await this.uploadMultipleFilesToggle.click({ timeout: 60000 });
+    }
+    async filldocumentReferenceInput(key) {
+        await this.documentReferenceInput.fill(key, { timeout: 60000 });
+    }
+    async clickDeployFormButton() {
+        await this.deployFormButton.click({ timeout: 60000 });
+    }
+    async clickDeployModalSubmitButton() {
+        await this.deployModalSubmitButton.click({ timeout: 60000 });
+    }
+    // Since camunda/camunda-hub#25831 a form lives inside a process application,
+    // and Hub scopes Deploy to that application unless the scope is narrowed --
+    // deployProcessApplication, not deployFile, so the "Form deployed!" toast
+    // never fires. Narrowing the scope keeps this a form-deploy test instead of
+    // silently turning it into a process-application deploy. Since
+    // camunda/camunda-hub#29791 Hub preselects "Only this resource" when
+    // deploying from a file, so the shared helper's already-selected guard is
+    // what keeps this from reopening the preselected scope select and failing.
+    async selectOnlyThisResource() {
+        await (0, hubDeployDialog_1.selectOnlyThisResourceInDialog)(this.page, this.deployDialog);
+    }
+    async deployForm() {
+        await this.clickDeployFormButton();
+        await (0, test_1.expect)(this.deployDialog).toBeVisible({ timeout: 30000 });
+        await (0, modelerCluster_1.selectModelerCluster)(this.deployDialog);
+        await this.selectOnlyThisResource();
+        await this.clickDeployModalSubmitButton();
+        await (0, test_1.expect)(this.deploySuccessNotification).toBeVisible({ timeout: 30000 });
+    }
+}
+exports.FormJsPage = FormJsPage;

package/dist/pages/SM-8.11/HomePage.d.ts

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+declare class HomePage {
+    private page;
+    readonly dashboardTab: Locator;
+    readonly clusterTab: Locator;
+    readonly organizationTab: Locator;
+    readonly organizationViewTitle: Locator;
+    readonly welcomeMessage: Locator;
+    readonly informationDialog: Locator;
+    readonly camundaAppsButton: Locator;
+    readonly camundaComponentsButton: Locator;
+    constructor(page: Page);
+    clickClusters(): Promise<void>;
+    clickDashboard(): Promise<void>;
+    clickOrganization(): Promise<void>;
+    closeInformationDialog(): Promise<void>;
+    clickCamundaComponents(): Promise<void>;
+    clickCamundaApps(): Promise<void>;
+}
+export { HomePage };

package/dist/pages/SM-8.11/HomePage.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomePage = void 0;
+class HomePage {
+    page;
+    dashboardTab;
+    clusterTab;
+    organizationTab;
+    organizationViewTitle;
+    welcomeMessage;
+    informationDialog;
+    camundaAppsButton;
+    camundaComponentsButton;
+    constructor(page) {
+        this.page = page;
+        this.dashboardTab = page.getByRole('link', { name: 'Dashboard' });
+        this.clusterTab = page.getByRole('link', { name: 'Clusters' });
+        this.organizationTab = page.getByRole('link', { name: 'Organization' });
+        this.organizationViewTitle = page.getByText('Organization Management');
+        this.welcomeMessage = page.getByText('Welcome, demo').first();
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.camundaComponentsButton = page.getByLabel('Camunda components');
+        this.camundaAppsButton = page.getByLabel('Camunda apps');
+    }
+    async clickClusters() {
+        await this.clusterTab.click({ timeout: 90000 });
+    }
+    async clickDashboard() {
+        await this.dashboardTab.click({ timeout: 90000 });
+    }
+    async clickOrganization() {
+        await this.organizationTab.click({ timeout: 90000 });
+    }
+    async closeInformationDialog() {
+        const isLocalTest = process.env.LOCAL_TEST;
+        if (isLocalTest) {
+            await this.informationDialog.click();
+        }
+    }
+    async clickCamundaComponents() {
+        await this.camundaComponentsButton.click({ timeout: 90000 });
+    }
+    async clickCamundaApps() {
+        await this.camundaAppsButton.click({ timeout: 90000 });
+    }
+}
+exports.HomePage = HomePage;