@camunda/e2e-test-suite 0.0.1442 → 0.0.1444

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

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Authorization = void 0;
+const test_1 = require("@playwright/test");
+const findLocatorWithPagination_1 = require("../../utils/assertionHelpers/findLocatorWithPagination");
+const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
+const sleep_1 = require("../../utils/sleep");
+class Authorization {
+    page;
+    selectResourceTypeTab;
+    createAuthorizationModal;
+    createAuthorizationButton;
+    createAuthorizationOwnerTypeCombobox;
+    createAuthorizationOwnerTypeOption;
+    createAuthorizationOwnerComboBox;
+    createAuthorizationOwnerOption;
+    createAuthorizationOwnerSearchInput;
+    createAuthorizationOwnerSearchOption;
+    createAuthorizationOwnerCommandInput;
+    createAuthorizationOwnerCommandOptions;
+    createAuthorizationResourceTypeDropdown;
+    createAuthorizationResourceTypeOption;
+    createAuthorizationResourceIdField;
+    createAuthorizationAccessPermission;
+    createAuthorizationSubmitButton;
+    authorizationsList;
+    deleteAuthorizationButton;
+    deleteAuthorizationModal;
+    deleteAuthorizationModalDeleteButton;
+    tableFilter;
+    constructor(page) {
+        this.page = page;
+        this.selectResourceTypeTab = (resourceType) => page.getByRole('tab', { name: resourceType });
+        this.authorizationsList = page.getByRole('table');
+        this.createAuthorizationButton = page.getByRole('button', {
+            name: /create authorization/i,
+        });
+        this.createAuthorizationModal = page.getByRole('dialog', {
+            name: 'Create authorization',
+        });
+        this.createAuthorizationOwnerTypeCombobox =
+            this.createAuthorizationModal.getByRole('combobox', {
+                name: 'Owner type',
+            });
+        // The design-system Select portals its listbox to the end of <body>, so
+        // the options are siblings of the dialog rather than descendants, and
+        // while the listbox is open Radix marks everything outside it aria-hidden
+        // - which takes the dialog itself out of the accessibility tree. Query the
+        // options from the page root so both placements resolve.
+        this.createAuthorizationOwnerTypeOption = (name) => this.page
+            .getByRole('option', {
+            name,
+            exact: true,
+        })
+            .first();
+        this.createAuthorizationOwnerComboBox =
+            this.createAuthorizationModal.getByRole('combobox', {
+                name: 'Owner',
+                exact: true,
+            });
+        this.createAuthorizationOwnerOption = (name) => this.createAuthorizationModal.getByRole('option', {
+            name,
+            exact: true,
+        });
+        // Every owner type now renders a server-backed search dropdown instead of
+        // the combobox that listed all owners up front. The dropdown is a Carbon
+        // Search inside a ListBox, so it has no combobox role; its results are
+        // list-box menu items that carry the owner ID as their title. The
+        // design-system build renders the same field as a command palette whose
+        // results are role=option items in a popover portalled out of the dialog.
+        this.createAuthorizationOwnerSearchInput =
+            this.createAuthorizationModal.getByPlaceholder('Search by owner ID');
+        this.createAuthorizationOwnerSearchOption = (name) => this.page
+            .locator('.cds--list-box__menu-item, [role="option"]')
+            .filter({ hasText: name })
+            .first();
+        // In the design-system build the closed Owner control is a combobox-role
+        // trigger that paints "Search by owner ID" as static text (no placeholder
+        // attribute), and the cmdk search box plus its result listbox only mount
+        // in a popover once the trigger is opened. That popover is portalled out
+        // of the dialog, and while it is open Radix marks the dialog aria-hidden,
+        // so both must be queried from the page root.
+        this.createAuthorizationOwnerCommandInput = this.page
+            .locator('[data-slot="command-input"]')
+            .first();
+        this.createAuthorizationOwnerCommandOptions = this.page
+            .getByRole('listbox')
+            .getByRole('option');
+        this.createAuthorizationResourceTypeDropdown =
+            this.createAuthorizationModal.getByRole('combobox', {
+                name: 'Resource type',
+            });
+        this.createAuthorizationResourceTypeOption = (name) => this.page
+            .getByRole('option', {
+            name,
+            exact: true,
+        })
+            .first();
+        this.createAuthorizationResourceIdField =
+            this.createAuthorizationModal.getByRole('textbox', {
+                name: 'Resource ID',
+            });
+        this.createAuthorizationAccessPermission = (name) => this.createAuthorizationModal.locator(`label[for="${name}"]`);
+        this.createAuthorizationSubmitButton =
+            this.createAuthorizationModal.getByRole('button', {
+                name: 'Create authorization',
+            });
+        this.authorizationsList = page.getByRole('table');
+        this.deleteAuthorizationButton = (name) => this.authorizationsList
+            .getByRole('row', { name })
+            .getByRole('button', { name: 'Delete' });
+        this.deleteAuthorizationModal = page.getByRole('dialog', {
+            name: /delete authorization/i,
+        });
+        this.deleteAuthorizationModalDeleteButton =
+            this.deleteAuthorizationModal.getByRole('button', {
+                name: /delete authorization/i,
+            });
+        // Carbon labels the table toolbar search "Filter table"; the
+        // design-system shell the Admin is migrating onto exposes the placeholder
+        // as the accessible name instead. Match either.
+        this.tableFilter = page
+            .getByRole('searchbox', { name: 'Filter table' })
+            .or(page.getByRole('searchbox', { name: 'Search by owner ID' }))
+            .first();
+    }
+    // The Admin's Authorizations page is migrating onto the new design-system
+    // shell, which replaces the per-resource-type tabs with a single filter
+    // combobox (identity/client ListV2.tsx). That combobox's accessible name was
+    // renamed from "Authorization type" to "Resource type" in camunda/camunda
+    // commit 377b0e3; match either so both image versions resolve. Select the
+    // resource type through whichever this build renders: click the tab, or open
+    // the combobox and pick the option.
+    async selectResourceType(resourceType, timeout = 60000) {
+        const tab = this.selectResourceTypeTab(resourceType);
+        const filterCombobox = this.page
+            .getByRole('combobox', { name: 'Resource type' })
+            .or(this.page.getByRole('combobox', { name: 'Authorization type' }));
+        await (0, test_1.expect)(tab.or(filterCombobox)).toBeVisible({ timeout });
+        if (await tab.isVisible()) {
+            await tab.click();
+            return;
+        }
+        await filterCombobox.click();
+        await this.page
+            .getByRole('option', { name: resourceType, exact: true })
+            .click({ timeout: Math.min(timeout, 30000) });
+    }
+    // Released 8.10 alpha images still render the Carbon combobox that lists
+    // every owner, so accept whichever of the three owner fields this build
+    // shows: the Carbon search dropdown, the Carbon combobox that lists every
+    // owner inline, or the design-system combobox whose cmdk popover only loads
+    // results once the owner ID is typed.
+    async selectAuthorizationOwner(ownerId) {
+        await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput.or(this.createAuthorizationOwnerComboBox)).toBeVisible({ timeout: 30000 });
+        if (await this.createAuthorizationOwnerSearchInput.isVisible()) {
+            await this.createAuthorizationOwnerSearchInput.fill(ownerId);
+            const ownerOption = this.createAuthorizationOwnerSearchOption(ownerId);
+            // The search is debounced and served by the API, so a just-created
+            // owner can take a while to surface.
+            await (0, test_1.expect)(ownerOption).toBeVisible({ timeout: 60000 });
+            await ownerOption.click({ timeout: 30000 });
+            // Picking an owner replaces the search input with a tag holding the
+            // selection, which is how we know the choice was committed.
+            await (0, test_1.expect)(this.createAuthorizationOwnerSearchInput).toBeHidden({
+                timeout: 30000,
+            });
+            return;
+        }
+        await this.createAuthorizationOwnerComboBox.click();
+        const commandInput = this.createAuthorizationOwnerCommandInput;
+        const inlineOwnerOption = this.createAuthorizationOwnerOption(ownerId);
+        await (0, test_1.expect)(commandInput.or(inlineOwnerOption).first()).toBeVisible({
+            timeout: 30000,
+        });
+        if (await commandInput.isVisible()) {
+            await commandInput.fill(ownerId);
+            // The result list is served by the API and debounced, and each option is
+            // labelled "<owner id> — <name>" rather than the bare ID, so narrow the
+            // search to the single row this unique owner ID resolves to instead of
+            // matching on the label text.
+            const ownerOptions = this.createAuthorizationOwnerCommandOptions;
+            await (0, test_1.expect)(ownerOptions).toHaveCount(1, { timeout: 60000 });
+            await ownerOptions.first().click({ timeout: 30000, force: true });
+            // Committing the choice closes the popover, which is what hands the
+            // dialog back to the accessibility tree for the fields that follow.
+            await (0, test_1.expect)(commandInput).toBeHidden({ timeout: 30000 });
+            return;
+        }
+        await (0, test_1.expect)(inlineOwnerOption).toBeVisible({
+            timeout: 30000,
+        });
+        await inlineOwnerOption.click({
+            timeout: 30000,
+        });
+    }
+    async createAuthorization(authorization) {
+        await this.createAuthorizationButton.click();
+        await (0, test_1.expect)(this.createAuthorizationModal).toBeVisible();
+        await this.createAuthorizationOwnerTypeCombobox.click();
+        await this.createAuthorizationOwnerTypeOption(authorization.ownerType).click();
+        await this.selectAuthorizationOwner(authorization.ownerId);
+        // The Resource type is pre-selected and disabled when the dialog is
+        // opened from a specific resource-type tab. Only pick it from the dropdown
+        // when the field is still enabled (editable).
+        await (0, test_1.expect)(this.createAuthorizationResourceTypeDropdown).toBeVisible({
+            timeout: 30000,
+        });
+        if (await this.createAuthorizationResourceTypeDropdown.isEnabled()) {
+            await this.createAuthorizationResourceTypeDropdown.click();
+            await this.createAuthorizationResourceTypeOption(authorization.resourceType).click({ timeout: 30000 });
+        }
+        await this.createAuthorizationResourceIdField.fill(authorization.resourceId);
+        for (const permission of authorization.accessPermissions) {
+            await (0, sleep_1.sleep)(200);
+            const permissionLabel = this.createAuthorizationAccessPermission(permission);
+            const permissionInput = this.createAuthorizationModal.locator(`input[id="${permission}"], [role="checkbox"][id="${permission}"]`);
+            await (0, test_1.expect)(permissionLabel).toBeVisible();
+            if (!(await permissionInput.isChecked())) {
+                await permissionLabel.scrollIntoViewIfNeeded();
+                await (0, sleep_1.sleep)(300);
+                let clickAttempts = 0;
+                const maxAttempts = 3;
+                while (!(await permissionInput.isChecked()) &&
+                    clickAttempts < maxAttempts) {
+                    clickAttempts++;
+                    await permissionLabel.click({ force: true });
+                    await (0, sleep_1.sleep)(500);
+                    if (await permissionInput.isChecked()) {
+                        break;
+                    }
+                    if (clickAttempts < maxAttempts) {
+                        await permissionLabel.click();
+                        await (0, sleep_1.sleep)(300);
+                    }
+                }
+                await (0, test_1.expect)(permissionInput).toBeChecked({ timeout: 3000 });
+            }
+        }
+        await (0, submitModalWithRetry_1.submitModalWithRetry)(this.createAuthorizationSubmitButton, this.createAuthorizationModal);
+        await this.selectResourceType(authorization.resourceType);
+        const item = this.page
+            .getByRole('row')
+            .filter({
+            hasText: `${authorization.ownerId}${authorization.resourceId}`,
+        })
+            .first();
+        await this.expectAuthorizationListed(authorization, item);
+    }
+    // The toolbar search filters by owner ID, so filling it with the resource
+    // type narrowed nothing, and the retry helper it fed reloads before it
+    // asserts, which dropped the filter entirely. That left the new row to be
+    // found on page 1 of the unfiltered table - and the authorizations table
+    // paginates, so with the RBA specs creating owners in parallel it is
+    // regularly on a later page. Filter by owner, then page through what is
+    // left; fall back to the unfiltered table for builds whose search has not
+    // caught up with a just-created owner yet.
+    async expectAuthorizationListed(authorization, item) {
+        const deadline = Date.now() + 180000;
+        const budget = (max) => Math.max(5000, Math.min(max, deadline - Date.now()));
+        const maxAttempts = 5;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (attempt > 0 && Date.now() >= deadline) {
+                break;
+            }
+            try {
+                await this.selectResourceType(authorization.resourceType, budget(30000));
+                for (const filterValue of [authorization.ownerId, '']) {
+                    await this.filterAuthorizationsByOwner(filterValue);
+                    const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, item, {
+                        timeout: budget(filterValue === '' ? 45000 : 15000),
+                    });
+                    if (found) {
+                        await (0, test_1.expect)(item).toBeVisible({ timeout: 5000 });
+                        return;
+                    }
+                }
+                throw new Error(`No row for owner "${authorization.ownerId}" and resource ` +
+                    `"${authorization.resourceId}" in the ` +
+                    `${authorization.resourceType} table`);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts - 1) {
+                    console.warn(`Attempt ${attempt + 1} did not list the ` +
+                        `${authorization.resourceType} authorization for ` +
+                        `"${authorization.ownerId}". Retrying...`);
+                    // A refused/reset connection while the gateway restarts must feed
+                    // the next attempt, not abort the retry loop.
+                    await this.page
+                        .reload({ waitUntil: 'domcontentloaded' })
+                        .catch((reloadError) => {
+                        lastError = reloadError;
+                    });
+                }
+            }
+        }
+        throw new Error(`Authorization for "${authorization.ownerId}" on ` +
+            `"${authorization.resourceId}" was not listed: ${String(lastError)}`);
+    }
+    async filterAuthorizationsByOwner(ownerId) {
+        const hasFilter = await this.tableFilter
+            .isVisible({ timeout: 5000 })
+            .catch(() => false);
+        if (!hasFilter) {
+            return;
+        }
+        await this.tableFilter.fill(ownerId);
+        await (0, sleep_1.sleep)(1000);
+    }
+    async deleteAuthorization(resourceId, resourceType) {
+        // Same paginated table as createAuthorization: the row being deleted is
+        // not necessarily on page 1, and the toolbar search cannot narrow by
+        // resource ID.
+        const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, this.deleteAuthorizationButton(resourceId), { timeout: 60000 });
+        if (!found) {
+            throw new Error(`No ${resourceType} authorization row for resource "${resourceId}"`);
+        }
+        await this.deleteAuthorizationButton(resourceId).click();
+        await (0, test_1.expect)(this.deleteAuthorizationModal).toBeVisible();
+        await this.deleteAuthorizationModalDeleteButton.click();
+        await (0, test_1.expect)(this.deleteAuthorizationModal).not.toBeVisible();
+        // Re-selecting the resource type takes two interactions on the
+        // design-system build, so this cannot go through the shared
+        // reload-click-assert helper, which only accepts a single click locator.
+        const deletedCell = this.authorizationsList
+            .getByRole('cell', { name: resourceId })
+            .first();
+        let lastError;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            await this.page.reload();
+            await this.page.waitForLoadState('domcontentloaded');
+            await this.selectResourceType(resourceType);
+            try {
+                await (0, test_1.expect)(deletedCell).not.toBeVisible({ timeout: 5000 });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                console.warn(`Attempt ${attempt + 1} still listed the ${resourceType} ` +
+                    `authorization for "${resourceId}". Retrying...`);
+            }
+        }
+        throw new Error(`Authorization for resource "${resourceId}" is still listed: ` +
+            String(lastError));
+    }
+}
+exports.Authorization = Authorization;

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

