rhdh-e2e-test-utils 1.0.1 → 1.1.0

package/dist/playwright/helpers/navbar.d.ts

@@ -0,0 +1,2 @@
+export type SidebarTabs = "Catalog" | "Settings" | "My Group" | "Home" | "Self-service" | "Learning Paths" | "Extensions" | "Bulk import" | "Docs" | "Clusters" | "Tech Radar" | "Notifications" | "Orchestrator";
+//# sourceMappingURL=navbar.d.ts.map

package/dist/playwright/helpers/navbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navbar.d.ts","sourceRoot":"","sources":["../../../src/playwright/helpers/navbar.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GACnB,SAAS,GACT,UAAU,GACV,UAAU,GACV,MAAM,GACN,cAAc,GACd,gBAAgB,GAChB,YAAY,GACZ,aAAa,GACb,MAAM,GACN,UAAU,GACV,YAAY,GACZ,eAAe,GACf,cAAc,CAAC"}

package/dist/playwright/helpers/navbar.js

@@ -0,0 +1 @@
+export {};

package/dist/playwright/helpers/ui-helper.d.ts

@@ -0,0 +1,106 @@
+import type { Locator, Page } from "@playwright/test";
+import type { SidebarTabs } from "./navbar.js";
+export declare class UIhelper {
+    private page;
+    constructor(page: Page);
+    waitForLoad(timeout?: number): Promise<void>;
+    verifyComponentInCatalog(kind: string, expectedRows: string[]): Promise<void>;
+    getSideBarMenuItem(menuItem: string): Locator;
+    fillTextInputByLabel(label: string, text: string): Promise<void>;
+    /**
+     * Fills the search input with the provided text.
+     *
+     * @param searchText - The text to be entered into the search input field.
+     */
+    searchInputPlaceholder(searchText: string): Promise<void>;
+    searchInputAriaLabel(searchText: string): Promise<void>;
+    pressTab(): Promise<void>;
+    checkCheckbox(text: string): Promise<void>;
+    uncheckCheckbox(text: string): Promise<void>;
+    clickButton(label: string | RegExp, options?: {
+        exact?: boolean;
+        force?: boolean;
+    }): Promise<Locator>;
+    clickBtnByTitleIfNotPressed(title: string): Promise<void>;
+    clickByDataTestId(dataTestId: string): Promise<void>;
+    /**
+     * Clicks on a button element by its text content, waiting for it to be visible first.
+     *
+     * @param buttonText - The text content of the button to click on.
+     * @param options - Optional configuration for exact match, timeout, and force click.
+     */
+    clickButtonByText(buttonText: string | RegExp, options?: {
+        exact?: boolean;
+        timeout?: number;
+        force?: boolean;
+    }): Promise<void>;
+    clickButtonByLabel(label: string | RegExp): Promise<void>;
+    clickLink(options: string | {
+        href: string;
+    } | {
+        ariaLabel: string;
+    }): Promise<void>;
+    openProfileDropdown(): Promise<void>;
+    goToPageUrl(url: string, heading?: string): Promise<void>;
+    verifyLink(arg: string | {
+        label: string;
+    }, options?: {
+        exact?: boolean;
+        notVisible?: boolean;
+    }): Promise<void>;
+    private isElementVisible;
+    isBtnVisibleByTitle(text: string): Promise<boolean>;
+    isBtnVisible(text: string): Promise<boolean>;
+    isTextVisible(text: string, timeout?: number): Promise<boolean>;
+    verifyTextVisible(text: string, exact?: boolean, timeout?: number): Promise<void>;
+    verifyLinkVisible(text: string, timeout?: number): Promise<void>;
+    openSidebar(navBarText: SidebarTabs): Promise<void>;
+    openCatalogSidebar(kind: string): Promise<void>;
+    openSidebarButton(navBarButtonLabel: string): Promise<void>;
+    selectMuiBox(label: string, value: string): Promise<void>;
+    verifyRowsInTable(rowTexts: (string | RegExp)[], exact?: boolean): Promise<void>;
+    waitForTextDisappear(text: string): Promise<void>;
+    verifyText(text: string | RegExp, exact?: boolean): Promise<void>;
+    private verifyTextInLocator;
+    verifyTextInSelector(selector: string, expectedText: string): Promise<void>;
+    verifyColumnHeading(rowTexts: string[] | RegExp[], exact?: boolean): Promise<void>;
+    verifyHeading(heading: string | RegExp, timeout?: number): Promise<void>;
+    verifyParagraph(paragraph: string): Promise<void>;
+    waitForTitle(text: string, level?: number): Promise<void>;
+    clickTab(tabName: string): Promise<void>;
+    verifyCellsInTable(texts: (string | RegExp)[]): Promise<void>;
+    verifyButtonURL(label: string | RegExp, url: string | RegExp, options?: {
+        locator?: string;
+        exact?: boolean;
+    }): Promise<void>;
+    /**
+     * Verifies that a table row, identified by unique text, contains specific cell texts.
+     * @param {string} uniqueRowText - The unique text present in one of the cells within the row. This is used to identify the specific row.
+     * @param {Array<string | RegExp>} cellTexts - An array of cell texts or regular expressions to match against the cells within the identified row.
+     * @example
+     * // Example usage to verify that a row containing "Developer-hub" has cells with the texts "service" and "active":
+     * await verifyRowInTableByUniqueText('Developer-hub', ['service', 'active']);
+     */
+    verifyRowInTableByUniqueText(uniqueRowText: string, cellTexts: string[] | RegExp[]): Promise<void>;
+    /**
+     * Clicks on a link within a table row that contains a unique text and matches a link's text.
+     * @param {string} uniqueRowText - The unique text present in one of the cells within the row. This is used to identify the specific row.
+     * @param {string | RegExp} linkText - The text of the link, can be a string or a regular expression.
+     * @param {boolean} [exact=true] - Whether to match the link text exactly. By default, this is set to true.
+     */
+    clickOnLinkInTableByUniqueText(uniqueRowText: string, linkText: string | RegExp, exact?: boolean): Promise<void>;
+    /**
+     * Clicks on a button within a table row that contains a unique text and matches a button's label or aria-label.
+     * @param {string} uniqueRowText - The unique text present in one of the cells within the row. This is used to identify the specific row.
+     * @param {string | RegExp} textOrLabel - The text of the button or the `aria-label` attribute, can be a string or a regular expression.
+     */
+    clickOnButtonInTableByUniqueText(uniqueRowText: string, textOrLabel: string | RegExp): Promise<void>;
+    verifyLinkinCard(cardHeading: string, linkText: string, exact?: boolean): Promise<void>;
+    clickBtnInCard(cardText: string, btnText: string, exact?: boolean): Promise<void>;
+    verifyTextinCard(cardHeading: string, text: string | RegExp, exact?: boolean): Promise<void>;
+    verifyTableHeadingAndRows(texts: string[]): Promise<void>;
+    verifyTableIsEmpty(): Promise<void>;
+    verifyAlertErrorMessage(message: string | RegExp): Promise<void>;
+    verifyTextInTooltip(text: string | RegExp): Promise<void>;
+}
+//# sourceMappingURL=ui-helper.d.ts.map

