auto-fxui 0.1.1__py3-none-any.whl

auto_fxui/__init__.py

@@ -0,0 +1,3 @@
+from .page_base import BasePage
+
+__all__ = ["BasePage"]

auto_fxui/browser_object.py

@@ -0,0 +1,20 @@
+from .browser_object_autofill_popup import *
+from .browser_object_context_menu import *
+from .browser_object_devtools import *
+from .browser_object_find_toolbar import *
+from .browser_object_forget_panel import *
+from .browser_object_glean import *
+from .browser_object_menu_bar import *
+from .browser_object_navigation import *
+from .browser_object_panel_ui import *
+from .browser_object_print_preview import *
+from .browser_object_reader_view import *
+from .browser_object_report_broken_site import *
+from .browser_object_sidebar import *
+from .browser_object_smart_bar import *
+from .browser_object_smart_window import *
+from .browser_object_smart_window_chat import *
+from .browser_object_split_view import *
+from .browser_object_tabbar import *
+from .browser_object_translations_panel import *
+from .browser_object_trust_panel import *

auto_fxui/browser_object_autofill_popup.py

@@ -0,0 +1,275 @@
+import time
+from typing import Union
+
+from selenium.common.exceptions import StaleElementReferenceException
+from selenium.webdriver import Keys
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support import expected_conditions as EC
+
+from .page_base import BasePage
+
+
+class AutofillPopup(BasePage):
+    """
+    Page Object Model for the popups that have to do with autofill (related to credit card and addresses)
+    """
+
+    URL_TEMPLATE = ""
+    iframe = None
+
+    # Verification methods
+    def verify_autofill_displayed(self):
+        """Confirms that autofill popup has loaded"""
+        self.element_clickable("autofill-panel")
+
+    def verify_element_displayed(self, reference: Union[str, tuple, WebElement]):
+        """Confirms that an element exists in popup"""
+        self.element_clickable(reference)
+
+    @BasePage.context_chrome
+    def ensure_autofill_dropdown_not_visible(self):
+        """
+        Verifies that the autofill dropdown does not appear
+        checks if the parent pop up component has hidden attribute.
+        """
+        self.element_exists("pop-up-component")
+        popup_component = self.get_element("pop-up-component")
+        if len(popup_component.get_attribute("innerHTML")) > 1:
+            self.element_attribute_contains("pop-up-component-box", "style", "0px;")
+        else:
+            self.element_attribute_contains("pop-up-component", "hidden", "true")
+        return self
+
+    @BasePage.context_chrome
+    def ensure_autofill_dropdown_visible(self):
+        """
+        Verifies that the autofill dropdown appears
+        checks if the parent pop up component has hidden attribute.
+        """
+        self.element_clickable("pop-up-component-box")
+        return self
+
+    @BasePage.context_chrome
+    def hover_over_autofill_panel(self):
+        self.element_clickable("pop-up-component-box")
+        self.hover("pop-up-component-box")
+        return self
+
+    # Interaction with popup elements
+    def click_doorhanger_button(self, button_type: str) -> BasePage:
+        """Presses a button in the doorhanger popup (e.g., save, update, dropdown)"""
+        self.element_visible(f"doorhanger-{button_type}-button")
+        self.js_click_on(f"doorhanger-{button_type}-button")
+        return self
+
+    @BasePage.context_chrome
+    def open_login_doorhanger_more_actions_menu(self) -> BasePage:
+        """Open the login doorhanger's 'More actions' menu and wait for it to render."""
+        self.element_visible("doorhanger-secondary-split-button")
+        self.js_click_on("doorhanger-more-actions-chevron")
+        self.element_visible("doorhanger-never-save-login-button")
+        return self
+
+    # Interaction with form options
+    @BasePage.context_chrome
+    def click_autofill_form_option(self) -> BasePage:
+        """Clicks the credit card or address selection in the autofill panel"""
+        self.get_element("select-form-option").click()
+        return self
+
+    @BasePage.context_chrome
+    def click_clear_form_option(self) -> BasePage:
+        """Clicks to clear the saved form option (address or credit card).
+
+        Firefox 154+ renders the footer rows ("Clear Autofill Form",
+        "Manage payment methods") with the same ``originaltype='action'`` and no
+        ``ac-value`` attribute, so the row is matched by its shadow-DOM label.
+        """
+        option = self.wait.until(
+            lambda _: self._get_option_by_value("Clear Autofill Form")
+        )
+        option.click()
+        return self
+
+    def get_doorhanger_cc_number(self) -> str:
+        """Retrieves the last 4 digits of the credit card from the doorhanger popup"""
+        return self.get_element("doorhanger-cc-number").text
+
+    @BasePage.context_chrome
+    def get_cc_doorhanger_data(self, selector: str) -> str:
+        """
+        get text for the credit card doorhanger data.
+        """
+        return self.get_element(selector).text
+
+    # Interaction with autocomplete list elements
+    @BasePage.context_chrome
+    def get_nth_element(self, index: str | int) -> WebElement:
+        """
+        Get the nth element from the autocomplete list
+        Parameters: index (str): The index of the element to retrieve (1-based)
+        Returns: WebElement: The nth element in the autocomplete list
+        """
+        self.wait.until(
+            EC.visibility_of(
+                self.get_element("select-form-option-by-index", labels=[str(index)])
+            )
+        )
+        return self.get_element("select-form-option-by-index", labels=[str(index)])
+
+    @BasePage.context_chrome
+    def select_nth_element(self, index: int):
+        """
+        Select the nth element from the autocomplete list
+        Arguments:
+            index (int): The index of the element to retrieve (1-based)
+        """
+        self.element_clickable("pop-up-component-box")
+        self.click_on("select-form-option-by-index", labels=[str(index)])
+
+    @BasePage.context_chrome
+    def select_autofill_panel(self):
+        """
+        Select the first autofill panel in the autocomplete list.
+        """
+        self.element_clickable("select-form-option-autofill")
+        self.click_on("select-form-option-autofill")
+        return self
+
+    @BasePage.context_chrome
+    def get_primary_value(self, element: WebElement) -> str:
+        """
+        Get the primary (label) value from an autocomplete row element.
+
+        Firefox 154 replaced the classic ``richlistitem[ac-value]`` rows with the
+        ``autocomplete-row-item`` custom element, moving the visible text into its
+        shadow DOM (``.labels-container .label``) and dropping the ``ac-value``
+        attribute. Prefer ``ac-value`` when present (older builds) and otherwise
+        read the shadow label.
+
+        Parameters: element (WebElement): The autocomplete row element.
+        Returns: str: The primary value (e.g. username, cardholder name, or footer label).
+        """
+        return self._get_primary_value(element)
+
+    def _get_primary_value(self, element: WebElement) -> str:
+        """Chrome-context body of :meth:`get_primary_value`.
+
+        Intentionally undecorated so it can be called from code already inside a
+        chrome context (e.g. ``get_option_by_value`` iterating rows) without
+        re-entering ``driver.context`` on every access.
+        """
+        ac_value = element.get_attribute("ac-value")
+        if ac_value:
+            return ac_value
+        return self.driver.execute_script(
+            """
+            const row = arguments[0].querySelector('autocomplete-row-item');
+            if (!row || !row.shadowRoot) return null;
+            const label = row.shadowRoot.querySelector('.labels-container .label, .label');
+            return label ? label.textContent.trim() : null;
+            """,
+            element,
+        )
+
+    @BasePage.context_chrome
+    def get_option_by_value(self, value: str) -> WebElement | None:
+        """
+        Return the first visible autocomplete row whose primary value contains
+        `value`, or None if no such row is present.
+        """
+        return self._get_option_by_value(value)
+
+    def _get_option_by_value(self, value: str) -> WebElement | None:
+        """Chrome-context body of :meth:`get_option_by_value`.
+
+        Undecorated so it can be polled inside a ``wait.until`` from a method that
+        already holds a chrome context (see :meth:`click_clear_form_option`,
+        :meth:`verify_autocomplete_option`) without a nested context switch on
+        every tick.
+
+        If the dropdown re-renders mid-iteration the rows go stale; return None
+        so a ``wait.until`` caller simply retries on the next tick (self.wait does
+        not ignore StaleElementReferenceException, so it must be caught here).
+        """
+        try:
+            for option in self.get_elements("select-form-option"):
+                primary = self._get_primary_value(option)
+                if primary and value in primary and option.is_displayed():
+                    return option
+        except StaleElementReferenceException:
+            return None
+        return None
+
+    @BasePage.context_chrome
+    def verify_update_password_doorhanger(self, nav, expected_text):
+        """
+        Wait for and verify that the 'Update password' doorhanger is displayed
+        with the expected text
+        """
+        # Wait for and open the doorhanger
+        time.sleep(1)
+        nav.expect(lambda _: nav.element_visible("password-notification-key"))
+        nav.click_on("password-notification-key")
+
+        # Verify the doorhanger text
+        self.expect(
+            lambda _: (
+                expected_text in self.get_element("password-update-doorhanger").text
+            )
+        )
+
+    @BasePage.context_chrome
+    def click_manage_passwords(self) -> BasePage:
+        # Clicks the "Manage Passwords" option from the autofill popup
+        self.click_on("manage-passwords")
+        return self
+
+    @BasePage.context_chrome
+    def verify_username_value(
+        self,
+        expected_username: str,
+        field: str = "password-notification-username-field",
+    ) -> WebElement:
+        """Wait until the username field contains the expected value."""
+        element = self.get_element(field)
+        self.wait.until(lambda _: element.get_attribute("value") == expected_username)
+        return element
+
+    @BasePage.context_chrome
+    def click_securely_generated_password(self) -> BasePage:
+        """Click the 'Use a Securely Generated Password' option from the autofill popup."""
+        self.click_on("generated-securely-password")
+        return self
+
+    @BasePage.context_chrome
+    def verify_autocomplete_option(self, value: str) -> BasePage:
+        """Wait until an autocomplete option whose label contains `value` is displayed."""
+        self.wait.until(lambda _: self._get_option_by_value(value) is not None)
+        return self
+
+    def _get_doorhanger_username_input(self):
+        """Helper to get the input element inside the password doorhanger username shadow DOM.
+        Must be called from chrome context.
+        """
+        parent = self.get_element("password-notification-username-field")
+        input_el = self.driver.execute_script(
+            "return arguments[0].shadowRoot.querySelector('input')", parent
+        )
+        if input_el is None:
+            raise RuntimeError(
+                "Could not find input inside password-notification-username-field shadow root"
+            )
+        return input_el
+
+    @BasePage.context_chrome
+    def type_username_in_password_doorhanger(self, username: str) -> BasePage:
+        """Type a username into the Password Manager doorhanger."""
+        self._get_doorhanger_username_input().send_keys(username)
+        return self
+
+    @BasePage.context_chrome
+    def dismiss_password_doorhanger(self) -> BasePage:
+        """Dismiss the Password Manager doorhanger using ESC."""
+        self._get_doorhanger_username_input().send_keys(Keys.ESCAPE)
+        return self