@@ -0,0 +1,8 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterDetailsPage {
+    private page;
+    readonly clusterDetailsHeading: Locator;
+    constructor(page: Page);
+    assertCustomPropertyIsNavigated(linkTitle: string, linkName: string, link: string | RegExp): Promise<void>;
+}
+export { ClusterDetailsPage };

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterDetailsPage = void 0;
+const test_1 = require("@playwright/test");
+class ClusterDetailsPage {
+    page;
+    // Custom properties no longer have a heading/section of their own — the
+    // Environments/Clusters redesign folds them into the "Cluster details"
+    // card as rows (camunda-hub's ClusterDetailFields.sm.tsx), so this is the
+    // heading that confirms that card — and the properties inside it — rendered.
+    clusterDetailsHeading;
+    constructor(page) {
+        this.page = page;
+        this.clusterDetailsHeading = this.page.getByRole('heading', {
+            name: 'Cluster details',
+        });
+    }
+    async assertCustomPropertyIsNavigated(linkTitle, linkName, link) {
+        const context = this.page.context();
+        const matchesLink = (url) => typeof link === 'string'
+            ? url.href.startsWith(link)
+            : link.test(url.href);
+        // Serve a stub document only when the external site itself is
+        // unreachable, so the popup still commits the URL Console navigated to.
+        const handler = async (route) => {
+            if (route.request().resourceType() !== 'document') {
+                await route.continue();
+                return;
+            }
+            try {
+                const response = await route.fetch({ timeout: 30000 });
+                await route.fulfill({ response });
+            }
+            catch (error) {
+                const url = route.request().url();
+                console.warn(`External link ${url} unreachable, stubbing: ${error}`);
+                await route.fulfill({
+                    status: 200,
+                    contentType: 'text/html',
+                    body: '<html><body></body></html>',
+                });
+            }
+        };
+        await context.route(matchesLink, handler);
+        try {
+            const pageTabPromise = this.page.waitForEvent('popup', {
+                timeout: 60000,
+            });
+            // Each custom property is a <dt>/<dd> row (direct child of the details
+            // card's <dl>), keyed by the property's own description — not by a
+            // generic "Link 1"/"Link 2" row title, which this DOM never had.
+            await this.page
+                .locator('dl > div')
+                .filter({ has: this.page.locator('dt', { hasText: linkTitle }) })
+                .getByRole('link', { name: linkName, exact: true })
+                .click({ timeout: 60000 });
+            const camundaPage = await pageTabPromise;
+            await (0, test_1.expect)(camundaPage).toHaveURL(link, { timeout: 60000 });
+        }
+        finally {
+            await context.unroute(matchesLink, handler);
+        }
+    }
+}
+exports.ClusterDetailsPage = ClusterDetailsPage;

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