package/dist/playwright/helpers/ui-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-helper.d.ts","sourceRoot":"","sources":["../../../src/playwright/helpers/ui-helper.ts"],"names":[],"mappings":"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"}

package/dist/playwright/helpers/ui-helper.js

@@ -0,0 +1,439 @@
+import { expect } from "@playwright/test";
+import { UI_HELPER_ELEMENTS, WAIT_OBJECTS, } from "../page-objects/global-obj.js";
+import { SEARCH_OBJECTS_COMPONENTS } from "../page-objects/page-obj.js";
+export class UIhelper {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    async waitForLoad(timeout = 120000) {
+        for (const item of Object.values(WAIT_OBJECTS)) {
+            await this.page.waitForSelector(item, {
+                state: "hidden",
+                timeout: timeout,
+            });
+        }
+    }
+    async verifyComponentInCatalog(kind, expectedRows) {
+        await this.openSidebar("Catalog");
+        await this.selectMuiBox("Kind", kind);
+        await this.verifyRowsInTable(expectedRows);
+    }
+    getSideBarMenuItem(menuItem) {
+        return this.page.getByTestId("login-button").getByText(menuItem);
+    }
+    async fillTextInputByLabel(label, text) {
+        await this.page.getByLabel(label).fill(text);
+    }
+    /**
+     * Fills the search input with the provided text.
+     *
+     * @param searchText - The text to be entered into the search input field.
+     */
+    async searchInputPlaceholder(searchText) {
+        await this.page.fill(SEARCH_OBJECTS_COMPONENTS.placeholderSearch, searchText);
+    }
+    async searchInputAriaLabel(searchText) {
+        await this.page.fill(SEARCH_OBJECTS_COMPONENTS.ariaLabelSearch, searchText);
+    }
+    async pressTab() {
+        await this.page.keyboard.press("Tab");
+    }
+    async checkCheckbox(text) {
+        const locator = this.page.getByRole("checkbox", {
+            name: text,
+        });
+        await locator.check();
+    }
+    async uncheckCheckbox(text) {
+        const locator = this.page.getByRole("checkbox", {
+            name: text,
+        });
+        await locator.uncheck();
+    }
+    async clickButton(label, options = {
+        exact: true,
+        force: false,
+    }) {
+        const selector = `${UI_HELPER_ELEMENTS.MuiButtonLabel}`;
+        const button = this.page
+            .locator(selector)
+            .getByText(label, { exact: options.exact })
+            .first();
+        if (options?.force) {
+            await button.click({ force: true });
+        }
+        else {
+            await button.click();
+        }
+        return button;
+    }
+    async clickBtnByTitleIfNotPressed(title) {
+        const button = this.page.locator(`button[title="${title}"]`);
+        const isPressed = await button.getAttribute("aria-pressed");
+        if (isPressed === "false") {
+            await button.click();
+        }
+    }
+    async clickByDataTestId(dataTestId) {
+        const element = this.page.getByTestId(dataTestId);
+        await element.waitFor({ state: "visible" });
+        await element.dispatchEvent("click");
+    }
+    /**
+     * Clicks on a button element by its text content, waiting for it to be visible first.
+     *
+     * @param buttonText - The text content of the button to click on.
+     * @param options - Optional configuration for exact match, timeout, and force click.
+     */
+    async clickButtonByText(buttonText, options = {
+        exact: true,
+        timeout: 10000,
+        force: false,
+    }) {
+        const buttonElement = this.page
+            .getByRole("button")
+            .getByText(buttonText, { exact: options.exact });
+        await buttonElement.waitFor({
+            state: "visible",
+            timeout: options.timeout,
+        });
+        if (options.force) {
+            await buttonElement.click({ force: true });
+        }
+        else {
+            await buttonElement.click();
+        }
+    }
+    async clickButtonByLabel(label) {
+        await this.page.getByRole("button", { name: label }).first().click();
+    }
+    async clickLink(options) {
+        let linkLocator;
+        if (typeof options === "string") {
+            linkLocator = this.page.locator("a").filter({ hasText: options }).first();
+        }
+        else if ("href" in options) {
+            linkLocator = this.page.locator(`a[href="${options.href}"]`).first();
+        }
+        else {
+            linkLocator = this.page
+                .locator(`div[aria-label='${options.ariaLabel}'] a`)
+                .first();
+        }
+        await linkLocator.waitFor({ state: "visible" });
+        await linkLocator.click();
+    }
+    async openProfileDropdown() {
+        const header = this.page.locator("nav[id='global-header']");
+        await expect(header).toBeVisible();
+        await header
+            .locator("[data-testid='KeyboardArrowDownOutlinedIcon']")
+            .click();
+    }
+    async goToPageUrl(url, heading) {
+        await this.page.goto(url);
+        await expect(this.page).toHaveURL(url);
+        if (heading) {
+            await this.verifyHeading(heading);
+        }
+    }
+    async verifyLink(arg, options = {
+        exact: true,
+        notVisible: false,
+    }) {
+        let linkLocator;
+        let notVisibleCheck;
+        if (typeof arg != "object") {
+            linkLocator = this.page
+                .locator("a")
+                .getByText(arg, { exact: options.exact })
+                .first();
+            notVisibleCheck = options?.notVisible ?? false;
+        }
+        else {
+            linkLocator = this.page.locator(`div[aria-label="${arg.label}"] a`);
+            notVisibleCheck = false;
+        }
+        if (notVisibleCheck) {
+            await expect(linkLocator).toBeHidden();
+        }
+        else {
+            await expect(linkLocator).toBeVisible();
+        }
+    }
+    async isElementVisible(locator, timeout = 10000, force = false) {
+        try {
+            await this.page.waitForSelector(locator, {
+                state: "visible",
+                timeout: timeout,
+            });
+            const button = this.page.locator(locator).first();
+            return button.isVisible();
+        }
+        catch (error) {
+            if (force)
+                throw error;
+            return false;
+        }
+    }
+    async isBtnVisibleByTitle(text) {
+        const locator = `BUTTON[title="${text}"]`;
+        return await this.isElementVisible(locator);
+    }
+    async isBtnVisible(text) {
+        const locator = `button:has-text("${text}")`;
+        return await this.isElementVisible(locator);
+    }
+    async isTextVisible(text, timeout = 10000) {
+        const locator = `:has-text("${text}")`;
+        return await this.isElementVisible(locator, timeout);
+    }
+    async verifyTextVisible(text, exact = false, timeout = 10000) {
+        const locator = this.page.getByText(text, { exact });
+        await expect(locator).toBeVisible({ timeout });
+    }
+    async verifyLinkVisible(text, timeout = 10000) {
+        const locator = this.page.locator(`a:has-text("${text}")`);
+        await expect(locator).toBeVisible({ timeout });
+    }
+    async openSidebar(navBarText) {
+        const navLink = this.page
+            .locator(`nav a:has-text("${navBarText}")`)
+            .first();
+        await navLink.waitFor({ state: "visible", timeout: 15_000 });
+        await navLink.dispatchEvent("click");
+    }
+    async openCatalogSidebar(kind) {
+        await this.openSidebar("Catalog");
+        await this.selectMuiBox("Kind", kind);
+        await expect(async () => {
+            await this.clickByDataTestId("user-picker-all");
+            await this.page.waitForTimeout(1_500);
+            await this.verifyHeading(new RegExp(`all ${kind}`, "i"));
+        }).toPass({
+            intervals: [3_000],
+            timeout: 20_000,
+        });
+    }
+    async openSidebarButton(navBarButtonLabel) {
+        const navLink = this.page.locator(`nav button[aria-label="${navBarButtonLabel}"]`);
+        await navLink.waitFor({ state: "visible" });
+        await navLink.click();
+    }
+    async selectMuiBox(label, value) {
+        await this.page.click(`div[aria-label="${label}"]`);
+        const optionSelector = `li[role="option"]:has-text("${value}")`;
+        await this.page.waitForSelector(optionSelector);
+        await this.page.click(optionSelector);
+    }
+    async verifyRowsInTable(rowTexts, exact = true) {
+        for (const rowText of rowTexts) {
+            await this.verifyTextInLocator(`tr>td`, rowText, exact);
+        }
+    }
+    async waitForTextDisappear(text) {
+        await this.page.waitForSelector(`text=${text}`, { state: "detached" });
+    }
+    async verifyText(text, exact = true) {
+        await this.verifyTextInLocator("", text, exact);
+    }
+    async verifyTextInLocator(locator, text, exact) {
+        const elementLocator = locator
+            ? this.page.locator(locator).getByText(text, { exact }).first()
+            : this.page.getByText(text, { exact }).first();
+        await elementLocator.waitFor({ state: "visible" });
+        await elementLocator.waitFor({ state: "attached" });
+        try {
+            await elementLocator.scrollIntoViewIfNeeded();
+        }
+        catch (error) {
+            console.warn(`Warning: Could not scroll element into view. Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        await expect(elementLocator).toBeVisible();
+    }
+    async verifyTextInSelector(selector, expectedText) {
+        const elementLocator = this.page
+            .locator(selector)
+            .getByText(expectedText, { exact: true });
+        try {
+            await elementLocator.waitFor({ state: "visible" });
+            const actualText = (await elementLocator.textContent()) || "No content";
+            if (actualText.trim() !== expectedText.trim()) {
+                console.error(`Verification failed for text: Expected "${expectedText}", but got "${actualText}"`);
+                throw new Error(`Expected text "${expectedText}" not found. Actual content: "${actualText}".`);
+            }
+            console.log(`Text "${expectedText}" verified successfully in selector: ${selector}`);
+        }
+        catch (error) {
+            const allTextContent = await this.page
+                .locator(selector)
+                .allTextContents();
+            console.error(`Verification failed for text: Expected "${expectedText}". Selector content: ${allTextContent.join(", ")}`);
+            throw error;
+        }
+    }
+    async verifyColumnHeading(rowTexts, exact = true) {
+        for (const rowText of rowTexts) {
+            const rowLocator = this.page
+                .locator(`tr>th`)
+                .getByText(rowText, { exact: exact })
+                .first();
+            await rowLocator.waitFor({ state: "visible" });
+            await rowLocator.scrollIntoViewIfNeeded();
+            await expect(rowLocator).toBeVisible();
+        }
+    }
+    async verifyHeading(heading, timeout = 20000) {
+        const headingLocator = this.page
+            .locator("h1, h2, h3, h4, h5, h6")
+            .filter({ hasText: heading })
+            .first();
+        await headingLocator.waitFor({ state: "visible", timeout: timeout });
+        await expect(headingLocator).toBeVisible();
+    }
+    async verifyParagraph(paragraph) {
+        const headingLocator = this.page
+            .locator("p")
+            .filter({ hasText: paragraph })
+            .first();
+        await headingLocator.waitFor({ state: "visible", timeout: 20000 });
+        await expect(headingLocator).toBeVisible();
+    }
+    async waitForTitle(text, level = 1) {
+        await this.page.waitForSelector(`h${level}:has-text("${text}")`);
+    }
+    async clickTab(tabName) {
+        const tabLocator = this.page.getByRole("tab", { name: tabName });
+        await tabLocator.waitFor({ state: "visible" });
+        await tabLocator.click();
+    }
+    async verifyCellsInTable(texts) {
+        for (const text of texts) {
+            const cellLocator = this.page
+                .locator(UI_HELPER_ELEMENTS.MuiTableCell)
+                .filter({ hasText: text });
+            const count = await cellLocator.count();
+            if (count === 0) {
+                throw new Error(`Expected at least one cell with text matching ${text}, but none were found.`);
+            }
+            // Checks if all matching cells are visible.
+            for (let i = 0; i < count; i++) {
+                await expect(cellLocator.nth(i)).toBeVisible();
+            }
+        }
+    }
+    async verifyButtonURL(label, url, options = {
+        locator: "",
+        exact: true,
+    }) {
+        // To verify the button URL if it is in a specific locator
+        const baseLocator = !options.locator || options.locator === ""
+            ? this.page
+            : this.page.locator(options.locator);
+        const buttonUrl = await baseLocator
+            .getByRole("button", { name: label, exact: options.exact })
+            .first()
+            .getAttribute("href");
+        expect(buttonUrl).toContain(url);
+    }
+    /**
+     * Verifies that a table row, identified by unique text, contains specific cell texts.
+     * @param {string} uniqueRowText - The unique text present in one of the cells within the row. This is used to identify the specific row.
+     * @param {Array<string | RegExp>} cellTexts - An array of cell texts or regular expressions to match against the cells within the identified row.
+     * @example
+     * // Example usage to verify that a row containing "Developer-hub" has cells with the texts "service" and "active":
+     * await verifyRowInTableByUniqueText('Developer-hub', ['service', 'active']);
+     */
+    async verifyRowInTableByUniqueText(uniqueRowText, cellTexts) {
+        const row = this.page.locator(UI_HELPER_ELEMENTS.rowByText(uniqueRowText));
+        await row.waitFor();
+        for (const cellText of cellTexts) {
+            await expect(row.locator("td").filter({ hasText: cellText }).first()).toBeVisible();
+        }
+    }
+    /**
+     * Clicks on a link within a table row that contains a unique text and matches a link's text.
+     * @param {string} uniqueRowText - The unique text present in one of the cells within the row. This is used to identify the specific row.
+     * @param {string | RegExp} linkText - The text of the link, can be a string or a regular expression.
+     * @param {boolean} [exact=true] - Whether to match the link text exactly. By default, this is set to true.
+     */
+    async clickOnLinkInTableByUniqueText(uniqueRowText, linkText, exact = true) {
+        const row = this.page.locator(UI_HELPER_ELEMENTS.rowByText(uniqueRowText));
+        await row.waitFor();
+        await row
+            .locator("a")
+            .getByText(linkText, { exact: exact })
+            .first()
+            .click();
+    }
+    /**
+     * Clicks on a button within a table row that contains a unique text and matches a button's label or aria-label.
+     * @param {string} uniqueRowText - The unique text present in one of the cells within the row. This is used to identify the specific row.
+     * @param {string | RegExp} textOrLabel - The text of the button or the `aria-label` attribute, can be a string or a regular expression.
+     */
+    async clickOnButtonInTableByUniqueText(uniqueRowText, textOrLabel) {
+        const row = this.page.locator(UI_HELPER_ELEMENTS.rowByText(uniqueRowText));
+        await row.waitFor();
+        await row
+            .locator(`button:has-text("${textOrLabel}"), button[aria-label="${textOrLabel}"]`)
+            .first()
+            .click();
+    }
+    async verifyLinkinCard(cardHeading, linkText, exact = true) {
+        const link = this.page
+            .locator(UI_HELPER_ELEMENTS.MuiCard(cardHeading))
+            .locator("a")
+            .getByText(linkText, { exact: exact })
+            .first();
+        await link.scrollIntoViewIfNeeded();
+        await expect(link).toBeVisible();
+    }
+    async clickBtnInCard(cardText, btnText, exact = true) {
+        const cardLocator = this.page
+            .locator(UI_HELPER_ELEMENTS.MuiCardRoot(cardText))
+            .first();
+        await cardLocator.scrollIntoViewIfNeeded();
+        await cardLocator
+            .getByRole("button", { name: btnText, exact: exact })
+            .first()
+            .click();
+    }
+    async verifyTextinCard(cardHeading, text, exact = true) {
+        const locator = this.page
+            .locator(UI_HELPER_ELEMENTS.MuiCard(cardHeading))
+            .getByText(text, { exact: exact })
+            .first();
+        await locator.scrollIntoViewIfNeeded();
+        await expect(locator).toBeVisible();
+    }
+    async verifyTableHeadingAndRows(texts) {
+        // Wait for the table to load by checking for the presence of table rows
+        await this.page.waitForSelector("table tbody tr", { state: "visible" });
+        for (const column of texts) {
+            const columnSelector = `table th:has-text("${column}")`;
+            //check if  columnSelector has at least one element or more
+            const columnCount = await this.page.locator(columnSelector).count();
+            expect(columnCount).toBeGreaterThan(0);
+        }
+        // Checks if the table has at least one row with data
+        // Excludes rows that have cells spanning multiple columns, such as "No data available" messages
+        const rowSelector = `table tbody tr:not(:has(td[colspan]))`;
+        const rowCount = await this.page.locator(rowSelector).count();
+        expect(rowCount).toBeGreaterThan(0);
+    }
+    async verifyTableIsEmpty() {
+        const rowSelector = `table tbody tr:not(:has(td[colspan]))`;
+        const rowCount = await this.page.locator(rowSelector).count();
+        expect(rowCount).toEqual(0);
+    }
+    async verifyAlertErrorMessage(message) {
+        const alert = this.page.getByRole("alert");
+        await alert.waitFor();
+        await expect(alert).toHaveText(message);
+    }
+    async verifyTextInTooltip(text) {
+        const tooltip = this.page.getByRole("tooltip").getByText(text);
+        await expect(tooltip).toBeVisible();
+    }
+}

package/dist/playwright/page-objects/global-obj.d.ts

@@ -0,0 +1,25 @@
+export declare const WAIT_OBJECTS: {
+    MuiLinearProgress: string;
+    MuiCircularProgress: string;
+};
+export declare const UI_HELPER_ELEMENTS: {
+    MuiButtonLabel: string;
+    MuiToggleButtonLabel: string;
+    MuiBoxLabel: string;
+    MuiTableHead: string;
+    MuiTableCell: string;
+    MuiTableRow: string;
+    MuiTypographyColorPrimary: string;
+    MuiSwitchColorPrimary: string;
+    MuiButtonTextPrimary: string;
+    MuiCard: (cardHeading: string) => string;
+    MuiCardRoot: (cardText: string) => string;
+    MuiTable: string;
+    MuiCardHeader: string;
+    MuiInputBase: string;
+    MuiTypography: string;
+    MuiAlert: string;
+    tabs: string;
+    rowByText: (text: string) => string;
+};
+//# sourceMappingURL=global-obj.d.ts.map

package/dist/playwright/page-objects/global-obj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-obj.d.ts","sourceRoot":"","sources":["../../../src/playwright/page-objects/global-obj.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;CAGxB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;2BAWN,MAAM;4BAEL,MAAM;;;;;;;sBAQZ,MAAM;CACzB,CAAC"}

package/dist/playwright/page-objects/global-obj.js

@@ -0,0 +1,24 @@
+export const WAIT_OBJECTS = {
+    MuiLinearProgress: 'div[class*="MuiLinearProgress-root"]',
+    MuiCircularProgress: '[class*="MuiCircularProgress-root"]',
+};
+export const UI_HELPER_ELEMENTS = {
+    MuiButtonLabel: 'span[class^="MuiButton-label"],button[class*="MuiButton-root"]',
+    MuiToggleButtonLabel: 'span[class^="MuiToggleButton-label"]',
+    MuiBoxLabel: 'div[class*="MuiBox-root"] label',
+    MuiTableHead: 'th[class*="MuiTableCell-root"]',
+    MuiTableCell: 'td[class*="MuiTableCell-root"]',
+    MuiTableRow: 'tr[class*="MuiTableRow-root"]',
+    MuiTypographyColorPrimary: ".MuiTypography-colorPrimary",
+    MuiSwitchColorPrimary: ".MuiSwitch-colorPrimary",
+    MuiButtonTextPrimary: ".MuiButton-textPrimary",
+    MuiCard: (cardHeading) => `//div[contains(@class,'MuiCardHeader-root') and descendant::*[text()='${cardHeading}']]/..`,
+    MuiCardRoot: (cardText) => `//div[contains(@class,'MuiCard-root')][descendant::text()[contains(., '${cardText}')]]`,
+    MuiTable: "table.MuiTable-root",
+    MuiCardHeader: 'div[class*="MuiCardHeader-root"]',
+    MuiInputBase: 'div[class*="MuiInputBase-root"]',
+    MuiTypography: 'span[class*="MuiTypography-root"]',
+    MuiAlert: 'div[class*="MuiAlert-message"]',
+    tabs: '[role="tab"]',
+    rowByText: (text) => `tr:has(:text-is("${text}"))`,
+};

package/dist/playwright/page-objects/page-obj.d.ts

@@ -0,0 +1,41 @@
+export declare const HOME_PAGE_COMPONENTS: {
+    MuiAccordion: string;
+    MuiCard: string;
+};
+export declare const SEARCH_OBJECTS_COMPONENTS: {
+    ariaLabelSearch: string;
+    placeholderSearch: string;
+};
+export declare const CATALOG_IMPORT_COMPONENTS: {
+    componentURL: string;
+};
+export declare const KUBERNETES_COMPONENTS: {
+    MuiAccordion: string;
+    statusOk: string;
+    podLogs: string;
+    MuiSnackbarContent: string;
+};
+export declare const BACKSTAGE_SHOWCASE_COMPONENTS: {
+    tableNextPage: string;
+    tablePreviousPage: string;
+    tableLastPage: string;
+    tableFirstPage: string;
+    tableRows: string;
+    tablePageSelectBox: string;
+};
+export declare const SETTINGS_PAGE_COMPONENTS: {
+    userSettingsMenu: string;
+    signOut: string;
+};
+export declare const ROLES_PAGE_COMPONENTS: {
+    editRole: (name: string) => string;
+    deleteRole: (name: string) => string;
+};
+export declare const DELETE_ROLE_COMPONENTS: {
+    roleName: string;
+};
+export declare const ROLE_OVERVIEW_COMPONENTS_TEST_ID: {
+    updatePolicies: string;
+    updateMembers: string;
+};
+//# sourceMappingURL=page-obj.d.ts.map

package/dist/playwright/page-objects/page-obj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-obj.d.ts","sourceRoot":"","sources":["../../../src/playwright/page-objects/page-obj.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB;;;CAGhC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;CAGrC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;CAErC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;CAKjC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;CAOzC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;CAGpC,CAAC;AAEF,eAAO,MAAM,qBAAqB;qBACf,MAAM;uBACJ,MAAM;CAC1B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;CAElC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;CAG5C,CAAC"}