@anddone/coretestautomation 1.0.1

package/src/utils/pageUtils.ts

@@ -0,0 +1,224 @@
+import type { Page, BrowserContext } from '@playwright/test';
+
+export class PageUtils {
+    /**
+   * Navigates to specified URL and waits for DOM to load
+   * @param page Playwright Page object
+   * @param url URL where page should navigate to
+   * @param timeout Maximum wait time in milliseconds (default: 15000)
+   */
+  static async navigateTo(page: Page, url: string, timeout: number = 15000): Promise<void> {
+    try {
+      await page.goto(url, { waitUntil: 'domcontentloaded', timeout });
+    }
+    catch (error) {
+      console.warn(`Navigation skipped: ${(error as Error).message}`);
+    }
+  }
+  /**
+   * closes the browser window represented by the given page object
+   * @param page Playwright page object
+   * @returns true if window is closed successfully
+   */
+  static async closeWindow(page: Page): Promise<boolean> {
+    try {
+      await page.close();
+      return true;
+    }
+    catch (error) {
+      console.warn(`Window close skipped: ${(error as Error).message}`);
+      return false;
+    }
+  }
+
+  /**
+   * closes the window whose index has been passed
+   * @param context Playwright BrowserContext containing all open pages
+   * @param index of the window which is to be closed
+   * @returns true if window is closed 
+   * calling e.g. - await closeWindowByIndex(context, 1)
+   */
+  static async closeWindowByIndex(context: BrowserContext, index: number): Promise<boolean> {
+    try {
+      const pages = context.pages();
+
+      if (index < 0 || index >= pages.length) {
+        console.warn(`Invalid window index: ${index}`);
+        return false;
+      }
+
+      await pages[index].close();
+      return true;
+    }
+    catch (error) {
+      console.warn(`Window close skipped: ${(error as Error).message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Closes all browser windows by closing the entire browser context
+   * @param context Playwright BrowserContext containing all open pages
+   */
+  static async closeAllWindows(context: BrowserContext): Promise<void> {
+    try {
+      return await context.close();
+    }
+    catch (error) {
+      console.warn(`Failed to close all windows: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * switch to particular window whose index has been passed
+   * @param context Playwright BrowserContext containing all open pages
+   * @param index of the window where we should switch
+   * @returns matching Page object if found, otherwise null
+   */
+  static async switchToWindowByIndex(context: BrowserContext, index: number): Promise<Page | null> {
+    try {
+      const pages = context.pages();
+
+      if (index < 0 || index >= pages.length) {
+        console.warn(`Invalid window index: ${index}`);
+        return null;
+      }
+
+      return pages[index];
+    }
+    catch (error) {
+      console.warn(`Window switch by index failed: ${(error as Error).message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Switches to particular window whose URL has been passed
+   * @param context Playwright BrowserContext containing all opened windows
+   * @param url of the window where we should switch
+   * @returns matching page object if found, otherwise null
+   */
+  static async switchToWindowByUrl(context: BrowserContext, url: string): Promise<Page | null> {
+    try {
+      const pages = context.pages();
+      const targetPage = pages.find(page => page.url().includes(url));
+
+      if (!targetPage) {
+        console.warn(`No window found with URL containing: ${url}`);
+        return null;
+      }
+      return targetPage;
+    }
+    catch (error) {
+      console.warn(`Window switch by URL failed: ${(error as Error).message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Method to return total number of opened browser windows
+   * @param context Playwright BrowserContext containing all open pages
+   * @returns total number of opened windows
+   */
+  static getTotalOpenedWindows(context: BrowserContext): number {
+    try {
+      return context.pages().length;
+    }
+    catch (error) {
+      console.warn(`Failed to get total opened windows: ${(error as Error).message}`);
+      return 0;
+    }
+  }
+
+  /**
+   * Method to return current window URL
+   * @param page Playwright Page object
+   * @returns URL of currently active playwright page
+   */
+  static async getCurrentWindowURL(page: Page): Promise<string | null> {
+    try {
+      const currentUrl = page.url();
+      return currentUrl;
+    }
+    catch (error) {
+      console.warn(`Unable to get current window: ${(error as Error).message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Fetches and returns title of the browser window represented by the given page
+   * @param page Playwright page object
+   * @returns title of the window
+   */
+  static async getWindowTitle(page: Page): Promise<string | null> {
+    try {
+      return await page.title();
+    }
+    catch (error) {
+      console.warn(`Unable to get Window title: ${(error as Error).message}`);
+      return null;
+    }
+  }
+
+  /**
+ * Gets the current page URL.
+ *
+ * @param page - Playwright Page instance
+ * @returns Current page URL or empty string if unavailable
+ */
+  static async getCurrentUrl(page: Page): Promise<string> {
+    try {
+      return page.url();
+    } catch (error) {
+      console.warn(`⚠ Unable to get current URL:`, (error as Error).message);
+      return '';
+    }
+  }
+
+  /**
+ * Checks whether the current page URL contains the expected value.
+ *
+ * @param page - Playwright Page instance
+ * @param expected - Expected value to be contained in the URL
+ * @returns True if URL contains expected value, otherwise false
+ */
+  static async isUrlContains(page: Page, expected: string,): Promise<boolean> {
+    try {
+      const url = page.url();
+      return url.includes(expected);
+    } catch {
+      console.warn(`⚠ URL does not contain "${expected}"}`);
+      return false;
+    }
+  }
+
+  /**
+   * Checks whether the current page URL exactly matches the expected value.
+   *
+   * @param page - Playwright Page instance
+   * @param expected - Expected URL
+   *
+   * @returns True if URL matches exactly, otherwise false
+   */
+  static async isUrlMatch(page: Page, expected: string): Promise<boolean> {
+    try {
+      return page.url() === expected;
+    } catch {
+      console.warn(`⚠ URL does not match "${expected}"`);
+      return false;
+    }
+  }
+
+  /**
+   * Waits until the current URL contains the expected value.
+   */
+  static async waitUntilUrlContains(page: Page, expected: string, timeout = 15000
+  ): Promise<void> {
+    try {
+      await page.waitForURL(url => url.toString().includes(expected), { timeout });
+    } catch {
+      console.error(`❌ URL did not contain "${expected}" after ${timeout}ms`);
+    }
+  }
+}