transit-core-taf 1.0.4 → 1.0.5

package/dist/transit-core-taf/baseui/basepagewaits.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePageWaits = void 0;
+class BasePageWaits {
+    page;
+    logger;
+    constructor(page, logger) {
+        this.page = page;
+        this.logger = logger;
+    }
+    /**
+     * Waits for the page to be fully loaded.
+     */
+    async waitForPageLoad(timeout = 240000) {
+        this.logger.info("Waiting for page to load...");
+        await this.page.waitForLoadState('domcontentloaded', { timeout });
+        try {
+            // await this.page.waitForLoadState('networkidle', { timeout });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Network idle state not reached within ${timeout / 1000}s. Continuing...`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitForDomContentLoad() {
+        this.logger.info("Waiting for DOM content to load...");
+        await this.page.waitForLoadState('domcontentloaded');
+    }
+    async waitForNetworkIdle() {
+        await this.page.waitForLoadState('networkidle');
+    }
+    /**
+     * Waits for either DOM content to load or the full page to load, based on the provided flag.
+     * @param {boolean} [waitForDomOnly=false] -
+     * If true, waits only for DOM content to be loaded using `waitForDomContentLoad()`.
+     * If false (default), waits for the full page load using `waitForPageLoad()`.
+     * This method is useful when navigating between pages or clicking links where
+     * you want to optimize waiting time based on the expected load behavior.
+     */
+    async waitForPageLoadOnCondition(waitForDomOnly = false) {
+        if (waitForDomOnly) {
+            await this.waitForDomContentLoad();
+        }
+        else {
+            await this.waitForPageLoad();
+        }
+    }
+    /**
+     * Waits for a specified number of seconds.
+     * @param seconds The number of seconds to wait.
+     */
+    async waitForSeconds(seconds) {
+        this.logger.info(`Waiting for ${seconds} seconds...`);
+        await this.page.waitForTimeout(seconds * 1000);
+    }
+    /**
+     * Navigates to a URL and waits for the page to load.
+     * @param url The URL to navigate to.
+     */
+    async goto(url) {
+        await this.page.goto(url);
+        await this.waitForPageLoad();
+    }
+    /**
+     * Checks if an element is visible on the page.
+     * @param selector The selector of the element to check.
+     * @returns A promise that resolves to true if the element is visible, and false otherwise.
+     */
+    async isElementVisible(selector) {
+        return await this.page.locator(selector).isVisible();
+    }
+    /**
+     * Waits for the progress spinner to become invisible.
+     * The spinner is identified by the '#progress-status' selector, and this method
+     * is robust against the changing text within the spinner.
+     */
+    async waitForProgressSpinnerInvisibility() {
+        const spinnerSelector = '#progress-status';
+        try {
+            await this.page.waitForSelector(spinnerSelector, { state: 'hidden', timeout: 240000 });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Progress spinner did not become invisible within 240 seconds.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitFoPhotosUploadingSpinnerInvisibility() {
+        const preparingPhotosSelector = this.page.getByText(/Preparing Photos...Uploading \d+ Photos/);
+        try {
+            await preparingPhotosSelector.waitFor({ state: 'hidden', timeout: 240000 });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Uploading spinner did not become invisible within 240 seconds.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitForLeftWellSpinnerInvisibility() {
+        const spinnerSelector = '#transparent-well-overlay';
+        try {
+            await this.page.waitForSelector(spinnerSelector, { state: 'hidden', timeout: 240000 });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Left well spinner did not become invisible within 240 seconds.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async waitForSaveToBeSuccessful(timeout) {
+        const saveTooltip = this.page.locator('#save-tooltip');
+        await saveTooltip.waitFor({ state: 'visible', timeout });
+        const message = this.page.locator('div.tooltip-gl__box:has-text("Your project was successfully saved")');
+        await message.waitFor({ state: 'visible', timeout });
+        await saveTooltip.waitFor({ state: 'hidden', timeout });
+    }
+    async waitForApplyLayoutsToAllPages() {
+        const overlaySelector = '#transparent-page-overlay';
+        try {
+            // Wait for the overlay to disappear (opacity = 0)
+            await this.page.waitForFunction((selector) => {
+                const element = document.querySelector(selector);
+                if (element) {
+                    const style = window.getComputedStyle(element);
+                    return parseFloat(style.opacity) === 0;
+                }
+                return true; // If element is gone, it's also considered "disappeared"
+            }, overlaySelector, { timeout: 240000 } // 4 minutes timeout for it to disappear
+            );
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                this.logger.warn(`Apply layouts to all pages overlay did not become transparent within the timeout.`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Waits for a given element to be visible on the page.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param timeout - Optional timeout in milliseconds (default: 5000).
+     */
+    async waitForElementToBeVisible(element, timeout = 10000) {
+        try {
+            this.logger.info(`🔍 Waiting for element to be visible: ${element.toString()} (timeout: ${timeout}ms)`);
+            await element.waitFor({ state: 'visible', timeout });
+        }
+        catch (error) {
+            this.logger.error(`❌ Failed to find visible element: ${element.toString()} within ${timeout}ms`);
+            throw error;
+        }
+    }
+}
+exports.BasePageWaits = BasePageWaits;

package/dist/transit-core-taf/baseui/commonpageactions.d.ts

@@ -0,0 +1,40 @@
+import { Locator, Page } from '@playwright/test';
+import { Logger } from './logger';
+export declare class CommonPageActions {
+    private page;
+    private waits;
+    constructor(page: Page, logger: Logger);
+    /**
+     * Click on an element if it's not expanded.
+     * @param locator The locator of the element.
+     */
+    clickIfNotExpanded(locator: Locator): Promise<void>;
+    /**
+     * Clicks an element without waiting for a full page load or network idle.
+     * This is ideal for clicking on-page elements like tabs that don't trigger navigation.
+     * @param element The locator of the element to click.
+     * @param timeout Optional timeout in ms.
+     */
+    clickElementOnly(element: Locator, timeout?: number): Promise<void>;
+    /**
+     * Removes the cookie consent popup from the DOM.
+     */
+    acceptCookiePopup(): Promise<void>;
+    /**
+     * Accepts the Transcend consent banner if it is visible.
+     */
+    acceptTranscendConsent(): Promise<void>;
+    /**
+     * Performs a robust, manual drag-and-drop by simulating mouse actions.
+     * This is useful for complex UIs where `dragTo` might fail.
+     * @param source The locator of the element to drag.
+     * @param target The locator of the drop target.
+     */
+    dragAndDrop(source: Locator, target: Locator): Promise<void>;
+    /**
+     * Waits for a given element to be hidden on the page.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param timeout - Optional timeout in milliseconds (default: 10000).
+     */
+    waitForElementToBeHidden(element: Locator, timeout?: number): Promise<void>;
+}

package/dist/transit-core-taf/baseui/commonpageactions.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonPageActions = void 0;
+const basepagewaits_1 = require("./basepagewaits");
+class CommonPageActions {
+    page;
+    waits;
+    constructor(page, logger) {
+        this.page = page;
+        this.waits = new basepagewaits_1.BasePageWaits(page, logger);
+    }
+    /**
+     * Click on an element if it's not expanded.
+     * @param locator The locator of the element.
+     */
+    async clickIfNotExpanded(locator) {
+        const isExpanded = await locator.getAttribute('aria-expanded');
+        if (isExpanded !== 'true') {
+            await locator.click();
+            await this.waits.waitForDomContentLoad();
+        }
+    }
+    /**
+     * Clicks an element without waiting for a full page load or network idle.
+     * This is ideal for clicking on-page elements like tabs that don't trigger navigation.
+     * @param element The locator of the element to click.
+     * @param timeout Optional timeout in ms.
+     */
+    async clickElementOnly(element, timeout = 30000) {
+        console.log(`[Action] Clicking element without page load wait: ${element}`);
+        await element.waitFor({ state: 'visible', timeout });
+        await element.click({ timeout });
+    }
+    /**
+     * Removes the cookie consent popup from the DOM.
+     */
+    async acceptCookiePopup() {
+        console.log('Attempting to accept cookie popup by clicking "OKAY"');
+        try {
+            /**First, try to click the "OKAY" button */
+            const okayButton = this.page.locator('button:has-text("OKAY")');
+            await okayButton.waitFor({ state: 'visible', timeout: 5000 });
+            await okayButton.click();
+            console.log('Successfully clicked "OKAY" on the cookie popup.');
+        }
+        catch (error) {
+            /** If clicking "OKAY" fails, fall back to the original DOM removal method */
+            console.log('Could not find or click "OKAY" button, falling back to DOM removal.');
+            await this.page.evaluate(() => {
+                const el = document.getElementById('transcend-consent-manager');
+                if (el) {
+                    el.remove();
+                    console.log('Removed transcend-consent-manager element as a fallback.');
+                }
+                else {
+                    console.log('transcend-consent-manager element not found for removal.');
+                }
+            });
+        }
+    }
+    /**
+     * Accepts the Transcend consent banner if it is visible.
+     */
+    async acceptTranscendConsent() {
+        const consentManager = this.page
+            .locator('#transcend-consent-manager')
+            .first();
+        if (await consentManager.isVisible()) {
+            await this.page.locator('button:has-text("Accept All")').click();
+        }
+        console.log('Accepting cookie popup');
+        await this.page.evaluate(() => {
+            const el = document.getElementById('transcend-consent-manager');
+            if (el) {
+                el.remove();
+            }
+        });
+    }
+    /**
+     * Performs a robust, manual drag-and-drop by simulating mouse actions.
+     * This is useful for complex UIs where `dragTo` might fail.
+     * @param source The locator of the element to drag.
+     * @param target The locator of the drop target.
+     */
+    async dragAndDrop(source, target) {
+        console.log(`Performing manual drag-and-drop from ${source} to ${target}`);
+        const sourceBounds = await source.boundingBox();
+        const targetBounds = await target.boundingBox();
+        if (sourceBounds && targetBounds) {
+            console.log(`Source bounds: ${JSON.stringify(sourceBounds)}`);
+            console.log(`Target bounds: ${JSON.stringify(targetBounds)}`);
+            await this.page.mouse.move(sourceBounds.x + sourceBounds.width / 2, sourceBounds.y + sourceBounds.height / 2);
+            await this.page.mouse.down();
+            await target.hover({ force: true });
+            await this.page.mouse.move(targetBounds.x + targetBounds.width / 2, targetBounds.y + targetBounds.height / 2, { steps: 5 });
+            await this.page.mouse.up();
+        }
+        else {
+            throw new Error('Could not get bounding boxes for one or both drag-and-drop elements.');
+        }
+    }
+    /**
+     * Waits for a given element to be hidden on the page.
+     * @param element - The Playwright Locator of the element to wait for.
+     * @param timeout - Optional timeout in milliseconds (default: 10000).
+     */
+    async waitForElementToBeHidden(element, timeout = 10000) {
+        try {
+            console.log(`🔍 Waiting for element to be hidden: ${element.toString()} (timeout: ${timeout}ms)`);
+            await element.waitFor({ state: 'hidden', timeout });
+        }
+        catch (error) {
+            console.error(`❌ Element did not become hidden: ${element.toString()} within ${timeout}ms`);
+            throw error;
+        }
+    }
+}
+exports.CommonPageActions = CommonPageActions;

package/dist/transit-core-taf/baseui/commonpagevalidations.d.ts

@@ -0,0 +1,10 @@
+import { Page } from '@playwright/test';
+export declare class CommonPageValidations {
+    protected page: Page;
+    constructor(page: Page);
+    /**
+     * Validates that the page is in fullscreen mode.
+     * @param isFullScreen A boolean indicating whether the page should be in fullscreen mode.
+     */
+    validateFullScreen(isFullScreen: boolean): Promise<void>;
+}

package/dist/transit-core-taf/baseui/commonpagevalidations.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonPageValidations = void 0;
+const test_1 = require("@playwright/test");
+class CommonPageValidations {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Validates that the page is in fullscreen mode.
+     * @param isFullScreen A boolean indicating whether the page should be in fullscreen mode.
+     */
+    async validateFullScreen(isFullScreen) {
+        const fullscreenState = await this.page.evaluate(() => {
+            return !!document.fullscreenElement;
+        });
+        (0, test_1.expect)(fullscreenState).toBe(isFullScreen);
+    }
+}
+exports.CommonPageValidations = CommonPageValidations;

package/dist/transit-core-taf/baseui/commonpagewaits.d.ts

@@ -0,0 +1,28 @@
+import { Locator, Page } from '@playwright/test';
+export declare class CommonPageWaits {
+    protected page: Page;
+    constructor(page: Page);
+    /**
+     * Waits for an element's attribute to match a specific value or pattern.
+     * @param locator The Playwright Locator of the element.
+     * @param attribute The name of the attribute to check.
+     * @param value The expected value of the attribute (string or RegExp).
+     * @param timeout Optional timeout in milliseconds.
+     */
+    waitForAttributeToBePresent(locator: Locator, attribute: string, value: string | RegExp, invert?: boolean, timeout?: number): Promise<void>;
+    /**
+     * Waits for the page URL to match a specific value or pattern.
+     * - If 'url' is a string, it waits for an exact URL match.
+     * - If 'url' is a RegExp, it waits for the URL to match the pattern.
+     *   (e.g., to check if URL contains 'login', use /login/).
+     * @param url The expected URL (string for exact match, or RegExp for pattern match).
+     * @param timeout Optional timeout in milliseconds.
+     */
+    waitForURL(url: string | RegExp, timeout?: number): Promise<void>;
+    /**
+     * Waits for an element to be hidden.
+     * @param locator The Playwright Locator of the element.
+     * @param timeout Optional timeout in milliseconds.
+     */
+    waitForElementToBeHidden(locator: Locator, timeout?: number): Promise<void>;
+}

package/dist/transit-core-taf/baseui/commonpagewaits.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonPageWaits = void 0;
+const test_1 = require("@playwright/test");
+class CommonPageWaits {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Waits for an element's attribute to match a specific value or pattern.
+     * @param locator The Playwright Locator of the element.
+     * @param attribute The name of the attribute to check.
+     * @param value The expected value of the attribute (string or RegExp).
+     * @param timeout Optional timeout in milliseconds.
+     */
+    async waitForAttributeToBePresent(locator, attribute, value, invert = false, timeout = 10000) {
+        await test_1.expect
+            .poll(async () => {
+            const attributeValue = await locator.getAttribute(attribute);
+            if (invert) {
+                return value instanceof RegExp
+                    ? !value.test(attributeValue || '')
+                    : attributeValue !== value;
+            }
+            else {
+                return value instanceof RegExp
+                    ? value.test(attributeValue || '')
+                    : attributeValue === value;
+            }
+        }, {
+            message: `Timed out waiting for attribute "${attribute}" to ${invert ? 'not be' : 'be'} "${value}" on ${locator.toString()}`,
+            timeout: timeout,
+        })
+            .toBe(true);
+    }
+    /**
+     * Waits for the page URL to match a specific value or pattern.
+     * - If 'url' is a string, it waits for an exact URL match.
+     * - If 'url' is a RegExp, it waits for the URL to match the pattern.
+     *   (e.g., to check if URL contains 'login', use /login/).
+     * @param url The expected URL (string for exact match, or RegExp for pattern match).
+     * @param timeout Optional timeout in milliseconds.
+     */
+    async waitForURL(url, timeout = 30000) {
+        await (0, test_1.expect)(this.page).toHaveURL(url, { timeout });
+    }
+    /**
+     * Waits for an element to be hidden.
+     * @param locator The Playwright Locator of the element.
+     * @param timeout Optional timeout in milliseconds.
+     */
+    async waitForElementToBeHidden(locator, timeout = 10000) {
+        await (0, test_1.expect)(locator).toBeHidden({ timeout });
+    }
+}
+exports.CommonPageWaits = CommonPageWaits;

package/dist/transit-core-taf/baseui/logger.d.ts

@@ -0,0 +1,10 @@
+export declare class Logger {
+    private testDescription;
+    constructor(testDescription: string);
+    private log;
+    info(message: string): void;
+    debug(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    errorAndThrow(message: string): never;
+}

package/dist/transit-core-taf/baseui/logger.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    testDescription;
+    constructor(testDescription) {
+        this.testDescription = testDescription;
+    }
+    log(level, message) {
+        const logMessage = `[${this.testDescription}] ${level.toUpperCase()}: ${message}`;
+        switch (level) {
+            case 'info':
+                console.info(logMessage);
+                break;
+            case 'warn':
+                console.warn(logMessage);
+                break;
+            case 'error':
+                console.error(logMessage);
+                break;
+            default:
+                console.log(logMessage);
+                break;
+        }
+    }
+    info(message) {
+        this.log('info', message);
+    }
+    debug(message) {
+        this.log('debug', message);
+    }
+    warn(message) {
+        this.log('warn', message);
+    }
+    error(message) {
+        this.log('error', message);
+    }
+    errorAndThrow(message) {
+        throw new Error(`[${this.testDescription}] ${message}`);
+    }
+}
+exports.Logger = Logger;

package/dist/transit-core-taf/constants/test-tags.d.ts

@@ -0,0 +1,4 @@
+export declare const tags: {
+    REGRESSION: string;
+    SMOKE: string;
+};

package/dist/transit-core-taf/constants/test-tags.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = void 0;
+exports.tags = {
+    REGRESSION: "@regression",
+    SMOKE: "@smoke"
+};

package/dist/transit-core-taf/fixtures.d.ts

@@ -0,0 +1,20 @@
+import { BasePageActions } from './baseui/basepageactions';
+import { BasePageValidations } from './baseui/basepagevalidations';
+import { BasePageWaits } from './baseui/basepagewaits';
+import { BaseApi } from './baseapi/baseapihelpers';
+import { CommonPageActions } from './baseui/commonpageactions';
+import { Logger } from './baseui/logger';
+import path = require('path');
+import fs = require('fs');
+type MyFixtures = {
+    logger: Logger;
+    actions: BasePageActions;
+    validations: BasePageValidations;
+    waits: BasePageWaits;
+    baseApi: BaseApi;
+    commonPageActions: CommonPageActions;
+};
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & MyFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export declare const expect: import("@playwright/test").Expect<{}>;
+export { tags } from './constants/test-tags';
+export { path, fs };

package/dist/transit-core-taf/fixtures.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fs = exports.path = exports.tags = exports.expect = exports.test = void 0;
+const test_1 = require("@playwright/test");
+const basepageactions_1 = require("./baseui/basepageactions");
+const basepagevalidations_1 = require("./baseui/basepagevalidations");
+const basepagewaits_1 = require("./baseui/basepagewaits");
+const baseapihelpers_1 = require("./baseapi/baseapihelpers");
+const commonpageactions_1 = require("./baseui/commonpageactions");
+const logger_1 = require("./baseui/logger");
+const path = require("path");
+exports.path = path;
+const fs = require("fs");
+exports.fs = fs;
+exports.test = test_1.test.extend({
+    logger: async ({}, use, testInfo) => {
+        const logger = new logger_1.Logger(testInfo.title);
+        await use(logger);
+    },
+    /**
+     * Fixture for BasePageActions.
+     */
+    actions: async ({ page, logger }, use) => {
+        const actions = new basepageactions_1.BasePageActions(page, logger);
+        await use(actions);
+    },
+    /**
+     * Fixture for BasePageValidations.
+     */
+    validations: async ({ page, logger }, use) => {
+        const basePageValidations = new basepagevalidations_1.BasePageValidations(page, logger);
+        await use(basePageValidations);
+    },
+    /**
+     * Fixture for BasePageWaits.
+     */
+    waits: async ({ page, logger }, use) => {
+        const waits = new basepagewaits_1.BasePageWaits(page, logger);
+        await use(waits);
+    },
+    /**
+    * Fixture for the BaseApi.
+    */
+    baseApi: async ({ logger }, use) => {
+        const baseApi = new baseapihelpers_1.BaseApi(logger);
+        await use(baseApi);
+    },
+    /**
+     * Fixture for CommonPageActions.
+     */
+    commonPageActions: async ({ page, logger }, use) => {
+        const commonPageActions = new commonpageactions_1.CommonPageActions(page, logger);
+        await use(commonPageActions);
+    }
+});
+exports.expect = exports.test.expect;
+var test_tags_1 = require("./constants/test-tags");
+Object.defineProperty(exports, "tags", { enumerable: true, get: function () { return test_tags_1.tags; } });

package/dist/transit-core-taf/global-setup.d.ts

@@ -0,0 +1,2 @@
+declare function globalSetup(): Promise<void>;
+export default globalSetup;