Merge pull request #100 from unicef/feature/setup-seleniumbase

Setup seleniumbase

Author: datamik

.github/workflows/test.yml

@@ -147,7 +147,7 @@ jobs:
               -v "./tests:/app/tests" \
               -v "./pytest.ini:/app/pytest.ini" \
               -t ${{env.IMAGE}} \
-              pytest tests/ --create-db --selenium -v --maxfail=5 --migrations --cov-report xml:./output/coverage.xml --record-mode none
+              pytest tests/ --create-db -v --maxfail=5 --migrations --cov-report xml:./output/coverage.xml --record-mode none
 
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4

pyproject.toml

@@ -89,14 +89,14 @@ dev-dependencies = [
     "pytest-factoryboy>=2.7.0",
     "pytest-mock>=3.14.0",
     "pytest-recording>=0.13.2",
-    "pytest-selenium>=4.1.0",
     "pytest-xdist>=3.6.1",
     "pytest>=8.2.2",
     "responses>=0.25.3",
     "types-python-dateutil>=2.9.0.20241003",
     "types-requests>=2.31.0.6",
     "vcrpy>=6.0.2",
     "ruff>=0.9.3",
+    "seleniumbase>=4.35.7",
 ]
 
 

tests/conftest.py

@@ -17,25 +17,6 @@
 sys.path.insert(0, str(here / "extras"))
 
 
-def pytest_addoption(parser):
-    parser.addoption(
-        "--selenium",
-        action="store_true",
-        dest="enable_selenium",
-        default=False,
-        help="enable selenium tests",
-    )
-
-    parser.addoption(
-        "--show-browser",
-        "-S",
-        action="store_true",
-        dest="show_browser",
-        default=False,
-        help="will not start browsers in headless mode",
-    )
-
-
 class MockStorage(Storage):
     def __init__(self):
         self._file_content = None
@@ -69,11 +50,6 @@ def patch_asyncjob(mock_storage):
 
 
 def pytest_configure(config):
-    if not config.option.enable_selenium and ("selenium" not in getattr(config.option, "markexpr", None)):
-        if config.option.markexpr:
-            config.option.markexpr += " and not selenium"
-        else:
-            config.option.markexpr = "not selenium"
     os.environ["DJANGO_SETTINGS_MODULE"] = "country_workspace.config.settings"
     os.environ.setdefault("STATIC_URL", "/static/")
     os.environ.setdefault("MEDIA_ROOT", "/tmp/static/")

tests/extras/testutils/selenium.py

@@ -1,52 +1,69 @@
-from django.urls import reverse
+from seleniumbase import BaseCase
 
 
-def check_link_by_class(selenium, cls, view_name):
-    link = selenium.find_element_by_class_name(cls)
-    url = reverse(f"{view_name}")
-    return f' href="{url}"' in link.get_attribute("innerHTML")
+class CountryWorkspaceSeleniumTC(BaseCase):
+    live_server_url: str = ""
 
+    def setUp(self, masterqa_mode=False):
+        super().setUp()
+        from testutils.factories.user import SuperUserFactory
 
-def wait_for(driver, *args):
-    from selenium.webdriver.support import expected_conditions as ec
-    from selenium.webdriver.support.ui import WebDriverWait
+        super().setUpClass()
+        self.admin_user = SuperUserFactory()
+        self.admin_user._password = "password"
 
-    wait = WebDriverWait(driver, 10)
-    wait.until(ec.visibility_of_element_located((*args,)))
-    return driver.find_element(*args)
+    def tearDown(self):
+        self.save_teardown_screenshot()
+        super().tearDown()
+        self.admin_user.delete()
 
+    def base_method(self):
+        pass
 
-def wait_for_url(driver, url):
-    from selenium.webdriver.support import expected_conditions as ec
-    from selenium.webdriver.support.ui import WebDriverWait
+    def open(self, url: str):
+        self.maximize_window()
+        return super().open(f"{self.live_server_url}{url}")
 
-    if "://" not in url:
-        url = f"{driver.live_server.url}{url}"
-    wait = WebDriverWait(driver, 10)
-    wait.until(ec.url_contains(url))
+    def select2_select(self, element_id: str, value: str):
+        self.slow_click(f"span[aria-labelledby=select2-{element_id}-container]")
+        self.wait_for_element_visible("input.select2-search__field")
+        self.click(f"li.select2-results__option:contains('{value}')")
+        self.wait_for_element_absent("input.select2-search__field")
 
+    def login_as_user(self, user=None):
+        if user is not None:
+            self.admin_user = user
+        self.open("/login/")
+        self.type("input[name=username]", f"{self.admin_user.username}")
+        self.type("input[name=password]", f"{self.admin_user._password}")
+        self.submit("#login-form")
+        self.wait_for_ready_state_complete()
 