@@ -0,0 +1,11 @@
+import { Page, Locator } from '@playwright/test';
+declare class ClusterPage {
+    private page;
+    readonly clustersList: Locator;
+    readonly defaultClusterName: string;
+    readonly cluster: Locator;
+    constructor(page: Page);
+    clickClusterLink(): Promise<void>;
+    assertCustomTagsAreVisible(tags: string[]): Promise<void>;
+}
+export { ClusterPage };

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterPage = void 0;
+const test_1 = require("@playwright/test");
+class ClusterPage {
+    page;
+    clustersList;
+    defaultClusterName = process.env.CLUSTER_NAME || 'integration-zeebe';
+    cluster;
+    constructor(page) {
+        this.page = page;
+        // The Clusters tab defaults to the card grid (`[data-test="cluster-card"]`),
+        // not a table — there is no `tbody` in that view.
+        this.clustersList = page.locator('[data-test="cluster-card"]');
+        this.cluster = this.clustersList.getByText(this.defaultClusterName).first();
+    }
+    async clickClusterLink() {
+        await (0, test_1.expect)(this.cluster).toBeVisible({ timeout: 60000 });
+        await this.cluster.click({ timeout: 30000 });
+        await (0, test_1.expect)(this.page.getByText('Cluster details').first()).toBeVisible({
+            timeout: 10000,
+        });
+    }
+    async assertCustomTagsAreVisible(tags) {
+        // The previous implementation called page.waitForLoadState('networkidle')
+        // here. The Console clusters page emits continuous polling/SSE traffic,
+        // so networkidle never fires — the test would hang for 12 min then
+        // retry, costing ~24 min total. The toBeVisible auto-waits below
+        // already cover the readiness window we actually need.
+        for (const tag of tags) {
+            await (0, test_1.expect)(this.page.getByText(tag, { exact: true }).first()).toBeVisible({
+                timeout: 60000,
+            });
+        }
+    }
+}
+exports.ClusterPage = ClusterPage;

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

@@ -0,0 +1,27 @@
+import { Page, Locator } from '@playwright/test';
+declare class ConnectorMarketplacePage {
+    private page;
+    private browseAllConnectorMarketplacePage;
+    private connectorName?;
+    private legacyMarketplaceDialog;
+    readonly searchForConnectorTextbox: Locator;
+    readonly downloadToProjectButton: Locator;
+    readonly addToProjectButton: Locator;
+    readonly replaceResourceButton: Locator;
+    readonly saveAsCopyButton: Locator;
+    readonly cancelButton: Locator;
+    readonly marketplaceErrorMessage: Locator;
+    readonly noResultsMessage: Locator;
+    constructor(page: Page);
+    clickSearchForConnectorTextbox(): Promise<void>;
+    fillSearchForConnectorTextbox(connectorName: string): Promise<void>;
+    clickDownloadToProjectButton(): Promise<void>;
+    clickCancelButton(): Promise<void>;
+    clickReplaceResourceButton(): Promise<void>;
+    waitForConnectorSearchResults(): Promise<void>;
+    downloadConnectorToProject(): Promise<void>;
+    private confirmImport;
+    private waitForImportToSettle;
+    private getLegacyDownloadButton;
+}
+export { ConnectorMarketplacePage };