auto_fxui/browser_object_context_menu.py

@@ -0,0 +1,261 @@
+import logging
+from typing import Dict, List, Union
+
+from selenium.webdriver.remote.webelement import WebElement
+
+from .page_base import BasePage
+
+
+class ContextMenu(BasePage):
+    """
+    Browser Object Model (base class/parent class) for the context menus upon right clicking
+    """
+
+    URL_TEMPLATE = ""
+
+    @BasePage.context_chrome
+    def click_context_item(
+        self, reference: Union[str, tuple, WebElement], labels=[]
+    ) -> BasePage:
+        """
+        Clicks the context item.
+        """
+
+        self.fetch(reference, labels=labels).click()
+        return self
+
+    @BasePage.context_chrome
+    def open_link_in_container(self) -> BasePage:
+        """Open a link from the context menu in a specific container tab."""
+        self.click_context_item("context-menu-open-link-in-new_container_tab")
+        self.click_context_item("context-menu-open-link-in-container-work")
+        return self
+
+    @BasePage.context_chrome
+    def verify_topsites_tile_context_menu_options(
+        self,
+        static_items: Dict[str, str],
+        dynamic_items: List[str],
+        tile_title: str,
+    ):
+        """
+        Verifies expected context menu options are present upon right clicking a topsite tile.
+        Arguments:
+            static_items: Dict mapping of selector name to expected label text.
+            dynamic_items: List of selector names for items with dynamic labels.
+            tile_title: Optional, required if dynamic label validation is needed (e.g., Wikipedia, YouTube).
+        """
+        # --- Static items ---
+        for selector, expected_label in static_items.items():
+            option = self.get_element(selector)
+            label = (option.get_attribute("label") or option.text or "").strip()
+            assert expected_label in label, (
+                f'Expected label "{expected_label}" not found. Got: "{label}"'
+            )
+
+        # --- Dynamic items ---
+        for selector in dynamic_items:
+            option = self.get_element(selector)
+            label = (option.get_attribute("label") or option.text or "").strip()
+            normalized = label.lower()
+            assert normalized.startswith("search"), (
+                f'Label does not start with "Search": "{label}"'
+            )
+            assert "for" in normalized, f'"for" not found in label: "{label}"'
+            assert tile_title.lower() in normalized, (
+                f'Search term "{tile_title}" not found in label: "{label}"'
+            )
+
+    @BasePage.context_chrome
+    def click_summarize_page_from_ai_chat(self):
+        """Activate the Summarize Page item from the already opened AI Chat submenu.
+
+        Pure Selenium cannot interact with XUL submenu items in the chrome context: ActionChains
+        move_to_element does not cross GeckoDriver's chrome context boundary, and Selenium's click()
+        on a XUL <menu> element does not open its popup. JS is used to dispatch the full mouse event
+        sequence (mousemove/mousedown/mouseup/click) directly on the menuitem, which fires the XUL
+        command event that triggers the sidebar to open.
+
+        Note: the menuitem is selected by label="Summarize Page" which is English-only; no stable
+        ID or anonid is exposed by this XUL element.
+        """
+        self.wait.until(
+            lambda _: self.driver.execute_script(
+                "const menu = document.getElementById('context_askChat');"
+                "if (!menu) return false;"
+                "const popup = menu.querySelector('menupopup') || menu.menupopup;"
+                "if (!popup) return false;"
+                "return popup.querySelector('menuitem[label=\"Summarize Page\"]') !== null;"
+            )
+        )
+        self.driver.execute_script(
+            "const menu = document.getElementById('context_askChat');"
+            "const popup = menu.querySelector('menupopup') || menu.menupopup;"
+            "const item = popup.querySelector('menuitem[label=\"Summarize Page\"]');"
+            "item.dispatchEvent(new MouseEvent('mousemove', {bubbles: true}));"
+            "item.dispatchEvent(new MouseEvent('mousedown', {bubbles: true}));"
+            "item.dispatchEvent(new MouseEvent('mouseup', {bubbles: true}));"
+            "item.dispatchEvent(new MouseEvent('click', {bubbles: true}));"
+        )
+        return self
+
+    @BasePage.context_chrome
+    def click_choose_ai_chatbot_from_context_menu(
+        self, source: str = "tab"
+    ) -> BasePage:
+        """Click the 'Choose an AI Chatbot' item from the AI Chat submenu.
+
+        source='tab' targets the tab context menu (DOM id 'context_askChat');
+        source='page' targets the page context menu (DOM id 'context-ask-chat').
+        menu.open = true keeps the submenu alive while searching for its children.
+        """
+        menu_id = "context_askChat" if source == "tab" else "context-ask-chat"
+        self.wait.until(
+            lambda _: self.driver.execute_script(
+                f"const menu = document.getElementById('{menu_id}');"
+                "if (!menu) return false;"
+                "menu.open = true;"
+                "const popup = menu.querySelector('menupopup') || menu.menupopup;"
+                "if (!popup || popup.children.length === 0) return false;"
+                "const item = popup.querySelector('[data-l10n-id=\"genai-menu-choose-chatbot\"]');"
+                "if (!item) return false;"
+                "item.dispatchEvent(new MouseEvent('mousemove', {bubbles: true}));"
+                "item.dispatchEvent(new MouseEvent('mousedown', {bubbles: true}));"
+                "item.dispatchEvent(new MouseEvent('mouseup', {bubbles: true}));"
+                "item.dispatchEvent(new MouseEvent('click', {bubbles: true}));"
+                "return true;"
+            )
+        )
+        return self
+
+    @BasePage.context_chrome
+    def click_open_chatbot_from_context_menu(self) -> BasePage:
+        """Click the item that opens the AI chatbot panel from the tab context menu.
+
+        The tabContextMenu must be open before calling this (via tabs.context_click). Setting
+        menu.open = true on the XUL <menu> element opens the submenu inline while the parent
+        tabContextMenu is still open, which triggers provider-specific children to be generated
+        in the menupopup DOM. Pure Selenium cannot hover XUL elements across GeckoDriver's chrome
+        context boundary; ActionChains.move_to_element does not cross that boundary.
+
+        menu.open = true must remain inside the retry loop: the XUL submenu closes between
+        separate execute_script calls, so the standard check-then-act split cannot be used here.
+
+        The l10n-id for the open-chatbot item varies across Firefox builds; flexible matching on
+        l10n-id and label is intentional — targeting a hardcoded id caused timeouts in the
+        current build where that exact id is absent.
+        """
+        self.wait.until(
+            lambda _: self.driver.execute_script(
+                "const menu = document.getElementById('context_askChat');"
+                "if (!menu) return false;"
+                "menu.open = true;"
+                "const popup = menu.querySelector('menupopup') || menu.menupopup;"
+                "if (!popup || popup.children.length === 0) return false;"
+                "const items = Array.from(popup.children).filter("
+                "  item => !item.hidden && !item.disabled"
+                ");"
+                "const item = items.find(item => {"
+                "  const l10n = item.getAttribute('data-l10n-id') || '';"
+                "  const label = (item.getAttribute('label') || '').toLowerCase();"
+                "  return l10n.includes('open') || l10n.includes('provider') ||"
+                "         label.includes('open') || label.includes('chat');"
+                "});"
+                "if (!item) return false;"
+                "item.dispatchEvent(new MouseEvent('mousemove', {bubbles: true}));"
+                "item.dispatchEvent(new MouseEvent('mousedown', {bubbles: true}));"
+                "item.dispatchEvent(new MouseEvent('mouseup', {bubbles: true}));"
+                "item.dispatchEvent(new MouseEvent('click', {bubbles: true}));"
+                "return true;"
+            )
+        )
+        return self
+
+    @BasePage.context_chrome
+    def click_summarize_page_from_sidebar_ai_chat_button(self) -> BasePage:
+        """Click 'Summarize Page' from the context menu opened by right-clicking the AI Chat
+        sidebar button.
+
+        The popup is at chrome-document level; a flat querySelectorAll('menupopup') is sufficient.
+        """
+        self.wait.until(
+            lambda _: self.driver.execute_script(
+                "for (const popup of document.querySelectorAll('menupopup')) {"
+                "  const s = popup.state;"
+                "  if (s === 'closed' || s === 'hiding') continue;"
+                "  const item = Array.from(popup.querySelectorAll('menuitem')).find(el =>"
+                "    el.getAttribute('label') === 'Summarize Page'"
+                "  );"
+                "  if (!item) continue;"
+                "  item.dispatchEvent(new MouseEvent('mousemove', {bubbles: true}));"
+                "  item.dispatchEvent(new MouseEvent('mousedown', {bubbles: true}));"
+                "  item.dispatchEvent(new MouseEvent('mouseup', {bubbles: true}));"
+                "  item.dispatchEvent(new MouseEvent('click', {bubbles: true}));"
+                "  return true;"
+                "}"
+                "return false;"
+            )
+        )
+        return self
+
+    @BasePage.context_chrome
+    def bookmark_tab_via_context_menu(self) -> BasePage:
+        """Click 'Bookmark Tab' in the tab context menu, dismiss the menu, then
+        confirm the Add Bookmark dialog by clicking its Save button via JS.
+
+        The dialog renders inside browser.dialogFrame > #document >
+        dialog#bookmarkpropertiesdialog (shadow root), so JS is used to pierce
+        through contentDocument and shadow DOM.
+        """
+        self.click_context_item("context-menu-bookmark-tab")
+        self.hide_popup("tabContextMenu")
+        self.wait.until(
+            lambda _: self.driver.execute_script(
+                "const cd = document.querySelector('browser.dialogFrame')?.contentDocument;"
+                "const btn = cd?.querySelector('dialog#bookmarkpropertiesdialog')"
+                "?.shadowRoot?.querySelector('button[dlgtype=\"accept\"]');"
+                "if (btn) { btn.click(); return true; }"
+            )
+        )
+        return self
+
+    @BasePage.context_chrome
+    def expect_ask_ai_chat_submenu_absent(self) -> BasePage:
+        """Verify the Ask AI chatbot submenu is not visible in the open tab context menu.
+
+        Gates on tabContextMenu being open first to prevent a false positive: context_askChat
+        is always in the DOM with hidden=true when the chatbot is disabled, so checking
+        before the menu opens would succeed even if the right-click never worked.
+        """
+        self.wait.until(
+            lambda _: self.driver.execute_script(
+                "const menu = document.getElementById('tabContextMenu');"
+                "if (!menu || menu.state !== 'open') return false;"
+                "const el = document.getElementById('context_askChat');"
+                "return !el || el.hidden;"
+            )
+        )
+        return self
+
+    @BasePage.context_chrome
+    def verify_item_disabled(self, reference: str, labels=None):
+        """Assert a context menu item is disabled (grayed out)."""
+        el = self.get_element(reference, labels=labels)
+        assert el.get_attribute("disabled") == "true", f"{reference} is not disabled"
+        return self
+
+
+class AboutDownloadsContextMenu(ContextMenu):
+    """
+    Browser object model for the context menu for right clicking a download in About:Downloads
+    """
+
+    def has_all_options_available(self) -> ContextMenu:
+        """Timeout unless all items labeled downloadOption are present, else return self"""
+        with self.driver.context(self.context_id):
+            for elname in [
+                k for k, v in self.elements.items() if "downloadOption" in v["groups"]
+            ]:
+                logging.info(f"elname {elname}")
+                self.element_exists(elname)
+        return self

auto_fxui/browser_object_devtools.py

@@ -0,0 +1,11 @@
+from .page_base import BasePage
+
+
+class Devtools(BasePage):
+    """BOM for the DevTools panel"""
+
+    URL_TEMPLATE = ""
+
+    def check_opened(self) -> BasePage:
+        self.wait_for_page_to_load()
+        return self