add separate test class and driver for chrome/edge tests

Author: navin772

py/conftest.py

@@ -167,21 +167,21 @@ def fin():
     global driver_instance
     if driver_instance is None:
         if driver_class == "Firefox":
-            options = get_options(driver_class, request.config, request)
+            options = get_options(driver_class, request.config)
             if platform.system() == "Linux":
                 # There are issues with window size/position when running Firefox
                 # under Wayland, so we use XWayland instead.
                 os.environ["MOZ_ENABLE_WAYLAND"] = "0"
         if driver_class == "Chrome":
-            options = get_options(driver_class, request.config, request)
+            options = get_options(driver_class, request.config)
         if driver_class == "Edge":
-            options = get_options(driver_class, request.config, request)
+            options = get_options(driver_class, request.config)
         if driver_class == "WebKitGTK":
-            options = get_options(driver_class, request.config, request)
+            options = get_options(driver_class, request.config)
         if driver_class == "WPEWebKit":
-            options = get_options(driver_class, request.config, request)
+            options = get_options(driver_class, request.config)
         if driver_class == "Remote":
-            options = get_options("Firefox", request.config, request) or webdriver.FirefoxOptions()
+            options = get_options("Firefox", request.config) or webdriver.FirefoxOptions()
             options.set_capability("moz:firefoxOptions", {})
             options.enable_downloads = True
         if driver_path is not None:
@@ -210,7 +210,7 @@ def fin():
         driver_instance = None
 
 
-def get_options(driver_class, config, request=None):
+def get_options(driver_class, config):
     browser_path = config.option.binary
     browser_args = config.option.args
     headless = config.option.headless
@@ -237,15 +237,6 @@ def get_options(driver_class, config, request=None):
         options.web_socket_url = True
         options.unhandled_prompt_behavior = "ignore"
 
-        # Only enable webextensions for Chromium-based browsers when the test is marked with @pytest.mark.webextension
-        if (
-            request
-            and request.node.get_closest_marker("webextension")
-            and driver_class in ("Chrome", "Edge")
-            and hasattr(options, "enable_webextensions")
-        ):
-            options.enable_webextensions = True
-
     return options
 
 
@@ -363,7 +354,7 @@ def clean_service(request):
 @pytest.fixture(scope="function")
 def clean_options(request):
     driver_class = get_driver_class(request.config.option.drivers[0])
-    yield get_options(driver_class, request.config, request)
+    yield get_options(driver_class, request.config)
 
 
 @pytest.fixture

py/pyproject.toml

@@ -83,8 +83,7 @@ markers = [
     "xfail_safari: Tests expected to fail in Safari",
     "xfail_webkitgtk: Tests expected to fail in WebKitGTK",
     "xfail_wpewebkit: Tests expected to fail in WPEWebKit",
-    "no_driver_after_test: If there are no drivers after the test it will create a new one.",
-    "webextension: Tests that require webextension support (adds special flags for Chrome/Edge)"
+    "no_driver_after_test: If there are no drivers after the test it will create a new one."
 ]
 python_files = ["test_*.py", "*_test.py", "*_tests.py"]
 testpaths = ["test"]

py/test/selenium/webdriver/common/bidi_webextension_tests.py

@@ -20,7 +20,9 @@
 
 import pytest
 from python.runfiles import Runfiles
-
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from selenium.webdriver.edge.options import Options as EdgeOptions
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.wait import WebDriverWait
 
@@ -60,92 +62,105 @@ def test_webextension_initialized(driver):
     assert driver.webextension is not None
 
 
-@pytest.mark.webextension
-def test_install_extension_path(driver, pages):
-    """Test installing an extension from a directory path.
+@pytest.mark.xfail_chrome
+@pytest.mark.xfail_edge
+class TestFirefoxWebExtension:
+    """Firefox-specific WebExtension tests."""
 
-    Note: For Chrome and Edge, webextensions are enabled when the test is marked with @pytest.mark.webextension.
-    You can also manually enable them using:
+    def test_install_extension_path(self, driver, pages):
+        """Test installing an extension from a directory path."""
 
-    from selenium.webdriver.chrome.options import Options
-    options = Options()
-    options.enable_webextensions = True
-    driver = webdriver.Chrome(options=options)
+        path = os.path.join(extensions, EXTENSION_PATH)
+        ext_info = install_extension(driver, path=path)
+        verify_extension_injection(driver, pages)
+        uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
 
-    Or directly pass the required flags when creating the driver:
+    def test_install_archive_extension_path(self, driver, pages):
+        """Test installing an extension from an archive path."""
 
-    from selenium import webdriver
-    from selenium.webdriver.chrome.options import Options
+        path = os.path.join(extensions, EXTENSION_ARCHIVE_PATH)
+        ext_info = install_extension(driver, archive_path=path)
+        verify_extension_injection(driver, pages)
+        uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
 
-    options = Options()
-    options.add_argument("--remote-debugging-pipe")
-    options.add_argument("--enable-unsafe-extension-debugging")
+    def test_install_base64_extension_path(self, driver, pages):
+        """Test installing an extension from a base64 encoded string."""
 
-    driver = webdriver.Chrome(options=options)
-    """
-    path = os.path.join(extensions, EXTENSION_PATH)
+        path = os.path.join(extensions, EXTENSION_ARCHIVE_PATH)
+        with open(path, "rb") as file:
+            base64_encoded = base64.b64encode(file.read()).decode("utf-8")
+        ext_info = install_extension(driver, base64_value=base64_encoded)
+        # TODO: the extension is installed but the script is not injected, check and fix
+        # verify_extension_injection(driver, pages)
+        uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
 