-def force_login(user, driver, base_url):
-    from importlib import import_module
+    def login(self, url=None):
+        self.open("/admin/")
+        if self.get_current_url() == f"{self.live_server_url}/admin/login/?next=/admin/":
+            self.type("input[name=username]", f"{self.admin_user.username}")
+            self.type("input[name=password]", f"{self.admin_user._password}")
+            self.submit('input[value="Log in"]')
+            self.wait_for_ready_state_complete()
 
-    from django.conf import settings
-    from django.contrib.auth import BACKEND_SESSION_KEY, HASH_SESSION_KEY, SESSION_KEY
+    def is_required(self, element: str) -> bool:
+        el = self.wait_for_element_visible(element)
+        return el.parent.find_element("label>span").text == "(required)"
 
-    SessionStore = import_module(settings.SESSION_ENGINE).SessionStore  # noqa: N806
-    with driver.with_timeouts(page=5):
-        driver.get(base_url)
+    def get_field_error(self, element: str) -> bool:
+        return self.wait_for_element_visible(f"fieldset.{element} ul.errorlist").text
 
-    session = SessionStore()
-    session[SESSION_KEY] = user._meta.pk.value_to_string(user)
-    session[BACKEND_SESSION_KEY] = settings.AUTHENTICATION_BACKENDS[0]
-    session[HASH_SESSION_KEY] = user.get_session_auth_hash()
-    session.save()
-
-    driver.add_cookie(
-        {
-            "name": settings.SESSION_COOKIE_NAME,
-            "value": session.session_key,
-            "path": "/",
-        }
-    )
-    driver.refresh()
+    def get_pixel_colors(self):
+        # Return the RGB colors of the canvas element's top left pixel
+        x = 0
+        y = 0
+        if self.browser == "safari":
+            x = 1
+            y = 1
+        color = self.execute_script(
+            "return document.querySelector('canvas').getContext('2d').getImageData(%s,%s,1,1).data;" % (x, y)
+        )
+        if self.is_chromium():
+            return [color[0], color[1], color[2]]
+        return [color["0"], color["1"], color["2"]]

tests/functional/conftest.py

@@ -1,100 +1,46 @@
-import contextlib
-import time
-from collections import namedtuple
-from typing import TYPE_CHECKING
+from typing import Generator
 
+from django.conf import settings
+from seleniumbase import config as sb_config
+from seleniumbase.core import session_helper
 import pytest
-from selenium.webdriver import Keys
-from selenium.webdriver.common.by import By
 
-if TYPE_CHECKING:
-    from selenium.webdriver.common.timeouts import Timeouts
-
-Proxy = namedtuple("Proxy", "host,port")
-
-
-def pytest_configure(config):
-    if not config.option.driver:
-        config.option.driver = "chrome"
-
-
-@contextlib.contextmanager
-def timeouts(driver, wait=None, page=None, script=None):
-    _current: Timeouts = driver.timeouts
-    if wait:
-        driver.implicitly_wait(wait)
-    if page:
-        driver.set_page_load_timeout(page)
-    if script:
-        driver.set_script_timeout(script)
-    yield
-    driver.timeouts = _current
-
-
-def set_input_value(driver, *args):
-    rules = args[:-1]
-    el = driver.find_element(*rules)
-    el.clear()
-    el.send_keys(args[-1])
-
-
-def find_by_css(selenium, *args):
-    from testutils.selenium import wait_for
-
-    return wait_for(selenium, By.CSS_SELECTOR, *args)
-
-
-def select2(driver, by, selector, value):
-    el = driver.find_element(by, selector)
-    el.click()
-    time.sleep(1)
-    driver.switch_to.active_element.send_keys(value)
-    driver.find_element(By.XPATH, f"//div[contains(text(),'{value}')]").click()
-    time.sleep(1)
-    driver.switch_to.active_element.send_keys(Keys.TAB)
-    time.sleep(1)
-    driver.switch_to.active_element.send_keys(Keys.TAB)
+from testutils.selenium import CountryWorkspaceSeleniumTC
 
 
 @pytest.fixture
