transit-core-taf 1.0.2 → 1.0.4

package/dist/transit-core-taf/base/basepageactions.js

@@ -1,288 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasePageActions = void 0;
-const basepagewaits_1 = require("./basepagewaits");
-class BasePageActions {
-    page;
-    waits;
-    logger;
-    constructor(page, logger) {
-        this.page = page;
-        this.waits = new basepagewaits_1.BasePageWaits(page, logger);
-        this.logger = logger;
-    }
-    /**
-     * Waits for an element to be visible and clicks on it.
-     * Logs the action and provides an error message if the element isn't visible in time.
-     * @param element The locator of the element to click.
-     * @param timeout Optional timeout in ms to wait for visibility (default: 30s).
-     */
-    async clickElement(element, timeout = 30000) {
-        try {
-            this.logger.info(`[Action] Waiting for element to be visible before clicking: ${element}`);
-            await element.waitFor({ state: 'visible', timeout });
-            this.logger.info(`[Action] Clicking on element: ${element}`);
-            await element.click({ timeout });
-        }
-        catch (error) {
-            this.logger.error(`[Error] Failed to click element. It was not visible within ${timeout}ms: ${element}`);
-            throw error;
-        }
-    }
-    /**
-     * Clicks an element using its locator.
-     * @param {Locator} element - The Playwright locator of the element to click.
-     * @param {Object} [options={}] - Click options.
-     * @param {number} [options.timeout=120000] - Maximum time to wait for the element.
-     * @param {boolean} [options.force=false] - Whether to force the click (useful if the element is not interactable).
-     */
-    async clickByLocator(element, options = {}) {
-        const { timeout = 120000, force = false } = options;
-        this.logger.info(`Clicking by locator: ${element}`);
-        await element.waitFor({ state: 'visible', timeout });
-        await element.click({ timeout, force });
-        await this.waits.waitForDomContentLoad();
-    }
-    /**
-     * Locates a button with the specified text on the page.
-     *
-     * Note: This function currently only creates the locator but does not perform a click.
-     *
-     * @param buttonText - The visible text of the button to locate.
-    */
-    async clickButtonByText(buttonText, timeout = 60000) {
-        const button = this.page.locator('button', { hasText: buttonText });
-        await button.click({ timeout });
-        await this.waits.waitForPageLoad();
-    }
-    /**
-     * Locates a button with the specified text on the page.
-     *
-     * Note: This function currently only creates the locator but does not perform a click.
-     *
-     * @param buttonText - The visible text of the button to locate.
-    */
-    async clickById(id, clickIfVisible = false, timeout = 60000) {
-        this.logger.info(`Clicking by id: ${id}`);
-        const element = this.page.locator(`#${id}`);
-        try {
-            await element.waitFor({ state: 'visible', timeout });
-            if (clickIfVisible) {
-                if (await element.isVisible()) {
-                    await element.click({ timeout });
-                    await this.waits.waitForDomContentLoad();
-                }
-            }
-            else {
-                await element.click({ timeout });
-                await this.waits.waitForDomContentLoad();
-            }
-        }
-        catch (error) {
-            this.logger.error(`Element with ID '${id}' was not visible within ${timeout} ms.`);
-            throw error;
-        }
-    }
-    /**
-     * Fills an input element with a given value.
-     * @param element The locator of the input element.
-     * @param value The value to fill the input with.
-     */
-    async fillInput(element, value) {
-        await element.fill(value);
-    }
-    /**
-     * Clears the value of an input element.
-     * @param element The locator of the input element.
-     */
-    async clearInput(element) {
-        await element.fill('');
-    }
-    /**
-     * Types a text into an element slowly, with a specified delay between keystrokes.
-     * @param element The locator of the element to type into.
-     * @param text The text to type.
-     * @param delay The delay between keystrokes in milliseconds (default is 100).
-     */
-    async typeSlowly(element, text, delay = 100) {
-        await element.type(text, { delay });
-    }
-    /**
-     * Hovers over a given element.
-     * @param element The locator of the element to hover over.
-     */
-    async hoverOverElement(element, timeout = 20000) {
-        await element.waitFor({ state: 'visible', timeout });
-        await element.hover();
-    }
-    /**
-     * Presses a key on a given element.
-     * @param element The locator of the element.
-     * @param key The key to press (e.g., 'Enter', 'ArrowDown').
-     */
-    async pressKey(element, key) {
-        await element.press(key);
-    }
-    /**
-     * Checks a checkbox if it is not already checked.
-     * @param element The locator of the checkbox element.
-     */
-    async checkCheckbox(element) {
-        if (!(await element.isChecked())) {
-            await element.check();
-        }
-    }
-    /**
-     * Unchecks a checkbox if it is already checked.
-     * @param element The locator of the checkbox element.
-     */
-    async uncheckCheckbox(element) {
-        if (await element.isChecked()) {
-            await element.uncheck();
-        }
-    }
-    /**
-     * Selects an option from a dropdown element by its value.
-     * @param element The locator of the select element.
-     * @param value The value of the option to select.
-     */
-    async selectOption(element, value) {
-        await element.selectOption(value);
-    }
-    /**
-   * Retrieves the text content of an element by its ID.
-   *
-   * @param id - The ID of the HTML element to retrieve text from.
-   * @returns The text content of the specified element.
-   */
-    async getElementTextById(id) {
-        const text = (await this.page.locator(`#${id}`).textContent())?.toString();
-        return text;
-    }
-    /**
-     * Retrieves the text content of an element by its Locator.
-     * @param locator - The Locator of the HTML element to retrieve text from.
-     * @returns The text content of the specified element.
-     */
-    async getElementTextByLocator(locator) {
-        return (await locator.textContent()) ?? '';
-    }
-    /**Gets the specified attribute value of an element using its ID.
-     * @param id The ID of the element.
-     * @param attribute The attribute name (e.g., 'value', 'min', 'max')
-     */
-    async getElementAttributeValueById(id, attribute) {
-        const locator = await this.page.locator(`#${id}`);
-        const attributeValue = (await locator.getAttribute(attribute))?.toString();
-        return attributeValue;
-    }
-    /**
-     * Gets the specified attribute value of an element using a Locator.
-     * @param locator The Playwright Locator for the element.
-     * @param attribute The attribute name (e.g., 'value', 'min', 'max').
-     * @returns The attribute value as a string (or undefined if not present).
-     */
-    async getAttributeValueByLocator(locator, attribute) {
-        const attributeValue = (await locator.getAttribute(attribute))?.toString();
-        return attributeValue;
-    }
-    /** Fills an input element identified by its ID with a given value.
-    * - Waits for the input to be visible before filling.
-    *
-    * @param elementId - The ID of the input element.
-    * @param value - The value to fill the input with.
-    */
-    async fillInputById(elementId, value) {
-        const element = await this.page.locator(`#${elementId}`);
-        await element.waitFor({ state: 'visible' });
-        await element.fill(value);
-    }
-    /**
-     * Clicks a tab by its text and validates that it's selected using accessibility and style attributes.
-     * @param tabText - Visible text of the tab (e.g., "Crop").
-     * @param timeout - Optional timeout for the click action.
-     */
-    async validateCropTabSelected(tabLocator, timeout = 60000) {
-        await tabLocator.click({ timeout });
-        await this.waits.waitForPageLoad();
-    }
-    /**
-     * Counts the number of objects in the array where the given key is null or undefined.
-     * @param items - The array of items to check.
-     * @param key - The key to inspect on each item.
-     * @returns The number of items where the key is null or undefined.
-     */
-    async getNullCountByType(items, key) {
-        return items.filter((item) => item[key] == null).length;
-    }
-    /**
-     * Sets the viewport size and waits for DOM content to be loaded.
-     * @param viewport - An object with width and height properties.
-     */
-    async setViewport(viewport) {
-        await this.page.setViewportSize(viewport);
-        await this.page.waitForLoadState('domcontentloaded');
-    }
-    /**
-     * Reloads the current page and waits until the DOM is fully loaded.
-     * @param options - Optional reload options (timeout, waitUntil).
-     */
-    async reloadPage(options = { waitUntil: 'load' }) {
-        await this.page.reload(options);
-    }
-    /**
-     * Universal drag-and-drop method for builder elements (photos, layouts, backgrounds, stickers).
-     * Accepts either a string selector or a Playwright Locator for both source and target.
-     * @param source - Locator or string selector for the element to drag.
-     * @param target - Locator or string selector for the drop target.
-     * @param attribute - (Optional) Attribute to return from the dragged element (default: "data-id").
-     * @returns The attribute value if available, otherwise null.
-     */
-    async dragElementToTarget(source, target, attribute = 'data-id') {
-        const toLocator = (input) => {
-            if (typeof input !== 'string')
-                return input;
-            if (/^(#|\.|\[)/.test(input)) {
-                return this.page.locator(input);
-            }
-            return this.page.locator(`#${input}`);
-        };
-        const sourceLocator = toLocator(source);
-        const targetLocator = toLocator(target);
-        await sourceLocator.waitFor({ state: 'visible' });
-        await targetLocator.waitFor({ state: 'visible' });
-        const attrValue = await sourceLocator.getAttribute(attribute);
-        await sourceLocator.dragTo(targetLocator);
-        return attrValue;
-    }
-    /**
-     * Gives the textcontent of all elements .
-     * @param locator The ID of the element.
-     * Returns array of values of all the elements textcontent
-     */
-    async getAllTextContents(locator) {
-        const textContent = await locator.allTextContents();
-        return textContent;
-    }
-    /**
-     * @param locator The ID of the element.
-     * Click on element if its not expanded
-     */
-    async clickIfNotExpanded(locator) {
-        const isExpanded = await locator.getAttribute('aria-expanded');
-        if (isExpanded !== 'true') {
-            await locator.click();
-            await this.waits.waitForDomContentLoad();
-        }
-    }
-    /**
-     * Performs a mouse click at the given screen coordinates.
-     * @param x - The x-coordinate for the click.
-     * @param y - The y-coordinate for the click.
-     * @param options - Optional click options like button or clickCount.
-     */
-    async mouseClickAt(x, y, options = {}) {
-        await this.page.mouse.click(x, y, options);
-    }
-}
-exports.BasePageActions = BasePageActions;

package/dist/transit-core-taf/base/basepagevalidations.d.ts

@@ -1,296 +0,0 @@
-import { Locator, Page } from '@playwright/test';
-import { Logger } from './logger';
-export declare class BasePageValidations {
-    private page;
-    private logger;
-    constructor(page: Page, logger: Logger);
-    /**
-     * Validates that a given element is visible.
-     * @param element The locator of the element to validate.
-     */
-    validateElementToBeVisible(element: Locator): Promise<void>;
-    /**
-     * Validates that a given element is not visible.
-     * This method asserts that the element exists in the DOM but is not currently visible.
-     * Visibility is determined based on factors such as CSS properties like `display: none`,
-     * `visibility: hidden`, or being off-screen.
-     * @param element The locator of the element to validate.
-     * @throws Will throw an assertion error if the element is visible.
-     */
-    validateElementNotToBeVisible(element: Locator): Promise<void>;
-    /**
-     * Validates that the number of elements matching the locator is equal to the expected count.
-     * @param locator - The Playwright Locator pointing to the elements.
-     * @param expectedCount - The expected number of elements.
-     * Example:
-     * await validateElementCountToBe(page.locator('.item'), 3);
-     * */
-    validateElementCountToBe(locator: Locator, expectedCount: number): Promise<void>;
-    /**
-     * Validates that two elements are not overlapping.
-     * @param element1 The first locator.
-     * @param element2 The second locator.
-     */
-    validateElementsDoNotOverlap(element1: Locator, element2: Locator): Promise<void>;
-    /**
-     * Waits for an element with the given ID to appear in the DOM within the specified timeout,
-     * and then validates that the element is visible.
-     *
-     * @param id - The ID of the element to validate visibility for.
-     * @param timeout - Maximum time to wait for the element to appear (in milliseconds). Defaults to 10 seconds.
-     */
-    validateElementToBeVisibleById(id: string, timeout?: number): Promise<void>;
-    /** Validates that a given element is visible and contains the expected text.
-     * @param element - The Playwright Locator for the element to validate.
-     * @param expectedText - The exact text expected to be present in the element.
-     * @param timeout - Optional timeout (in ms) to wait for visibility and text match. Default is 60 seconds.
-     * await validations.validateElementToHaveText(page.locator('.success-message'), 'Upload Complete');
-     */
-    validateElementToHaveText(element: Locator | string, expectedText: string, timeout?: number): Promise<void>;
-    /**
-     * Validates that a given element has the expected text.
-     * @param element The locator of the element to validate.
-     * @param expectedText The expected text of the element.
-     */
-    validateText(actualText?: string, expectedText?: string | number): Promise<void>;
-    /**
-     * Validates that a given element has the expected text.
-     * @param element The locator of the element to validate.
-     * @param expectedText The expected text of the element.
-     */
-    validateTextNotToBe(actualText?: string, expectedText?: string | number): Promise<void>;
-    /**
-     * Validates that a given element is enabled.
-     * @param element The locator of the element to validate.
-     */
-    validateElementToBeEnabled(element: Locator): Promise<void>;
-    /**
-     * Validates that a given element is hidden.
-     * @param element The locator of the element to validate.
-     */
-    validateElementToBeHidden(element: Locator): Promise<void>;
-    /**
-     * Validates that multiple elements are hidden.
-     * @param elements Array of Playwright locators to validate.
-     */
-    validateElementsToBeHidden(elements: Locator[]): Promise<void>;
-    /**
-     * Validates that a given element (Locator or string ID) has a specific attribute with a specific value.
-     * @param element - The element to validate (Playwright Locator or string ID).
-     * @param attr - The attribute to check.
-     * @param value - The expected value of the attribute.
-     * @param timeout - Optional timeout in milliseconds (default: 10s).
-     */
-    validateElementToHaveAttribute(element: Locator | string, attr: string, value: string, timeout?: number): Promise<void>;
-    /**
-    * Validates that a given element contains the expected text (partial or regex).
-    * @param element The locator or string ID of the element.
-    * @param expectedText The expected partial text or RegExp to be found in the element.
-    * @param timeout Maximum time to wait for the element to become visible and contain the text (default: 60s).
-    */
-    validateElementToContainText(element: Locator | string, expectedText: string | RegExp, timeout?: number): Promise<void>;
-    /**
-     * Checks if an element with the given ID is visible on the page.
-     * This method runs inside the browser context using `page.evaluate` to:
-     * - Find the DOM element using `getElementById`.
-     * - Return false if the element doesn't exist.
-     * - Otherwise, check if the element's `display` style is not set to `"none"`,
-     *   which indicates whether the element is visible or hidden via CSS.
-     * @param elementId - The ID of the element to check visibility for.
-     * @returns A promise that resolves to `true` if the element is visible,
-     * or `false` if it's hidden or not found.
-     */
-    isElementVisible(elementId: string): Promise<boolean>;
-    /**
-     * Checks if an element with the given ID is visible on the page using Playwright commands.
-     * It asserts that the element is visible within the given timeout.
-     *
-     * @param elementId - The ID of the element to check.
-     * @param timeout - The maximum time to wait for the element to become visible (in ms). Default is 5000 ms.
-     */
-    validateElementVisibleById(elementId: string, timeout?: number): Promise<void>;
-    /**
-    * Validates that a value is null.
-    * @param actual The actual value to check.
-    */
-    validateValueToBeNull(actual: any): Promise<void>;
-    /**
-     * Validates that a value is not null.
-     * @param actual The actual value to check.
-     */
-    validateValueNotToBeNull(actual: any): Promise<void>;
-    /**
-     * Validates that a value is greater than the expected value.
-     * @param actual The actual number.
-     * @param expected The number to compare against.
-     */
-    validateValueToBeGreaterThan(actual: number, expected: number): Promise<void>;
-    /**
-     * Validates that a value is less than or equal to the expected value.
-     * @param actual The actual number.
-     * @param expected The number to compare against.
-     */
-    validateValueToBeLessThanOrEqual(actual: number, expected: number): Promise<void>;
-    /**
-    * Validates that the actual value is equal to the expected value.
-    * @param actual - The actual value.
-    * @param expected - The expected value to compare.
-    * @param message - Optional custom message for assertion failure.
-    */
-    validateValueToEqual(actual: any, expected: any, message?: string): Promise<void>;
-    /**
-     * Validates that the actual value is NOT equal to the expected value.
-     * @param actual - The actual value.
-     * @param expected - The value that should not match.
-     * @param message - Optional custom message for assertion failure.
-     */
-    validateValueNotToEqual(actual: any, expected: any, message?: string): Promise<void>;
-    /**
-     * Validates that the actual number is less than the expected number.
-     * @param actual - The actual number.
-     * @param expected - The number to compare against.
-     */
-    validateValueToBeLessThan(actual: number, expected: number): Promise<void>;
-    /**
-     * Validates that the actual value is truthy.
-     * @param actual - The value to validate.
-     */
-    validateValueToBeTruthy(actual: any): Promise<void>;
-    /**
-     * Validates that the actual value is falsy.
-     * @param actual - The value to validate.
-     */
-    validateValueToBeFalsy(actual: any): Promise<void>;
-    /**
-     * Validates that the actual array or string contains the expected item or substring.
-     * @param actual - The array or string.
-     * @param expected - The item or substring to check for.
-     */
-    validateValueToContain(actual: any[] | string, expected: any): Promise<void>;
-    /**
-     * Validates that the actual string matches the given regular expression or substring.
-     * @param actual - The string to validate.
-     * @param expected - The regular expression or substring.
-     */
-    validateValueToMatch(actual: string, expected: string | RegExp): Promise<void>;
-    /**
-     * Compares two arrays for equality (order-sensitive) using Playwright's expect.
-     * @param expected The expected array values.
-     * @param actual The actual array values.
-     * @param message Optional message for error context.
-     */
-    validateArrayTextValues(expected: any[], actual: any[], message?: string): Promise<void>;
-    /**
-     * Compares two objects containing arrays (order-sensitive) using Playwright's expect.
-     * Each key in the object is compared individually with soft assertions.
-     * @param expected The expected object with array values.
-     * @param actual The actual object with array values.
-     * @param message Optional message for error context.
-     */
-    validateObjectOfArrayTextValues(expected: {
-        [key: string]: string[];
-    }, actual: {
-        [key: string]: string[];
-    }, message?: string): Promise<void>;
-    /**
-     * Validates that the current page URL contains the expected string.
-     * Useful when the URL may include dynamic query parameters or fragments.
-     * @param expectedUrl - The expected substring to be present in the current URL.
-     */
-    validateUrlToMatch(endpoint: RegExp): Promise<void>;
-    /**
-     * Validates that the current page URL starts with the expected string.
-     * Useful when the URL has dynamic query parameters.
-     * @param expectedUrl - The expected base URL (without query params).
-     */
-    validateUrlToContain(expectedUrl: string): Promise<void>;
-    /**
-     * Validates that the element has the expected class name.
-     * @param locator - The element locator.
-     * @param expected - The class name to match (string or RegExp).
-     */
-    validateLocatorToHaveClass(locator: Locator, expected: string | RegExp): Promise<void>;
-    /** Validates all visible crop drag handles have correct accessibility attributes.
-     * Skips any handles that are not currently visible.
-     * @param page - Playwright Page instance
-     */
-    validateCropDragHandles(page: Page): Promise<void>;
-    /**
-     * Validates if a given value is true or false.
-     * @param actual - The actual boolean value or a function that returns a boolean.
-     * @param expected - Expected boolean value (true or false).
-     * @param message - Optional custom error message on failure.
-     */
-    validateToBeBoolean(actual: boolean | (() => Promise<boolean> | boolean), expected: boolean, message?: string): Promise<void>;
-    /**
-     * Validates that a given element has the specified class or matches the given class pattern.
-     * @param element The locator of the element to validate.
-     * @param expectedClass The expected class name or regex pattern.
-     */
-    validateElementToHaveClass(element: Locator | string, expected: string | RegExp): Promise<void>;
-    /**
-     * Validates that a given element has the expected CSS class.
-     * @param element The locator of the element to validate.
-     * @param expectedClass The class name expected to be present on the element.
-     */
-    validateElementToContainClass(element: Locator, expectedClass: string): Promise<void>;
-    /**
-    * Validates that an asynchronous condition passes within a given timeout.
-    * @param condition A function that returns a promise to be resolved.
-    * @param timeout The timeout for the condition to pass.
-    */
-    validateAsyncCondition(condition: () => Promise<void>, timeout: number): Promise<void>;
-    /**
-     * Validates that a given element has the expected CSS property and value.
-     * @param locator The locator of the element to validate.
-     * @param cssProperty The CSS property to check.
-     * @param expectedValue The expected value of the CSS property.
-     */
-    validateElementToHaveCSS(locator: Locator, cssProperty: string, expectedValue: string | RegExp): Promise<void>;
-    /**
-     * Validates that the actual value is equal to the expected value.
-     * @param actual - The actual value.
-     * @param expected - The expected value to compare.
-     */
-    validateValueToBe(actual: any, expected: any): Promise<void>;
-    /**
-     * Gets the value of a given attribute from a locator.
-     * @param locator - Playwright Locator for the element.
-     * @param attributeName - The attribute name to fetch (e.g., "aria-checked", "data-id").
-     * @returns Promise resolving to the attribute value or null if not present.
-     */
-    getAttributeValueByLocator(locator: Locator, attributeName: string): Promise<string | null>;
-    /**
-     * Validates that the given element does NOT have the specified attribute value.
-     * If the attribute is missing, the check passes.
-     * If the attribute exists, its value must not equal the provided one.
-     * @param element Locator of the element to validate
-     * @param attr Attribute name to check (e.g., "class", "disabled")
-     * @param value Attribute value that should NOT be present
-     */
-    validateElementNotToHaveAttributeValue(element: Locator, attr: string, value: string): Promise<void>;
-    /**
-     * Validates that all layered file names exist in the photo tray file names.
-     * @param photoTrayFileNames - Array of file names currently available in the photo tray.
-     * @param layeredFileNames   - Array of file names that are layered/applied on the canvas.
-     * The function ensures integrity between the canvas and the photo tray,
-     * by checking that every layered file originates from the photo tray.
-     */
-    validateValuesToContain(photoTrayFileNames: string[], layeredFileNames: string[]): Promise<void>;
-    /**
-     * Validates that multiple elements are visible on the page.
-     * @param {Locator[]} elements - Array of Playwright locators to validate.
-     * @returns {Promise<void>} Resolves when all elements are confirmed visible.
-     */
-    validateElementsToBeVisible(elements: Locator[]): Promise<void>;
-    /** Waits until a given element is visible in the DOM.
-     * @param element - The Playwright Locator of the element to wait for.
-     * @param timeout - Optional timeout in ms (default: 10s).
-     */
-    waitForElementVisible(element: Locator, timeout?: number): Promise<void>;
-    /**
-     * Checks if given elements have expected text.
-     * Accepts either locator or string ID.
-     */
-    validateElementsToHaveText(locators: any[], expectedTexts: string[]): Promise<void>;
-}