@camunda/e2e-test-suite 0.0.1443 → 0.0.1445

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

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCIdentityRolesPage = void 0;
+const test_1 = require("@playwright/test");
+const UtilitiesPage_1 = require("../SM-8.11/UtilitiesPage");
+const expectLocatorWithPagination_1 = require("../../utils/assertionHelpers/expectLocatorWithPagination");
+const findLocatorWithPagination_1 = require("../../utils/assertionHelpers/findLocatorWithPagination");
+const submitModalWithRetry_1 = require("../../utils/assertionHelpers/submitModalWithRetry");
+const SEARCH_MAPPING_RULE_LABEL = /^(Search by mapping rule ID|searchByMappingRuleId)$/;
+class OCIdentityRolesPage {
+    page;
+    selectResourceTypeTab;
+    assignMappingRuleButton;
+    mappingSearchBox;
+    mappingSearchTrigger;
+    assignMappingModal;
+    assignMappingRuleOption;
+    assignMappingModalAssignRuleButton;
+    rolesList;
+    roleCell;
+    mappingRuleRow;
+    createRoleButton;
+    createRoleModal;
+    createNameField;
+    createIdField;
+    createRoleModalCreateButton;
+    deleteRoleButton;
+    deleteRoleModal;
+    closeDeleteRoleModal;
+    deleteRoleModalCancelButton;
+    deleteRoleModalDeleteButton;
+    adminRole;
+    rolesNavTab;
+    assignUserButton;
+    usernameTextBox;
+    assignUserSubButton;
+    clientsTab;
+    assignClientsButton;
+    clientIdTextBox;
+    assignClientIdSubButton;
+    notFoundText;
+    constructor(page) {
+        this.page = page;
+        this.rolesList = page.getByRole('table');
+        this.notFoundText = page.getByText('404 not found');
+        this.selectResourceTypeTab = (resourceType) => page.getByRole('tab', { name: resourceType });
+        this.assignMappingRuleButton = page.getByRole('button', {
+            name: /^(Assign mapping rule|assignMapping)$/,
+        });
+        this.assignMappingModal = page.getByRole('dialog', {
+            name: 'Assign mapping rule',
+        });
+        // The design-system modal renders a MultiSelect whose trigger is a
+        // div[role="combobox"], not the searchbox the pre design-system modal
+        // rendered; the Mapping rules list page keeps a page-level searchbox with
+        // the same accessible name, so scope this to the dialog and accept either
+        // role. The modal's field resolves its placeholder through the
+        // `entitySelection` i18n namespace, which carries no `searchByMappingRuleId`
+        // entry, so it is labelled with the raw key instead of the translated
+        // string the list page renders - match either form.
+        this.mappingSearchTrigger = this.assignMappingModal
+            .getByRole('combobox', { name: SEARCH_MAPPING_RULE_LABEL })
+            .or(this.assignMappingModal.getByRole('searchbox', {
+            name: SEARCH_MAPPING_RULE_LABEL,
+        }))
+            .first();
+        // The current design-system modal renders the cmdk <input cmdk-input> inline
+        // inside the dialog (data-slot="command-input", role="combobox"), so the
+        // trigger and the editable field are the same element - match that input
+        // scoped to the dialog. Older builds render a MultiSelect whose trigger div
+        // opens a Radix popover that portals to <body> as a sibling of the dialog,
+        // with the editable cmdk <input> inside it; that popover input is outside
+        // the dialog subtree, so match it page-wide. Pre-design-system builds render
+        // a dialog-scoped searchbox instead of either - fall back to that last.
+        this.mappingSearchBox = page
+            .locator('[data-slot="multi-select-content"] input[cmdk-input]')
+            .or(this.assignMappingModal.locator('input[cmdk-input]'))
+            .or(this.assignMappingModal.getByRole('searchbox', {
+            name: SEARCH_MAPPING_RULE_LABEL,
+        }))
+            .first();
+        this.createRoleButton = page.getByRole('button', {
+            name: /create role/i,
+        });
+        // The design-system assign-mapping-rule modal renders its result list in a
+        // Radix popover that portals to <body> as a sibling of the dialog, so the
+        // options are not inside assignMappingModal's DOM subtree - query them from
+        // the page. Each option repeats the id as both title and subtitle, so match
+        // on contained text rather than the accessible name.
+        //
+        // Builds predating the design-system migration (released alpha
+        // generations such as 8.10.0-alpha5) still render the Carbon
+        // `DropdownSearch` list inside the dialog as a role="listbox", with the
+        // mapping rule id as the item title - accept either shape.
+        this.assignMappingRuleOption = (name) => page
+            .getByRole('option')
+            .filter({ hasText: name })
+            .or(this.assignMappingModal.getByRole('listbox').getByText(name))
+            .first();
+        this.assignMappingModalAssignRuleButton = this.assignMappingModal.getByRole('button', {
+            name: 'Assign mapping rule',
+        });
+        this.roleCell = (roleID) => this.rolesList.getByRole('cell', { name: roleID, exact: true });
+        this.mappingRuleRow = (name) => page.getByRole('row').filter({ hasText: name });
+        this.createRoleModal = page.getByRole('dialog', {
+            name: 'Create role',
+        });
+        this.createIdField = this.createRoleModal.getByRole('textbox', {
+            name: 'Role ID',
+            exact: true,
+        });
+        this.createNameField = this.createRoleModal.getByRole('textbox', {
+            name: 'Role name',
+            exact: true,
+        });
+        this.createRoleModalCreateButton = this.createRoleModal.getByRole('button', { name: 'Create role' });
+        // The design-system DataTable renders the row's dangerous action as a
+        // labelled button - the trash icon is aria-hidden and the accessible name
+        // comes from the visible "Delete" text - while Carbon rendered an icon
+        // button carrying aria-label="Delete". getByLabel only matches the latter,
+        // so match the accessible name instead, which covers both DOMs.
+        this.deleteRoleButton = (rowName) => this.rolesList
+            .getByRole('row', { name: rowName })
+            .getByRole('button', { name: /^delete/i });
+        this.deleteRoleModal = page.getByRole('dialog', { name: /delete role/i });
+        this.closeDeleteRoleModal = this.deleteRoleModal.getByRole('button', {
+            name: 'Close',
+        });
+        this.deleteRoleModalCancelButton = this.deleteRoleModal.getByRole('button', {
+            name: 'Cancel',
+        });
+        this.deleteRoleModalDeleteButton = this.deleteRoleModal.getByRole('button', {
+            name: /delete role/i,
+        });
+        this.adminRole = page.getByRole('cell', { name: 'admin', exact: true });
+        this.rolesNavTab = page
+            .getByRole('navigation', { name: 'Main navigation' })
+            .getByRole('link', { name: 'Roles', exact: true })
+            .or(page
+            .getByRole('banner')
+            .locator('a')
+            .filter({ hasText: /^Roles$/ }))
+            .first();
+        this.assignUserButton = page.getByRole('button', { name: 'Assign user' });
+        this.usernameTextBox = page.getByRole('textbox', { name: 'Username' });
+        this.assignUserSubButton = page
+            .getByLabel('Assign user')
+            .getByRole('button', { name: 'Assign user' });
+        this.clientsTab = page.getByRole('tab', { name: 'Clients' });
+        this.assignClientsButton = page.getByRole('button', {
+            name: 'Assign client',
+        });
+        this.clientIdTextBox = page.getByPlaceholder('Enter client ID');
+        this.assignClientIdSubButton = page
+            .getByLabel('Assign client')
+            .getByRole('button', { name: 'Assign client' });
+    }
+    async clickMappingRulesTab() {
+        await (0, test_1.expect)(this.selectResourceTypeTab('Mapping Rules')).toBeVisible({
+            timeout: 60000,
+        });
+        await this.selectResourceTypeTab('Mapping Rules').click();
+    }
+    async clickRole(roleID) {
+        await (0, test_1.expect)(this.roleCell(roleID).first()).toBeVisible({ timeout: 60000 });
+        await this.roleCell(roleID).first().click();
+    }
+    async assignMappingRuleToRole(roleId, mappingId) {
+        const maxRetries = 3;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Inside the try so a retry that lands on the role detail page rather
+                // than the roles list reports the failure that caused it, instead of
+                // masking it as a roles-table timeout from this lookup.
+                await this.clickRole(roleId);
+                // After clicking the role, the detail page may show a 404 if the role
+                // was just created and the backend hasn't fully provisioned it yet.
+                const gotNotFound = await this.notFoundText
+                    .isVisible({ timeout: 3000 })
+                    .catch(() => false);
+                if (gotNotFound) {
+                    console.warn(`Attempt ${attempt + 1}: Role detail page returned 404 for "${roleId}", retrying...`);
+                    await this.recoverToRolesList();
+                    continue;
+                }
+                await this.clickMappingRulesTab();
+                await (0, test_1.expect)(this.assignMappingRuleButton).toBeVisible({
+                    timeout: 60000,
+                });
+                await this.assignMappingRuleButton.click({ timeout: 60000 });
+                await (0, test_1.expect)(this.assignMappingModal).toBeVisible({ timeout: 60000 });
+                // The design-system search input is a cmdk combobox that only issues
+                // its server-side query on real keystrokes, so type the id in rather
+                // than setting the value in one shot. It lives in the popover the
+                // trigger opens, so wait for it before typing. Budgeted like every
+                // other step here rather than inheriting the 10s actionTimeout.
+                await this.mappingSearchTrigger.click({ timeout: 60000 });
+                await (0, test_1.expect)(this.mappingSearchBox).toBeVisible({ timeout: 60000 });
+                await this.mappingSearchBox.pressSequentially(mappingId, {
+                    timeout: 60000,
+                });
+                await this.assignMappingRuleOption(mappingId).click({ timeout: 30000 });
+                // The submit button stays disabled until the MultiSelect commits the
+                // pick, which lands a tick after the option click - budget that wait
+                // like the rest of the method instead of leaving it to the 10s
+                // actionTimeout the bare click would inherit.
+                await (0, test_1.expect)(this.assignMappingModalAssignRuleButton).toBeEnabled({
+                    timeout: 30000,
+                });
+                await this.assignMappingModalAssignRuleButton.click({ timeout: 30000 });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed to assign mapping rule to role "${roleId}". Retrying...`);
+                    await this.recoverToRolesList();
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    async createRole(role) {
+        await this.createRoleButton.click();
+        await (0, test_1.expect)(this.createRoleModal).toBeVisible();
+        await this.createIdField.fill(role.id);
+        await this.createNameField.fill(role.name);
+        await (0, submitModalWithRetry_1.submitModalWithRetry)(this.createRoleModalCreateButton, this.createRoleModal);
+        await (0, expectLocatorWithPagination_1.expectLocatorWithPagination)(this.page, this.rolesList
+            .getByRole('cell', {
+            name: role.name,
+        })
+            .first(), { maxRetries: 10 });
+    }
+    async deleteRole(name, options) {
+        const { throwError = true } = options || {};
+        try {
+            // The roles table paginates at 10 rows and the RBA specs run in
+            // parallel against a cluster that already ships six built-in roles, so
+            // a role created by this test is regularly on page 2 by the time it is
+            // deleted. Without walking the pages the row - and therefore its Delete
+            // button - simply never resolves, which is what the 10s click timeout
+            // reported.
+            const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, this.deleteRoleButton(name), { timeout: 30000 });
+            if (!found) {
+                throw new Error(`Role "${name}" was not found on any page of the roles table`);
+            }
+            await this.deleteRoleButton(name).click();
+            await (0, test_1.expect)(this.deleteRoleModal).toBeVisible();
+            await this.deleteRoleModalDeleteButton.click();
+            await (0, test_1.expect)(this.deleteRoleModal).not.toBeVisible();
+            await (0, UtilitiesPage_1.assertLocatorVisibleWithRetry)(this.page, this.rolesList
+                .getByRole('cell', {
+                name,
+            })
+                .first(), name, 5000, true);
+        }
+        catch (error) {
+            if (throwError) {
+                throw error;
+            }
+            else {
+                console.warn(`Role "${name}" could not be deleted or did not exist.`);
+            }
+        }
+    }
+    async isRolesListOpen(timeout) {
+        return this.createRoleButton
+            .first()
+            .waitFor({ state: 'visible', timeout })
+            .then(() => true)
+            .catch(() => false);
+    }
+    // Re-enters the roles list through the in-app nav rather than reloading.
+    // `page.reload()` re-runs the OIDC round-trip and its post-login redirect
+    // drops the deep path, so a reload-based retry re-ran against whatever the
+    // Admin root rendered: a view with no table at all, or the wrong table.
+    // Clicking the banner's Roles link is a client-side route change, so it
+    // cannot lose the session; the reload is kept only for the case where the
+    // app shell itself is gone.
+    async openRolesList(timeout) {
+        if (await this.isRolesListOpen(Math.min(timeout, 15000))) {
+            return;
+        }
+        const shellVisible = await this.rolesNavTab
+            .waitFor({ state: 'visible', timeout: 15000 })
+            .then(() => true)
+            .catch(() => false);
+        if (!shellVisible) {
+            await this.page.reload({ waitUntil: 'domcontentloaded' });
+            await (0, test_1.expect)(this.rolesNavTab).toBeVisible({ timeout });
+        }
+        await this.rolesNavTab.click({ timeout });
+        await (0, test_1.expect)(this.createRoleButton.first()).toBeVisible({ timeout });
+    }
+    // `page.goBack()` is one history entry, and the role detail page's tab routes
+    // are entries of their own, so backing out of a failed assign-mapping step
+    // landed on the same role's Users tab - where the next attempt's roles-table
+    // lookup could only time out. Re-enter the list through the nav instead, and
+    // dismiss the dialog first: an open design-system dialog sets
+    // `pointer-events: none` on the body, which makes the nav link unclickable.
+    async recoverToRolesList() {
+        const modalOpen = await this.assignMappingModal
+            .isVisible()
+            .catch(() => false);
+        if (modalOpen) {
+            await this.page.keyboard.press('Escape');
+            const closed = await this.assignMappingModal
+                .waitFor({ state: 'hidden', timeout: 15000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!closed) {
+                await this.page.reload({ waitUntil: 'domcontentloaded' });
+            }
+        }
+        await this.openRolesList(60000);
+    }
+    async clickAdminRole() {
+        // The roles table is fetched after the Roles tab click, and other specs in
+        // the nightly add roles that can push `admin` onto a later page, so a bare
+        // click had only the 10s actionTimeout to cover both the load and the
+        // lookup. Use the same pagination-aware lookup createRole/clickRole use.
+        //
+        // Bounded overall: this runs in the smoke suite's beforeEach, whose time is
+        // charged to the test, and three attempts of the previous per-step budgets
+        // could occupy 540s of the 720s test timeout on their own — which is why a
+        // stuck recovery here surfaced as a timeout in the test body rather than as
+        // this method's own error.
+        const deadline = Date.now() + 300000;
+        const budget = (max) => Math.max(5000, Math.min(max, deadline - Date.now()));
+        const adminCell = this.adminRole.first();
+        const maxRetries = 3;
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries && Date.now() < deadline; attempt++) {
+            try {
+                // Every attempt starts from a confirmed roles list, so a swallowed nav
+                // click or a redirect back to the Admin root is recovered instead of
+                // being scanned again.
+                await this.openRolesList(budget(60000));
+                // Wait for the admin row itself before scanning: the scan gives each
+                // page only 5s, so against a table that is still fetching it reports
+                // the row missing and — with no next page to walk to — gives up in 5s.
+                // That is the shape of the run log's 52 "No more pages available after
+                // page 1" against 600 finds on page 1.
+                const onCurrentPage = await adminCell
+                    .waitFor({ state: 'visible', timeout: budget(30000) })
+                    .then(() => true)
+                    .catch(() => false);
+                if (!onCurrentPage) {
+                    // Scanned directly rather than through expectLocatorWithPagination:
+                    // that wrapper hard-codes the scan to 30s (it forwards no options),
+                    // which is ~5 pages, and the roles table reached 5 pages in the same
+                    // run. Its retry also reloads, which is the recovery openRolesList
+                    // exists to avoid.
+                    const found = await (0, findLocatorWithPagination_1.findLocatorWithPagination)(this.page, adminCell, {
+                        timeout: budget(90000),
+                    });
+                    if (!found) {
+                        throw new Error('admin role row not found on any page of the roles table');
+                    }
+                }
+                await adminCell.click({ timeout: budget(30000) });
+                // The row click is the only thing that navigates to the role detail
+                // page, and nothing confirmed it landed — a click the table swallowed
+                // mid-render left the caller waiting out assignUserButton's whole
+                // budget on a page that never had one.
+                await (0, test_1.expect)(this.assignUserButton).toBeVisible({
+                    timeout: budget(30000),
+                });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1}: admin role detail page did not open, retrying...`);
+                }
+            }
+        }
+        throw new Error(`Admin role detail page did not open after ${maxRetries} attempts: ${String(lastError)}`);
+    }
+    async assignUserToRole(userId) {
+        await this.clickAssignUserButton();
+        await this.clickUsernameTextbox();
+        await this.fillUsernameTextbox(userId);
+        await this.clickAssignUserSubButton();
+    }
+    async clickAssignUserButton() {
+        // Rendered only once the role detail page has loaded its users tab, which
+        // outlasts the 10s actionTimeout a bare click inherits. Same budget the
+        // SaaS 8.10 doAssignUserToRole already gives this button.
+        await (0, test_1.expect)(this.assignUserButton).toBeVisible({ timeout: 60000 });
+        await this.assignUserButton.click({ timeout: 60000 });
+    }
+    async clickUsernameTextbox() {
+        // Waiting for the textbox is what confirms the modal finished opening.
+        await (0, test_1.expect)(this.usernameTextBox).toBeVisible({ timeout: 60000 });
+        await this.usernameTextBox.click({ timeout: 60000 });
+    }
+    async fillUsernameTextbox(userId) {
+        await this.usernameTextBox.fill(userId);
+    }
+    async clickAssignUserSubButton() {
+        // The modal's submit button stays disabled until the username field
+        // validates, so wait for it to be actionable rather than racing the 10s
+        // actionTimeout.
+        await (0, test_1.expect)(this.assignUserSubButton).toBeEnabled({ timeout: 60000 });
+        await this.assignUserSubButton.click({ timeout: 60000 });
+    }
+    async clickClientsTab() {
+        await this.clientsTab.click();
+    }
+    async clickAssignClientButton() {
+        await this.assignClientsButton.click();
+    }
+    async clickClientIdTextbox() {
+        await this.clientIdTextBox.click();
+    }
+    async fillClientIdTextbox(clientId) {
+        await this.clientIdTextBox.fill(clientId);
+    }
+    async clickAssignClientIdSubButton() {
+        await this.assignClientIdSubButton.click();
+    }
+    async addClientToRole(clientId) {
+        await this.clickClientsTab();
+        await this.clickAssignClientButton();
+        await this.clickClientIdTextbox();
+        await this.fillClientIdTextbox(clientId);
+        await this.clickAssignClientIdSubButton();
+    }
+}
+exports.OCIdentityRolesPage = OCIdentityRolesPage;

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