-def chrome_options(request, chrome_options):
-    if not request.config.getvalue("show_browser"):
-        chrome_options.add_argument("--headless")
-    chrome_options.add_argument("--allow-insecure-localhost")
-    chrome_options.add_argument("--disable-browser-side-navigation")
-    chrome_options.add_argument("--disable-dev-shm-usage")
-    chrome_options.add_argument("--disable-gpu")
-    chrome_options.add_argument("--disable-translate")
-    chrome_options.add_argument("--ignore-certificate-errors")
-    chrome_options.add_argument("--lang=en-GB")
-    chrome_options.add_argument("--no-sandbox")
-    chrome_options.add_argument("--proxy-bypass-list=*")
-    chrome_options.add_argument("--proxy-server='direct://'")
-    chrome_options.add_argument("--start-maximized")
-
-    prefs = {"profile.default_content_setting_values.notifications": 1}  # explicitly allow notifications
-    chrome_options.add_experimental_option("prefs", prefs)
-
-    return chrome_options
-
-
-SELENIUM_DEFAULT_PAGE_LOAD_TIMEOUT = 5
-SELENIUM_DEFAULT_IMPLICITLY_WAIT = 1
-SELENIUM_DEFAULT_SCRIPT_TIMEOUT = 1
-
-
-@pytest.fixture
-def selenium(monkeypatch, live_server, settings, driver):
-    from testutils.selenium import wait_for, wait_for_url
-
+def browser(live_server, request) -> Generator[CountryWorkspaceSeleniumTC, None, None]:
+    """SeleniumBase as a pytest fixture.
+    Usage example: "def test_one(sb):"
+    You may need to use this for tests that use other pytest fixtures."""
     settings.FLAGS = {"LOCAL_LOGIN": [("boolean", True)]}
-
-    driver.with_timeouts = timeouts.__get__(driver)
-    driver.set_input_value = set_input_value.__get__(driver)
-    driver.live_server = live_server
-    driver.wait_for = wait_for.__get__(driver)
-    driver.wait_for_url = wait_for_url.__get__(driver)
-    driver.find_by_css = find_by_css.__get__(driver)
-    driver.select2 = select2.__get__(driver)
-
-    return driver
+    if request.cls:
+        if sb_config.reuse_class_session:
+            the_class = str(request.cls).split(".")[-1].split("'")[0]
+            if the_class != sb_config._sb_class:
+                session_helper.end_reused_class_session_as_needed()
+                sb_config._sb_class = the_class
+        request.cls.sb = CountryWorkspaceSeleniumTC("base_method")
+        request.cls.sb.live_server_url = str(live_server)
+        request.cls.sb.setUp()
+        request.cls.sb._needs_tearDown = True
+        request.cls.sb._using_sb_fixture = True
+        request.cls.sb._using_sb_fixture_class = True
+        sb_config._sb_node[request.node.nodeid] = request.cls.sb
+        yield request.cls.sb
+        if request.cls.sb._needs_tearDown:
+            request.cls.sb.tearDown()
+            request.cls.sb._needs_tearDown = False
+    else:
+        sb = CountryWorkspaceSeleniumTC("base_method")
+        sb.live_server_url = str(live_server)
+        sb.setUp()
+        sb._needs_tearDown = True
+        sb._using_sb_fixture = True
+        sb._using_sb_fixture_no_class = True
+        sb_config._sb_node[request.node.nodeid] = sb
+        sb.maximize_window()
+        yield sb
+        if sb._needs_tearDown:
+            sb.tearDown()
+            sb._needs_tearDown = False

tests/functional/test_f_household.py

@@ -1,8 +1,6 @@
 from typing import TYPE_CHECKING
 
 import pytest
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.select import Select
 
 if TYPE_CHECKING:
     from country_workspace.workspaces.models import CountryHousehold
@@ -39,7 +37,7 @@ def household(program):
 
 @pytest.mark.selenium
 @pytest.mark.xfail
-def test_list_household(selenium, admin_user, household: "CountryHousehold"):
+def test_list_household(browser, admin_user, household: "CountryHousehold"):
     from testutils.perms import user_grant_permissions
 
     with user_grant_permissions(
@@ -51,22 +49,14 @@ def test_list_household(selenium, admin_user, household: "CountryHousehold"):
         ],
         household.program.country_office,
     ):
-        selenium.get(f"{selenium.live_server.url}")
-        # Login
-        selenium.find_by_css("input[name=username").send_keys(admin_user.username)
-        selenium.find_by_css("input[name=password").send_keys(admin_user._password)
-        selenium.find_by_css("button.primary").click()
+        browser.login()
         # Select Tenant
-        Select(selenium.wait_for(By.CSS_SELECTOR, "select[name=tenant]")).select_by_visible_text(
-            household.program.country_office.name
-        )
-        selenium.select2(By.ID, "select2-id_program-container", household.program.name)
-        selenium.wait_for(By.LINK_TEXT, "Households").click()
-
-        selenium.wait_for(By.LINK_TEXT, str(household.name)).click()
-        selenium.wait_for_url(household.get_change_url())
-        selenium.wait_for(
-            By.CSS_SELECTOR,
-            "a.closelink",
-        ).click()
-        selenium.wait_for_url("/workspaces/countryhousehold/")
+        browser.select_option_by_text("select[name=tenant]", household.program.country_office.name)
+        browser.select2_select("id_program", household.program.name)
+
+        browser.click_link("Households")
+        browser.click_link(str(household.name))
+        browser.assert_current_url(household.get_change_url())
+
+        browser.click("a.closelink")
+        browser.assert_current_url("/workspaces/countryhousehold/")