vs/Refactoring 2

Author: vsangereanMOZ

modules/page_base.py

@@ -431,7 +431,7 @@ def element_has_text(self, name: str, text: str, labels=[]) -> Page:
         self.expect(lambda _: text in self.get_element(name, labels=labels).text)
         return self
 
-    def element_attribute_contains(
+    def expect_element_attribute_contains(
         self, name: str, attr_name: str, attr_value: Union[str, float, int], labels=[]
     ) -> Page:
         """Expect helper: wait until element attribute contains certain value"""

modules/page_object_example_page.py

@@ -1,3 +1,5 @@
+from selenium.webdriver.common.by import By
+
 from modules.page_base import BasePage
 
 
@@ -10,3 +12,11 @@ class ExamplePage(BasePage):
     TITLE = "Example Domain"
     MORE_INFO_URL = "https://www.iana.org/help/example-domains"
     MORE_INFO_TITLE = "Example Domains"
+
+    @BasePage.context_content
+    def search_selected_header_via_context_menu(self):
+        """Open the page, triple-click the <h1>, right-click it to trigger the context menu."""
+        self.open()
+        header = (By.TAG_NAME, "h1")
+        self.triple_click(header)
+        self.context_click(header)

tests/address_bar_and_search/test_adaptive_history_autofill.py

@@ -9,6 +9,8 @@
 WAIT_TIMEOUT = 10
 TEST_URL = "https://www.nationalgeographic.com/science/"
 EXPECTED_TITLE = "Science"
+EXPECTED_TYPE = "autofill_adaptive"
+EXPECTED_TEXT_FRAGMENT = "nationalgeographic.com/science"
 
 
 @pytest.fixture()
@@ -28,24 +30,26 @@ def test_add_adaptive_history_autofill(driver: Firefox):
     nav = Navigation(driver)
     tabs = TabBar(driver)
 
+    # Step 1: Visit the test site and verify tab title
     nav.search(TEST_URL)
     WebDriverWait(driver, WAIT_TIMEOUT).until(
         lambda d: tabs.get_tab_title(tabs.get_tab(1)) == EXPECTED_TITLE
     )
 
+    # Step 2: Open new tab, close the original
     tabs.new_tab_by_button()
     tabs.wait_for_num_tabs(2)
     driver.switch_to.window(driver.window_handles[1])
-
     with driver.context(driver.CONTEXT_CHROME):
         tabs.get_elements("tab-x-icon")[0].click()
 
+    # Step 3: Type in address bar, click adaptive suggestion
     nav.type_in_awesome_bar("nat")
     with driver.context(driver.CONTEXT_CHROME):
         nav.get_element("firefox-suggest").click()
-
     nav.expect_in_content(EC.url_contains(TEST_URL))
 
+    # Step 4: Open new tab and check for autofill suggestion
     tabs.new_tab_by_button()
     tabs.wait_for_num_tabs(2)
     driver.switch_to.window(driver.window_handles[-1])
@@ -54,9 +58,9 @@ def test_add_adaptive_history_autofill(driver: Firefox):
     tabs.set_chrome_context()
     autofill_element = nav.get_element("search-result-autofill-adaptive-element")
 
-    assert autofill_element.get_attribute("type") == "autofill_adaptive", (
-        f"Expected type 'autofill_adaptive', got '{autofill_element.get_attribute('type')}'"
+    assert autofill_element.get_attribute("type") == EXPECTED_TYPE, (
+        f"Expected type '{EXPECTED_TYPE}', got '{autofill_element.get_attribute('type')}'"
     )
-    assert "nationalgeographic.com/science" in autofill_element.text, (
+    assert EXPECTED_TEXT_FRAGMENT in autofill_element.text, (
         f"Autofill text did not contain expected URL. Got: {autofill_element.text}"
     )

tests/address_bar_and_search/test_add_engine_address_bar.py

@@ -3,6 +3,8 @@
 
 from modules.browser_object import ContextMenu, Navigation, TabBar
 
+TEST_URL = "https://youtube.com"
+EXPECTED_ENGINE = "YouTube"
 
 @pytest.fixture()
 def test_case():
@@ -22,17 +24,17 @@ def test_add_search_engine_from_address_bar(driver: Firefox):
     menu = ContextMenu(driver)
     tabs = TabBar(driver)
 
-    driver.get("https://youtube.com")
+    driver.get(TEST_URL)
     nav.custom_wait(timeout=20).until(lambda d: "youtube.com" in d.current_url)
 
     with driver.context(driver.CONTEXT_CHROME):
         nav.context_click_in_awesome_bar()
         menu.click_context_item("context-menu-add-search-engine")
 
         tabs.new_tab_by_button()
-        youtube_tab = tabs.get_tab_by_title("YouTube")
+        youtube_tab = tabs.get_tab_by_title(EXPECTED_ENGINE)
         tabs.close_tab(youtube_tab)
 
         nav.click_on("searchmode-switcher")
-        nav.element_exists("search-mode-switcher-option", labels=["YouTube"])
+        nav.element_exists("search-mode-switcher-option", labels=[EXPECTED_ENGINE])
         nav.click_on("searchmode-switcher")

tests/address_bar_and_search/test_addon_suggestion.py

@@ -1,13 +1,22 @@
 import pytest
-from selenium.common.exceptions import TimeoutException
 from selenium.webdriver import Firefox
 from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.support.ui import WebDriverWait
 
 from modules.browser_object import Navigation
 
+WAIT_TIMEOUT = 10
 ADDONS_BASE_URL = "https://addons.mozilla.org/en-US/firefox/addon/"
 
+INPUT_TO_ADDON_NAME = {
+    "clips": "video-downloadhelper",
+    "grammar": "languagetool",
+    "Temp mail": "private-relay",
+    "pics search": "search_by_image",
+    "darker theme": "darkreader",
+    "privacy": "privacy-badger17",
+    "read aloud": "read-aloud",
+}
+
 
 @pytest.fixture()
 def test_case():
@@ -26,31 +35,16 @@ def test_addon_suggestion_based_on_search_input(driver: Firefox):
     """
     C2234714 - Verify that the address bar suggests relevant add-ons based on search input.
     """
-    input_to_addon_name = {
-        "clips": "video-downloadhelper",
-        "grammar": "languagetool",
-        "Temp mail": "private-relay",
-        "pics search": "search_by_image",
-        "darker theme": "darkreader",
-        "privacy": "privacy-badger17",
-        "read aloud": "read-aloud",
-    }
-
     nav = Navigation(driver)
     nav.set_awesome_bar()
 
-    for input_text, addon_name in input_to_addon_name.items():
+    for input_text, addon_slug in INPUT_TO_ADDON_NAME.items():
         nav.type_in_awesome_bar(input_text)
-        try:
-            nav.element_visible("addon-suggestion")
-        except TimeoutException:
-            raise AssertionError(
-                f"Addon suggestion not visible for input: '{input_text}'"
-            )
 
-        nav.select_element_in_nav("addon-suggestion")
+        if not nav.element_visible("addon-suggestion"):
+            raise AssertionError(f"Addon suggestion not visible for input: '{input_text}'")
 
-        expected_url = f"{ADDONS_BASE_URL}{addon_name}/"
+        nav.select_element_in_nav("addon-suggestion")
+        expected_url = f"{ADDONS_BASE_URL}{addon_slug}/"
         nav.expect_in_content(EC.url_contains(expected_url))
-
         nav.clear_awesome_bar()

tests/address_bar_and_search/test_default_search_provider_change_awesome_bar.py

@@ -24,7 +24,8 @@ def test_default_search_provider_change_awesome_bar(driver: Firefox):
 
     driver.get("about:newtab")
     nav.open_searchmode_switcher_settings()
+
     prefs.search_engine_dropdown().select_option(SEARCH_ENGINE)
 
     driver.get("about:newtab")
-    nav.element_attribute_contains("awesome-bar", "placeholder", EXPECTED_PLACEHOLDER)
+    nav.expect_element_attribute_contains("awesome-bar", "placeholder", EXPECTED_PLACEHOLDER)

tests/address_bar_and_search/test_default_search_provider_change_legacy_search_bar.py

@@ -20,33 +20,38 @@ def test_default_search_provider_change_legacy_search_bar(driver: Firefox):
     """
     C1365245 - Verify that changing the default search provider is reflected in the legacy search bar.
     """
+    nav = Navigation(driver)
     panel_ui = PanelUi(driver)
     customize = CustomizeFirefox(driver)
-    nav = Navigation(driver)
     tabs = TabBar(driver)
     prefs = AboutPrefs(driver, category="search")
 
+    # Add legacy search bar to toolbar
     panel_ui.open_panel_menu()
     panel_ui.navigate_to_customize_toolbar()
     customize.add_widget_to_toolbar("search-bar")
 
+    # Open a new tab and trigger search settings navigation
     tabs.new_tab_by_button()
     nav.type_in_search_bar(SEARCH_TERM)
     nav.click_on_change_search_settings_button()
     driver.switch_to.window(driver.window_handles[2])
     assert driver.current_url == SEARCH_SETTINGS_URL
 
+    # Validate navigation returns to site and settings page opens in new tab
     driver.get("https://9gag.com/")
     nav.type_in_search_bar(SEARCH_TERM)
     nav.click_on_change_search_settings_button()
     assert driver.current_url == "https://9gag.com/"
     driver.switch_to.window(driver.window_handles[3])
     assert driver.current_url == SEARCH_SETTINGS_URL
 
+    # Change the default search engine
     prefs.open()
     prefs.search_engine_dropdown().select_option(SEARCH_ENGINE)
-    nav.type_in_search_bar(SEARCH_TERM)
 
+    # Perform another search and validate engine label
+    nav.type_in_search_bar(SEARCH_TERM)
     with driver.context(driver.CONTEXT_CHROME):
         engine_name = driver.find_element(By.CSS_SELECTOR, ".searchbar-engine-name")
         assert engine_name.get_attribute("value") == EXPECTED_ENGINE_DISPLAY

tests/address_bar_and_search/test_glean_basic.py

@@ -11,92 +11,101 @@
 from werkzeug.wrappers import Request, Response
 
 from modules.browser_object import Navigation
-from modules.page_object import AboutGlean, AboutPrefs, GenericPage
+from modules.page_object import AboutGlean, AboutPrefs, GenericPage, AboutConfig
 from modules.util import Utilities
 
+# Constants
+SEARCH_TERM_GOOGLE = "trombone"
+SEARCH_TERM_BING = "trumpet"
+ENGINE_NAME_INITIAL = "Google"
+ENGINE_NAME_UPDATED = "Bing"
+EXPECTED_BING_LOCATOR = (By.ID, "b_context")
+EXPECTED_SEARCH_LOCATOR = (By.CSS_SELECTOR, "div[role='navigation']")
+PING_METRIC_PATH = ["metrics", "string", "search.engine.default.display_name"]
+WAIT_PING_SECONDS = 1
+
+# Globals (used for tracking ping verification)
+pings_with_id = 0
+ping_id_global = ""
+
 
 @pytest.fixture()
 def test_case():
     return "2234689"
 
 
-PINGS_WITH_ID = 0
-PING_ID = ""
-
-
-def confirm_glean_correctness(
-    ping_ground: str, ping_test: str, engine_ground: str, engine_test: str
-) -> bool:
-    """Helper to confirm that the glean ping contains expected info"""
-    assert ping_ground == ping_test
-    assert engine_ground.lower() == engine_test.lower()
-
-
-def glean_handler(rq: Request) -> Response:
-    """HTTP mock of Glean"""
-    global PINGS_WITH_ID
-    global PING_ID
-    if "X-Debug-Id" in rq.headers.keys():
-        ping_id = rq.headers["X-Debug-Id"]
-        if rq.data:
-            body = json.loads(gzip.decompress(rq.data).decode())
-            engine_name = body["metrics"]["string"][
-                "search.engine.default.display_name"
-            ]
-            if PINGS_WITH_ID == 0:
-                engine_ground = "Google"
-            else:
-                engine_ground = "Bing"
-            confirm_glean_correctness(
-                ping_ground=PING_ID,
-                ping_test=ping_id,
-                engine_ground=engine_ground,
-                engine_test=engine_name,
+def _verify_glean_ping(ping_actual: str, ping_expected: str, engine_actual: str, engine_expected: str):
+    assert ping_actual == ping_expected
+    assert engine_actual.lower() == engine_expected.lower()
+
+
+def glean_handler(request: Request) -> Response:
+    global pings_with_id, ping_id_global
+
+    if "X-Debug-Id" in request.headers:
+        incoming_ping_id = request.headers["X-Debug-Id"]
+        if request.data:
+            decompressed = gzip.decompress(request.data).decode()
+            body = json.loads(decompressed)
+            engine_name = body
+            for key in PING_METRIC_PATH:
+                engine_name = engine_name[key]
+            expected_engine = ENGINE_NAME_INITIAL if pings_with_id == 0 else ENGINE_NAME_UPDATED
+            _verify_glean_ping(
+                ping_actual=incoming_ping_id,
+                ping_expected=ping_id_global,
+                engine_actual=engine_name,
+                engine_expected=expected_engine,
             )
-            PINGS_WITH_ID += 1
+            pings_with_id += 1
+
     return Response("", status=200)
 
 
 @pytest.mark.unstable
+# Still unstable sometime due to Captcha.
 def test_glean_ping(driver: Firefox, httpserver: HTTPServer):
-    """C2234689: Test that Glean pings contain expected info"""
-    global PINGS_WITH_ID
-    global PING_ID
-    u = Utilities()
+    """C2234689 - Test that Glean pings contain expected info"""
+
+    global pings_with_id, ping_id_global
+    utils = Utilities()
 
-    # mock server
+    # Setup mock server
     httpserver.expect_request(re.compile("^/")).respond_with_handler(glean_handler)
 
-    # Set ping name
-    ping = u.random_string(8)
-    PING_ID = ping
+    # Configure Glean ping ID
+    ping_id = utils.random_string(8)
+    ping_id_global = ping_id
     about_glean = AboutGlean(driver)
     about_glean.open()
-    about_glean.change_ping_id(ping)
+    about_glean.change_ping_id(ping_id)
 
-    # Search 1 (Google)
+    # Disable cookie banner
+    about_config = AboutConfig(driver)
+    about_config.change_config_value("cookiebanners.service.mode", 1)
+    # Test is more stable if this is done here instead of prefs
+
+    # Perform search using default engine (Google)
     page = GenericPage(driver, url="")
     nav = Navigation(driver)
-    nav.search("trombone")
+    nav.search(SEARCH_TERM_GOOGLE)
     page.title_contains("Search")
-    page.expect(
-        EC.presence_of_element_located((By.CSS_SELECTOR, "div[role='navigation']"))
-    )
+    page.expect(EC.presence_of_element_located(EXPECTED_SEARCH_LOCATOR))
 
-    # Change default search engine
-    about_prefs = AboutPrefs(driver, category="search")
-    about_prefs.open()
-    about_prefs.search_engine_dropdown().select_option("Bing")
+    # Change default engine to Bing
+    prefs = AboutPrefs(driver, category="search")
+    prefs.open()
+    prefs.search_engine_dropdown().select_option(ENGINE_NAME_UPDATED)
 
-    # Search 2 (Bing)
-    nav = Navigation(driver)
+    # Perform search using updated engine (Bing)
     nav.open()
-    nav.search("trumpet")
+    nav.search(SEARCH_TERM_BING)
     page.url_contains("bing.com")
-    page.expect(EC.visibility_of_element_located((By.ID, "b_context")))
+    page.expect(EC.visibility_of_element_located(EXPECTED_BING_LOCATOR))
 
-    # We could go back to about:glean, but this is faster
+    # Send metrics ping
     with driver.context(driver.CONTEXT_CHROME):
         driver.execute_script('Services.fog.sendPing("metrics");')
-    sleep(1)
-    assert PINGS_WITH_ID == 2
+
+    sleep(WAIT_PING_SECONDS)
+    assert pings_with_id == 2