@@ -0,0 +1,73 @@
+import { Page, Locator } from '@playwright/test';
+declare class OCTenantPage {
+    private page;
+    readonly createTenantMainButton: Locator;
+    readonly enterTenantNameInput: Locator;
+    readonly enterTenantIdInput: Locator;
+    readonly createTenantSubButton: Locator;
+    readonly usersTab: Locator;
+    readonly assignUsersButton: Locator;
+    readonly usernameInput: Locator;
+    readonly assignUserFinalButton: Locator;
+    readonly removeUserButton: Locator;
+    readonly removeButton: Locator;
+    readonly openSidebarButton: Locator;
+    readonly logoutButton: Locator;
+    readonly assignedApplicationsTab: Locator;
+    readonly searchApplicationsInput: Locator;
+    readonly assignApplicationsButtonFinal: Locator;
+    readonly assignApplicationsButton: Locator;
+    readonly tenantDescriptionInput: Locator;
+    readonly modalCloseButton: Locator;
+    readonly rolesTab: Locator;
+    readonly assignRoleButton: Locator;
+    readonly roleIdSearchBox: Locator;
+    readonly roleIdSearchTrigger: Locator;
+    readonly assignRoleSubButton: Locator;
+    readonly assignRoleModal: Locator;
+    readonly cancelButton: Locator;
+    readonly gotItButton: Locator;
+    readonly filterTableSearchbox: Locator;
+    readonly row: (name: string) => Locator;
+    constructor(page: Page);
+    clickCreateTenantMainButton(): Promise<void>;
+    clickCreateTenantSubButton(): Promise<void>;
+    clickEnterTenantNameInput(): Promise<void>;
+    fillEnterTenantNameInput(tenantName: string): Promise<void>;
+    clickEnterTenantIdInput(): Promise<void>;
+    fillEnterTenantIdInput(tenantId: string): Promise<void>;
+    clickUsersTab(): Promise<void>;
+    clickAssignUsersButton(): Promise<void>;
+    clickUsernameInput(): Promise<void>;
+    fillUsernameInput(user: string): Promise<void>;
+    clickAssignUserFinalButton(): Promise<void>;
+    clickRemoveUserButton(): Promise<void>;
+    clickRemoveButton(): Promise<void>;
+    clickTenantDescriptionInput(): Promise<void>;
+    fillTenantDescriptionInput(description: string): Promise<void>;
+    createTenant(tenantName: string): Promise<void>;
+    assertTenantCreated(): Promise<void>;
+    clickCancelButton(): Promise<void>;
+    clickGotItButton(): Promise<void>;
+    filterTable(tenantName: string): Promise<void>;
+    clickTenant(tenantName: string): Promise<void>;
+    assignUserToTenant(user: string): Promise<void>;
+    removeUserFromTenant(tenantName: string): Promise<void>;
+    clickOpenSidebarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+    assignClientToTenant(clientName: string): Promise<void>;
+    clickAssignedApplicationsTab(): Promise<void>;
+    clickSearchApplicationsInput(): Promise<void>;
+    fillSearchApplicationsInput(clientName: string): Promise<void>;
+    clickAssignApplicationsFinalButton(): Promise<void>;
+    clickAssignApplicationsButton(): Promise<void>;
+    clickRolesTab(): Promise<void>;
+    clickAssignRoleButton(): Promise<void>;
+    clickRoleIdSearchBox(): Promise<void>;
+    private ensureRoleIdSearchBoxOpen;
+    fillRoleIdSearchBox(roleId: string, roleIdentifier: string): Promise<void>;
+    clickAssignRoleSubButton(): Promise<void>;
+    private isRoleAssigned;
+    assignRoleToTenant(roleId: string, roleIdentifier: string): Promise<void>;
+}
+export { OCTenantPage };