-    if driver.capabilities["browserName"].lower() in ("chrome", "microsoftedge"):
-        # chrome/edge does not uses extension id from manifest.json so we cannot assert the id
-        ext_info = driver.webextension.install(path=path)
-    else:
+    def test_install_unsigned_extension(self, driver, pages):
+        """Test installing an unsigned extension."""
+
+        path = os.path.join(extensions, "webextensions-selenium-example")
         ext_info = install_extension(driver, path=path)
-    verify_extension_injection(driver, pages)
-    uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
+        verify_extension_injection(driver, pages)
+        uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
 
+    def test_install_with_extension_id_uninstall(self, driver, pages):
+        """Test uninstalling an extension using just the extension ID."""
 
-@pytest.mark.xfail_chrome
-@pytest.mark.xfail_edge
-def test_install_archive_extension_path(driver, pages):
-    """Test installing an extension from an archive path."""
-    path = os.path.join(extensions, EXTENSION_ARCHIVE_PATH)
-
-    ext_info = install_extension(driver, archive_path=path)
-    verify_extension_injection(driver, pages)
-    uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
+        path = os.path.join(extensions, EXTENSION_PATH)
+        ext_info = install_extension(driver, path=path)
+        extension_id = ext_info.get("extension")
+        # Uninstall using the extension ID
+        uninstall_extension_and_verify_extension_uninstalled(driver, extension_id)
 
 
-@pytest.mark.xfail_chrome
-@pytest.mark.xfail_edge
-def test_install_base64_extension_path(driver, pages):
-    """Test installing an extension from a base64 encoded string."""
-    path = os.path.join(extensions, EXTENSION_ARCHIVE_PATH)
+@pytest.mark.xfail_firefox
+class TestChromiumWebExtension:
+    """Chrome/Edge-specific WebExtension tests with custom driver."""
 
-    with open(path, "rb") as file:
-        base64_encoded = base64.b64encode(file.read()).decode("utf-8")
+    @pytest.fixture
+    def chromium_driver(self, request):
+        driver_option = request.config.option.drivers[0].lower()
 
-    ext_info = install_extension(driver, base64_value=base64_encoded)
+        if driver_option == "chrome":
+            options = ChromeOptions()
+            browser_class = webdriver.Chrome
+        elif driver_option == "edge":
+            options = EdgeOptions()
+            browser_class = webdriver.Edge
+        else:
+            pytest.skip(f"This test requires Chrome or Edge, got {driver_option}")
 
-    # TODO: the extension is installed but the script is not injected, check and fix
-    # verify_extension_injection(driver, pages)
+        options.enable_bidi = True
+        options.enable_webextensions = True
 
-    uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
+        driver = browser_class(options=options)
 
+        yield driver
+        driver.quit()
 
-@pytest.mark.webextension
-def test_install_unsigned_extension(driver, pages):
-    """Test installing an unsigned extension."""
-    path = os.path.join(extensions, "webextensions-selenium-example")
+    def test_install_extension_path(self, chromium_driver, pages):
+        """Test installing an extension from a directory path."""
+        path = os.path.join(extensions, EXTENSION_PATH)
+        ext_info = chromium_driver.webextension.install(path=path)
 
-    if driver.capabilities["browserName"].lower() in ["chrome", "microsoftedge"]:
-        ext_info = driver.webextension.install(path=path)
-    else:
-        ext_info = install_extension(driver, path=path)
-    verify_extension_injection(driver, pages)
-    uninstall_extension_and_verify_extension_uninstalled(driver, ext_info)
+        chromium_driver.get("https://www.webpagetest.org/blank.html")
 
+        verify_extension_injection(chromium_driver, pages)
+        uninstall_extension_and_verify_extension_uninstalled(chromium_driver, ext_info)
 
-@pytest.mark.webextension
-def test_install_with_extension_id_uninstall(driver, pages):
-    """Test uninstalling an extension using just the extension ID."""
-    path = os.path.join(extensions, EXTENSION_PATH)
+    def test_install_unsigned_extension(self, chromium_driver, pages):
+        """Test installing an unsigned extension."""
+        path = os.path.join(extensions, "webextensions-selenium-example")
+        ext_info = chromium_driver.webextension.install(path=path)
 
-    if driver.capabilities["browserName"].lower() in ["chrome", "microsoftedge"]:
-        ext_info = driver.webextension.install(path=path)
-    else:
-        ext_info = install_extension(driver, path=path)
+        chromium_driver.get("https://www.webpagetest.org/blank.html")
 
-    extension_id = ext_info.get("extension")
+        verify_extension_injection(chromium_driver, pages)
+        uninstall_extension_and_verify_extension_uninstalled(chromium_driver, ext_info)
 
-    # Uninstall using the extension ID
-    uninstall_extension_and_verify_extension_uninstalled(driver, extension_id)
+    def test_install_with_extension_id_uninstall(self, chromium_driver, pages):
+        """Test uninstalling an extension using just the extension ID."""
+        path = os.path.join(extensions, EXTENSION_PATH)
+        ext_info = chromium_driver.webextension.install(path=path)
+        extension_id = ext_info.get("extension")
+        # Uninstall using the extension ID
+        uninstall_extension_and_verify_extension_uninstalled(chromium_driver, extension_id)