transit-core-taf 1.0.2

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

@@ -0,0 +1,296 @@
+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>;
+}