diff --git a/.github/workflows/selenium.yml b/.github/workflows/playwright.yml
similarity index 76%
rename from .github/workflows/selenium.yml
rename to .github/workflows/playwright.yml
index 7ac14710f1c3..a3f526154929 100644
--- a/.github/workflows/selenium.yml
+++ b/.github/workflows/playwright.yml
@@ -1,4 +1,4 @@
-name: Selenium Tests
+name: Playwright Tests
 
 on:
   pull_request:
@@ -14,8 +14,8 @@ permissions:
    contents: read
 
 jobs:
-  selenium-sqlite:
-    if: contains(github.event.pull_request.labels.*.name, 'selenium')
+  playwright-sqlite:
+    if: contains(github.event.pull_request.labels.*.name, 'playwright')
     runs-on: ubuntu-latest
     name: SQLite
     timeout-minutes: 60
@@ -37,13 +37,15 @@ jobs:
       - name: Install and upgrade packaging tools
         run: python -m pip install --upgrade pip wheel
       - run: python -m pip install -r tests/requirements/py3.txt -e .
-      - name: Run Selenium tests
+      - name: Install Playwright browsers
+        run: python -m playwright install --with-deps chromium
+      - name: Run Playwright tests
         working-directory: ./tests/
         run: |
-          python -Wall runtests.py --verbosity 2 --noinput --selenium=chrome --headless --settings=test_sqlite --parallel 1
+          python -Wall runtests.py --verbosity 2 --noinput --playwright=chromium --settings=test_sqlite --parallel 1
 
-  selenium-postgresql:
-    if: contains(github.event.pull_request.labels.*.name, 'selenium')
+  playwright-postgresql:
+    if: contains(github.event.pull_request.labels.*.name, 'playwright')
     runs-on: ubuntu-latest
     name: PostgreSQL
     timeout-minutes: 60
@@ -79,9 +81,11 @@ jobs:
       - name: Install and upgrade packaging tools
         run: python -m pip install --upgrade pip wheel
       - run: python -m pip install -r tests/requirements/py3.txt -r tests/requirements/postgres.txt -e .
+      - name: Install Playwright browsers
+        run: python -m playwright install --with-deps chromium
       - name: Create PostgreSQL settings file
         run: mv ./.github/workflows/data/test_postgres.py.tpl ./tests/test_postgres.py
-      - name: Run Selenium tests
+      - name: Run Playwright tests
         working-directory: ./tests/
         run: |
-          python -Wall runtests.py --verbosity 2 --noinput --selenium=chrome --headless --settings=test_postgres --parallel 1
+          python -Wall runtests.py --verbosity 2 --noinput --playwright=chromium --settings=test_postgres --parallel 1
diff --git a/.github/workflows/schedule_tests.yml b/.github/workflows/schedule_tests.yml
index 3cb894a7a093..e6ddfccabafd 100644
--- a/.github/workflows/schedule_tests.yml
+++ b/.github/workflows/schedule_tests.yml
@@ -91,9 +91,9 @@ jobs:
       - run: npm install
       - run: npm test
 
-  selenium-sqlite:
+  playwright-sqlite:
     runs-on: ubuntu-latest
-    name: Selenium tests, SQLite
+    name: Playwright tests, SQLite
     timeout-minutes: 60
     steps:
       - name: Checkout
@@ -113,14 +113,16 @@ jobs:
       - name: Install and upgrade packaging tools
         run: python -m pip install --upgrade pip wheel
       - run: python -m pip install -r tests/requirements/py3.txt -e .
-      - name: Run Selenium tests
+      - name: Install Playwright browsers
+        run: python -m playwright install --with-deps chromium
+      - name: Run Playwright tests
         working-directory: ./tests/
         run: |
-          python -Wall runtests.py --verbosity 2 --noinput --selenium=chrome --headless --settings=test_sqlite --parallel 1
+          python -Wall runtests.py --verbosity 2 --noinput --playwright=chromium --settings=test_sqlite --parallel 1
 
-  selenium-postgresql:
+  playwright-postgresql:
     runs-on: ubuntu-latest
-    name: Selenium tests, PostgreSQL
+    name: Playwright tests, PostgreSQL
     timeout-minutes: 60
     services:
       postgres:
@@ -154,12 +156,14 @@ jobs:
       - name: Install and upgrade packaging tools
         run: python -m pip install --upgrade pip wheel
       - run: python -m pip install -r tests/requirements/py3.txt -r tests/requirements/postgres.txt -e .
+      - name: Install Playwright browsers
+        run: python -m playwright install --with-deps chromium
       - name: Create PostgreSQL settings file
         run: mv ./.github/workflows/data/test_postgres.py.tpl ./tests/test_postgres.py
-      - name: Run Selenium tests
+      - name: Run Playwright tests
         working-directory: ./tests/
         run: |
-          python -Wall runtests.py --verbosity 2 --noinput --selenium=chrome --headless --settings=test_postgres --parallel 1
+          python -Wall runtests.py --verbosity 2 --noinput --playwright=chromium --settings=test_postgres --parallel 1
 
   postgresql:
     strategy:
diff --git a/.github/workflows/screenshots.yml b/.github/workflows/screenshots.yml
index c98aa00db6bc..30e2b7f0ef64 100644
--- a/.github/workflows/screenshots.yml
+++ b/.github/workflows/screenshots.yml
@@ -14,7 +14,7 @@ permissions:
   contents: read
 
 jobs:
-  selenium-screenshots:
+  playwright-screenshots:
     if: contains(join(github.event.pull_request.labels.*.name, '|'), 'screenshots')
     runs-on: ubuntu-latest
     name: Screenshots
@@ -37,10 +37,12 @@ jobs:
       - name: Install and upgrade packaging tools
         run: python -m pip install --upgrade pip wheel
       - run: python -m pip install -r tests/requirements/py3.txt -e .
+      - name: Install Playwright browsers
+        run: python -m playwright install --with-deps chromium
 
-      - name: Run Selenium tests with screenshots
+      - name: Run Playwright tests with screenshots
         working-directory: ./tests/
-        run: python -Wall runtests.py --verbosity=2 --noinput --selenium=chrome --headless --screenshots --settings=test_sqlite --parallel=1
+        run: python -Wall runtests.py --verbosity=2 --noinput --playwright=chromium --screenshots --settings=test_sqlite --parallel=1
 
       - name: Cache oxipng
         uses: actions/cache@v6
diff --git a/django/contrib/admin/tests.py b/django/contrib/admin/tests.py
deleted file mode 100644
index bd9c76b5fd52..000000000000
--- a/django/contrib/admin/tests.py
+++ /dev/null
@@ -1,257 +0,0 @@
-from contextlib import contextmanager
-
-from django.contrib.staticfiles.testing import StaticLiveServerTestCase
-from django.test import modify_settings, override_settings
-from django.test.selenium import SeleniumTestCase
-from django.utils.csp import CSP
-from django.utils.translation import gettext as _
-
-# Make unittest ignore frames in this module when reporting failures.
-__unittest = True
-
-
-@modify_settings(
-    MIDDLEWARE={"append": "django.middleware.csp.ContentSecurityPolicyMiddleware"}
-)
-@override_settings(
-    SECURE_CSP={
-        "default-src": [CSP.NONE],
-        "connect-src": [CSP.SELF],
-        "img-src": [CSP.SELF],
-        "script-src": [CSP.SELF],
-        "style-src": [CSP.SELF],
-    },
-)
-class AdminSeleniumTestCase(SeleniumTestCase, StaticLiveServerTestCase):
-    available_apps = [
-        "django.contrib.admin",
-        "django.contrib.auth",
-        "django.contrib.contenttypes",
-        "django.contrib.sessions",
-        "django.contrib.sites",
-    ]
-
-    def tearDown(self):
-        # Ensure that no CSP violations were logged in the browser.
-        self.assertEqual(self.get_browser_logs(source="security"), [])
-        super().tearDown()
-
-    def wait_until(self, callback, timeout=10):
-        """
-        Block the execution of the tests until the specified callback returns a
-        value that is not falsy. This method can be called, for example, after
-        clicking a link or submitting a form. See the other public methods that
-        call this function for more details.
-        """
-        from selenium.webdriver.support.wait import WebDriverWait
-
-        WebDriverWait(self.selenium, timeout).until(callback)
-
-    def wait_for_and_switch_to_popup(self, num_windows=2, timeout=10):
-        """
-        Block until `num_windows` are present and are ready (usually 2, but can
-        be overridden in the case of pop-ups opening other pop-ups). Switch the
-        current window to the new pop-up.
-        """
-        self.wait_until(lambda d: len(d.window_handles) == num_windows, timeout)
-        self.selenium.switch_to.window(self.selenium.window_handles[-1])
-        self.wait_page_ready()
-
-    def wait_for(self, css_selector, timeout=10):
-        """
-        Block until a CSS selector is found on the page.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        self.wait_until(
-            ec.presence_of_element_located((By.CSS_SELECTOR, css_selector)), timeout
-        )
-
-    def wait_for_text(self, css_selector, text, timeout=10):
-        """
-        Block until the text is found in the CSS selector.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        self.wait_until(
-            ec.text_to_be_present_in_element((By.CSS_SELECTOR, css_selector), text),
-            timeout,
-        )
-
-    def wait_for_value(self, css_selector, text, timeout=10):
-        """
-        Block until the value is found in the CSS selector.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        self.wait_until(
-            ec.text_to_be_present_in_element_value(
-                (By.CSS_SELECTOR, css_selector), text
-            ),
-            timeout,
-        )
-
-    def wait_until_visible(self, css_selector, timeout=10):
-        """
-        Block until the element described by the CSS selector is visible.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        self.wait_until(
-            ec.visibility_of_element_located((By.CSS_SELECTOR, css_selector)), timeout
-        )
-
-    def wait_until_invisible(self, css_selector, timeout=10):
-        """
-        Block until the element described by the CSS selector is invisible.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        self.wait_until(
-            ec.invisibility_of_element_located((By.CSS_SELECTOR, css_selector)), timeout
-        )
-
-    def wait_page_ready(self, timeout=10):
-        """
-        Block until the page is ready.
-        """
-        self.wait_until(
-            lambda driver: driver.execute_script("return document.readyState;")
-            == "complete",
-            timeout,
-        )
-
-    @contextmanager
-    def wait_page_loaded(self, timeout=10):
-        """
-        Block until a new page has loaded and is ready.
-        """
-        from selenium.common.exceptions import WebDriverException
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        old_page = self.selenium.find_element(By.TAG_NAME, "html")
-        yield
-        # Wait for the next page to be loaded
-        try:
-            self.wait_until(ec.staleness_of(old_page), timeout=timeout)
-        except WebDriverException:
-            # Issue in version 113+ of Chrome driver where a WebDriverException
-            # error is raised rather than a StaleElementReferenceException.
-            # See: https://issues.chromium.org/issues/42323468
-            pass
-
-        self.wait_page_ready(timeout=timeout)
-
-    def trigger_resize(self):
-        width = self.selenium.get_window_size()["width"]
-        height = self.selenium.get_window_size()["height"]
-        self.selenium.set_window_size(width + 1, height)
-        self.wait_page_ready()
-        self.selenium.set_window_size(width, height)
-        self.wait_page_ready()
-
-    def admin_login(self, username, password, login_url="/admin/"):
-        """
-        Log in to the admin.
-        """
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get("%s%s" % (self.live_server_url, login_url))
-        username_input = self.selenium.find_element(By.NAME, "username")
-        username_input.send_keys(username)
-        password_input = self.selenium.find_element(By.NAME, "password")
-        password_input.send_keys(password)
-        login_text = _("Log in")
-        with self.wait_page_loaded():
-            self.selenium.find_element(
-                By.XPATH, '//input[@value="%s"]' % login_text
-            ).click()
-
-    def select_option(self, selector, value):
-        """
-        Select the <OPTION> with the value `value` inside the <SELECT> widget
-        identified by the CSS selector `selector`.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
-        select = Select(self.selenium.find_element(By.CSS_SELECTOR, selector))
-        select.select_by_value(value)
-
-    def deselect_option(self, selector, value):
-        """
-        Deselect the <OPTION> with the value `value` inside the <SELECT> widget
-        identified by the CSS selector `selector`.
-        """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
-        select = Select(self.selenium.find_element(By.CSS_SELECTOR, selector))
-        select.deselect_by_value(value)
-
-    def assertCountSeleniumElements(self, selector, count, root_element=None):
-        """
-        Assert number of matches for a CSS selector.
-
-        `root_element` allow restriction to a pre-selected node.
-        """
-        from selenium.webdriver.common.by import By
-
-        root_element = root_element or self.selenium
-        self.assertEqual(
-            len(root_element.find_elements(By.CSS_SELECTOR, selector)), count
-        )
-
-    def _assertOptionsValues(self, options_selector, values):
-        from selenium.webdriver.common.by import By
-
-        if values:
-            options = self.selenium.find_elements(By.CSS_SELECTOR, options_selector)
-            actual_values = []
-            for option in options:
-                actual_values.append(option.get_attribute("value"))
-            self.assertEqual(values, actual_values)
-        else:
-            # Prevent the `find_elements(By.CSS_SELECTOR, …)` call from
-            # blocking if the selector doesn't match any options as we expect
-            # it to be the case.
-            with self.disable_implicit_wait():
-                self.wait_until(
-                    lambda driver: not driver.find_elements(
-                        By.CSS_SELECTOR, options_selector
-                    )
-                )
-
-    def assertSelectOptions(self, selector, values):
-        """
-        Assert that the <SELECT> widget identified by `selector` has the
-        options with the given `values`.
-        """
-        self._assertOptionsValues("%s > option" % selector, values)
-
-    def assertSelectedOptions(self, selector, values):
-        """
-        Assert that the <SELECT> widget identified by `selector` has the
-        selected options with the given `values`.
-        """
-        self._assertOptionsValues("%s > option:checked" % selector, values)
-
-    def is_disabled(self, selector):
-        """
-        Return True if the element identified by `selector` has the `disabled`
-        attribute.
-        """
-        from selenium.webdriver.common.by import By
-
-        return (
-            self.selenium.find_element(By.CSS_SELECTOR, selector).get_attribute(
-                "disabled"
-            )
-            == "true"
-        )
diff --git a/django/db/models/query.py b/django/db/models/query.py
index 222b1c28d95f..65d85751bd69 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -6,7 +6,7 @@
 import operator
 import warnings
 from contextlib import nullcontext
-from functools import reduce
+from functools import partial, reduce
 from itertools import chain, islice
 from weakref import ref as weak_ref
 
@@ -52,6 +52,7 @@
     warn_about_external_use,
 )
 from django.utils.functional import cached_property
+from django.utils.inspect import func_accepts_kwargs, func_supports_parameter
 from django.utils.warnings import django_file_prefixes
 
 # The maximum number of results to fetch in a get() query.
@@ -63,6 +64,34 @@
 DEFAULT_FETCH_MODE = FETCH_ONE
 
 
+# RemovedInDjango70Warning: When the deprecation ends, remove this function
+# and restore direct model_cls.from_db(..., fetch_mode=fetch_mode) calls at
+# its call sites.
+def _get_from_db(model_cls, fetch_mode):
+    """
+    Return a callable equivalent to model_cls.from_db with fetch_mode already
+    bound, accommodating deprecated from_db() overrides that don't accept the
+    fetch_mode keyword argument.
+    """
+    from django.db.models import Model
+
+    from_db = model_cls.from_db
+    if (
+        from_db.__func__ is Model.from_db.__func__
+        or func_supports_parameter(from_db, "fetch_mode")
+        or func_accepts_kwargs(from_db)
+    ):
+        return partial(from_db, fetch_mode=fetch_mode)
+    warnings.warn(
+        f"{model_cls.__qualname__}.from_db() must accept a fetch_mode keyword "
+        "argument. Support for from_db() methods that do not accept it is "
+        "deprecated.",
+        RemovedInDjango70Warning,
+        skip_file_prefixes=django_file_prefixes(),
+    )
+    return from_db
+
+
 class BaseIterable:
     def __init__(
         self, queryset, chunked_fetch=False, chunk_size=GET_ITERATOR_CHUNK_SIZE
@@ -123,6 +152,10 @@ def __iter__(self):
         init_list = [
             f[0].target.attname for f in select[model_fields_start:model_fields_end]
         ]
+        # RemovedInDjango70Warning: When the deprecation ends, remove this
+        # assignment and call model_cls.from_db(..., fetch_mode=fetch_mode)
+        # directly in the loop below.
+        from_db = _get_from_db(model_cls, fetch_mode)
         related_populators = get_related_populators(klass_info, select, db, fetch_mode)
         known_related_objects = [
             (
@@ -142,11 +175,10 @@ def __iter__(self):
         ]
         peers = []
         for row in compiler.results_iter(results):
-            obj = model_cls.from_db(
+            obj = from_db(
                 db,
                 init_list,
                 row[model_fields_start:model_fields_end],
-                fetch_mode=fetch_mode,
             )
             if fetch_mode.track_peers:
                 peers.append(weak_ref(obj))
@@ -213,13 +245,16 @@ def __iter__(self):
                     query_iterator, cols
                 )
             fetch_mode = self.queryset._fetch_mode
+            # RemovedInDjango70Warning: When the deprecation ends, remove
+            # this assignment and call
+            # model_cls.from_db(..., fetch_mode=fetch_mode) directly in the
+            # loop below.
+            from_db = _get_from_db(model_cls, fetch_mode)
             peers = []
             for values in query_iterator:
                 # Associate fields to values
                 model_init_values = [values[pos] for pos in model_init_pos]
-                instance = model_cls.from_db(
-                    db, model_init_names, model_init_values, fetch_mode=fetch_mode
-                )
+                instance = from_db(db, model_init_names, model_init_values)
                 if fetch_mode.track_peers:
                     peers.append(weak_ref(instance))
                     instance._state.peers = peers
@@ -3044,6 +3079,11 @@ def __init__(self, klass_info, select, db, fetch_mode):
             )
 
         self.model_cls = klass_info["model"]
+        # RemovedInDjango70Warning: When the deprecation ends, remove this
+        # assignment and call
+        # self.model_cls.from_db(..., fetch_mode=fetch_mode) directly in
+        # populate().
+        self.from_db = _get_from_db(self.model_cls, fetch_mode)
         # A primary key must have all of its constituents not-NULL as
         # NULL != NULL and thus NULL cannot be referenced through a foreign
         # relationship. Therefore checking for a single member of the primary
@@ -3063,11 +3103,10 @@ def populate(self, row, from_obj):
         if obj_data[self.pk_idx] is None:
             obj = None
         else:
-            obj = self.model_cls.from_db(
+            obj = self.from_db(
                 self.db,
                 self.init_list,
                 obj_data,
-                fetch_mode=self.fetch_mode,
             )
             for rel_iter in self.related_populators:
                 rel_iter.populate(row, obj)
diff --git a/django/test/selenium.py b/django/test/selenium.py
deleted file mode 100644
index 264ca7f71383..000000000000
--- a/django/test/selenium.py
+++ /dev/null
@@ -1,288 +0,0 @@
-import sys
-import unittest
-from contextlib import contextmanager
-from functools import wraps
-from pathlib import Path
-
-from django.conf import settings
-from django.test import LiveServerTestCase, override_settings, tag
-from django.utils.functional import classproperty
-from django.utils.module_loading import import_string
-from django.utils.text import capfirst
-
-
-class SeleniumTestCaseBase(type(LiveServerTestCase)):
-    # List of browsers to dynamically create test classes for.
-    browsers = []
-    # A selenium hub URL to test against.
-    selenium_hub = None
-    # The external host Selenium Hub can reach.
-    external_host = None
-    # Sentinel value to differentiate browser-specific instances.
-    browser = None
-    # Run browsers in headless mode.
-    headless = False
-
-    def __new__(cls, name, bases, attrs):
-        """
-        Dynamically create new classes and add them to the test module when
-        multiple browsers specs are provided (e.g. --selenium=firefox,chrome).
-        """
-        test_class = super().__new__(cls, name, bases, attrs)
-        # If the test class is either browser-specific or a test base, return
-        # it.
-        if test_class.browser or not any(
-            name.startswith("test") and callable(value) for name, value in attrs.items()
-        ):
-            return test_class
-        elif test_class.browsers:
-            # Reuse the created test class to make it browser-specific.
-            # We can't rename it to include the browser name or create a
-            # subclass like we do with the remaining browsers as it would
-            # either duplicate tests or prevent pickling of its instances.
-            first_browser = test_class.browsers[0]
-            test_class.browser = first_browser
-            # Listen on an external interface if using a selenium hub.
-            host = test_class.host if not test_class.selenium_hub else "0.0.0.0"
-            test_class.host = host
-            test_class.external_host = cls.external_host
-            # Create subclasses for each of the remaining browsers and expose
-            # them through the test's module namespace.
-            module = sys.modules[test_class.__module__]
-            for browser in test_class.browsers[1:]:
-                browser_test_class = cls.__new__(
-                    cls,
-                    "%s%s" % (capfirst(browser), name),
-                    (test_class,),
-                    {
-                        "browser": browser,
-                        "host": host,
-                        "external_host": cls.external_host,
-                        "__module__": test_class.__module__,
-                    },
-                )
-                setattr(module, browser_test_class.__name__, browser_test_class)
-            return test_class
-        # If no browsers were specified, skip this class (it'll still be
-        # discovered).
-        return unittest.skip("No browsers specified.")(test_class)
-
-    @classmethod
-    def import_webdriver(cls, browser):
-        return import_string("selenium.webdriver.%s.webdriver.WebDriver" % browser)
-
-    @classmethod
-    def import_options(cls, browser):
-        return import_string("selenium.webdriver.%s.options.Options" % browser)
-
-    @classmethod
-    def get_capability(cls, browser):
-        from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
-
-        caps = getattr(DesiredCapabilities, browser.upper())
-        if browser == "chrome":
-            caps["goog:loggingPrefs"] = {"browser": "ALL"}
-
-        return caps
-
-    def create_options(self):
-        options = self.import_options(self.browser)()
-        if self.browser == "chrome":
-            # Disable Google Password Manager "Data Breach" alert pop-ups.
-            options.add_argument("--guest")
-            options.add_argument("--disable-infobars")
-        if self.headless:
-            match self.browser:
-                case "chrome" | "edge":
-                    options.add_argument("--headless=new")
-                case "firefox":
-                    options.add_argument("-headless")
-        return options
-
-    def create_webdriver(self):
-        options = self.create_options()
-        if self.selenium_hub:
-            from selenium import webdriver
-
-            for key, value in self.get_capability(self.browser).items():
-                options.set_capability(key, value)
-
-            return webdriver.Remote(command_executor=self.selenium_hub, options=options)
-        return self.import_webdriver(self.browser)(options=options)
-
-
-class ChangeWindowSize:
-    def __init__(self, width, height, selenium):
-        self.selenium = selenium
-        self.new_size = (width, height)
-
-    def __enter__(self):
-        self.old_size = self.selenium.get_window_size()
-        self.selenium.set_window_size(*self.new_size)
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.selenium.set_window_size(self.old_size["width"], self.old_size["height"])
-
-
-@tag("selenium")
-class SeleniumTestCase(LiveServerTestCase, metaclass=SeleniumTestCaseBase):
-    implicit_wait = 10
-    external_host = None
-    screenshots = False
-
-    @classmethod
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
-        if not cls.screenshots:
-            return
-
-        for name, func in list(cls.__dict__.items()):
-            if not hasattr(func, "_screenshot_cases"):
-                continue
-            # Remove the main test.
-            delattr(cls, name)
-            # Add separate tests for each screenshot type.
-            for screenshot_case in getattr(func, "_screenshot_cases"):
-
-                @wraps(func)
-                def test(self, *args, _func=func, _case=screenshot_case, **kwargs):
-                    with getattr(self, _case)():
-                        return _func(self, *args, **kwargs)
-
-                test.__name__ = f"{name}_{screenshot_case}"
-                test.__qualname__ = f"{test.__qualname__}_{screenshot_case}"
-                test._screenshot_name = name
-                test._screenshot_case = screenshot_case
-                setattr(cls, test.__name__, test)
-
-    @classproperty
-    def live_server_url(cls):
-        return "http://%s:%s" % (cls.external_host or cls.host, cls.server_thread.port)
-
-    @classproperty
-    def allowed_host(cls):
-        return cls.external_host or cls.host
-
-    @classmethod
-    def setUpClass(cls):
-        cls.selenium = cls.create_webdriver()
-        cls.selenium.implicitly_wait(cls.implicit_wait)
-        super().setUpClass()
-        cls.addClassCleanup(cls._quit_selenium)
-
-    @contextmanager
-    def desktop_size(self):
-        with ChangeWindowSize(1280, 720, self.selenium):
-            yield
-
-    @contextmanager
-    def small_screen_size(self):
-        with ChangeWindowSize(1024, 768, self.selenium):
-            yield
-
-    @contextmanager
-    def mobile_size(self):
-        with ChangeWindowSize(360, 800, self.selenium):
-            yield
-
-    @contextmanager
-    def rtl(self):
-        with self.desktop_size():
-            with override_settings(LANGUAGE_CODE=settings.LANGUAGES_BIDI[-1]):
-                yield
-
-    @contextmanager
-    def dark(self):
-        # Navigate to a page before executing a script.
-        self.selenium.get(self.live_server_url)
-        self.selenium.execute_script("localStorage.setItem('theme', 'dark');")
-        with self.desktop_size():
-            try:
-                yield
-            finally:
-                self.selenium.execute_script("localStorage.removeItem('theme');")
-
-    def set_emulated_media(self, *, media=None, features=None):
-        if self.browser not in {"chrome", "edge"}:
-            self.skipTest(
-                "Emulation.setEmulatedMedia is only supported on Chromium and "
-                "Chrome-based browsers. See https://chromedevtools.github.io/devtools-"
-                "protocol/1-3/Emulation/#method-setEmulatedMedia for more details."
-            )
-        params = {}
-        if media is not None:
-            params["media"] = media
-        if features is not None:
-            params["features"] = features
-
-        # Not using .execute_cdp_cmd() as it isn't supported by the remote web
-        # driver when using --selenium-hub.
-        self.selenium.execute(
-            driver_command="executeCdpCommand",
-            params={"cmd": "Emulation.setEmulatedMedia", "params": params},
-        )
-
-    @contextmanager
-    def high_contrast(self):
-        self.set_emulated_media(features=[{"name": "forced-colors", "value": "active"}])
-        with self.desktop_size():
-            try:
-                yield
-            finally:
-                self.set_emulated_media(
-                    features=[{"name": "forced-colors", "value": "none"}]
-                )
-
-    def take_screenshot(self, name):
-        if not self.screenshots:
-            return
-        test = getattr(self, self._testMethodName)
-        filename = f"{test._screenshot_name}--{name}--{test._screenshot_case}.png"
-        path = Path.cwd() / "screenshots" / filename
-        path.parent.mkdir(exist_ok=True, parents=True)
-        self.selenium.save_screenshot(path)
-
-    def get_browser_logs(self, source=None, level="ALL"):
-        """
-        Return Chrome console logs filtered by level and optionally source.
-        """
-        try:
-            logs = self.selenium.get_log("browser")
-        except AttributeError:
-            logs = []
-        return [
-            log
-            for log in logs
-            if (level == "ALL" or log["level"] == level)
-            and (source is None or log["source"] == source)
-        ]
-
-    @classmethod
-    def _quit_selenium(cls):
-        # quit() the WebDriver before attempting to terminate and join the
-        # single-threaded LiveServerThread to avoid a dead lock if the browser
-        # kept a connection alive.
-        if hasattr(cls, "selenium"):
-            cls.selenium.quit()
-
-    @contextmanager
-    def disable_implicit_wait(self):
-        """Disable the default implicit wait."""
-        self.selenium.implicitly_wait(0)
-        try:
-            yield
-        finally:
-            self.selenium.implicitly_wait(self.implicit_wait)
-
-
-def screenshot_cases(method_names):
-    if isinstance(method_names, str):
-        method_names = method_names.split(",")
-
-    def wrapper(func):
-        func._screenshot_cases = method_names
-        setattr(func, "tags", {"screenshot"}.union(getattr(func, "tags", set())))
-        return func
-
-    return wrapper
diff --git a/docs/internals/contributing/committing-code.txt b/docs/internals/contributing/committing-code.txt
index 479e23bbd426..2a41fe60cfe9 100644
--- a/docs/internals/contributing/committing-code.txt
+++ b/docs/internals/contributing/committing-code.txt
@@ -25,7 +25,7 @@ standard themselves.
 
 You may want to have Jenkins or GitHub actions test the pull request with one
 of the pull request builders that doesn't run automatically, such as Oracle or
-Selenium. See the `CI wiki page`_ for instructions.
+Playwright. See the `CI wiki page`_ for instructions.
 
 .. _CI wiki page: https://code.djangoproject.com/wiki/CI
 
diff --git a/docs/internals/contributing/writing-code/unit-tests.txt b/docs/internals/contributing/writing-code/unit-tests.txt
index 40f534eabded..40044888ba99 100644
--- a/docs/internals/contributing/writing-code/unit-tests.txt
+++ b/docs/internals/contributing/writing-code/unit-tests.txt
@@ -253,61 +253,78 @@ Note that the ``--reverse`` option doesn't impact on ``--start-at`` or
 ``--start-after`` options. Moreover these options cannot be used with test
 labels.
 
-.. _running-selenium-tests:
+.. _running-playwright-tests:
 
-Running the Selenium tests
---------------------------
+Running the Playwright tests
+----------------------------
+
+.. versionadded:: 6.2
+
+Some tests require Playwright and a web browser. To run these tests, you must
+install the :pypi:`playwright` package, install the browser binaries it needs,
+and run the tests with the ``--playwright=<BROWSERS>`` option.
 
-Some tests require Selenium and a web browser. To run these tests, you must
-install the :pypi:`selenium` package and run the tests with the
-``--selenium=<BROWSERS>`` option. For example, if you have Firefox and Google
-Chrome installed:
+First install the Python package and browser binaries. For example, to install
+Chromium or Firefox and its system dependencies:
 
 .. console::
 
-   $ ./runtests.py --selenium=firefox,chrome
+   $ python -m pip install playwright
+   $ python -m playwright install --with-deps chromium
+   $ python -m playwright install --with-deps firefox
 
-See the `selenium.webdriver`_ package for the list of available browsers.
+Then run the tests. For example, if you want to run against Chromium and
+Firefox:
+
+.. console::
 
-Specifying ``--selenium`` automatically sets ``--tags=selenium`` to run only
-the tests that require selenium.
+   $ ./runtests.py --playwright=chromium,firefox
 
-Some browsers (e.g. Chrome or Firefox) support headless testing, which can be
-faster and more stable. Add the ``--headless`` option to enable this mode.
+See the `Playwright browsers`_ documentation for the list of available
+browsers.
 
-.. _selenium.webdriver: https://github.com/SeleniumHQ/selenium/tree/trunk/py/selenium/webdriver
+Specifying ``--playwright`` automatically sets ``--tags=playwright`` to run
+only the tests that require Playwright.
+
+Browsers run in headless mode by default, which is faster and more stable.
+Add the ``--headed`` option to run with a visible browser window instead.
+
+To slow down Playwright operations for debugging, pass ``--slowmo=<MS>`` with a
+delay in milliseconds, for example ``--slowmo=500``.
+
+.. _Playwright browsers: https://playwright.dev/python/docs/browsers
 
 .. _screenshot-tests:
 
 Screenshot tests
 ~~~~~~~~~~~~~~~~
 
-For testing changes to the admin UI, the selenium tests can be run with the
+For testing changes to the admin UI, the Playwright tests can be run with the
 ``--screenshots`` option enabled. Screenshots will be saved to the
 ``tests/screenshots/`` directory.
 
-To define when screenshots should be taken during a selenium test, the test
-class must use the ``@django.test.selenium.screenshot_cases`` decorator with a
-list of supported screenshot types (``"desktop_size"``, ``"mobile_size"``,
+To define when screenshots should be taken during a Playwright test, the test
+class must use the ``@playwright_tests.screenshot_cases`` decorator with
+a list of supported screenshot types (``"desktop_size"``, ``"mobile_size"``,
 ``"small_screen_size"``, ``"rtl"``, ``"dark"``, and ``"high_contrast"``). It
 can then call ``self.take_screenshot("unique-screenshot-name")`` at the desired
 point to generate the screenshots. For example::
 
-    from django.test.selenium import SeleniumTestCase, screenshot_cases
+    from playwright_tests import PlaywrightTestCase, screenshot_cases
+
     from django.urls import reverse
 
 
-    class SeleniumTests(SeleniumTestCase):
+    class PlaywrightTests(PlaywrightTestCase):
         @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
         def test_login_button_centered(self):
-            self.selenium.get(self.live_server_url + reverse("admin:login"))
+            self.page.goto(self.live_server_url + reverse("admin:login"))
             self.take_screenshot("login")
             ...
 
 This generates multiple screenshots of the login page - one for a desktop
 screen, one for a mobile screen, one for right-to-left languages on desktop,
-one for the dark mode on desktop, and one for high contrast mode on desktop
-when using chrome.
+one for the dark mode on desktop, and one for high contrast mode on desktop.
 
 .. _running-unit-tests-dependencies:
 
@@ -334,7 +351,7 @@ dependencies:
   <https://memcached.org/>`_
 * `gettext <https://www.gnu.org/software/gettext/manual/gettext.html>`_
   (:ref:`gettext_on_windows`)
-* :pypi:`selenium` 4.23.0+
+* :pypi:`playwright` 1.62.0+
 * :pypi:`sqlparse` 0.5.0+ (required)
 * :pypi:`tblib` 3.0.0+
 
diff --git a/docs/internals/deprecation.txt b/docs/internals/deprecation.txt
index e86a456fd943..e7d68380926e 100644
--- a/docs/internals/deprecation.txt
+++ b/docs/internals/deprecation.txt
@@ -151,6 +151,9 @@ details on these changes.
 * The ``django.db.transaction.savepoint()`` alias to
   ``django.db.transaction.savepoint_create()`` will be removed.
 
+* Support for ``Model.from_db()`` methods that do not accept the
+  ``fetch_mode`` keyword argument will be removed.
+
 .. _deprecation-removed-in-6.1:
 
 6.1
diff --git a/docs/intro/contributing.txt b/docs/intro/contributing.txt
index f2714fed6e82..bb38c83f09f0 100644
--- a/docs/intro/contributing.txt
+++ b/docs/intro/contributing.txt
@@ -244,7 +244,7 @@ __ https://djangoci.com
     is sufficient, however, it's possible (and sometimes necessary) to
     :ref:`run the tests using a different database
     <running-unit-tests-settings>`. When making UI changes, you will need to
-    :ref:`run the Selenium tests <running-selenium-tests>`.
+    :ref:`run the Playwright tests <running-playwright-tests>`.
 
 Working on an approved new feature
 ==================================
diff --git a/docs/ref/models/instances.txt b/docs/ref/models/instances.txt
index 83e2e97e8579..bfe90671c1c5 100644
--- a/docs/ref/models/instances.txt
+++ b/docs/ref/models/instances.txt
@@ -150,6 +150,11 @@ is done. In this case it would be possible to use a ``super()`` call in the
 
     The ``fetch_mode`` parameter was added.
 
+.. deprecated:: 6.1
+
+    Support for ``from_db()`` methods that do not accept the ``fetch_mode``
+    keyword argument is deprecated and will be removed in Django 7.0.
+
 .. _refreshing-objects:
 
 Refreshing objects from database
diff --git a/docs/releases/6.1.1.txt b/docs/releases/6.1.1.txt
index ec9affd7e790..1b7a25bb2ad9 100644
--- a/docs/releases/6.1.1.txt
+++ b/docs/releases/6.1.1.txt
@@ -34,3 +34,8 @@ Bugfixes
 * Fixed a bug in Django 6.1 where :class:`~django.db.models.DecimalField`
   without ``max_digits`` and ``decimal_places`` caused a crash when retrieving
   values on SQLite (:ticket:`37275`).
+
+* Fixed a regression in Django 6.1 that caused a crash when iterating a
+  ``QuerySet`` of a model overriding ``Model.from_db()`` without the new
+  ``fetch_mode`` keyword argument. Such overrides now work again, but are
+  deprecated and should be updated to accept ``fetch_mode`` (:ticket:`37259`).
diff --git a/docs/releases/6.1.txt b/docs/releases/6.1.txt
index e4380f4f1f77..3d7700bfc93e 100644
--- a/docs/releases/6.1.txt
+++ b/docs/releases/6.1.txt
@@ -661,6 +661,9 @@ Miscellaneous
   is deprecated. Pass an explicit field name, like
   ``values_list("pk", flat=True)``.
 
+* Support for ``Model.from_db()`` methods that do not accept the
+  ``fetch_mode`` keyword argument is deprecated.
+
 * The use of ``None`` to represent a top-level JSON scalar ``null`` when
   querying :class:`~django.db.models.JSONField` is now deprecated in favor of
   the new :class:`~django.db.models.JSONNull` expression. At the end of the
diff --git a/docs/releases/6.2.txt b/docs/releases/6.2.txt
index d0c963f10806..69d5b3b69fc3 100644
--- a/docs/releases/6.2.txt
+++ b/docs/releases/6.2.txt
@@ -277,6 +277,8 @@ backends.
   consistently returning an HTTP 403 response for staff users without the view
   or change permission regardless of whether the object exists.
 
+* The undocumented ``django.contrib.admin.tests`` module was removed.
+
 :mod:`django.contrib.gis`
 -------------------------
 
@@ -284,6 +286,11 @@ backends.
   :meth:`~django.contrib.gis.gdal.Field.as_datetime` is now a ``c_float``
   rather than a ``c_int``.
 
+Tests
+-----
+
+* The undocumented ``django.test.selenium`` module was removed.
+
 Miscellaneous
 -------------
 
diff --git a/tests/admin_changelist/tests.py b/tests/admin_changelist/tests.py
index fd1adb10b243..c81d69868ec2 100644
--- a/tests/admin_changelist/tests.py
+++ b/tests/admin_changelist/tests.py
@@ -1,11 +1,12 @@
 import datetime
 from unittest import mock
 
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.contrib import admin
 from django.contrib.admin.models import LogEntry
 from django.contrib.admin.options import IncorrectLookupParameters
 from django.contrib.admin.templatetags.admin_list import pagination, result_headers
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.admin.views.main import (
     ALL_VAR,
     IS_FACETS_VAR,
@@ -1927,8 +1928,8 @@ def test_without_for_user(self):
 
 
 @override_settings(ROOT_URLCONF="admin_changelist.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_changelist"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_changelist"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         User.objects.create_superuser(username="super", password="secret", email=None)
@@ -1937,323 +1938,253 @@ def test_add_row_selection(self):
         """
         The status line for selected rows gets updated correctly (#22038).
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
+        self.page.goto(self.live_server_url + reverse("admin:auth_user_changelist"))
 
         form_id = "#changelist-form"
 
         # Test amount of rows in the Changelist
-        rows = self.selenium.find_elements(
-            By.CSS_SELECTOR, "%s #result_list tbody tr" % form_id
-        )
-        self.assertEqual(len(rows), 1)
-        row = rows[0]
+        rows = self.page.locator("%s #result_list tbody tr" % form_id)
+        self.expect(rows).to_have_count(1)
+        row = rows.first
 
-        selection_indicator = self.selenium.find_element(
-            By.CSS_SELECTOR, "%s .action-counter" % form_id
-        )
-        all_selector = self.selenium.find_element(By.ID, "action-toggle")
-        row_selector = self.selenium.find_element(
-            By.CSS_SELECTOR,
-            "%s #result_list tbody tr:first-child .action-select" % form_id,
+        selection_indicator = self.page.locator("%s .action-counter" % form_id)
+        all_selector = self.page.locator("#action-toggle")
+        row_selector = self.page.locator(
+            "%s #result_list tbody tr:first-child .action-select" % form_id
         )
 
         # Test current selection
-        self.assertEqual(selection_indicator.text, "0 of 1 selected")
-        self.assertIs(all_selector.get_property("checked"), False)
-        self.assertEqual(row.get_attribute("class"), "")
+        self.expect(selection_indicator).to_have_text("0 of 1 selected")
+        self.expect(all_selector).not_to_be_checked()
+        self.expect(row).not_to_have_class("selected")
 
         # Select a row and check again
         row_selector.click()
-        self.assertEqual(selection_indicator.text, "1 of 1 selected")
-        self.assertIs(all_selector.get_property("checked"), True)
-        self.assertEqual(row.get_attribute("class"), "selected")
+        self.expect(selection_indicator).to_have_text("1 of 1 selected")
+        self.expect(all_selector).to_be_checked()
+        self.expect(row).to_have_class("selected")
 
         # Deselect a row and check again
         row_selector.click()
-        self.assertEqual(selection_indicator.text, "0 of 1 selected")
-        self.assertIs(all_selector.get_property("checked"), False)
-        self.assertEqual(row.get_attribute("class"), "")
+        self.expect(selection_indicator).to_have_text("0 of 1 selected")
+        self.expect(all_selector).not_to_be_checked()
+        self.expect(row).to_have_attribute("class", "")
 
     def test_modifier_allows_multiple_section(self):
         """
         Selecting a row and then selecting another row whilst holding shift
         should select all rows in-between.
         """
-        from selenium.webdriver.common.action_chains import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         Parent.objects.bulk_create([Parent(name="parent%d" % i) for i in range(5)])
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
         )
-        checkboxes = self.selenium.find_elements(
-            By.CSS_SELECTOR, "tr input.action-select"
-        )
-        self.assertEqual(len(checkboxes), 5)
-        for c in checkboxes:
-            self.assertIs(c.get_property("checked"), False)
+        checkboxes = self.page.locator("tr input.action-select")
+        self.expect(checkboxes).to_have_count(5)
+        all_checkboxes = checkboxes.all()
+        for c in all_checkboxes:
+            self.expect(c).not_to_be_checked()
         # Check first row. Hold-shift and check next-to-last row.
-        checkboxes[0].click()
-        ActionChains(self.selenium).key_down(Keys.SHIFT).click(checkboxes[-2]).key_up(
-            Keys.SHIFT
-        ).perform()
-        for c in checkboxes[:-2]:
-            self.assertIs(c.get_property("checked"), True)
-        self.assertIs(checkboxes[-1].get_property("checked"), False)
+        all_checkboxes[0].click()
+        all_checkboxes[-2].click(modifiers=["Shift"])
+        for c in all_checkboxes[:-2]:
+            self.expect(c).to_be_checked()
+        self.expect(all_checkboxes[-1]).not_to_be_checked()
 
     def test_selection_counter_is_synced_when_page_is_shown(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
+        self.page.goto(self.live_server_url + reverse("admin:auth_user_changelist"))
 
         form_id = "#changelist-form"
         first_row_checkbox_selector = (
             f"{form_id} #result_list tbody tr:first-child .action-select"
         )
         selection_indicator_selector = f"{form_id} .action-counter"
-        selection_indicator = self.selenium.find_element(
-            By.CSS_SELECTOR, selection_indicator_selector
-        )
-        row_checkbox = self.selenium.find_element(
-            By.CSS_SELECTOR, first_row_checkbox_selector
-        )
+
+        selection_indicator = self.page.locator(selection_indicator_selector)
+        row_checkbox = self.page.locator(first_row_checkbox_selector)
+
         # Select a row.
         row_checkbox.click()
-        self.assertEqual(selection_indicator.text, "1 of 1 selected")
+        self.expect(selection_indicator).to_have_text("1 of 1 selected")
         # Go to another page and get back.
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
         )
-        self.selenium.back()
+        self.page.go_back()
         # The selection indicator is synced with the selected checkboxes.
-        selection_indicator = self.selenium.find_element(
-            By.CSS_SELECTOR, selection_indicator_selector
-        )
-        row_checkbox = self.selenium.find_element(
-            By.CSS_SELECTOR, first_row_checkbox_selector
-        )
-        selected_rows = 1 if row_checkbox.is_selected() else 0
-        self.assertEqual(selection_indicator.text, f"{selected_rows} of 1 selected")
+        selection_indicator = self.page.locator(selection_indicator_selector)
+        row_checkbox = self.page.locator(first_row_checkbox_selector)
+        selected_rows = 1 if row_checkbox.is_checked() else 0
+        self.expect(selection_indicator).to_have_text(f"{selected_rows} of 1 selected")
 
     def test_select_all_across_pages(self):
-        from selenium.webdriver.common.by import By
-
         Parent.objects.bulk_create([Parent(name="parent%d" % i) for i in range(101)])
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
         )
 
-        selection_indicator = self.selenium.find_element(
-            By.CSS_SELECTOR, ".action-counter"
-        )
-        select_all_indicator = self.selenium.find_element(
-            By.CSS_SELECTOR, ".actions .all"
-        )
-        question = self.selenium.find_element(By.CSS_SELECTOR, ".actions > .question")
-        clear = self.selenium.find_element(By.CSS_SELECTOR, ".actions > .clear")
-        select_all = self.selenium.find_element(By.ID, "action-toggle")
-        select_across = self.selenium.find_elements(By.NAME, "select_across")
+        selection_indicator = self.page.locator(".action-counter").first
+        select_all_indicator = self.page.locator(".actions .all").first
+        question = self.page.locator(".actions > .question").first
+        clear = self.page.locator(".actions > .clear").first
+        select_all = self.page.locator("#action-toggle")
+        select_across = self.page.locator("[name='select_across']").all()
 
-        self.assertIs(question.is_displayed(), False)
-        self.assertIs(clear.is_displayed(), False)
-        self.assertIs(select_all.get_property("checked"), False)
+        self.expect(question).to_be_hidden()
+        self.expect(clear).to_be_hidden()
+        self.expect(select_all).not_to_be_checked()
         for hidden_input in select_across:
-            self.assertEqual(hidden_input.get_property("value"), "0")
-        self.assertIs(selection_indicator.is_displayed(), True)
-        self.assertEqual(selection_indicator.text, "0 of 100 selected")
-        self.assertIs(select_all_indicator.is_displayed(), False)
+            self.expect(hidden_input).to_have_value("0")
+        self.expect(selection_indicator).to_be_visible()
+        self.expect(selection_indicator).to_have_text("0 of 100 selected")
+        self.expect(select_all_indicator).to_be_hidden()
 
         select_all.click()
-        self.assertIs(question.is_displayed(), True)
-        self.assertIs(clear.is_displayed(), False)
-        self.assertIs(select_all.get_property("checked"), True)
+        self.expect(question).to_be_visible()
+        self.expect(clear).to_be_hidden()
+        self.expect(select_all).to_be_checked()
         for hidden_input in select_across:
-            self.assertEqual(hidden_input.get_property("value"), "0")
-        self.assertIs(selection_indicator.is_displayed(), True)
-        self.assertEqual(selection_indicator.text, "100 of 100 selected")
-        self.assertIs(select_all_indicator.is_displayed(), False)
+            self.expect(hidden_input).to_have_value("0")
+        self.expect(selection_indicator).to_be_visible()
+        self.expect(selection_indicator).to_have_text("100 of 100 selected")
+        self.expect(select_all_indicator).to_be_hidden()
 
         question.click()
-        self.assertIs(question.is_displayed(), False)
-        self.assertIs(clear.is_displayed(), True)
-        self.assertIs(select_all.get_property("checked"), True)
+        self.expect(question).to_be_hidden()
+        self.expect(clear).to_be_visible()
+        self.expect(select_all).to_be_checked()
         for hidden_input in select_across:
-            self.assertEqual(hidden_input.get_property("value"), "1")
-        self.assertIs(selection_indicator.is_displayed(), False)
-        self.assertIs(select_all_indicator.is_displayed(), True)
+            self.expect(hidden_input).to_have_value("1")
+        self.expect(selection_indicator).to_be_hidden()
+        self.expect(select_all_indicator).to_be_visible()
 
         clear.click()
-        self.assertIs(question.is_displayed(), False)
-        self.assertIs(clear.is_displayed(), False)
-        self.assertIs(select_all.get_property("checked"), False)
+        self.expect(question).to_be_hidden()
+        self.expect(clear).to_be_hidden()
+        self.expect(select_all).not_to_be_checked()
         for hidden_input in select_across:
-            self.assertEqual(hidden_input.get_property("value"), "0")
-        self.assertIs(selection_indicator.is_displayed(), True)
-        self.assertEqual(selection_indicator.text, "0 of 100 selected")
-        self.assertIs(select_all_indicator.is_displayed(), False)
+            self.expect(hidden_input).to_have_attribute("value", "0")
+        self.expect(selection_indicator).to_be_visible()
+        self.expect(selection_indicator).to_have_text("0 of 100 selected")
+        self.expect(select_all_indicator).to_be_hidden()
 
     def test_actions_warn_on_pending_edits(self):
-        from selenium.webdriver.common.by import By
-
         Parent.objects.create(name="foo")
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
         )
 
-        name_input = self.selenium.find_element(By.ID, "id_form-0-name")
-        name_input.clear()
-        name_input.send_keys("bar")
-        self.selenium.find_element(By.ID, "action-toggle").click()
-        self.selenium.find_element(By.NAME, "index").click()  # Go
-        alert = self.selenium.switch_to.alert
-        try:
-            self.assertEqual(
-                alert.text,
-                "You have unsaved changes on individual editable fields. If you "
-                "run an action, your unsaved changes will be lost.",
-            )
-        finally:
-            alert.dismiss()
+        self.page.locator("#id_form-0-name").fill("bar")
+        self.page.locator("#action-toggle").click()
 
-    def test_save_with_changes_warns_on_pending_action(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
+        self.page.once("dialog", lambda dialog: dialog.dismiss())
+        with self.page.expect_event("dialog") as dialog_info:
+            self.page.locator('[name="index"]').first.click()
+        self.assertEqual(
+            dialog_info.value.message,
+            "You have unsaved changes on individual editable fields. If you "
+            "run an action, your unsaved changes will be lost.",
+        )
 
+    def test_save_with_changes_warns_on_pending_action(self):
         Parent.objects.create(name="parent")
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
         )
 
-        name_input = self.selenium.find_element(By.ID, "id_form-0-name")
-        name_input.clear()
-        name_input.send_keys("other name")
-        Select(self.selenium.find_element(By.NAME, "action")).select_by_value(
-            "delete_selected"
-        )
-        self.selenium.find_element(By.NAME, "_save").click()
-        alert = self.selenium.switch_to.alert
-        try:
-            self.assertEqual(
-                alert.text,
-                "You have selected an action, but you haven’t saved your "
-                "changes to individual fields yet. Please click OK to save. "
-                "You’ll need to re-run the action.",
-            )
-        finally:
-            alert.dismiss()
+        self.page.locator("#id_form-0-name").fill("other name")
+        self.page.locator('[name="action"]').first.select_option("delete_selected")
 
-    def test_save_without_changes_warns_on_pending_action(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
+        self.page.once("dialog", lambda dialog: dialog.dismiss())
+        with self.page.expect_event("dialog") as dialog_info:
+            self.page.locator('[name="_save"]').first.click()
+        self.assertEqual(
+            dialog_info.value.message,
+            "You have selected an action, but you haven’t saved your "
+            "changes to individual fields yet. Please click OK to save. "
+            "You’ll need to re-run the action.",
+        )
 
+    def test_save_without_changes_warns_on_pending_action(self):
         Parent.objects.create(name="parent")
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_parent_changelist")
         )
 
-        Select(self.selenium.find_element(By.NAME, "action")).select_by_value(
-            "delete_selected"
+        self.page.locator('[name="action"]').first.select_option("delete_selected")
+
+        self.page.once("dialog", lambda dialog: dialog.dismiss())
+        with self.page.expect_event("dialog") as dialog_info:
+            self.page.locator('[name="_save"]').first.click()
+        self.assertEqual(
+            dialog_info.value.message,
+            "You have selected an action, and you haven’t made any "
+            "changes on individual fields. You’re probably looking for "
+            "the Run button rather than the Save button.",
         )
-        self.selenium.find_element(By.NAME, "_save").click()
-        alert = self.selenium.switch_to.alert
-        try:
-            self.assertEqual(
-                alert.text,
-                "You have selected an action, and you haven’t made any "
-                "changes on individual fields. You’re probably looking for "
-                "the Run button rather than the Save button.",
-            )
-        finally:
-            alert.dismiss()
 
     def test_collapse_filters(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
+        self.page.goto(self.live_server_url + reverse("admin:auth_user_changelist"))
 
         # The UserAdmin has 3 field filters by default: "staff status",
         # "superuser status", and "active".
-        details = self.selenium.find_elements(By.CSS_SELECTOR, "details")
+        details = self.page.locator("details").all()
         # All filters are opened at first.
         for detail in details:
-            self.assertTrue(detail.get_attribute("open"))
+            self.expect(detail).to_have_attribute("open")
         # Collapse "staff' and "superuser" filters.
         for detail in details[:2]:
-            summary = detail.find_element(By.CSS_SELECTOR, "summary")
-            summary.click()
-            self.assertFalse(detail.get_attribute("open"))
+            detail.locator("summary").click()
+            self.expect(detail).not_to_have_attribute("open")
         # Filters are in the same state after refresh.
-        self.selenium.refresh()
-        self.assertFalse(
-            self.selenium.find_element(
-                By.CSS_SELECTOR, "[data-filter-title='staff status']"
-            ).get_attribute("open")
-        )
-        self.assertFalse(
-            self.selenium.find_element(
-                By.CSS_SELECTOR, "[data-filter-title='superuser status']"
-            ).get_attribute("open")
-        )
-        self.assertTrue(
-            self.selenium.find_element(
-                By.CSS_SELECTOR, "[data-filter-title='active']"
-            ).get_attribute("open")
-        )
+        self.page.reload()
+        self.expect(
+            self.page.locator("[data-filter-title='staff status']")
+        ).not_to_have_attribute("open")
+        self.expect(
+            self.page.locator("[data-filter-title='superuser status']")
+        ).not_to_have_attribute("open")
+        self.expect(
+            self.page.locator("[data-filter-title='active']")
+        ).to_have_attribute("open")
         # Collapse a filter on another view (Bands).
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_band_changelist")
         )
-        self.selenium.find_element(By.CSS_SELECTOR, "summary").click()
+        self.page.locator("summary").click()
         # Go to Users view and then, back again to Bands view.
-        self.selenium.get(self.live_server_url + reverse("admin:auth_user_changelist"))
-        self.selenium.get(
+        self.page.goto(self.live_server_url + reverse("admin:auth_user_changelist"))
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_changelist_band_changelist")
         )
         # The filter remains in the same state.
-        self.assertFalse(
-            self.selenium.find_element(
-                By.CSS_SELECTOR,
-                "[data-filter-title='number of members']",
-            ).get_attribute("open")
-        )
+        self.expect(
+            self.page.locator("[data-filter-title='number of members']")
+        ).not_to_have_attribute("open")
 
     def test_collapse_filter_with_unescaped_title(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
         changelist_url = reverse("admin:admin_changelist_proxyuser_changelist")
-        self.selenium.get(self.live_server_url + changelist_url)
+        self.page.goto(self.live_server_url + changelist_url)
         # Title is escaped.
-        filter_title = self.selenium.find_element(
-            By.CSS_SELECTOR, "[data-filter-title='It\\'s OK']"
-        )
-        filter_title.find_element(By.CSS_SELECTOR, "summary").click()
-        self.assertFalse(filter_title.get_attribute("open"))
+        filter_title = self.page.locator("[data-filter-title='It\\'s OK']")
+        filter_title.locator("summary").click()
+        self.expect(filter_title).not_to_have_attribute("open")
         # Filter is in the same state after refresh.
-        self.selenium.refresh()
-        self.assertFalse(
-            self.selenium.find_element(
-                By.CSS_SELECTOR, "[data-filter-title='It\\'s OK']"
-            ).get_attribute("open")
-        )
+        self.page.reload()
+        self.expect(
+            self.page.locator("[data-filter-title='It\\'s OK']")
+        ).not_to_have_attribute("open")
 
     def test_list_display_ordering(self):
-        from selenium.webdriver.common.by import By
-
         parent_a = Parent.objects.create(name="Parent A")
         child_l = Child.objects.create(name="Child L", parent=None)
         child_m = Child.objects.create(name="Child M", parent=parent_a)
@@ -2263,12 +2194,15 @@ def test_list_display_ordering(self):
 
         self.admin_login(username="super", password="secret")
         changelist_url = reverse("admin:admin_changelist_grandchild_changelist")
-        self.selenium.get(self.live_server_url + changelist_url)
+        self.page.goto(self.live_server_url + changelist_url)
 
         def find_result_row_texts():
-            table = self.selenium.find_element(By.ID, "result_list")
+            table = self.page.locator("#result_list")
             # Drop header from the result list
-            return [row.text for row in table.find_elements(By.TAG_NAME, "tr")][1:]
+            return [
+                row.inner_text().replace("\t", " ").strip()
+                for row in table.locator("tr").all()[1:]
+            ]
 
         def expected_from_queryset(qs):
             return [
@@ -2300,7 +2234,8 @@ def expected_from_queryset(qs):
         ]
         for css_selector, ordering in cases:
             with self.subTest(ordering=ordering):
-                self.selenium.find_element(By.CSS_SELECTOR, css_selector).click()
+                self.page.locator(css_selector).click()
+                self.page.wait_for_load_state("load")
                 expected = expected_from_queryset(
                     GrandChild.objects.all().order_by(*ordering)
                 )
diff --git a/tests/admin_inlines/tests.py b/tests/admin_inlines/tests.py
index e27dc919498a..7ec2b5e09fe9 100644
--- a/tests/admin_inlines/tests.py
+++ b/tests/admin_inlines/tests.py
@@ -1,10 +1,12 @@
+import re
+
+from playwright_tests import AdminPlaywrightTestCase, screenshot_cases
+
 from django.contrib.admin import ModelAdmin, TabularInline
 from django.contrib.admin.helpers import InlineAdminForm
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.auth.models import Permission, User
 from django.contrib.contenttypes.models import ContentType
 from django.test import RequestFactory, TestCase, override_settings
-from django.test.selenium import screenshot_cases
 from django.urls import reverse
 from django.utils.translation import gettext
 
@@ -1953,8 +1955,8 @@ def test_inline_headings(self):
 
 
 @override_settings(ROOT_URLCONF="admin_inlines.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_inlines"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_inlines"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         User.objects.create_superuser(
@@ -1966,182 +1968,144 @@ def test_add_stackeds(self):
         """
         The "Add another XXX" link correctly adds items to the stacked formset.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_holder4_add")
         )
 
         inline_id = "#inner4stacked_set-group"
         rows_selector = "%s .dynamic-inner4stacked_set" % inline_id
 
-        self.assertCountSeleniumElements(rows_selector, 3)
-        add_button = self.selenium.find_element(
-            By.LINK_TEXT, "Add another Inner4 stacked"
-        )
+        self.expect(self.page.locator(rows_selector)).to_have_count(3)
+        add_button = self.page.get_by_role("button", name="Add another Inner4 stacked")
         add_button.click()
-        self.assertCountSeleniumElements(rows_selector, 4)
+        self.expect(self.page.locator(rows_selector)).to_have_count(4)
         self.take_screenshot("added")
 
     def test_delete_stackeds(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_holder4_add")
         )
 
         inline_id = "#inner4stacked_set-group"
         rows_selector = "%s .dynamic-inner4stacked_set" % inline_id
 
-        self.assertCountSeleniumElements(rows_selector, 3)
+        self.expect(self.page.locator(rows_selector)).to_have_count(3)
 
-        add_button = self.selenium.find_element(
-            By.LINK_TEXT, "Add another Inner4 stacked"
-        )
+        add_button = self.page.get_by_role("button", name="Add another Inner4 stacked")
         add_button.click()
         add_button.click()
 
-        self.assertCountSeleniumElements(rows_selector, 5)
-        for delete_link in self.selenium.find_elements(
-            By.CSS_SELECTOR, "%s .inline-deletelink" % inline_id
-        ):
-            delete_link.click()
-        with self.disable_implicit_wait():
-            self.assertCountSeleniumElements(rows_selector, 0)
+        self.expect(self.page.locator(rows_selector)).to_have_count(5)
+        delete_links = self.page.locator("%s .inline-deletelink" % inline_id)
+        for _ in range(delete_links.count()):
+            delete_links.first.click()
+        self.expect(self.page.locator(rows_selector)).to_have_count(0)
 
     def test_delete_invalid_stacked_inlines(self):
-        from selenium.common.exceptions import NoSuchElementException
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_holder4_add")
         )
 
         inline_id = "#inner4stacked_set-group"
         rows_selector = "%s .dynamic-inner4stacked_set" % inline_id
 
-        self.assertCountSeleniumElements(rows_selector, 3)
+        self.expect(self.page.locator(rows_selector)).to_have_count(3)
 
-        add_button = self.selenium.find_element(
-            By.LINK_TEXT,
-            "Add another Inner4 stacked",
+        add_button = self.page.get_by_role(
+            "button",
+            name="Add another Inner4 stacked",
         )
         add_button.click()
         add_button.click()
-        self.assertCountSeleniumElements("#id_inner4stacked_set-4-dummy", 1)
+        self.expect(self.page.locator("#id_inner4stacked_set-4-dummy")).to_have_count(1)
 
         # Enter some data and click 'Save'.
-        self.selenium.find_element(By.NAME, "dummy").send_keys("1")
-        self.selenium.find_element(By.NAME, "inner4stacked_set-0-dummy").send_keys(
-            "100"
-        )
-        self.selenium.find_element(By.NAME, "inner4stacked_set-1-dummy").send_keys(
-            "101"
-        )
-        self.selenium.find_element(By.NAME, "inner4stacked_set-2-dummy").send_keys(
-            "222"
-        )
-        self.selenium.find_element(By.NAME, "inner4stacked_set-3-dummy").send_keys(
-            "103"
-        )
-        self.selenium.find_element(By.NAME, "inner4stacked_set-4-dummy").send_keys(
-            "222"
-        )
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator("[name='dummy']").fill("1")
+        self.page.locator("[name='inner4stacked_set-0-dummy']").fill("100")
+        self.page.locator("[name='inner4stacked_set-1-dummy']").fill("101")
+        self.page.locator("[name='inner4stacked_set-2-dummy']").fill("222")
+        self.page.locator("[name='inner4stacked_set-3-dummy']").fill("103")
+        self.page.locator("[name='inner4stacked_set-4-dummy']").fill("222")
+        self.page.locator('input[value="Save"]').click()
 
         # Sanity check.
-        self.assertCountSeleniumElements(rows_selector, 5)
-        errorlist = self.selenium.find_element(
-            By.CSS_SELECTOR,
+        self.expect(self.page.locator(rows_selector)).to_have_count(5)
+        errorlist = self.page.locator(
             "%s .dynamic-inner4stacked_set .errorlist li" % inline_id,
         )
-        self.assertEqual("Please correct the duplicate values below.", errorlist.text)
-        delete_link = self.selenium.find_element(
-            By.CSS_SELECTOR, "#inner4stacked_set-4 .inline-deletelink"
+        self.expect(errorlist.first).to_have_text(
+            "Please correct the duplicate values below."
         )
+        delete_link = self.page.locator("#inner4stacked_set-4 .inline-deletelink")
         delete_link.click()
-        self.assertCountSeleniumElements(rows_selector, 4)
-        with self.disable_implicit_wait(), self.assertRaises(NoSuchElementException):
-            self.selenium.find_element(
-                By.CSS_SELECTOR,
+        self.expect(self.page.locator(rows_selector)).to_have_count(4)
+        self.expect(
+            self.page.locator(
                 "%s .dynamic-inner4stacked_set .errorlist li" % inline_id,
             )
+        ).to_have_count(0)
 
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator('input[value="Save"]').click()
+        self.expect(self.page.locator(".messagelist .success")).to_contain_text(
+            "was added successfully."
+        )
 
         # The objects have been created in the database.
         self.assertEqual(Inner4Stacked.objects.count(), 4)
 
     def test_delete_invalid_tabular_inlines(self):
-        from selenium.common.exceptions import NoSuchElementException
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_holder4_add")
         )
 
         inline_id = "#inner4tabular_set-group"
         rows_selector = "%s .dynamic-inner4tabular_set" % inline_id
 
-        self.assertCountSeleniumElements(rows_selector, 3)
+        self.expect(self.page.locator(rows_selector)).to_have_count(3)
 
-        add_button = self.selenium.find_element(
-            By.LINK_TEXT, "Add another Inner4 tabular"
-        )
+        add_button = self.page.get_by_role("button", name="Add another Inner4 tabular")
         add_button.click()
         add_button.click()
-        self.assertCountSeleniumElements("#id_inner4tabular_set-4-dummy", 1)
+        self.expect(self.page.locator("#id_inner4tabular_set-4-dummy")).to_have_count(1)
 
         # Enter some data and click 'Save'.
-        self.selenium.find_element(By.NAME, "dummy").send_keys("1")
-        self.selenium.find_element(By.NAME, "inner4tabular_set-0-dummy").send_keys(
-            "100"
-        )
-        self.selenium.find_element(By.NAME, "inner4tabular_set-1-dummy").send_keys(
-            "101"
-        )
-        self.selenium.find_element(By.NAME, "inner4tabular_set-2-dummy").send_keys(
-            "222"
-        )
-        self.selenium.find_element(By.NAME, "inner4tabular_set-3-dummy").send_keys(
-            "103"
-        )
-        self.selenium.find_element(By.NAME, "inner4tabular_set-4-dummy").send_keys(
-            "222"
-        )
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator("[name='dummy']").fill("1")
+        self.page.locator("[name='inner4tabular_set-0-dummy']").fill("100")
+        self.page.locator("[name='inner4tabular_set-1-dummy']").fill("101")
+        self.page.locator("[name='inner4tabular_set-2-dummy']").fill("222")
+        self.page.locator("[name='inner4tabular_set-3-dummy']").fill("103")
+        self.page.locator("[name='inner4tabular_set-4-dummy']").fill("222")
+        self.page.locator('input[value="Save"]').click()
 
         # Sanity Check.
-        self.assertCountSeleniumElements(rows_selector, 5)
+        self.expect(self.page.locator(rows_selector)).to_have_count(5)
 
         # Non-field errorlist is in its own <tr> just before
         # tr#inner4tabular_set-3:
-        errorlist = self.selenium.find_element(
-            By.CSS_SELECTOR,
+        errorlist = self.page.locator(
             "%s #inner4tabular_set-3 + .row-form-errors .errorlist li" % inline_id,
         )
-        self.assertEqual("Please correct the duplicate values below.", errorlist.text)
-        delete_link = self.selenium.find_element(
-            By.CSS_SELECTOR, "#inner4tabular_set-4 .inline-deletelink"
+        self.expect(errorlist.first).to_have_text(
+            "Please correct the duplicate values below."
         )
+        delete_link = self.page.locator("#inner4tabular_set-4 .inline-deletelink")
         delete_link.click()
 
-        self.assertCountSeleniumElements(rows_selector, 4)
-        with self.disable_implicit_wait(), self.assertRaises(NoSuchElementException):
-            self.selenium.find_element(
-                By.CSS_SELECTOR,
+        self.expect(self.page.locator(rows_selector)).to_have_count(4)
+        self.expect(
+            self.page.locator(
                 "%s .dynamic-inner4tabular_set .errorlist li" % inline_id,
             )
+        ).to_have_count(0)
 
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator('input[value="Save"]').click()
+        self.expect(self.page.locator(".messagelist .success")).to_contain_text(
+            "was added successfully."
+        )
 
         # The objects have been created in the database.
         self.assertEqual(Inner4Tabular.objects.count(), 4)
@@ -2150,93 +2114,87 @@ def test_add_inlines(self):
         """
         The "Add another XXX" link correctly adds items to the inline form.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_profilecollection_add")
         )
 
         # There's only one inline to start with and it has the correct ID.
-        self.assertCountSeleniumElements(".dynamic-profile_set", 1)
-        self.assertEqual(
-            self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-profile_set")[
-                0
-            ].get_attribute("id"),
-            "profile_set-0",
-        )
-        self.assertCountSeleniumElements(
-            ".dynamic-profile_set#profile_set-0 input[name=profile_set-0-first_name]", 1
-        )
-        self.assertCountSeleniumElements(
-            ".dynamic-profile_set#profile_set-0 input[name=profile_set-0-last_name]", 1
-        )
+        self.expect(self.page.locator(".dynamic-profile_set")).to_have_count(1)
+        self.expect(self.page.locator(".dynamic-profile_set").first).to_have_id(
+            "profile_set-0"
+        )
+        self.expect(
+            self.page.locator(
+                ".dynamic-profile_set#profile_set-0"
+                " input[name=profile_set-0-first_name]"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                ".dynamic-profile_set#profile_set-0"
+                " input[name=profile_set-0-last_name]"
+            )
+        ).to_have_count(1)
 
         # Add an inline
-        self.selenium.find_element(By.LINK_TEXT, "Add another Profile").click()
+        self.page.get_by_role("button", name="Add another Profile").click()
 
         # The inline has been added, it has the right id, and it contains the
         # correct fields.
-        self.assertCountSeleniumElements(".dynamic-profile_set", 2)
-        self.assertEqual(
-            self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-profile_set")[
-                1
-            ].get_attribute("id"),
-            "profile_set-1",
-        )
-        self.assertCountSeleniumElements(
-            ".dynamic-profile_set#profile_set-1 input[name=profile_set-1-first_name]", 1
-        )
-        self.assertCountSeleniumElements(
-            ".dynamic-profile_set#profile_set-1 input[name=profile_set-1-last_name]", 1
-        )
+        self.expect(self.page.locator(".dynamic-profile_set")).to_have_count(2)
+        self.expect(self.page.locator(".dynamic-profile_set").nth(1)).to_have_id(
+            "profile_set-1"
+        )
+        self.expect(
+            self.page.locator(
+                ".dynamic-profile_set#profile_set-1"
+                " input[name=profile_set-1-first_name]"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                ".dynamic-profile_set#profile_set-1"
+                " input[name=profile_set-1-last_name]"
+            )
+        ).to_have_count(1)
         # Let's add another one to be sure
-        self.selenium.find_element(By.LINK_TEXT, "Add another Profile").click()
-        self.assertCountSeleniumElements(".dynamic-profile_set", 3)
-        self.assertEqual(
-            self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-profile_set")[
-                2
-            ].get_attribute("id"),
-            "profile_set-2",
-        )
-        self.assertCountSeleniumElements(
-            ".dynamic-profile_set#profile_set-2 input[name=profile_set-2-first_name]", 1
-        )
-        self.assertCountSeleniumElements(
-            ".dynamic-profile_set#profile_set-2 input[name=profile_set-2-last_name]", 1
-        )
+        self.page.get_by_role("button", name="Add another Profile").click()
+        self.expect(self.page.locator(".dynamic-profile_set")).to_have_count(3)
+        self.expect(self.page.locator(".dynamic-profile_set").nth(2)).to_have_id(
+            "profile_set-2"
+        )
+        self.expect(
+            self.page.locator(
+                ".dynamic-profile_set#profile_set-2"
+                " input[name=profile_set-2-first_name]"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                ".dynamic-profile_set#profile_set-2"
+                " input[name=profile_set-2-last_name]"
+            )
+        ).to_have_count(1)
 
         # Enter some data and click 'Save'
-        self.selenium.find_element(By.NAME, "profile_set-0-first_name").send_keys(
-            "0 first name 1"
-        )
-        self.selenium.find_element(By.NAME, "profile_set-0-last_name").send_keys(
-            "0 last name 2"
-        )
-        self.selenium.find_element(By.NAME, "profile_set-1-first_name").send_keys(
-            "1 first name 1"
-        )
-        self.selenium.find_element(By.NAME, "profile_set-1-last_name").send_keys(
-            "1 last name 2"
-        )
-        self.selenium.find_element(By.NAME, "profile_set-2-first_name").send_keys(
-            "2 first name 1"
-        )
-        self.selenium.find_element(By.NAME, "profile_set-2-last_name").send_keys(
-            "2 last name 2"
-        )
+        self.page.locator("[name='profile_set-0-first_name']").fill("0 first name 1")
+        self.page.locator("[name='profile_set-0-last_name']").fill("0 last name 2")
+        self.page.locator("[name='profile_set-1-first_name']").fill("1 first name 1")
+        self.page.locator("[name='profile_set-1-last_name']").fill("1 last name 2")
+        self.page.locator("[name='profile_set-2-first_name']").fill("2 first name 1")
+        self.page.locator("[name='profile_set-2-last_name']").fill("2 last name 2")
 
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator('input[value="Save"]').click()
+        self.expect(self.page.locator(".messagelist .success")).to_contain_text(
+            "was added successfully."
+        )
 
         # The objects have been created in the database
         self.assertEqual(ProfileCollection.objects.count(), 1)
         self.assertEqual(Profile.objects.count(), 3)
 
     def test_add_inline_link_absent_for_view_only_parent_model(self):
-        from selenium.common.exceptions import NoSuchElementException
-        from selenium.webdriver.common.by import By
-
         user = User.objects.create_user("testing", password="password", is_staff=True)
         user.user_permissions.add(
             Permission.objects.get(
@@ -2253,121 +2211,127 @@ def test_add_inline_link_absent_for_view_only_parent_model(self):
         self.admin_login(username="testing", password="password")
         poll = Poll.objects.create(name="Survey")
         change_url = reverse("admin:admin_inlines_poll_change", args=(poll.id,))
-        self.selenium.get(self.live_server_url + change_url)
-        with self.disable_implicit_wait():
-            with self.assertRaises(NoSuchElementException):
-                self.selenium.find_element(By.LINK_TEXT, "Add another Question")
+        self.page.goto(self.live_server_url + change_url)
+        self.expect(
+            self.page.get_by_role("button", name="Add another Question")
+        ).to_have_count(0)
 
     def test_delete_inlines(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_profilecollection_add")
         )
 
         # Add a few inlines
-        self.selenium.find_element(By.LINK_TEXT, "Add another Profile").click()
-        self.selenium.find_element(By.LINK_TEXT, "Add another Profile").click()
-        self.selenium.find_element(By.LINK_TEXT, "Add another Profile").click()
-        self.selenium.find_element(By.LINK_TEXT, "Add another Profile").click()
-        self.assertCountSeleniumElements(
-            "#profile_set-group table tr.dynamic-profile_set", 5
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-0", 1
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-1", 1
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-2", 1
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-3", 1
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-4", 1
-        )
+        self.page.get_by_role("button", name="Add another Profile").click()
+        self.page.get_by_role("button", name="Add another Profile").click()
+        self.page.get_by_role("button", name="Add another Profile").click()
+        self.page.get_by_role("button", name="Add another Profile").click()
+        self.expect(
+            self.page.locator("#profile_set-group table tr.dynamic-profile_set")
+        ).to_have_count(5)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-0"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-1"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-2"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-3"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-4"
+            )
+        ).to_have_count(1)
         # Click on a few delete buttons
-        self.selenium.find_element(
-            By.CSS_SELECTOR,
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-1 "
-            "td.delete a",
+        self.page.locator(
+            "form#profilecollection_form tr.dynamic-profile_set#profile_set-1"
+            " td.delete a"
         ).click()
-        self.selenium.find_element(
-            By.CSS_SELECTOR,
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-2 "
-            "td.delete a",
+        self.page.locator(
+            "form#profilecollection_form tr.dynamic-profile_set#profile_set-2"
+            " td.delete a"
         ).click()
         # The rows are gone and the IDs have been re-sequenced
-        self.assertCountSeleniumElements(
-            "#profile_set-group table tr.dynamic-profile_set", 3
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-0", 1
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-1", 1
-        )
-        self.assertCountSeleniumElements(
-            "form#profilecollection_form tr.dynamic-profile_set#profile_set-2", 1
-        )
+        self.expect(
+            self.page.locator("#profile_set-group table tr.dynamic-profile_set")
+        ).to_have_count(3)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-0"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-1"
+            )
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(
+                "form#profilecollection_form tr.dynamic-profile_set#profile_set-2"
+            )
+        ).to_have_count(1)
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_collapsed_inlines(self):
-        from selenium.webdriver.common.by import By
-
         # Collapsed inlines use details and summary elements.
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_inlines_author_add")
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_inlines_author_add"))
         # One field is in a stacked inline, other in a tabular one.
         test_fields = [
             "#id_nonautopkbook_set-0-title",
             "#id_nonautopkbook_set-2-0-title",
         ]
-        summaries = self.selenium.find_elements(By.TAG_NAME, "summary")
-        self.assertEqual(len(summaries), 3)
+        self.expect(self.page.locator("summary")).to_have_count(3)
+        summaries = self.page.locator("summary").all()
         self.take_screenshot("loaded")
         for show_index, field_name in enumerate(test_fields, 0):
-            self.wait_until_invisible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_hidden()
             summaries[show_index].click()
-            self.wait_until_visible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_visible()
         self.take_screenshot("expanded")
         for hide_index, field_name in enumerate(test_fields, 0):
-            self.wait_until_visible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_visible()
             summaries[hide_index].click()
-            self.wait_until_invisible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_hidden()
         self.take_screenshot("collapsed")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_added_stacked_inline_with_collapsed_fields(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_teacher_add")
         )
         add_text = gettext("Add another %(verbose_name)s") % {"verbose_name": "Child"}
-        self.selenium.find_element(By.LINK_TEXT, add_text).click()
+        self.page.get_by_role("button", name=add_text).click()
         test_fields = ["#id_child_set-0-name", "#id_child_set-1-name"]
-        summaries = self.selenium.find_elements(By.TAG_NAME, "summary")
-        self.assertEqual(len(summaries), 3)
+        self.expect(self.page.locator("summary")).to_have_count(3)
+        summaries = self.page.locator("summary").all()
         self.take_screenshot("loaded")
         for show_index, field_name in enumerate(test_fields, 0):
-            self.wait_until_invisible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_hidden()
             summaries[show_index].click()
-            self.wait_until_visible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_visible()
         self.take_screenshot("expanded")
         for hide_index, field_name in enumerate(test_fields, 0):
-            self.wait_until_visible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_visible()
             summaries[hide_index].click()
-            self.wait_until_invisible(field_name)
+            self.expect(self.page.locator(field_name)).to_be_hidden()
         self.take_screenshot("collapsed")
 
-    def assertBorder(self, element, border):
+    def assertBorder(self, locator, border):
         width, style, color = border.split(" ")
         border_properties = [
             "border-bottom-%s",
@@ -2376,51 +2340,44 @@ def assertBorder(self, element, border):
             "border-top-%s",
         ]
         for prop in border_properties:
-            self.assertEqual(element.value_of_css_property(prop % "width"), width)
+            self.expect(locator).to_have_css(prop % "width", width)
         for prop in border_properties:
-            self.assertEqual(element.value_of_css_property(prop % "style"), style)
+            self.expect(locator).to_have_css(prop % "style", style)
         # Convert hex color to rgb.
-        self.assertRegex(color, "#[0-9a-f]{6}")
         r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:], 16)
         # The value may be expressed as either rgb() or rgba() depending on the
         # browser.
-        colors = [
-            "rgb(%d, %d, %d)" % (r, g, b),
-            "rgba(%d, %d, %d, 1)" % (r, g, b),
-        ]
+        color_pattern = re.compile(r"rgba?\(%d, %d, %d(?:, 1)?\)" % (r, g, b))
         for prop in border_properties:
-            self.assertIn(element.value_of_css_property(prop % "color"), colors)
+            self.expect(locator).to_have_css(prop % "color", color_pattern)
 
     def test_inline_formset_error_input_border(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_holder5_add")
         )
-        self.wait_until_visible("#id_dummy")
-        self.selenium.find_element(By.ID, "id_dummy").send_keys(1)
+        self.page.locator("#id_dummy").fill("1")
         fields = ["id_inner5stacked_set-0-dummy", "id_inner5tabular_set-0-dummy"]
-        summaries = self.selenium.find_elements(By.TAG_NAME, "summary")
+        self.expect(self.page.locator("summary")).to_have_count(2)
+        summaries = self.page.locator("summary").all()
         for show_index, field_name in enumerate(fields):
             summaries[show_index].click()
-            self.wait_until_visible("#" + field_name)
-            self.selenium.find_element(By.ID, field_name).send_keys(1)
+            self.page.locator("#" + field_name).fill("1")
 
         # Before save all inputs have default border
         for inline in ("stacked", "tabular"):
             for field_name in ("name", "select", "text"):
                 element_id = "id_inner5%s_set-0-%s" % (inline, field_name)
                 self.assertBorder(
-                    self.selenium.find_element(By.ID, element_id),
+                    self.page.locator("#" + element_id),
                     "1px solid #cccccc",
                 )
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator('input[value="Save"]').click()
         # Test the red border around inputs by css selectors
         stacked_selectors = [".errors input", ".errors select", ".errors textarea"]
         for selector in stacked_selectors:
             self.assertBorder(
-                self.selenium.find_element(By.CSS_SELECTOR, selector),
+                self.page.locator(selector).first,
                 "1px solid #ba2121",
             )
         tabular_selectors = [
@@ -2430,15 +2387,13 @@ def test_inline_formset_error_input_border(self):
         ]
         for selector in tabular_selectors:
             self.assertBorder(
-                self.selenium.find_element(By.CSS_SELECTOR, selector),
+                self.page.locator(selector).first,
                 "1px solid #ba2121",
             )
 
     def test_inline_formset_error(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_holder5_add")
         )
         stacked_inline_details_selector = (
@@ -2448,50 +2403,39 @@ def test_inline_formset_error(self):
             "div#inner5tabular_set-group fieldset.module.collapse details"
         )
         # Inlines without errors, both inlines collapsed
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.assertCountSeleniumElements(
-            stacked_inline_details_selector + ":not([open])", 1
-        )
-        self.assertCountSeleniumElements(
-            tabular_inline_details_selector + ":not([open])", 1
-        )
-        summaries = self.selenium.find_elements(By.TAG_NAME, "summary")
-        self.assertEqual(len(summaries), 2)
+        self.page.locator('input[value="Save"]').click()
+        self.expect(
+            self.page.locator(stacked_inline_details_selector + ":not([open])")
+        ).to_have_count(1)
+        self.expect(
+            self.page.locator(tabular_inline_details_selector + ":not([open])")
+        ).to_have_count(1)
+        self.expect(self.page.locator("summary")).to_have_count(2)
+        summaries = self.page.locator("summary").all()
 
         # Inlines with errors, both inlines expanded
         test_fields = ["#id_inner5stacked_set-0-dummy", "#id_inner5tabular_set-0-dummy"]
         for show_index, field_name in enumerate(test_fields):
             summaries[show_index].click()
-            self.wait_until_visible(field_name)
-            self.selenium.find_element(By.ID, field_name[1:]).send_keys(1)
+            self.page.locator(field_name).fill("1")
         for hide_index, field_name in enumerate(test_fields):
             summary = summaries[hide_index]
-            self.selenium.execute_script(
-                "window.scrollTo(0, %s);" % summary.location["y"]
-            )
+            summary.scroll_into_view_if_needed()
             summary.click()
-            self.wait_until_invisible(field_name)
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.assertCountSeleniumElements(stacked_inline_details_selector, 0)
-        self.assertCountSeleniumElements(tabular_inline_details_selector, 0)
+            self.expect(self.page.locator(field_name)).to_be_hidden()
+        self.page.locator('input[value="Save"]').click()
+        self.expect(self.page.locator(stacked_inline_details_selector)).to_have_count(0)
+        self.expect(self.page.locator(tabular_inline_details_selector)).to_have_count(0)
 
     def test_inlines_verbose_name(self):
         """
         The item added by the "Add another XXX" link must use the correct
         verbose_name in the inline form.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
         # Hide sidebar.
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_inlines_course_add")
-        )
-        toggle_button = self.selenium.find_element(
-            By.CSS_SELECTOR, "#toggle-nav-sidebar"
-        )
-        toggle_button.click()
+        self.page.goto(self.live_server_url + reverse("admin:admin_inlines_course_add"))
+        self.page.locator("#toggle-nav-sidebar").click()
         # Each combination of horizontal/vertical filter with stacked/tabular
         # inlines.
         tests = [
@@ -2507,50 +2451,34 @@ def test_inlines_verbose_name(self):
 
         for url_name in tests:
             with self.subTest(url=url_name):
-                self.selenium.get(self.live_server_url + reverse(url_name))
+                self.page.goto(self.live_server_url + reverse(url_name))
                 # First inline shows the verbose_name.
-                available = self.selenium.find_element(
-                    By.CSS_SELECTOR, css_available_selector % 0
-                )
-                chosen = self.selenium.find_element(
-                    By.CSS_SELECTOR, css_chosen_selector % 0
-                )
-                self.assertIn("Available attendant", available.text)
-                self.assertIn("Chosen attendant", chosen.text)
+                available = self.page.locator(css_available_selector % 0)
+                chosen = self.page.locator(css_chosen_selector % 0)
+                self.expect(available).to_contain_text("Available attendant")
+                self.expect(chosen).to_contain_text("Chosen attendant")
                 # Added inline should also have the correct verbose_name.
-                self.selenium.find_element(By.LINK_TEXT, "Add another Class").click()
-                available = self.selenium.find_element(
-                    By.CSS_SELECTOR, css_available_selector % 1
-                )
-                chosen = self.selenium.find_element(
-                    By.CSS_SELECTOR, css_chosen_selector % 1
-                )
-                self.assertIn("Available attendant", available.text)
-                self.assertIn("Chosen attendant", chosen.text)
+                self.page.get_by_role("button", name="Add another Class").click()
+                available = self.page.locator(css_available_selector % 1)
+                chosen = self.page.locator(css_chosen_selector % 1)
+                self.expect(available).to_contain_text("Available attendant")
+                self.expect(chosen).to_contain_text("Chosen attendant")
                 # Third inline should also have the correct verbose_name.
-                self.selenium.find_element(By.LINK_TEXT, "Add another Class").click()
-                available = self.selenium.find_element(
-                    By.CSS_SELECTOR, css_available_selector % 2
-                )
-                chosen = self.selenium.find_element(
-                    By.CSS_SELECTOR, css_chosen_selector % 2
-                )
-                self.assertIn("Available attendant", available.text)
-                self.assertIn("Chosen attendant", chosen.text)
+                self.page.get_by_role("button", name="Add another Class").click()
+                available = self.page.locator(css_available_selector % 2)
+                chosen = self.page.locator(css_chosen_selector % 2)
+                self.expect(available).to_contain_text("Available attendant")
+                self.expect(chosen).to_contain_text("Chosen attendant")
 
     def test_tabular_inline_layout(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_photographer_add")
         )
-        tabular_inline = self.selenium.find_element(
-            By.CSS_SELECTOR, "[data-inline-type='tabular']"
-        )
-        headers = tabular_inline.find_elements(By.TAG_NAME, "th")
-        self.assertEqual(
-            [h.get_attribute("innerText") for h in headers],
+        tabular_inline = self.page.locator("[data-inline-type='tabular']")
+        headers = tabular_inline.locator("th")
+        self.expect(headers).to_have_count(8)
+        self.expect(headers).to_have_text(
             [
                 "",
                 "IMAGE",
@@ -2561,33 +2489,27 @@ def test_tabular_inline_layout(self):
                 "UPDATED BY",
                 "DELETE?",
             ],
+            use_inner_text=True,
         )
         # There are no fieldset section names rendered.
-        self.assertNotIn("Details", tabular_inline.text)
+        self.expect(tabular_inline).not_to_contain_text("Details")
         # There are no fieldset section descriptions rendered.
-        self.assertNotIn("First group", tabular_inline.text)
-        self.assertNotIn("Second group", tabular_inline.text)
-        self.assertNotIn("Third group", tabular_inline.text)
+        self.expect(tabular_inline).not_to_contain_text("First group")
+        self.expect(tabular_inline).not_to_contain_text("Second group")
+        self.expect(tabular_inline).not_to_contain_text("Third group")
         # There are no fieldset classes applied.
-        self.assertEqual(
-            tabular_inline.find_elements(By.CSS_SELECTOR, ".collapse"),
-            [],
-        )
+        self.expect(tabular_inline.locator(".collapse")).to_have_count(0)
         # The table does not overflow the content section.
-        content = self.selenium.find_element(By.ID, "content-main")
-        tabular_wrapper = self.selenium.find_element(
-            By.CSS_SELECTOR, "div.tabular.inline-related div.wrapper"
-        )
-        self.assertGreater(
-            tabular_wrapper.find_element(By.TAG_NAME, "table").size["width"],
-            tabular_wrapper.size["width"],
-        )
-        self.assertLessEqual(tabular_wrapper.size["width"], content.size["width"])
+        content = self.page.locator("#content-main")
+        tabular_wrapper = self.page.locator("div.tabular.inline-related div.wrapper")
+        table_box = tabular_wrapper.locator("table").bounding_box()
+        wrapper_box = tabular_wrapper.bounding_box()
+        content_box = content.bounding_box()
+        self.assertGreater(table_box["width"], wrapper_box["width"])
+        self.assertLessEqual(wrapper_box["width"], content_box["width"])
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_tabular_inline_delete_layout(self):
-        from selenium.webdriver.common.by import By
-
         user = User.objects.create_user("testing", password="password", is_staff=True)
         et_permission = Permission.objects.filter(
             content_type=ContentType.objects.get_for_model(ExtraTerrestrial),
@@ -2600,61 +2522,50 @@ def test_tabular_inline_delete_layout(self):
         self.admin_login(username="testing", password="password")
         cf = ExtraTerrestrial.objects.create(name="test")
         url = reverse("admin:admin_inlines_extraterrestrial_change", args=(cf.pk,))
-        self.selenium.get(self.live_server_url + url)
-        headers = self.selenium.find_elements(
-            By.CSS_SELECTOR, "fieldset.module thead tr th"
-        )
-        self.assertHTMLEqual(headers[-1].get_attribute("outerHTML"), "<th></th>")
-        delete = self.selenium.find_element(
-            By.CSS_SELECTOR,
-            "fieldset.module tbody tr.dynamic-sighting_set:not(.original) td.delete",
-        )
-        self.assertIn(
-            '<a role="button" class="inline-deletelink" href="#">',
-            delete.get_attribute("innerHTML"),
-        )
+        self.page.goto(self.live_server_url + url)
+        headers = self.page.locator("fieldset.module thead tr th")
+        self.expect(headers.last).to_have_text("")
+        delete = self.page.locator(
+            "fieldset.module tbody" " tr.dynamic-sighting_set:not(.original) td.delete",
+        ).first
+        self.expect(
+            delete.locator('a.inline-deletelink[role="button"]')
+        ).to_be_visible()
         self.take_screenshot("loaded")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_tabular_inline_object_with_show_change_link(self):
-        from selenium.webdriver.common.by import By
-
         et = ExtraTerrestrial.objects.create(name="test")
         Sighting.objects.create(et=et, place="Desert")
         self.admin_login(username="super", password="secret")
         url = reverse("admin:admin_inlines_extraterrestrial_change", args=(et.pk,))
-        self.selenium.get(self.live_server_url + url)
-        object_str = self.selenium.find_element(
-            By.CSS_SELECTOR, "fieldset.module tbody tr td.original p"
-        )
-        self.assertTrue(object_str.is_displayed())
-        self.assertIn("Desert", object_str.text)
+        self.page.goto(self.live_server_url + url)
+        object_str = self.page.locator("fieldset.module tbody tr td.original p")
+        self.expect(object_str).to_be_visible()
+        self.expect(object_str).to_contain_text("Desert")
         self.take_screenshot("tabular")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_tabular_inline_with_filter_horizontal(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_courseproxy2_add")
         )
-        m2m_widget = self.selenium.find_element(By.CSS_SELECTOR, "div.selector")
-        self.assertTrue(m2m_widget.is_displayed())
+        m2m_widget = self.page.locator("div.selector")
+        self.expect(m2m_widget).to_be_visible()
         self.take_screenshot("tabular")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_tabular_inline_m2m_widget_option_bg(self):
-        from selenium.webdriver.common.by import By
-
         Person.objects.create(firstname="Lee")
         self.admin_login(username="super", password="secret")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_inlines_courseproxy2_add")
         )
-        selector = self.selenium.find_element(By.CSS_SELECTOR, "div.selector")
-        options = selector.find_elements(By.CSS_SELECTOR, "select option")
-        self.assertGreater(len(options), 0)
-        options[0].click()
-        selector.find_element(By.CSS_SELECTOR, "p.selector-filter input").click()
+        selector = self.page.locator("div.selector")
+        select = selector.locator("select").first
+        options = select.locator("option")
+        self.expect(options.first).to_be_attached()
+        select.select_option(index=0)
+        selector.locator("p.selector-filter input").first.click()
         self.take_screenshot("focus_out")
diff --git a/tests/admin_views/admin.py b/tests/admin_views/admin.py
index fe73c049438c..63ce3904c252 100644
--- a/tests/admin_views/admin.py
+++ b/tests/admin_views/admin.py
@@ -933,7 +933,7 @@ class CustomTemplateFilterColorAdmin(admin.ModelAdmin):
     list_filter = (("warm", CustomTemplateBooleanFieldListFilter),)
 
 
-# For Selenium Prepopulated tests -------------------------------------
+# For Prepopulated tests ----------------------------------------------
 class RelatedPrepopulatedInline1(admin.StackedInline):
     fieldsets = (
         (
diff --git a/tests/admin_views/test_autocomplete_view.py b/tests/admin_views/test_autocomplete_view.py
index d9595cdb286b..c3ad4978f7fb 100644
--- a/tests/admin_views/test_autocomplete_view.py
+++ b/tests/admin_views/test_autocomplete_view.py
@@ -2,9 +2,10 @@
 import json
 from contextlib import contextmanager
 
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.contrib import admin
 from django.contrib.admin.exceptions import NotRegistered
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.admin.views.autocomplete import AutocompleteJsonView
 from django.contrib.auth.models import Permission, User
 from django.contrib.contenttypes.models import ContentType
@@ -394,8 +395,8 @@ def serialize_result(self, obj, to_field_name):
 
 
 @override_settings(ROOT_URLCONF="admin_views.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_views"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
@@ -409,191 +410,132 @@ def setUp(self):
             login_url=reverse("autocomplete_admin:index"),
         )
 
-    @contextmanager
-    def select2_ajax_wait(self, timeout=10):
-        from selenium.common.exceptions import NoSuchElementException
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support import expected_conditions as ec
-
-        yield
-        with self.disable_implicit_wait():
-            try:
-                loading_element = self.selenium.find_element(
-                    By.CSS_SELECTOR, "li.select2-results__option.loading-results"
-                )
-            except NoSuchElementException:
-                pass
-            else:
-                self.wait_until(ec.staleness_of(loading_element), timeout=timeout)
-
     def test_select(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-        from selenium.webdriver.support.ui import Select
-
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("autocomplete_admin:admin_views_answer_add")
         )
-        elem = self.selenium.find_element(By.CSS_SELECTOR, ".select2-selection")
-        with self.select2_ajax_wait():
+        elem = self.page.locator(".select2-selection")
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
             elem.click()  # Open the autocomplete dropdown.
-        results = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
-        self.assertTrue(results.is_displayed())
-        option = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results__option")
-        self.assertEqual(option.text, "No results found")
-        with self.select2_ajax_wait():
-            elem.click()  # Close the autocomplete dropdown.
+        results = self.page.locator(".select2-results")
+        self.expect(results).to_be_visible()
+        option = self.page.locator(".select2-results__option")
+        self.expect(option).to_have_text("No results found")
+        elem.click()  # Close the autocomplete dropdown.
         q1 = Question.objects.create(question="Who am I?")
         Question.objects.bulk_create(
             Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10)
         )
-        with self.select2_ajax_wait():
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
             elem.click()  # Reopen the dropdown now that some objects exist.
-        result_container = self.selenium.find_element(
-            By.CSS_SELECTOR, ".select2-results"
-        )
-        self.assertTrue(result_container.is_displayed())
+        result_container = self.page.locator(".select2-results")
+        self.expect(result_container).to_be_visible()
         # PAGINATOR_SIZE results and "Loading more results".
-        self.assertCountSeleniumElements(
-            ".select2-results__option",
-            PAGINATOR_SIZE + 1,
-            root_element=result_container,
+        self.expect(result_container.locator(".select2-results__option")).to_have_count(
+            PAGINATOR_SIZE + 1
         )
-        search = self.selenium.find_element(By.CSS_SELECTOR, ".select2-search__field")
+        search = self.page.locator(".select2-search__field")
         # Load next page of results by scrolling to the bottom of the list.
         for _ in range(PAGINATOR_SIZE + 1):
-            with self.select2_ajax_wait():
-                search.send_keys(Keys.ARROW_DOWN)
+            search.press("ArrowDown")
         # All objects are now loaded.
-        self.assertCountSeleniumElements(
-            ".select2-results__option",
-            PAGINATOR_SIZE + 11,
-            root_element=result_container,
+        self.expect(result_container.locator(".select2-results__option")).to_have_count(
+            PAGINATOR_SIZE + 11
         )
         # Limit the results with the search field.
-        with self.select2_ajax_wait():
-            search.send_keys("Who")
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
+            search.press_sequentially("Who")
             # Ajax request is delayed.
-            self.assertTrue(result_container.is_displayed())
-            self.assertCountSeleniumElements(
-                ".select2-results__option",
-                PAGINATOR_SIZE + 12,
-                root_element=result_container,
-            )
-        self.assertTrue(result_container.is_displayed())
-        self.assertCountSeleniumElements(
-            ".select2-results__option", 1, root_element=result_container
+            self.expect(result_container).to_be_visible()
+            self.expect(
+                result_container.locator(".select2-results__option")
+            ).to_have_count(PAGINATOR_SIZE + 12)
+        self.expect(result_container).to_be_visible()
+        self.expect(result_container.locator(".select2-results__option")).to_have_count(
+            1
         )
         # Select the result.
-        with self.select2_ajax_wait():
-            search.send_keys(Keys.RETURN)
-        select = Select(self.selenium.find_element(By.ID, "id_question"))
-        self.assertEqual(
-            select.first_selected_option.get_attribute("value"), str(q1.pk)
-        )
+        search.press("Enter")
+        select = self.page.locator("#id_question")
+        self.expect(select).to_have_value(str(q1.pk))
 
     def test_select_multiple(self):
-        from selenium.common import NoSuchElementException
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-        from selenium.webdriver.support.ui import Select
-
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("autocomplete_admin:admin_views_question_add")
         )
-        elem = self.selenium.find_element(By.CSS_SELECTOR, ".select2-selection")
-        with self.select2_ajax_wait():
+        elem = self.page.locator(".select2-selection")
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
             elem.click()  # Open the autocomplete dropdown.
-        results = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
-        self.assertTrue(results.is_displayed())
-        option = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results__option")
-        self.assertEqual(option.text, "No results found")
-        with self.select2_ajax_wait():
-            elem.click()  # Close the autocomplete dropdown.
+        results = self.page.locator(".select2-results")
+        self.expect(results).to_be_visible()
+        option = self.page.locator(".select2-results__option")
+        self.expect(option).to_have_text("No results found")
+        elem.click()  # Close the autocomplete dropdown.
         Question.objects.create(question="Who am I?")
         Question.objects.bulk_create(
             Question(question=str(i)) for i in range(PAGINATOR_SIZE + 10)
         )
-        with self.select2_ajax_wait():
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
             elem.click()  # Reopen the dropdown now that some objects exist.
-        result_container = self.selenium.find_element(
-            By.CSS_SELECTOR, ".select2-results"
-        )
-        self.assertIs(result_container.is_displayed(), True)
-        self.assertCountSeleniumElements(
-            ".select2-results__option",
-            PAGINATOR_SIZE + 1,
-            root_element=result_container,
+        result_container = self.page.locator(".select2-results")
+        self.expect(result_container).to_be_visible()
+        self.expect(result_container.locator(".select2-results__option")).to_have_count(
+            PAGINATOR_SIZE + 1
         )
-        search = self.selenium.find_element(By.CSS_SELECTOR, ".select2-search__field")
+        search = self.page.locator(".select2-search__field")
         # Load next page of results by scrolling to the bottom of the list.
         for _ in range(PAGINATOR_SIZE + 1):
-            with self.select2_ajax_wait():
-                search.send_keys(Keys.ARROW_DOWN)
-        self.assertCountSeleniumElements(
-            ".select2-results__option",
-            PAGINATOR_SIZE + 11,
-            root_element=result_container,
+            search.press("ArrowDown")
+        self.expect(result_container.locator(".select2-results__option")).to_have_count(
+            PAGINATOR_SIZE + 11
         )
         # Limit the results with the search field.
-        with self.select2_ajax_wait():
-            search.send_keys("Who")
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
+            search.press_sequentially("Who")
             # Ajax request is delayed.
-            self.assertIs(result_container.is_displayed(), True)
-            self.assertCountSeleniumElements(
-                ".select2-results__option",
-                PAGINATOR_SIZE + 12,
-                root_element=result_container,
-            )
-        self.assertIs(result_container.is_displayed(), True)
-
-        self.assertCountSeleniumElements(
-            ".select2-results__option", 1, root_element=result_container
+            self.expect(result_container).to_be_visible()
+            self.expect(
+                result_container.locator(".select2-results__option")
+            ).to_have_count(PAGINATOR_SIZE + 12)
+        self.expect(result_container).to_be_visible()
+        self.expect(result_container.locator(".select2-results__option")).to_have_count(
+            1
         )
-        with self.select2_ajax_wait():
-            # Select the result.
-            search.send_keys(Keys.RETURN)
-        with self.disable_implicit_wait():
-            with self.assertRaises(NoSuchElementException):
-                self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
-        with self.select2_ajax_wait():
-            # Reopen the dropdown.
+        # Select the result.
+        search.press("Enter")
+        self.expect(self.page.locator(".select2-results")).to_be_hidden()
+        # Reopen the dropdown.
+        with self.page.expect_response(lambda r: "autocomplete" in r.url):
             elem.click()
-        result_container = self.selenium.find_element(
-            By.CSS_SELECTOR, ".select2-results"
-        )
-        self.assertIs(result_container.is_displayed(), True)
-        with self.select2_ajax_wait():
-            # Add the first result to the selection.
-            search.send_keys(Keys.ARROW_DOWN)
-            search.send_keys(Keys.RETURN)
-        select = Select(self.selenium.find_element(By.ID, "id_related_questions"))
-        self.assertEqual(len(select.all_selected_options), 2)
+        result_container = self.page.locator(".select2-results")
+        self.expect(result_container).to_be_visible()
+        # Add the first result to the selection.
+        search.press("ArrowDown")
+        search.press("Enter")
+        self.expect(
+            self.page.locator("#id_related_questions option:checked")
+        ).to_have_count(2)
 
     def test_inline_add_another_widgets(self):
-        from selenium.webdriver.common.by import By
-
         def assertNoResults(row):
-            elem = row.find_element(By.CSS_SELECTOR, ".select2-selection")
-            with self.select2_ajax_wait():
+            elem = row.locator(".select2-selection")
+            with self.page.expect_response(lambda r: "autocomplete" in r.url):
                 elem.click()  # Open the autocomplete dropdown.
-            results = self.selenium.find_element(By.CSS_SELECTOR, ".select2-results")
-            self.assertTrue(results.is_displayed())
-            option = self.selenium.find_element(
-                By.CSS_SELECTOR, ".select2-results__option"
-            )
-            self.assertEqual(option.text, "No results found")
+            results = self.page.locator(".select2-results")
+            self.expect(results).to_be_visible()
+            option = self.page.locator(".select2-results__option")
+            self.expect(option).to_have_text("No results found")
 
         # Autocomplete works in rows present when the page loads.
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("autocomplete_admin:admin_views_book_add")
         )
-        rows = self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-authorship_set")
-        self.assertEqual(len(rows), 3)
-        assertNoResults(rows[0])
+        rows = self.page.locator(".dynamic-authorship_set")
+        self.expect(rows).to_have_count(3)
+        assertNoResults(rows.nth(0))
         # Autocomplete works in rows added using the "Add another" button.
-        self.selenium.find_element(By.LINK_TEXT, "Add another Authorship").click()
-        rows = self.selenium.find_elements(By.CSS_SELECTOR, ".dynamic-authorship_set")
-        self.assertEqual(len(rows), 4)
-        assertNoResults(rows[-1])
+        self.page.get_by_role("button", name="Add another Authorship").click()
+        rows = self.page.locator(".dynamic-authorship_set")
+        self.expect(rows).to_have_count(4)
+        assertNoResults(rows.last)
diff --git a/tests/admin_views/test_history_view.py b/tests/admin_views/test_history_view.py
index 4015f139f3b3..0bba782965a4 100644
--- a/tests/admin_views/test_history_view.py
+++ b/tests/admin_views/test_history_view.py
@@ -1,5 +1,8 @@
+import re
+
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.contrib.admin.models import CHANGE, LogEntry
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.auth.models import User
 from django.core.paginator import Paginator
 from django.test import TestCase, override_settings
@@ -51,8 +54,8 @@ def test_changed_message_uses_form_labels(self):
 
 
 @override_settings(ROOT_URLCONF="admin_views.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_views"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
@@ -74,38 +77,32 @@ def setUp(self):
         )
 
     def test_pagination(self):
-        from selenium.webdriver.common.by import By
-
         user_history_url = reverse("admin:auth_user_history", args=(self.superuser.pk,))
-        self.selenium.get(self.live_server_url + user_history_url)
+        self.page.goto(self.live_server_url + user_history_url)
 
-        paginator = self.selenium.find_element(By.CSS_SELECTOR, ".paginator")
-        self.assertEqual(paginator.tag_name, "nav")
-        labelledby = paginator.get_attribute("aria-labelledby")
-        description = self.selenium.find_element(By.CSS_SELECTOR, "#%s" % labelledby)
-        self.assertHTMLEqual(
-            description.get_attribute("outerHTML"),
-            '<h2 id="pagination" class="visually-hidden">Pagination user entries</h2>',
-        )
-        self.assertTrue(paginator.is_displayed())
-        aria_current_link = paginator.find_elements(By.CSS_SELECTOR, "[aria-current]")
-        self.assertEqual(len(aria_current_link), 1)
+        paginator = self.page.locator(".paginator")
+        self.expect(paginator).to_have_role("navigation")
+        self.expect(paginator).to_have_accessible_name("Pagination user entries")
+        self.expect(self.page.locator("#pagination")).to_have_class("visually-hidden")
+        self.expect(paginator).to_be_visible()
+        aria_current_link = paginator.locator("[aria-current]")
+        self.expect(aria_current_link).to_have_count(1)
         # The current page.
-        current_page_link = aria_current_link[0]
-        self.assertEqual(current_page_link.get_attribute("aria-current"), "page")
-        self.assertEqual(current_page_link.get_attribute("href"), "")
-        self.assertIn("%s entries" % LogEntry.objects.count(), paginator.text)
-        self.assertIn(str(Paginator.ELLIPSIS), paginator.text)
-        self.assertEqual(current_page_link.text, "1")
+        current_page_link = aria_current_link.first
+        self.expect(current_page_link).to_have_attribute("aria-current", "page")
+        self.expect(current_page_link).to_have_attribute("href", "")
+        self.expect(paginator).to_contain_text("%s entries" % LogEntry.objects.count())
+        self.expect(paginator).to_contain_text(str(Paginator.ELLIPSIS))
+        self.expect(current_page_link).to_have_text("1")
         # The last page.
-        last_page_link = self.selenium.find_element(By.XPATH, "//ul/li[last()]/a")
-        self.assertEqual(last_page_link.text, "11")
+        last_page_link = self.page.locator("ul > li:last-child > a")
+        self.expect(last_page_link).to_have_text("11")
         # Select the second page.
-        pages = paginator.find_elements(By.TAG_NAME, "a")
-        second_page_link = pages[1]
-        self.assertEqual(second_page_link.text, "2")
+        pages = paginator.locator("a")
+        second_page_link = pages.nth(1)
+        self.expect(second_page_link).to_have_text("2")
         second_page_link.click()
-        self.assertIn("?p=2", self.selenium.current_url)
-        rows = self.selenium.find_elements(By.CSS_SELECTOR, "#change-history tbody tr")
-        self.assertIn("Changed something 101", rows[0].text)
-        self.assertIn("Changed something 200", rows[-1].text)
+        self.expect(self.page).to_have_url(re.compile(r"\?p=2"))
+        rows = self.page.locator("#change-history tbody tr")
+        self.expect(rows.first).to_contain_text("Changed something 101")
+        self.expect(rows.last).to_contain_text("Changed something 200")
diff --git a/tests/admin_views/test_nav_sidebar.py b/tests/admin_views/test_nav_sidebar.py
index 74fd648ab0de..8dfa1d47a4b5 100644
--- a/tests/admin_views/test_nav_sidebar.py
+++ b/tests/admin_views/test_nav_sidebar.py
@@ -1,5 +1,6 @@
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.contrib import admin
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.auth.models import User
 from django.test import TestCase, override_settings
 from django.urls import path, reverse
@@ -118,8 +119,8 @@ def test_sidebar_model_name_non_ascii(self):
 
 
 @override_settings(ROOT_URLCONF="admin_views.test_nav_sidebar")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_views"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
@@ -132,102 +133,80 @@ def setUp(self):
             password="secret",
             login_url=reverse("test_with_sidebar:index"),
         )
-        self.selenium.execute_script(
-            "localStorage.removeItem('django.admin.navSidebarIsOpen')"
-        )
+        self.page.local_storage.remove_item("django.admin.navSidebarIsOpen")
 
     def test_sidebar_starts_open(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("test_with_sidebar:auth_user_changelist")
         )
-        main_element = self.selenium.find_element(By.CSS_SELECTOR, "#main")
-        self.assertIn("shifted", main_element.get_attribute("class").split())
+        main_element = self.page.locator("#main")
+        self.expect(main_element).to_contain_class("shifted")
 
     def test_sidebar_can_be_closed(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("test_with_sidebar:auth_user_changelist")
         )
-        toggle_button = self.selenium.find_element(
-            By.CSS_SELECTOR, "#toggle-nav-sidebar"
-        )
-        self.assertEqual(toggle_button.tag_name, "button")
-        self.assertEqual(toggle_button.get_attribute("aria-label"), "Toggle navigation")
-        nav_sidebar = self.selenium.find_element(By.ID, "nav-sidebar")
-        self.assertEqual(nav_sidebar.get_attribute("aria-expanded"), "true")
-        self.assertTrue(nav_sidebar.is_displayed())
+        toggle_button = self.page.locator("#toggle-nav-sidebar")
+        self.expect(toggle_button).to_have_role("button")
+        self.expect(toggle_button).to_have_accessible_name("Toggle navigation")
+        nav_sidebar = self.page.locator("#nav-sidebar")
+        self.expect(nav_sidebar).to_have_attribute("aria-expanded", "true")
+        self.expect(nav_sidebar).to_be_visible()
         toggle_button.click()
 
         # Hidden sidebar is not visible.
-        nav_sidebar = self.selenium.find_element(By.ID, "nav-sidebar")
-        self.assertEqual(nav_sidebar.get_attribute("aria-expanded"), "false")
-        self.assertFalse(nav_sidebar.is_displayed())
-        main_element = self.selenium.find_element(By.CSS_SELECTOR, "#main")
-        self.assertNotIn("shifted", main_element.get_attribute("class").split())
+        self.expect(nav_sidebar).to_have_attribute("aria-expanded", "false")
+        self.expect(nav_sidebar).to_be_hidden()
+        main_element = self.page.locator("#main")
+        self.expect(main_element).not_to_contain_class("shifted")
 
     def test_sidebar_state_persists(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("test_with_sidebar:auth_user_changelist")
         )
         self.assertIsNone(
-            self.selenium.execute_script(
-                "return localStorage.getItem('django.admin.navSidebarIsOpen')"
-            )
-        )
-        toggle_button = self.selenium.find_element(
-            By.CSS_SELECTOR, "#toggle-nav-sidebar"
+            self.page.local_storage.get_item("django.admin.navSidebarIsOpen")
         )
+        toggle_button = self.page.locator("#toggle-nav-sidebar")
         toggle_button.click()
         self.assertEqual(
-            self.selenium.execute_script(
-                "return localStorage.getItem('django.admin.navSidebarIsOpen')"
-            ),
+            self.page.local_storage.get_item("django.admin.navSidebarIsOpen"),
             "false",
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("test_with_sidebar:auth_user_changelist")
         )
-        main_element = self.selenium.find_element(By.CSS_SELECTOR, "#main")
-        self.assertNotIn("shifted", main_element.get_attribute("class").split())
+        main_element = self.page.locator("#main")
+        self.expect(main_element).not_to_contain_class("shifted")
 
-        toggle_button = self.selenium.find_element(
-            By.CSS_SELECTOR, "#toggle-nav-sidebar"
-        )
+        toggle_button = self.page.locator("#toggle-nav-sidebar")
         # Hidden sidebar is not visible.
-        nav_sidebar = self.selenium.find_element(By.ID, "nav-sidebar")
-        self.assertEqual(nav_sidebar.get_attribute("aria-expanded"), "false")
-        self.assertFalse(nav_sidebar.is_displayed())
+        nav_sidebar = self.page.locator("#nav-sidebar")
+        self.expect(nav_sidebar).to_have_attribute("aria-expanded", "false")
+        self.expect(nav_sidebar).to_be_hidden()
         toggle_button.click()
-        nav_sidebar = self.selenium.find_element(By.ID, "nav-sidebar")
-        self.assertEqual(nav_sidebar.get_attribute("aria-expanded"), "true")
-        self.assertTrue(nav_sidebar.is_displayed())
+        self.expect(nav_sidebar).to_have_attribute("aria-expanded", "true")
+        self.expect(nav_sidebar).to_be_visible()
         self.assertEqual(
-            self.selenium.execute_script(
-                "return localStorage.getItem('django.admin.navSidebarIsOpen')"
-            ),
+            self.page.local_storage.get_item("django.admin.navSidebarIsOpen"),
             "true",
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("test_with_sidebar:auth_user_changelist")
         )
-        main_element = self.selenium.find_element(By.CSS_SELECTOR, "#main")
-        self.assertIn("shifted", main_element.get_attribute("class").split())
+        main_element = self.page.locator("#main")
+        self.expect(main_element).to_contain_class("shifted")
 
     def test_sidebar_filter_persists(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("test_with_sidebar:auth_user_changelist")
         )
-        filter_value_script = (
-            "return sessionStorage.getItem('django.admin.navSidebarFilterValue')"
+        self.assertIsNone(
+            self.page.session_storage.get_item("django.admin.navSidebarFilterValue")
+        )
+        filter_input = self.page.locator("#nav-filter")
+        filter_input.fill("users")
+        self.assertEqual(
+            self.page.session_storage.get_item("django.admin.navSidebarFilterValue"),
+            "users",
         )
-        self.assertIsNone(self.selenium.execute_script(filter_value_script))
-        filter_input = self.selenium.find_element(By.CSS_SELECTOR, "#nav-filter")
-        filter_input.send_keys("users")
-        self.assertEqual(self.selenium.execute_script(filter_value_script), "users")
diff --git a/tests/admin_views/test_password_form.py b/tests/admin_views/test_password_form.py
index 15f6037d07d8..1a523afc83ab 100644
--- a/tests/admin_views/test_password_form.py
+++ b/tests/admin_views/test_password_form.py
@@ -1,13 +1,13 @@
-from django.contrib.admin.tests import AdminSeleniumTestCase
+from playwright_tests import AdminPlaywrightTestCase, screenshot_cases
+
 from django.contrib.auth.models import User
 from django.test import override_settings
-from django.test.selenium import screenshot_cases
 from django.urls import reverse
 
 
 @override_settings(ROOT_URLCONF="auth_tests.urls_admin")
-class SeleniumAuthTests(AdminSeleniumTestCase):
-    available_apps = AdminSeleniumTestCase.available_apps
+class PlaywrightAuthTests(AdminPlaywrightTestCase):
+    available_apps = AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
@@ -22,48 +22,38 @@ def test_add_new_user(self):
         Enabling/disabling the usable password field shows/hides the password
         fields when adding a user.
         """
-        from selenium.common import NoSuchElementException
-        from selenium.webdriver.common.by import By
-
         user_add_url = reverse("auth_test_admin:auth_user_add")
         self.admin_login(username="super", password="secret")
-        self.selenium.get(self.live_server_url + user_add_url)
+        self.page.goto(self.live_server_url + user_add_url)
 
-        pw_switch_on = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="usable_password"][value="true"]'
-        )
-        pw_switch_off = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="usable_password"][value="false"]'
-        )
-        password1 = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="password1"]'
-        )
-        password2 = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="password2"]'
+        pw_switch_on = self.page.locator('input[name="usable_password"][value="true"]')
+        pw_switch_off = self.page.locator(
+            'input[name="usable_password"][value="false"]'
         )
+        password1 = self.page.locator('input[name="password1"]')
+        password2 = self.page.locator('input[name="password2"]')
 
         # Default is to set a password on user creation.
-        self.assertIs(pw_switch_on.is_selected(), True)
-        self.assertIs(pw_switch_off.is_selected(), False)
+        self.expect(pw_switch_on).to_be_checked()
+        self.expect(pw_switch_off).not_to_be_checked()
 
         # The password fields are visible.
-        self.assertIs(password1.is_displayed(), True)
-        self.assertIs(password2.is_displayed(), True)
+        self.expect(password1).to_be_visible()
+        self.expect(password2).to_be_visible()
 
         # Click to disable password-based authentication.
         pw_switch_off.click()
 
         # Radio buttons are updated accordingly.
-        self.assertIs(pw_switch_on.is_selected(), False)
-        self.assertIs(pw_switch_off.is_selected(), True)
+        self.expect(pw_switch_on).not_to_be_checked()
+        self.expect(pw_switch_off).to_be_checked()
 
         # The password fields are hidden.
-        self.assertIs(password1.is_displayed(), False)
-        self.assertIs(password2.is_displayed(), False)
+        self.expect(password1).to_be_hidden()
+        self.expect(password2).to_be_hidden()
 
         # The warning message should not be shown.
-        with self.assertRaises(NoSuchElementException):
-            self.selenium.find_element(By.ID, "id_unusable_warning")
+        self.expect(self.page.locator("#id_unusable_warning")).to_have_count(0)
 
     def test_change_password_for_existing_user(self):
         """A user can have their password changed or unset.
@@ -71,84 +61,72 @@ def test_change_password_for_existing_user(self):
         Enabling/disabling the usable password field shows/hides the password
         fields and the warning about password lost.
         """
-        from selenium.webdriver.common.by import By
-
         user = User.objects.create_user(
             username="ada", password="charles", email="ada@example.com"
         )
         user_url = reverse("auth_test_admin:auth_user_password_change", args=(user.pk,))
         self.admin_login(username="super", password="secret")
-        self.selenium.get(self.live_server_url + user_url)
+        self.page.goto(self.live_server_url + user_url)
 
-        pw_switch_on = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="usable_password"][value="true"]'
-        )
-        pw_switch_off = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="usable_password"][value="false"]'
-        )
-        password1 = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="password1"]'
-        )
-        password2 = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[name="password2"]'
-        )
-        submit_set = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[type="submit"].set-password'
-        )
-        submit_unset = self.selenium.find_element(
-            By.CSS_SELECTOR, 'input[type="submit"].unset-password'
+        pw_switch_on = self.page.locator('input[name="usable_password"][value="true"]')
+        pw_switch_off = self.page.locator(
+            'input[name="usable_password"][value="false"]'
         )
+        password1 = self.page.locator('input[name="password1"]')
+        password2 = self.page.locator('input[name="password2"]')
+        submit_set = self.page.locator('input[type="submit"].set-password')
+        submit_unset = self.page.locator('input[type="submit"].unset-password')
 
         # By default password-based authentication is enabled.
-        self.assertIs(pw_switch_on.is_selected(), True)
-        self.assertIs(pw_switch_off.is_selected(), False)
+        self.expect(pw_switch_on).to_be_checked()
+        self.expect(pw_switch_off).not_to_be_checked()
 
         # The password fields are visible.
-        self.assertIs(password1.is_displayed(), True)
-        self.assertIs(password2.is_displayed(), True)
+        self.expect(password1).to_be_visible()
+        self.expect(password2).to_be_visible()
 
         # Only the set password submit button is visible.
-        self.assertIs(submit_set.is_displayed(), True)
-        self.assertIs(submit_unset.is_displayed(), False)
+        self.expect(submit_set).to_be_visible()
+        self.expect(submit_unset).to_be_hidden()
 
         # Click to disable password-based authentication.
         pw_switch_off.click()
 
         # Radio buttons are updated accordingly.
-        self.assertIs(pw_switch_on.is_selected(), False)
-        self.assertIs(pw_switch_off.is_selected(), True)
+        self.expect(pw_switch_on).not_to_be_checked()
+        self.expect(pw_switch_off).to_be_checked()
 
         # The password fields are hidden.
-        self.assertIs(password1.is_displayed(), False)
-        self.assertIs(password2.is_displayed(), False)
+        self.expect(password1).to_be_hidden()
+        self.expect(password2).to_be_hidden()
 
         # Only the unset password submit button is visible.
-        self.assertIs(submit_unset.is_displayed(), True)
-        self.assertIs(submit_set.is_displayed(), False)
+        self.expect(submit_unset).to_be_visible()
+        self.expect(submit_set).to_be_hidden()
 
         # The warning about password being lost is shown.
-        warning = self.selenium.find_element(By.ID, "id_unusable_warning")
-        self.assertIs(warning.is_displayed(), True)
+        warning = self.page.locator("#id_unusable_warning")
+        self.expect(warning).to_be_visible()
 
         # Click to enable password-based authentication.
         pw_switch_on.click()
 
         # The warning disappears.
-        self.assertIs(warning.is_displayed(), False)
+        self.expect(warning).to_be_hidden()
 
         # The password fields are shown.
-        self.assertIs(password1.is_displayed(), True)
-        self.assertIs(password2.is_displayed(), True)
+        self.expect(password1).to_be_visible()
+        self.expect(password2).to_be_visible()
 
         # Only the set password submit button is visible.
-        self.assertIs(submit_set.is_displayed(), True)
-        self.assertIs(submit_unset.is_displayed(), False)
+        self.expect(submit_set).to_be_visible()
+        self.expect(submit_unset).to_be_hidden()
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_fieldset_legend_wide_alignment(self):
         user_add_url = reverse("auth_test_admin:auth_user_add")
         self.admin_login(username="super", password="secret")
-        self.selenium.get(self.live_server_url + user_add_url)
+        self.page.goto(self.live_server_url + user_add_url)
 
         # The fieldset legend is aligned with other fields.
         self.take_screenshot("fieldset_legend_wide")
diff --git a/tests/admin_views/test_related_object_lookups.py b/tests/admin_views/test_related_object_lookups.py
index d15625efa66f..e2597058ee67 100644
--- a/tests/admin_views/test_related_object_lookups.py
+++ b/tests/admin_views/test_related_object_lookups.py
@@ -1,4 +1,5 @@
-from django.contrib.admin.tests import AdminSeleniumTestCase
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.contrib.auth.models import User
 from django.test import override_settings
 from django.urls import reverse
@@ -7,8 +8,8 @@
 
 
 @override_settings(ROOT_URLCONF="admin_views.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_views"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
@@ -19,10 +20,8 @@ def setUp(self):
         )
 
     def test_related_object_link_images_attributes(self):
-        from selenium.webdriver.common.by import By
-
         album_add_url = reverse("admin:admin_views_album_add")
-        self.selenium.get(self.live_server_url + album_add_url)
+        self.page.goto(self.live_server_url + album_add_url)
 
         tests = [
             "add_id_owner",
@@ -32,18 +31,14 @@ def test_related_object_link_images_attributes(self):
         ]
         for link_id in tests:
             with self.subTest(link_id):
-                link_image = self.selenium.find_element(
-                    By.XPATH, f'//*[@id="{link_id}"]/img'
-                )
-                self.assertEqual(link_image.get_attribute("alt"), "")
-                self.assertEqual(link_image.get_attribute("width"), "24")
-                self.assertEqual(link_image.get_attribute("height"), "24")
+                link_image = self.page.locator(f"#{link_id} img")
+                self.expect(link_image).to_have_attribute("alt", "")
+                self.expect(link_image).to_have_attribute("width", "24")
+                self.expect(link_image).to_have_attribute("height", "24")
 
     def test_related_object_lookup_link_initial_state(self):
-        from selenium.webdriver.common.by import By
-
         album_add_url = reverse("admin:admin_views_album_add")
-        self.selenium.get(self.live_server_url + album_add_url)
+        self.page.goto(self.live_server_url + album_add_url)
 
         tests = [
             "change_id_owner",
@@ -52,21 +47,16 @@ def test_related_object_lookup_link_initial_state(self):
         ]
         for link_id in tests:
             with self.subTest(link_id):
-                link = self.selenium.find_element(By.XPATH, f'//*[@id="{link_id}"]')
-                self.assertEqual(link.get_attribute("aria-disabled"), "true")
+                link = self.page.locator(f"#{link_id}")
+                self.expect(link).to_have_attribute("aria-disabled", "true")
 
     def test_related_object_lookup_link_enabled(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.select import Select
-
         album_add_url = reverse("admin:admin_views_album_add")
-        self.selenium.get(self.live_server_url + album_add_url)
+        self.page.goto(self.live_server_url + album_add_url)
 
-        select_element = self.selenium.find_element(By.XPATH, '//*[@id="id_owner"]')
-        option = Select(select_element).options[-1]
-        self.assertEqual(option.text, "super")
-        select_element.click()
-        option.click()
+        last_option = self.page.locator("#id_owner option").last
+        self.expect(last_option).to_have_text("super")
+        self.page.locator("#id_owner").select_option(label="super")
 
         tests = [
             "add_id_owner",
@@ -76,50 +66,42 @@ def test_related_object_lookup_link_enabled(self):
         ]
         for link_id in tests:
             with self.subTest(link_id):
-                link = self.selenium.find_element(By.XPATH, f'//*[@id="{link_id}"]')
-                self.assertIsNone(link.get_attribute("aria-disabled"))
+                link = self.page.locator(f"#{link_id}")
+                self.expect(link).not_to_have_attribute("aria-disabled")
 
     def test_related_object_update_with_camel_casing(self):
-        from selenium.webdriver.common.by import By
-
         add_url = reverse("admin:admin_views_camelcaserelatedmodel_add")
-        self.selenium.get(self.live_server_url + add_url)
+        self.page.goto(self.live_server_url + add_url)
         interesting_name = "A test name"
 
         # Add a new CamelCaseModel using the "+" icon next to the "fk" field.
-        self.selenium.find_element(By.ID, "add_id_fk").click()
-
-        # Switch to the add popup window.
-        self.wait_for_and_switch_to_popup()
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#add_id_fk").click()
+        popup = popup_info.value
 
         # Find the "interesting_name" field and enter a value, then save it.
-        self.selenium.find_element(By.ID, "id_interesting_name").send_keys(
-            interesting_name
-        )
-        self.selenium.find_element(By.NAME, "_save").click()
-
-        # Return to the main window.
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        popup.locator("#id_interesting_name").fill(interesting_name)
+        with popup.expect_event("close"):
+            popup.locator('input[value="Save"]').click()
 
         id_value = CamelCaseModel.objects.get(interesting_name=interesting_name).id
 
         # Check that both the "Available" m2m box and the "Fk" dropdown now
         # include the newly added CamelCaseModel instance.
-        fk_dropdown = self.selenium.find_element(By.ID, "id_fk")
+        fk_dropdown = self.page.locator("#id_fk")
         self.assertHTMLEqual(
-            fk_dropdown.get_attribute("innerHTML"),
+            fk_dropdown.inner_html(),
             f"""
             <option value="" selected="">- Select an option -</option>
             <option value="{id_value}" selected>{interesting_name}</option>
             """,
         )
         # Check the newly added instance is not also added in the "to" box.
-        m2m_to = self.selenium.find_element(By.ID, "id_m2m_to")
-        self.assertHTMLEqual(m2m_to.get_attribute("innerHTML"), "")
-        m2m_box = self.selenium.find_element(By.ID, "id_m2m_from")
+        m2m_to = self.page.locator("#id_m2m_to")
+        self.assertHTMLEqual(m2m_to.inner_html(), "")
+        m2m_box = self.page.locator("#id_m2m_from")
         self.assertHTMLEqual(
-            m2m_box.get_attribute("innerHTML"),
+            m2m_box.inner_html(),
             f"""
             <option title="{interesting_name}" value="{id_value}">
             {interesting_name}</option>
@@ -127,33 +109,31 @@ def test_related_object_update_with_camel_casing(self):
         )
 
     def test_related_object_add_js_actions(self):
-        from selenium.webdriver.common.by import By
-
         add_url = reverse("admin:admin_views_camelcaserelatedmodel_add")
-        self.selenium.get(self.live_server_url + add_url)
-        m2m_to = self.selenium.find_element(By.ID, "id_m2m_to")
-        m2m_box = self.selenium.find_element(By.ID, "id_m2m_from")
-        fk_dropdown = self.selenium.find_element(By.ID, "id_fk")
+        self.page.goto(self.live_server_url + add_url)
+        m2m_to = self.page.locator("#id_m2m_to")
+        m2m_box = self.page.locator("#id_m2m_from")
+        fk_dropdown = self.page.locator("#id_fk")
 
         # Add new related entry using +.
         name = "Bergeron"
-        self.selenium.find_element(By.ID, "add_id_m2m").click()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.ID, "id_interesting_name").send_keys(name)
-        self.selenium.find_element(By.NAME, "_save").click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#add_id_m2m").click()
+        popup = popup_info.value
+        popup.locator("#id_interesting_name").fill(name)
+        with popup.expect_event("close"):
+            popup.locator('input[value="Save"]').click()
 
         id_value = CamelCaseModel.objects.get(interesting_name=name).id
 
         # Check the new value correctly appears in the "to" box.
         self.assertHTMLEqual(
-            m2m_to.get_attribute("innerHTML"),
+            m2m_to.inner_html(),
             f"""<option title="{name}" value="{id_value}">{name}</option>""",
         )
-        self.assertHTMLEqual(m2m_box.get_attribute("innerHTML"), "")
+        self.assertHTMLEqual(m2m_box.inner_html(), "")
         self.assertHTMLEqual(
-            fk_dropdown.get_attribute("innerHTML"),
+            fk_dropdown.inner_html(),
             f"""
             <option value="" selected>- Select an option -</option>
             <option value="{id_value}">{name}</option>
@@ -161,45 +141,46 @@ def test_related_object_add_js_actions(self):
         )
 
         # Move the new value to the from box.
-        self.selenium.find_element(By.XPATH, "//*[@id='id_m2m_to']/option").click()
-        self.selenium.find_element(By.XPATH, "//*[@id='id_m2m_remove']").click()
+        self.page.locator("#id_m2m_to").select_option(value=str(id_value))
+        self.page.locator("#id_m2m_remove").click()
 
         self.assertHTMLEqual(
-            m2m_box.get_attribute("innerHTML"),
+            m2m_box.inner_html(),
             f"""<option title="{name}" value="{id_value}">{name}</option>""",
         )
-        self.assertHTMLEqual(m2m_to.get_attribute("innerHTML"), "")
+        self.assertHTMLEqual(m2m_to.inner_html(), "")
 
         # Move the new value to the to box.
-        self.selenium.find_element(By.XPATH, "//*[@id='id_m2m_from']/option").click()
-        self.selenium.find_element(By.XPATH, "//*[@id='id_m2m_add']").click()
+        self.page.locator("#id_m2m_from").select_option(value=str(id_value))
+        self.page.locator("#id_m2m_add").click()
 
-        self.assertHTMLEqual(m2m_box.get_attribute("innerHTML"), "")
+        self.assertHTMLEqual(m2m_box.inner_html(), "")
         self.assertHTMLEqual(
-            m2m_to.get_attribute("innerHTML"),
+            m2m_to.inner_html(),
             f"""<option title="{name}" value="{id_value}">{name}</option>""",
         )
 
-    def test_child_popup_not_closed_when_parent_minimized(self):
-        from selenium.common.exceptions import TimeoutException
-        from selenium.webdriver.common.by import By
-
+    def test_child_popup_not_closed_on_visibilitychange(self):
+        """
+        Child popups must not close when the parent page is hidden.
+        Refs #35943.
+        """
         album_add_url = reverse("admin:admin_views_album_add")
-        self.selenium.get(self.live_server_url + album_add_url)
+        self.page.goto(self.live_server_url + album_add_url)
 
         # Open a popup window using the "+" icon next to the "owner" field.
-        self.selenium.find_element(By.ID, "add_id_owner").click()
-        self.wait_for_and_switch_to_popup()
-
-        # Minimize the main window.
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
-        self.wait_page_ready()
-        self.selenium.minimize_window()
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#add_id_owner").click()
+        popup = popup_info.value
+        popup.wait_for_load_state("load")
+
+        self.page.evaluate("""() => {
+                Object.defineProperty(document, 'visibilityState', {
+                    get: () => 'hidden',
+                });
+                window.dispatchEvent(new Event('visibilitychange'));
+            }""")
 
         # The popup should not be closed by dismissChildPopups().
-        try:
-            self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        except TimeoutException:
-            pass  # expected
-        else:
-            self.fail("The popup was unexpectedly closed.")
+        self.page.wait_for_timeout(1000)
+        self.assertFalse(popup.is_closed())
diff --git a/tests/admin_views/test_skip_link_to_content.py b/tests/admin_views/test_skip_link_to_content.py
index a32dd8108c82..86b29771dca9 100644
--- a/tests/admin_views/test_skip_link_to_content.py
+++ b/tests/admin_views/test_skip_link_to_content.py
@@ -1,4 +1,5 @@
-from django.contrib.admin.tests import AdminSeleniumTestCase
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.contrib.auth.models import User
 from django.test import override_settings
 from django.urls import reverse
@@ -7,10 +8,12 @@
 
 
 @override_settings(ROOT_URLCONF="admin_views.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_views"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
+        if self.browser == "webkit":
+            self.skipTest("WebKit Tab key only focuses form controls, not links.")
         self.superuser = User.objects.create_superuser(
             username="super",
             password="secret",
@@ -18,10 +21,6 @@ def setUp(self):
         )
 
     def test_use_skip_link_to_content(self):
-        from selenium.webdriver.common.action_chains import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.admin_login(
             username="super",
             password="secret",
@@ -29,53 +28,44 @@ def test_use_skip_link_to_content(self):
         )
 
         # `Skip link` is not present.
-        skip_link = self.selenium.find_element(By.CLASS_NAME, "skip-to-content-link")
-        self.assertFalse(skip_link.is_displayed())
+        skip_link = self.page.locator(".skip-to-content-link")
+        self.expect(skip_link).not_to_be_in_viewport()
 
         # 1st TAB is pressed, `skip link` is shown.
-        body = self.selenium.find_element(By.TAG_NAME, "body")
-        body.send_keys(Keys.TAB)
-        self.assertTrue(skip_link.is_displayed())
+        self.page.keyboard.press("Tab")
+        self.expect(skip_link).to_be_in_viewport()
 
-        # Press RETURN to skip the navbar links (view site / documentation /
+        # Press Enter key to skip the navbar links (view site / documentation /
         # change password / log out) and focus first model in the admin_views
         # list.
-        skip_link.send_keys(Keys.RETURN)
-        self.assertFalse(skip_link.is_displayed())  # `skip link` disappear.
-        keys = [Keys.TAB, Keys.TAB]  # The 1st TAB is the section title.
-        if self.browser == "firefox":
-            # For some reason Firefox doesn't focus the section title
-            # ('ADMIN_VIEWS').
-            keys.remove(Keys.TAB)
-        body.send_keys(keys)
-        actors_a_tag = self.selenium.find_element(By.LINK_TEXT, "Actors")
-        self.assertEqual(self.selenium.switch_to.active_element, actors_a_tag)
+        self.page.keyboard.press("Enter")
+        self.expect(skip_link).not_to_be_in_viewport()  # `skip link` disappear.
+        # Firefox doesn't focus the section title ('ADMIN_VIEWS').
+        tab_count = 1 if self.browser == "firefox" else 2
+        for _ in range(tab_count):
+            self.page.keyboard.press("Tab")
+        actors_link = self.page.get_by_role("link", name="Actors")
+        self.expect(actors_link).to_be_focused()
 
         # Go to Actors changelist, skip sidebar and focus "Add actor +".
-        with self.wait_page_loaded():
-            actors_a_tag.send_keys(Keys.RETURN)
-        body = self.selenium.find_element(By.TAG_NAME, "body")
-        body.send_keys(Keys.TAB)
-        skip_link = self.selenium.find_element(By.CLASS_NAME, "skip-to-content-link")
-        self.assertTrue(skip_link.is_displayed())
-        ActionChains(self.selenium).send_keys(Keys.RETURN, Keys.TAB).perform()
+        actors_link.press("Enter")
+        self.page.wait_for_load_state("load")
+        self.page.keyboard.press("Tab")
+        skip_link = self.page.locator(".skip-to-content-link")
+        self.expect(skip_link).to_be_in_viewport()
+        self.page.keyboard.press("Enter")
+        self.page.keyboard.press("Tab")
         actors_add_url = reverse("admin:admin_views_actor_add")
-        actors_a_tag = self.selenium.find_element(
-            By.CSS_SELECTOR, f"#content [href='{actors_add_url}']"
-        )
-        self.assertEqual(self.selenium.switch_to.active_element, actors_a_tag)
+        actors_add_link = self.page.locator(f"#content [href='{actors_add_url}']")
+        self.expect(actors_add_link).to_be_focused()
 
         # Go to the Actor form and the first input will be focused
         # automatically.
-        with self.wait_page_loaded():
-            actors_a_tag.send_keys(Keys.RETURN)
-        first_input = self.selenium.find_element(By.ID, "id_name")
-        self.assertEqual(self.selenium.switch_to.active_element, first_input)
+        actors_add_link.press("Enter")
+        first_input = self.page.locator("#id_name")
+        self.expect(first_input).to_be_focused()
 
     def test_dont_use_skip_link_to_content(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.admin_login(
             username="super",
             password="secret",
@@ -83,28 +73,22 @@ def test_dont_use_skip_link_to_content(self):
         )
 
         # `Skip link` is not present.
-        skip_link = self.selenium.find_element(By.CLASS_NAME, "skip-to-content-link")
-        self.assertFalse(skip_link.is_displayed())
+        skip_link = self.page.locator(".skip-to-content-link")
+        self.expect(skip_link).not_to_be_in_viewport()
 
         # 1st TAB is pressed, `skip link` is shown.
-        body = self.selenium.find_element(By.TAG_NAME, "body")
-        body.send_keys(Keys.TAB)
-        self.assertTrue(skip_link.is_displayed())
+        self.page.keyboard.press("Tab")
+        self.expect(skip_link).to_be_in_viewport()
 
         # The 2nd TAB will focus the page title.
-        body.send_keys(Keys.TAB)
-        django_administration_title = self.selenium.find_element(
-            By.LINK_TEXT, "Django administration"
-        )
-        self.assertFalse(skip_link.is_displayed())  # `skip link` disappear.
-        self.assertEqual(
-            self.selenium.switch_to.active_element, django_administration_title
+        self.page.keyboard.press("Tab")
+        django_administration_title = self.page.get_by_role(
+            "link", name="Django administration"
         )
+        self.expect(skip_link).not_to_be_in_viewport()  # `skip link` disappear.
+        self.expect(django_administration_title).to_be_focused()
 
     def test_skip_link_with_RTL_language_doesnt_create_horizontal_scrolling(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         with override_settings(LANGUAGE_CODE="ar"):
             self.admin_login(
                 username="super",
@@ -112,31 +96,30 @@ def test_skip_link_with_RTL_language_doesnt_create_horizontal_scrolling(self):
                 login_url=reverse("admin:index"),
             )
 
-            skip_link = self.selenium.find_element(
-                By.CLASS_NAME, "skip-to-content-link"
-            )
-            body = self.selenium.find_element(By.TAG_NAME, "body")
-            body.send_keys(Keys.TAB)
-            self.assertTrue(skip_link.is_displayed())
+            self.page.goto(f"{self.live_server_url}{reverse('admin:index')}")
 
-            is_vertical_scrolleable = self.selenium.execute_script(
-                "return arguments[0].scrollHeight > arguments[0].offsetHeight;", body
+            skip_link = self.page.locator(".skip-to-content-link")
+            body = self.page.locator("body")
+            self.page.keyboard.press("Tab")
+            self.expect(skip_link).to_be_in_viewport()
+
+            is_vertical_scrolleable = body.evaluate(
+                "el => el.scrollHeight > el.offsetHeight"
             )
-            is_horizontal_scrolleable = self.selenium.execute_script(
-                "return arguments[0].scrollWidth > arguments[0].offsetWidth;", body
+            is_horizontal_scrolleable = body.evaluate(
+                "el => el.scrollWidth > el.offsetWidth"
             )
             self.assertTrue(is_vertical_scrolleable)
             self.assertFalse(is_horizontal_scrolleable)
 
     def test_skip_link_keyboard_navigation_in_changelist(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         Podcast.objects.create(name="apple", release_date="2000-09-19")
         self.admin_login(
-            username="super", password="secret", login_url=reverse("admin:index")
+            username="super",
+            password="secret",
+            login_url=reverse("admin:index"),
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_podcast_changelist")
         )
         selectors = [
@@ -148,24 +131,21 @@ def test_skip_link_keyboard_navigation_in_changelist(self):
             "table#result_list",  # table.
             "div.changelist-footer",  # footer.
         ]
-        content = self.selenium.find_element(By.ID, "content-start")
-        content.send_keys(Keys.TAB)
+        self.page.locator("#content-start").press("Tab")
 
         for selector in selectors:
             with self.subTest(selector=selector):
                 # Currently focused element.
-                focused_element = self.selenium.switch_to.active_element
-                expected_element = self.selenium.find_element(By.CSS_SELECTOR, selector)
-                element_points = self.selenium.find_elements(
-                    By.CSS_SELECTOR,
-                    f"{selector} a, {selector} input, {selector} button",
-                )
-                self.assertIn(
-                    focused_element.get_attribute("outerHTML"),
-                    expected_element.get_attribute("innerHTML"),
+                focused_outer_html = self.page.evaluate(
+                    "document.activeElement.outerHTML"
                 )
+                expected_inner_html = self.page.locator(selector).inner_html()
+                element_points = self.page.locator(
+                    f"{selector} a, {selector} input, {selector} button"
+                ).all()
+                self.assertIn(focused_outer_html, expected_inner_html)
                 # Move to the next container element via TAB.
                 for point in element_points[::-1]:
-                    if point.is_displayed():
-                        point.send_keys(Keys.TAB)
+                    if point.is_visible():
+                        point.press("Tab")
                         break
diff --git a/tests/admin_views/tests.py b/tests/admin_views/tests.py
index 77aae5ec2d46..35a8895ca534 100644
--- a/tests/admin_views/tests.py
+++ b/tests/admin_views/tests.py
@@ -1,13 +1,14 @@
 import datetime
 import os
 import re
-import sys
 import unittest
 import zoneinfo
 from http import HTTPStatus
 from unittest import mock
 from urllib.parse import parse_qsl, urljoin, urlsplit
 
+from playwright_tests import AdminPlaywrightTestCase, screenshot_cases
+
 from django import forms
 from django.contrib import admin
 from django.contrib.admin import AdminSite, ModelAdmin
@@ -15,7 +16,6 @@
 from django.contrib.admin.models import ADDITION, DELETION, LogEntry
 from django.contrib.admin.options import SOURCE_MODEL_VAR, TO_FIELD_VAR
 from django.contrib.admin.templatetags.admin_urls import add_preserved_filters
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.admin.utils import quote
 from django.contrib.admin.views.main import IS_POPUP_VAR
 from django.contrib.auth import REDIRECT_FIELD_NAME, get_permission_codename
@@ -36,7 +36,6 @@
     override_settings,
     skipUnlessDBFeature,
 )
-from django.test.selenium import screenshot_cases
 from django.test.utils import override_script_prefix
 from django.urls import NoReverseMatch, resolve, reverse
 from django.utils import formats, translation
@@ -44,6 +43,7 @@
 from django.utils.encoding import iri_to_uri
 from django.utils.html import escape
 from django.utils.http import urlencode
+from django.utils.translation import gettext as _
 
 from . import customadmin
 from .admin import CityAdmin, site, site2
@@ -6434,13 +6434,13 @@ def test_view_only_change_form(self):
         self.assertContains(response, '<div class="readonly">%s</div>' % self.p1.slug)
 
 
-def _clean_sidebar_state(driver):
-    driver.execute_script("localStorage.removeItem('django.admin.navSidebarIsOpen')")
+def _clean_sidebar_state(page):
+    page.local_storage.remove_item("django.admin.navSidebarIsOpen")
 
 
 @override_settings(ROOT_URLCONF="admin_views.urls")
-class SeleniumTests(AdminSeleniumTestCase):
-    available_apps = ["admin_views"] + AdminSeleniumTestCase.available_apps
+class PlaywrightTests(AdminPlaywrightTestCase):
+    available_apps = ["admin_views"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.superuser = User.objects.create_superuser(
@@ -6450,24 +6450,18 @@ def setUp(self):
             title="A Long Title", published=True, slug="a-long-title"
         )
 
-    @property
-    def modifier_key(self):
-        from selenium.webdriver.common.keys import Keys
-
-        return Keys.COMMAND if sys.platform == "darwin" else Keys.CONTROL
-
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_login_button_centered(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(self.live_server_url + reverse("admin:login"))
-        button = self.selenium.find_element(By.CSS_SELECTOR, ".submit-row input")
-        offset_left = button.get_property("offsetLeft")
-        offset_right = button.get_property("offsetParent").get_property(
-            "offsetWidth"
-        ) - (offset_left + button.get_property("offsetWidth"))
-        # Use assertAlmostEqual to avoid pixel rounding errors.
-        self.assertAlmostEqual(offset_left, offset_right, delta=3)
+
+        self.page.goto(self.live_server_url + reverse("admin:login"))
+        button = self.page.get_by_role("button", name=_("Log in"))
+        submit_row = self.page.locator(".submit-row")
+        submit_row_box = submit_row.bounding_box()
+        button_box = button.bounding_box()
+        submit_row_center = submit_row_box["x"] + submit_row_box["width"] / 2
+        button_center = button_box["x"] + button_box["width"] / 2
+        # Allow for subpixel layout and pixel rounding.
+        self.assertAlmostEqual(button_center, submit_row_center, delta=3)
         self.take_screenshot("login")
 
     def test_prepopulated_fields(self):
@@ -6476,212 +6470,178 @@ def test_prepopulated_fields(self):
         and with stacked and tabular inlines.
         Refs #13068, #9264, #9983, #9784.
         """
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
 
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_mainprepopulated_add")
         )
-        self.wait_for(".select2")
 
         # Main form ----------------------------------------------------------
-        self.selenium.find_element(By.ID, "id_pubdate").send_keys("2012-02-18")
-        status = self.selenium.find_element(By.ID, "id_status")
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.select_option("#id_status", "option two")
-        self.selenium.find_element(By.ID, "id_name").send_keys(
-            " the mAin nÀMë and it's awεšomeıııİ"
-        )
-        slug1 = self.selenium.find_element(By.ID, "id_slug1").get_attribute("value")
-        slug2 = self.selenium.find_element(By.ID, "id_slug2").get_attribute("value")
-        slug3 = self.selenium.find_element(By.ID, "id_slug3").get_attribute("value")
-        self.assertEqual(slug1, "the-main-name-and-its-awesomeiiii-2012-02-18")
-        self.assertEqual(slug2, "option-two-the-main-name-and-its-awesomeiiii")
-        self.assertEqual(
-            slug3, "the-main-n\xe0m\xeb-and-its-aw\u03b5\u0161ome\u0131\u0131\u0131i"
+        self.page.locator("#id_pubdate").fill("2012-02-18")
+        self.page.locator("#id_pubdate").dispatch_event("keyup")
+        self.page.locator("#id_status").select_option("option two")
+        self.page.locator("#id_name").fill(" the mAin nÀMë and it's awεšomeıııİ")
+        self.page.locator("#id_name").dispatch_event("keyup")
+        self.expect(self.page.locator("#id_slug1")).to_have_value(
+            "the-main-name-and-its-awesomeiiii-2012-02-18"
+        )
+        self.expect(self.page.locator("#id_slug2")).to_have_value(
+            "option-two-the-main-name-and-its-awesomeiiii"
+        )
+        self.expect(self.page.locator("#id_slug3")).to_have_value(
+            "the-main-n\xe0m\xeb-and-its-aw\u03b5\u0161ome\u0131\u0131\u0131i"
         )
 
         # Stacked inlines with fieldsets -------------------------------------
         # Initial inline
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-0-pubdate"
-        ).send_keys("2011-12-17")
-        status = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-0-status"
-        )
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.select_option("#id_relatedprepopulated_set-0-status", "option one")
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-0-name"
-        ).send_keys(" here is a sŤāÇkeð   inline !  ")
-        slug1 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-0-slug1"
-        ).get_attribute("value")
-        slug2 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-0-slug2"
-        ).get_attribute("value")
-        self.assertEqual(slug1, "here-is-a-stacked-inline-2011-12-17")
-        self.assertEqual(slug2, "option-one-here-is-a-stacked-inline")
-        initial_select2_inputs = self.selenium.find_elements(
-            By.CLASS_NAME, "select2-selection"
+        self.page.locator("#id_relatedprepopulated_set-0-pubdate").fill("2011-12-17")
+        self.page.locator("#id_relatedprepopulated_set-0-pubdate").dispatch_event(
+            "keyup"
+        )
+        self.page.locator("#id_relatedprepopulated_set-0-status").select_option(
+            "option one"
+        )
+        self.page.locator("#id_relatedprepopulated_set-0-name").fill(
+            " here is a sŤāÇkeð   inline !  "
         )
+        self.page.locator("#id_relatedprepopulated_set-0-name").dispatch_event("keyup")
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-0-slug1")
+        ).to_have_value("here-is-a-stacked-inline-2011-12-17")
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-0-slug2")
+        ).to_have_value("option-one-here-is-a-stacked-inline")
+
+        # Select2 inputs assertions
         # Inline formsets have empty/invisible forms.
         # Only the 4 visible select2 inputs are initialized.
-        num_initial_select2_inputs = len(initial_select2_inputs)
-        self.assertEqual(num_initial_select2_inputs, 4)
+        self.expect(self.page.locator(".select2-selection")).to_have_count(4)
 
         # Add an inline
-        self.selenium.find_elements(By.LINK_TEXT, "Add another Related prepopulated")[
-            0
-        ].click()
-        self.assertEqual(
-            len(self.selenium.find_elements(By.CLASS_NAME, "select2-selection")),
-            num_initial_select2_inputs + 2,
-        )
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-1-pubdate"
-        ).send_keys("1999-01-25")
-        status = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-1-status"
-        )
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.select_option("#id_relatedprepopulated_set-1-status", "option two")
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-1-name"
-        ).send_keys(
+        self.page.get_by_text("Add another Related prepopulated").first.click()
+        self.expect(self.page.locator(".select2-selection")).to_have_count(6)
+
+        self.page.locator("#id_relatedprepopulated_set-1-pubdate").fill("1999-01-25")
+        self.page.locator("#id_relatedprepopulated_set-1-pubdate").dispatch_event(
+            "keyup"
+        )
+        self.page.locator("#id_relatedprepopulated_set-1-status").select_option(
+            "option two"
+        )
+        self.page.locator("#id_relatedprepopulated_set-1-name").fill(
             " now you haVe anöther   sŤāÇkeð  inline with a very ... "
             "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog "
             "text... "
         )
-        slug1 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-1-slug1"
-        ).get_attribute("value")
-        slug2 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-1-slug2"
-        ).get_attribute("value")
+        self.page.locator("#id_relatedprepopulated_set-1-name").dispatch_event("keyup")
         # 50 characters maximum for slug1 field
-        self.assertEqual(slug1, "now-you-have-another-stacked-inline-with-a-very-lo")
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-1-slug1")
+        ).to_have_value("now-you-have-another-stacked-inline-with-a-very-lo")
         # 60 characters maximum for slug2 field
-        self.assertEqual(
-            slug2, "option-two-now-you-have-another-stacked-inline-with-a-very-l"
-        )
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-1-slug2")
+        ).to_have_value("option-two-now-you-have-another-stacked-inline-with-a-very-l")
 
         # Tabular inlines ----------------------------------------------------
         # Initial inline
-        status = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-0-status"
-        )
         # Fix for Firefox which does not scroll to clicked elements
-        # automatically with the Options API
-        self.selenium.execute_script("arguments[0].scrollIntoView();", status)
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-0-pubdate"
-        ).send_keys("1234-12-07")
-        self.select_option("#id_relatedprepopulated_set-2-0-status", "option two")
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-0-name"
-        ).send_keys("And now, with a tÃbűlaŘ inline !!!")
-        slug1 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-0-slug1"
-        ).get_attribute("value")
-        slug2 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-0-slug2"
-        ).get_attribute("value")
-        self.assertEqual(slug1, "and-now-with-a-tabular-inline-1234-12-07")
-        self.assertEqual(slug2, "option-two-and-now-with-a-tabular-inline")
+        # automatically with the Options API.
+        status = self.page.locator("#id_relatedprepopulated_set-2-0-status")
+        status.scroll_into_view_if_needed()
+        self.page.locator("#id_relatedprepopulated_set-2-0-pubdate").fill("1234-12-07")
+        self.page.locator("#id_relatedprepopulated_set-2-0-pubdate").dispatch_event(
+            "keyup"
+        )
+        status.select_option("option two")
+        self.page.locator("#id_relatedprepopulated_set-2-0-name").fill(
+            "And now, with a tÃbűlaŘ inline !!!"
+        )
+        self.page.locator("#id_relatedprepopulated_set-2-0-name").dispatch_event(
+            "keyup"
+        )
+
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-2-0-slug1")
+        ).to_have_value("and-now-with-a-tabular-inline-1234-12-07")
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-2-0-slug2")
+        ).to_have_value("option-two-and-now-with-a-tabular-inline")
 
         # Add an inline
         # Button may be outside the browser frame.
-        element = self.selenium.find_elements(
-            By.LINK_TEXT, "Add another Related prepopulated"
-        )[1]
-        self.selenium.execute_script("window.scrollTo(0, %s);" % element.location["y"])
-        element.click()
-        self.assertEqual(
-            len(self.selenium.find_elements(By.CLASS_NAME, "select2-selection")),
-            num_initial_select2_inputs + 4,
-        )
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-1-pubdate"
-        ).send_keys("1981-08-22")
-        status = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-1-status"
-        )
-        self.selenium.execute_script("arguments[0].scrollIntoView();", status)
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.select_option("#id_relatedprepopulated_set-2-1-status", "option one")
-        self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-1-name"
-        ).send_keys(r'tÃbűlaŘ inline with ignored ;"&*^\%$#@-/`~ characters')
-        slug1 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-1-slug1"
-        ).get_attribute("value")
-        slug2 = self.selenium.find_element(
-            By.ID, "id_relatedprepopulated_set-2-1-slug2"
-        ).get_attribute("value")
-        self.assertEqual(slug1, "tabular-inline-with-ignored-characters-1981-08-22")
-        self.assertEqual(slug2, "option-one-tabular-inline-with-ignored-characters")
+        add_link = self.page.get_by_text("Add another Related prepopulated").nth(1)
+        add_link.scroll_into_view_if_needed()
+        add_link.click()
+        self.expect(self.page.locator(".select2-selection")).to_have_count(8)
+
+        self.page.locator("#id_relatedprepopulated_set-2-1-pubdate").fill("1981-08-22")
+        self.page.locator("#id_relatedprepopulated_set-2-1-pubdate").dispatch_event(
+            "keyup"
+        )
+        status = self.page.locator("#id_relatedprepopulated_set-2-1-status")
+        status.scroll_into_view_if_needed()
+        status.select_option("option one")
+        self.page.locator("#id_relatedprepopulated_set-2-1-name").fill(
+            r'tÃbűlaŘ inline with ignored ;"&*^\%$#@-/`~ characters'
+        )
+        self.page.locator("#id_relatedprepopulated_set-2-1-name").dispatch_event(
+            "keyup"
+        )
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-2-1-slug1")
+        ).to_have_value("tabular-inline-with-ignored-characters-1981-08-22")
+        self.expect(
+            self.page.locator("#id_relatedprepopulated_set-2-1-slug2")
+        ).to_have_value("option-one-tabular-inline-with-ignored-characters")
+
         # Add an inline without an initial inline.
         # The button is outside of the browser frame.
-        self.selenium.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-        self.selenium.find_elements(By.LINK_TEXT, "Add another Related prepopulated")[
-            2
-        ].click()
-        self.assertEqual(
-            len(self.selenium.find_elements(By.CLASS_NAME, "select2-selection")),
-            num_initial_select2_inputs + 6,
-        )
+        self.page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+        self.page.get_by_text("Add another Related prepopulated").nth(2).click()
+        self.expect(self.page.locator(".select2-selection")).to_have_count(10)
+
         # Stacked Inlines without fieldsets ----------------------------------
         # Initial inline.
-        row_id = "id_relatedprepopulated_set-4-0-"
-        self.selenium.find_element(By.ID, f"{row_id}pubdate").send_keys("2011-12-12")
-        status = self.selenium.find_element(By.ID, f"{row_id}status")
-        self.selenium.execute_script("arguments[0].scrollIntoView();", status)
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.select_option(f"#{row_id}status", "option one")
-        self.selenium.find_element(By.ID, f"{row_id}name").send_keys(
-            " sŤāÇkeð  inline !  "
-        )
-        slug1 = self.selenium.find_element(By.ID, f"{row_id}slug1").get_attribute(
-            "value"
-        )
-        slug2 = self.selenium.find_element(By.ID, f"{row_id}slug2").get_attribute(
-            "value"
-        )
-        self.assertEqual(slug1, "stacked-inline-2011-12-12")
-        self.assertEqual(slug2, "option-one")
+        row_id = "#id_relatedprepopulated_set-4-0-"
+        self.page.locator(f"{row_id}pubdate").fill("2011-12-12")
+        self.page.locator(f"{row_id}pubdate").dispatch_event("keyup")
+        status = self.page.locator(f"{row_id}status")
+        status.scroll_into_view_if_needed()
+        status.select_option("option one")
+        self.page.locator(f"{row_id}name").fill(" sŤāÇkeð  inline !  ")
+        self.page.locator(f"{row_id}name").dispatch_event("keyup")
+        self.expect(self.page.locator(f"{row_id}slug1")).to_have_value(
+            "stacked-inline-2011-12-12"
+        )
+        self.expect(self.page.locator(f"{row_id}slug2")).to_have_value("option-one")
+
         # Add inline.
-        add_link = self.selenium.find_elements(
-            By.LINK_TEXT,
-            "Add another Related prepopulated",
-        )[3]
-        self.selenium.execute_script("arguments[0].scrollIntoView();", add_link)
+        add_link = self.page.get_by_text("Add another Related prepopulated").nth(3)
+        add_link.scroll_into_view_if_needed()
         add_link.click()
-        row_id = "id_relatedprepopulated_set-4-1-"
-        self.selenium.find_element(By.ID, f"{row_id}pubdate").send_keys("1999-01-20")
-        status = self.selenium.find_element(By.ID, f"{row_id}status")
-        self.selenium.execute_script("arguments[0].scrollIntoView();", status)
-        ActionChains(self.selenium).move_to_element(status).click(status).perform()
-        self.select_option(f"#{row_id}status", "option two")
-        self.selenium.find_element(By.ID, f"{row_id}name").send_keys(
+        row_id = "#id_relatedprepopulated_set-4-1-"
+        self.page.locator(f"{row_id}pubdate").fill("1999-01-20")
+        self.page.locator(f"{row_id}pubdate").dispatch_event("keyup")
+        status = self.page.locator(f"{row_id}status")
+        status.scroll_into_view_if_needed()
+        status.select_option("option two")
+        self.page.locator(f"{row_id}name").fill(
             " now you haVe anöther   sŤāÇkeð  inline with a very loooong "
         )
-        slug1 = self.selenium.find_element(By.ID, f"{row_id}slug1").get_attribute(
-            "value"
-        )
-        slug2 = self.selenium.find_element(By.ID, f"{row_id}slug2").get_attribute(
-            "value"
+        self.page.locator(f"{row_id}name").dispatch_event("keyup")
+        self.expect(self.page.locator(f"{row_id}slug1")).to_have_value(
+            "now-you-have-another-stacked-inline-with-a-very-lo"
         )
-        self.assertEqual(slug1, "now-you-have-another-stacked-inline-with-a-very-lo")
-        self.assertEqual(slug2, "option-two")
+        self.expect(self.page.locator(f"{row_id}slug2")).to_have_value("option-two")
 
         # Save and check that everything is properly stored in the database
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator('input[value="Save"]').click()
+        self.expect(self.page.locator(".messagelist .success")).to_contain_text(
+            "was added successfully."
+        )
         self.assertEqual(MainPrepopulated.objects.count(), 1)
         MainPrepopulated.objects.get(
             name=" the mAin nÀMë and it's awεšomeıııİ",
@@ -6730,8 +6690,6 @@ def test_populate_existing_object(self):
         The prepopulation works for existing objects too, as long as
         the original field is empty (#19082).
         """
-        from selenium.webdriver.common.by import By
-
         # Slugs are empty to start with.
         item = MainPrepopulated.objects.create(
             name=" this is the mAin nÀMë",
@@ -6748,28 +6706,36 @@ def test_populate_existing_object(self):
             "admin:admin_views_mainprepopulated_change", args=(item.id,)
         )
 
-        self.selenium.get(object_url)
-        self.selenium.find_element(By.ID, "id_name").send_keys(" the best")
+        self.page.goto(object_url)
+        self.page.locator("#id_name").fill(item.name + " the best")
+        self.page.locator("#id_name").dispatch_event("keyup")
 
         # The slugs got prepopulated since they were originally empty
-        slug1 = self.selenium.find_element(By.ID, "id_slug1").get_attribute("value")
-        slug2 = self.selenium.find_element(By.ID, "id_slug2").get_attribute("value")
-        self.assertEqual(slug1, "this-is-the-main-name-the-best-2012-02-18")
-        self.assertEqual(slug2, "option-two-this-is-the-main-name-the-best")
+        self.expect(self.page.locator("#id_slug1")).to_have_value(
+            "this-is-the-main-name-the-best-2012-02-18"
+        )
+        self.expect(self.page.locator("#id_slug2")).to_have_value(
+            "option-two-this-is-the-main-name-the-best"
+        )
 
         # Save the object
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+        self.page.locator('input[value="Save"]').click()
+        self.expect(self.page.locator(".messagelist .success")).to_have_text(
+            f"The main prepopulated “{item}” was changed successfully."
+        )
 
-        self.selenium.get(object_url)
-        self.selenium.find_element(By.ID, "id_name").send_keys(" hello")
+        self.page.goto(object_url)
+        self.page.locator("#id_name").fill(item.name + " the best hello")
+        self.page.locator("#id_name").dispatch_event("keyup")
 
         # The slugs got prepopulated didn't change since they were originally
         # not empty
-        slug1 = self.selenium.find_element(By.ID, "id_slug1").get_attribute("value")
-        slug2 = self.selenium.find_element(By.ID, "id_slug2").get_attribute("value")
-        self.assertEqual(slug1, "this-is-the-main-name-the-best-2012-02-18")
-        self.assertEqual(slug2, "option-two-this-is-the-main-name-the-best")
+        self.expect(self.page.locator("#id_slug1")).to_have_value(
+            "this-is-the-main-name-the-best-2012-02-18"
+        )
+        self.expect(self.page.locator("#id_slug2")).to_have_value(
+            "option-two-this-is-the-main-name-the-best"
+        )
 
     @screenshot_cases(["desktop_size", "mobile_size", "dark", "high_contrast"])
     def test_collapsible_fieldset(self):
@@ -6777,163 +6743,122 @@ def test_collapsible_fieldset(self):
         The 'collapse' class in fieldsets definition allows to
         show/hide the appropriate field section.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_views_article_add")
-        )
-        self.assertFalse(self.selenium.find_element(By.ID, "id_title").is_displayed())
+        self.page.goto(self.live_server_url + reverse("admin:admin_views_article_add"))
+        self.expect(self.page.locator("#id_title")).not_to_be_visible()
         self.take_screenshot("collapsed")
-        self.selenium.find_elements(By.TAG_NAME, "summary")[0].click()
-        self.assertTrue(self.selenium.find_element(By.ID, "id_title").is_displayed())
+        self.page.locator("summary").first.click()
+        self.expect(self.page.locator("#id_title")).to_be_visible()
         self.take_screenshot("expanded")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_selectbox_height_collapsible_fieldset(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super",
             password="secret",
             login_url=reverse("admin7:index"),
         )
-        url = self.live_server_url + reverse("admin7:admin_views_pizza_add")
-        self.selenium.get(url)
-        self.selenium.find_elements(By.TAG_NAME, "summary")[0].click()
-        available_box = self.selenium.find_element(By.CLASS_NAME, "selector-available")
-        chosen_box = self.selenium.find_element(By.CLASS_NAME, "selector-chosen")
+        self.page.goto(self.live_server_url + reverse("admin7:admin_views_pizza_add"))
+        self.page.locator("summary").first.click()
+        available_box = self.page.locator(".selector-available")
+        chosen_box = self.page.locator(".selector-chosen")
         self.assertEqual(
-            available_box.get_property("offsetHeight"),
-            chosen_box.get_property("offsetHeight"),
+            available_box.bounding_box()["height"],
+            chosen_box.bounding_box()["height"],
         )
         self.take_screenshot("selectbox-collapsible")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_selectbox_height_not_collapsible_fieldset(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super",
             password="secret",
             login_url=reverse("admin7:index"),
         )
-        url = self.live_server_url + reverse("admin7:admin_views_question_add")
-        self.selenium.get(url)
-        available_box = self.selenium.find_element(By.CLASS_NAME, "selector-available")
-        chosen_box = self.selenium.find_element(By.CLASS_NAME, "selector-chosen")
+        self.page.goto(
+            self.live_server_url + reverse("admin7:admin_views_question_add")
+        )
+        available_box = self.page.locator(".selector-available")
+        chosen_box = self.page.locator(".selector-chosen")
         self.assertEqual(
-            available_box.get_property("offsetHeight"),
-            chosen_box.get_property("offsetHeight"),
+            available_box.bounding_box()["height"],
+            chosen_box.bounding_box()["height"],
         )
         self.take_screenshot("selectbox-non-collapsible")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_selectbox_selected_rows(self):
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         # Create a new user to ensure that no extra permissions have been set.
         user = User.objects.create_user(username="new", password="newuser")
         url = self.live_server_url + reverse("admin:auth_user_change", args=[user.id])
-        self.selenium.get(url)
-        self.trigger_resize()
+        self.page.goto(url)
 
         # Scroll to the User permissions section.
-        user_permissions = self.selenium.find_element(
-            By.CSS_SELECTOR, "#id_user_permissions_from"
-        )
-        ActionChains(self.selenium).move_to_element(user_permissions).perform()
+        self.page.locator("#id_user_permissions_from").scroll_into_view_if_needed()
         self.take_screenshot("selectbox-available-perms-none-selected")
 
         # Select multiple permissions from the "Available" list.
         ct = ContentType.objects.get_for_model(Permission)
         perms = list(Permission.objects.filter(content_type=ct))
-        for perm in perms:
-            elem = self.selenium.find_element(
-                By.CSS_SELECTOR, f"#id_user_permissions_from option[value='{perm.id}']"
-            )
-            ActionChains(self.selenium).key_down(self.modifier_key).click(elem).key_up(
-                self.modifier_key
-            ).perform()
+        self.page.locator("#id_user_permissions_from").select_option(
+            value=[str(perm.id) for perm in perms]
+        )
 
         # Move focus to other element.
-        self.selenium.find_element(
-            By.CSS_SELECTOR, "#id_user_permissions_input"
-        ).click()
+        self.page.locator("#id_user_permissions_input").click()
         self.take_screenshot("selectbox-available-perms-some-selected")
 
         # Move permissions to the "Chosen" list, but none is selected yet.
-        self.selenium.find_element(By.CSS_SELECTOR, "#id_user_permissions_add").click()
+        self.page.locator("#id_user_permissions_add").click()
         self.take_screenshot("selectbox-chosen-perms-none-selected")
 
         # Select some permissions from the "Chosen" list.
-        for perm in [perms[0], perms[-1]]:
-            elem = self.selenium.find_element(
-                By.CSS_SELECTOR, f"#id_user_permissions_to option[value='{perm.id}']"
-            )
-            ActionChains(self.selenium).key_down(self.modifier_key).click(elem).key_up(
-                self.modifier_key
-            ).perform()
+        self.page.locator("#id_user_permissions_to").select_option(
+            value=[str(perms[0].id), str(perms[-1].id)]
+        )
 
         # Move focus to other element.
-        body = self.selenium.find_element(By.TAG_NAME, "body")
-        body.send_keys(Keys.TAB)
+        self.page.keyboard.press("Tab")
         self.take_screenshot("selectbox-chosen-perms-some-selected")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_first_field_focus(self):
         """JavaScript-assisted auto-focus on first usable form field."""
-        from selenium.webdriver.common.by import By
-
         # First form field has a single widget
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        with self.wait_page_loaded():
-            self.selenium.get(
-                self.live_server_url + reverse("admin:admin_views_picture_add")
-            )
-        self.assertEqual(
-            self.selenium.switch_to.active_element,
-            self.selenium.find_element(By.ID, "id_name"),
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_views_picture_add"))
+        self.expect(self.page.locator("#id_name")).to_be_focused()
         self.take_screenshot("focus-single-widget")
 
         # First form field has a MultiWidget
-        with self.wait_page_loaded():
-            self.selenium.get(
-                self.live_server_url + reverse("admin:admin_views_reservation_add")
-            )
-        self.assertEqual(
-            self.selenium.switch_to.active_element,
-            self.selenium.find_element(By.ID, "id_start_date_0"),
+        self.page.goto(
+            self.live_server_url + reverse("admin:admin_views_reservation_add")
         )
+        self.expect(self.page.locator("#id_start_date_0")).to_be_focused()
         self.take_screenshot("focus-multi-widget")
 
     def test_cancel_delete_confirmation(self):
         "Cancelling the deletion of an object takes the user back one page."
-        from selenium.webdriver.common.by import By
-
         pizza = Pizza.objects.create(name="Double Cheese")
         url = reverse("admin:admin_views_pizza_change", args=(pizza.id,))
         full_url = self.live_server_url + url
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(full_url)
-        self.selenium.find_element(By.CLASS_NAME, "deletelink").click()
+        self.page.goto(full_url)
+        self.page.locator(".deletelink").click()
         # Click 'cancel' on the delete page.
-        self.selenium.find_element(By.CLASS_NAME, "cancel-link").click()
+        self.page.locator(".cancel-link").click()
         # Wait until we're back on the change page.
-        self.wait_for_text("#content h1", "Change pizza")
-        self.assertEqual(self.selenium.current_url, full_url)
+        self.expect(self.page.locator("#content h1")).to_have_text("Change pizza")
+        self.expect(self.page).to_have_url(full_url)
         self.assertEqual(Pizza.objects.count(), 1)
 
     def test_cancel_delete_related_confirmation(self):
@@ -6941,8 +6866,6 @@ def test_cancel_delete_related_confirmation(self):
         Cancelling the deletion of an object with relations takes the user back
         one page.
         """
-        from selenium.webdriver.common.by import By
-
         pizza = Pizza.objects.create(name="Double Cheese")
         topping1 = Topping.objects.create(name="Cheddar")
         topping2 = Topping.objects.create(name="Mozzarella")
@@ -6952,13 +6875,13 @@ def test_cancel_delete_related_confirmation(self):
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(full_url)
-        self.selenium.find_element(By.CLASS_NAME, "deletelink").click()
+        self.page.goto(full_url)
+        self.page.locator(".deletelink").click()
         # Click 'cancel' on the delete page.
-        self.selenium.find_element(By.CLASS_NAME, "cancel-link").click()
+        self.page.locator(".cancel-link").click()
         # Wait until we're back on the change page.
-        self.wait_for_text("#content h1", "Change pizza")
-        self.assertEqual(self.selenium.current_url, full_url)
+        self.expect(self.page.locator("#content h1")).to_have_text("Change pizza")
+        self.expect(self.page).to_have_url(full_url)
         self.assertEqual(Pizza.objects.count(), 1)
         self.assertEqual(Topping.objects.count(), 2)
 
@@ -6966,9 +6889,6 @@ def test_list_editable_popups(self):
         """
         list_editable foreign keys have add/change popups.
         """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         s1 = Section.objects.create(name="Test section")
         Article.objects.create(
             title="foo",
@@ -6979,55 +6899,44 @@ def test_list_editable_popups(self):
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_article_changelist")
         )
         # Change popup
-        self.selenium.find_element(By.ID, "change_id_form-0-section").click()
-        self.wait_for_and_switch_to_popup()
-        self.wait_for_text("#content h1", "Change section")
-        name_input = self.selenium.find_element(By.ID, "id_name")
-        name_input.clear()
-        name_input.send_keys("<i>edited section</i>")
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#change_id_form-0-section").click()
+        popup = popup_info.value
+        self.expect(popup.locator("#content h1")).to_have_text("Change section")
+        popup.locator("#id_name").fill("<i>edited section</i>")
+        with popup.expect_event("close"):
+            popup.locator('input[value="Save"]').click()
         # Hide sidebar.
-        toggle_button = self.selenium.find_element(
-            By.CSS_SELECTOR, "#toggle-nav-sidebar"
-        )
-        toggle_button.click()
-        self.addCleanup(_clean_sidebar_state, self.selenium)
-        select = Select(self.selenium.find_element(By.ID, "id_form-0-section"))
-        self.assertEqual(select.first_selected_option.text, "<i>edited section</i>")
+        self.page.locator("#toggle-nav-sidebar").click()
+        self.addCleanup(_clean_sidebar_state, self.page)
+        selected_option = self.page.locator("#id_form-0-section option:checked")
+        self.expect(selected_option).to_have_text("<i>edited section</i>")
         # Rendered select2 input.
-        select2_display = self.selenium.find_element(
-            By.CLASS_NAME, "select2-selection__rendered"
+        select2_display = self.page.locator(".select2-selection__rendered")
+        # Clear button (×) is included in text whereas \n is browser-dependent.
+        self.expect(select2_display).to_have_text(
+            re.compile(r"^×\n?<i>edited section</i>$")
         )
-        # Clear button (×\n) is included in text.
-        self.assertEqual(select2_display.text, "×\n<i>edited section</i>")
 
         # Add popup
-        self.selenium.find_element(By.ID, "add_id_form-0-section").click()
-        self.wait_for_and_switch_to_popup()
-        self.wait_for_text("#content h1", "Add section")
-        self.selenium.find_element(By.ID, "id_name").send_keys("new section")
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
-        select = Select(self.selenium.find_element(By.ID, "id_form-0-section"))
-        self.assertEqual(select.first_selected_option.text, "new section")
-        select2_display = self.selenium.find_element(
-            By.CLASS_NAME, "select2-selection__rendered"
-        )
-        # Clear button (×\n) is included in text.
-        self.assertEqual(select2_display.text, "×\nnew section")
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#add_id_form-0-section").click()
+        popup = popup_info.value
+        self.expect(popup.locator("#content h1")).to_have_text("Add section")
+        popup.locator("#id_name").fill("new section")
+        with popup.expect_event("close"):
+            popup.locator('input[value="Save"]').click()
+        selected_option = self.page.locator("#id_form-0-section option:checked")
+        self.expect(selected_option).to_have_text("new section")
+        select2_display = self.page.locator(".select2-selection__rendered")
+        # Clear button (×) is included in text whereas \n is browser-dependent.
+        self.expect(select2_display).to_have_text(re.compile(r"^×\n?new section$"))
 
     def test_inline_uuid_pk_edit_with_popup(self):
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         parent = ParentWithUUIDPK.objects.create(title="test")
         related_with_parent = RelatedWithUUIDPKModel.objects.create(parent=parent)
         self.admin_login(
@@ -7037,46 +6946,36 @@ def test_inline_uuid_pk_edit_with_popup(self):
             "admin:admin_views_relatedwithuuidpkmodel_change",
             args=(related_with_parent.id,),
         )
-        with self.wait_page_loaded():
-            self.selenium.get(self.live_server_url + change_url)
-        change_parent = self.selenium.find_element(By.ID, "change_id_parent")
-        ActionChains(self.selenium).move_to_element(change_parent).click().perform()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
-        select = Select(self.selenium.find_element(By.ID, "id_parent"))
-        self.assertEqual(select.first_selected_option.text, str(parent.id))
-        self.assertEqual(
-            select.first_selected_option.get_attribute("value"), str(parent.id)
-        )
+        self.page.goto(self.live_server_url + change_url)
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#change_id_parent").click()
+        popup = popup_info.value
+        with popup.expect_event("close"):
+            popup.locator('input[value="Save"]').click()
+        selected_option = self.page.locator("#id_parent option:checked")
+        self.expect(selected_option).to_have_text(str(parent.id))
+        self.expect(selected_option).to_have_attribute("value", str(parent.id))
 
     def test_inline_uuid_pk_add_with_popup(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("admin:admin_views_relatedwithuuidpkmodel_add")
         )
-        self.selenium.find_element(By.ID, "add_id_parent").click()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.ID, "id_title").send_keys("test")
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
-        select = Select(self.selenium.find_element(By.ID, "id_parent"))
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#add_id_parent").click()
+        popup = popup_info.value
+        popup.locator("#id_title").fill("test")
+        with popup.expect_event("close"):
+            popup.locator('input[value="Save"]').click()
         uuid_id = str(ParentWithUUIDPK.objects.first().id)
-        self.assertEqual(select.first_selected_option.text, uuid_id)
-        self.assertEqual(select.first_selected_option.get_attribute("value"), uuid_id)
+        selected_option = self.page.locator("#id_parent option:checked")
+        self.expect(selected_option).to_have_text(uuid_id)
+        self.expect(selected_option).to_have_attribute("value", uuid_id)
 
     def test_inline_uuid_pk_delete_with_popup(self):
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         parent = ParentWithUUIDPK.objects.create(title="test")
         related_with_parent = RelatedWithUUIDPKModel.objects.create(parent=parent)
         self.admin_login(
@@ -7086,24 +6985,19 @@ def test_inline_uuid_pk_delete_with_popup(self):
             "admin:admin_views_relatedwithuuidpkmodel_change",
             args=(related_with_parent.id,),
         )
-        with self.wait_page_loaded():
-            self.selenium.get(self.live_server_url + change_url)
-        delete_parent = self.selenium.find_element(By.ID, "delete_id_parent")
-        ActionChains(self.selenium).move_to_element(delete_parent).click().perform()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.XPATH, '//input[@value="Yes, I’m sure"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
-        select = Select(self.selenium.find_element(By.ID, "id_parent"))
+        self.page.goto(self.live_server_url + change_url)
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#delete_id_parent").click()
+        popup = popup_info.value
+        with popup.expect_event("close"):
+            popup.locator('input[value="Yes, I’m sure"]').click()
+        selected_option = self.page.locator("#id_parent option:checked")
         self.assertEqual(ParentWithUUIDPK.objects.count(), 0)
-        self.assertEqual(select.first_selected_option.text, get_blank_choice_label())
-        self.assertEqual(select.first_selected_option.get_attribute("value"), "")
+        self.expect(selected_option).to_have_text(str(get_blank_choice_label()))
+        self.expect(selected_option).to_have_attribute("value", "")
 
     def test_inline_with_popup_cancel_delete(self):
-        """Clicking ""No, take me back" on a delete popup closes the window."""
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
-
+        """Clicking "No, take me back" on a delete popup closes the window."""
         parent = ParentWithUUIDPK.objects.create(title="test")
         related_with_parent = RelatedWithUUIDPKModel.objects.create(parent=parent)
         self.admin_login(
@@ -7113,18 +7007,16 @@ def test_inline_with_popup_cancel_delete(self):
             "admin:admin_views_relatedwithuuidpkmodel_change",
             args=(related_with_parent.id,),
         )
-        with self.wait_page_loaded():
-            self.selenium.get(self.live_server_url + change_url)
-        delete_parent = self.selenium.find_element(By.ID, "delete_id_parent")
-        ActionChains(self.selenium).move_to_element(delete_parent).click().perform()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.XPATH, '//a[text()="No, take me back"]').click()
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
-        self.assertEqual(len(self.selenium.window_handles), 1)
+        self.page.goto(self.live_server_url + change_url)
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#delete_id_parent").click()
+        popup = popup_info.value
+        popup.wait_for_load_state("load")
+        self.click_and_expect_popup_to_close(popup.get_by_text("No, take me back"))
+        # After the popup closes, only the main page should remain.
+        self.assertEqual(len(self.page.context.pages), 1)
 
     def test_list_editable_raw_id_fields(self):
-        from selenium.webdriver.common.by import By
-
         parent = ParentWithUUIDPK.objects.create(title="test")
         parent2 = ParentWithUUIDPK.objects.create(title="test2")
         RelatedWithUUIDPKModel.objects.create(parent=parent)
@@ -7135,32 +7027,30 @@ def test_list_editable_raw_id_fields(self):
             "admin:admin_views_relatedwithuuidpkmodel_changelist",
             current_app=site2.name,
         )
-        self.selenium.get(self.live_server_url + change_url)
-        self.selenium.find_element(By.ID, "lookup_id_form-0-parent").click()
-        self.wait_for_and_switch_to_popup()
+        self.page.goto(self.live_server_url + change_url)
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#lookup_id_form-0-parent").click()
+        popup = popup_info.value
         # Select "parent2" in the popup.
-        self.selenium.find_element(By.LINK_TEXT, str(parent2.pk)).click()
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        self.click_and_expect_popup_to_close(
+            popup.get_by_role("link", name=str(parent2.pk))
+        )
         # The newly selected pk should appear in the raw id input.
-        value = self.selenium.find_element(By.ID, "id_form-0-parent").get_attribute(
-            "value"
+        self.expect(self.page.locator("#id_form-0-parent")).to_have_value(
+            str(parent2.pk)
         )
-        self.assertEqual(value, str(parent2.pk))
 
     def test_input_element_font(self):
         """
         Browsers' default stylesheets override the font of inputs. The admin
         adds additional CSS to handle this.
         """
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(self.live_server_url + reverse("admin:login"))
-        element = self.selenium.find_element(By.ID, "id_username")
-        # Some browsers quotes the fonts, some don't.
-        fonts = [
-            font.strip().strip('"')
-            for font in element.value_of_css_property("font-family").split(",")
-        ]
+        self.page.goto(self.live_server_url + reverse("admin:login"))
+        element = self.page.locator("#id_username")
+        # Evaluate computed font-family in the browser.
+        font_family = element.evaluate("el => window.getComputedStyle(el).fontFamily")
+        # Some browsers quote the font names, some don't.
+        fonts = [font.strip().strip('"') for font in font_family.split(",")]
         self.assertEqual(
             fonts,
             [
@@ -7178,173 +7068,153 @@ def test_input_element_font(self):
         )
 
     def test_search_input_filtered_page(self):
-        from selenium.webdriver.common.by import By
-
         Person.objects.create(name="Guido van Rossum", gender=1, alive=True)
         Person.objects.create(name="Grace Hopper", gender=1, alive=False)
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         person_url = reverse("admin:admin_views_person_changelist") + "?q=Gui"
-        self.selenium.get(self.live_server_url + person_url)
+        self.page.goto(self.live_server_url + person_url)
         # Hide sidebar.
-        toggle_button = self.selenium.find_element(
-            By.CSS_SELECTOR, "#toggle-nav-sidebar"
-        )
-        toggle_button.click()
-        self.addCleanup(_clean_sidebar_state, self.selenium)
-        self.assertGreater(
-            self.selenium.find_element(By.ID, "searchbar").rect["width"],
-            50,
-        )
+        self.page.locator("#toggle-nav-sidebar").click()
+        self.addCleanup(_clean_sidebar_state, self.page)
+        searchbar = self.page.locator("#searchbar")
+        self.assertGreater(searchbar.bounding_box()["width"], 50)
 
     def test_related_popup_index(self):
         """
         Create a chain of 'self' related objects via popups.
         """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         add_url = reverse("admin:admin_views_box_add", current_app=site.name)
-        self.selenium.get(self.live_server_url + add_url)
-
-        base_window = self.selenium.current_window_handle
-        self.selenium.find_element(By.ID, "add_id_next_box").click()
-        self.wait_for_and_switch_to_popup()
-
-        popup_window_test = self.selenium.current_window_handle
-        self.selenium.find_element(By.ID, "id_title").send_keys("test")
-        self.selenium.find_element(By.ID, "add_id_next_box").click()
-        self.wait_for_and_switch_to_popup(num_windows=3)
-
-        popup_window_test2 = self.selenium.current_window_handle
-        self.selenium.find_element(By.ID, "id_title").send_keys("test2")
-        self.selenium.find_element(By.ID, "add_id_next_box").click()
-        self.wait_for_and_switch_to_popup(num_windows=4)
-
-        self.selenium.find_element(By.ID, "id_title").send_keys("test3")
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 3, 1)
-        self.selenium.switch_to.window(popup_window_test2)
-        select = Select(self.selenium.find_element(By.ID, "id_next_box"))
+        self.page.goto(self.live_server_url + add_url)
+
+        # Open first popup from the base page.
+        with self.page.expect_popup() as popup1_info:
+            self.page.locator("#add_id_next_box").click()
+        popup_test = popup1_info.value
+        popup_test.wait_for_load_state("load")
+        popup_test.locator("#id_title").fill("test")
+
+        # Open second popup from the first popup.
+        with popup_test.expect_popup() as popup2_info:
+            popup_test.locator("#add_id_next_box").click()
+        popup_test2 = popup2_info.value
+        popup_test2.wait_for_load_state("load")
+        popup_test2.locator("#id_title").fill("test2")
+
+        # Open third popup from the second popup.
+        with popup_test2.expect_popup() as popup3_info:
+            popup_test2.locator("#add_id_next_box").click()
+        popup_test3 = popup3_info.value
+        popup_test3.wait_for_load_state("load")
+        popup_test3.locator("#id_title").fill("test3")
+
+        # Save in the deepest popup — it closes itself.
+        with popup_test3.expect_event("close"):
+            popup_test3.locator('input[value="Save"]').click()
+        # After popup_test3 closes, popup_test2 should have "test3" selected.
         next_box_id = str(Box.objects.get(title="test3").id)
-        self.assertEqual(
-            select.first_selected_option.get_attribute("value"), next_box_id
-        )
-
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 2, 1)
-        self.selenium.switch_to.window(popup_window_test)
-        select = Select(self.selenium.find_element(By.ID, "id_next_box"))
+        self.expect(
+            popup_test2.locator("#id_next_box option:checked")
+        ).to_have_attribute("value", next_box_id)
+
+        # Save popup_test2 — it closes itself.
+        with popup_test2.expect_event("close"):
+            popup_test2.locator('input[value="Save"]').click()
+        # After popup_test2 closes, popup_test should have "test2" selected.
         next_box_id = str(Box.objects.get(title="test2").id)
-        self.assertEqual(
-            select.first_selected_option.get_attribute("value"), next_box_id
-        )
-
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(base_window)
-        select = Select(self.selenium.find_element(By.ID, "id_next_box"))
+        self.expect(
+            popup_test.locator("#id_next_box option:checked")
+        ).to_have_attribute("value", next_box_id)
+
+        # Save popup_test — it closes itself.
+        with popup_test.expect_event("close"):
+            popup_test.locator('input[value="Save"]').click()
+        # After popup_test closes, base page should have "test" selected.
         next_box_id = str(Box.objects.get(title="test").id)
-        self.assertEqual(
-            select.first_selected_option.get_attribute("value"), next_box_id
+        self.expect(self.page.locator("#id_next_box option:checked")).to_have_attribute(
+            "value", next_box_id
         )
 
     def test_related_popup_incorrect_close(self):
         """
         Cleanup child popups when closing a parent popup.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         add_url = reverse("admin:admin_views_box_add", current_app=site.name)
-        self.selenium.get(self.live_server_url + add_url)
-
-        self.selenium.find_element(By.ID, "add_id_next_box").click()
-        self.wait_for_and_switch_to_popup()
-
-        test_window = self.selenium.current_window_handle
-        self.selenium.find_element(By.ID, "id_title").send_keys("test")
-        self.selenium.find_element(By.ID, "add_id_next_box").click()
-        self.wait_for_and_switch_to_popup(num_windows=3)
-
-        test2_window = self.selenium.current_window_handle
-        self.selenium.find_element(By.ID, "id_title").send_keys("test2")
-        self.selenium.find_element(By.ID, "add_id_next_box").click()
-        self.wait_for_and_switch_to_popup(num_windows=4)
-        self.assertEqual(len(self.selenium.window_handles), 4)
-
-        self.selenium.switch_to.window(test2_window)
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 2, 1)
-        self.assertEqual(len(self.selenium.window_handles), 2)
+        self.page.goto(self.live_server_url + add_url)
+
+        with self.page.expect_popup() as popup1_info:
+            self.page.locator("#add_id_next_box").click()
+        test_popup = popup1_info.value
+        test_popup.wait_for_load_state("load")
+        test_popup.locator("#id_title").fill("test")
+
+        with test_popup.expect_popup() as popup2_info:
+            test_popup.locator("#add_id_next_box").click()
+        test2_popup = popup2_info.value
+        test2_popup.wait_for_load_state("load")
+        test2_popup.locator("#id_title").fill("test2")
+
+        with test2_popup.expect_popup() as popup3_info:
+            test2_popup.locator("#add_id_next_box").click()
+        # Wait for third popup to open.
+        popup3 = popup3_info.value
+        popup3.wait_for_load_state("load")
+        self.assertEqual(len(self.page.context.pages), 4)
+
+        # Save test2_popup — should close test2_popup and its child (popup3).
+        with test2_popup.expect_event("close"), popup3.expect_event("close"):
+            test2_popup.locator('input[value="Save"]').click()
+        self.assertEqual(len(self.page.context.pages), 2)
 
         # Close final popup to clean up test.
-        self.selenium.switch_to.window(test_window)
-        self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[-1])
+        with test_popup.expect_event("close"):
+            test_popup.locator('input[value="Save"]').click()
 
     def test_hidden_fields_small_window(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super",
             password="secret",
             login_url=reverse("admin:index"),
         )
-        self.selenium.get(self.live_server_url + reverse("admin:admin_views_story_add"))
-        field_title = self.selenium.find_element(By.CLASS_NAME, "field-title")
+        self.page.goto(self.live_server_url + reverse("admin:admin_views_story_add"))
+        field_title = self.page.locator(".field-title")
         with self.small_screen_size():
-            self.assertIs(field_title.is_displayed(), False)
+            self.expect(field_title).not_to_be_visible()
         with self.mobile_size():
-            self.assertIs(field_title.is_displayed(), False)
+            self.expect(field_title).not_to_be_visible()
 
     def test_updating_related_objects_updates_fk_selects_except_autocompletes(self):
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         born_country_select_id = "id_born_country"
         living_country_select_id = "id_living_country"
         living_country_select2_textbox_id = "select2-id_living_country-container"
         favorite_country_to_vacation_select_id = "id_favorite_country_to_vacation"
         continent_select_id = "id_continent"
 
-        def _get_HTML_inside_element_by_id(id_):
-            return self.selenium.find_element(By.ID, id_).get_attribute("innerHTML")
-
-        def _get_text_inside_element_by_selector(selector):
-            return self.selenium.find_element(By.CSS_SELECTOR, selector).get_attribute(
-                "innerText"
-            )
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         add_url = reverse("admin:admin_views_traveler_add")
-        self.selenium.get(self.live_server_url + add_url)
+        self.page.goto(self.live_server_url + add_url)
 
         # Add new Country from the born_country select.
-        self.selenium.find_element(By.ID, f"add_{born_country_select_id}").click()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.ID, "id_name").send_keys("Argentina")
-        continent_select = Select(
-            self.selenium.find_element(By.ID, continent_select_id)
-        )
-        continent_select.select_by_visible_text("South America")
-        self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        with self.page.expect_popup() as popup_info:
+            self.page.locator(f"#add_{born_country_select_id}").click()
+        popup = popup_info.value
+        popup.locator("#id_name").fill("Argentina")
+        popup.locator(f"#{continent_select_id}").select_option(label="South America")
+        with popup.expect_event("close"):
+            popup.locator('[type="submit"]').click()
 
         argentina = Country.objects.get(name="Argentina")
         self.assertHTMLEqual(
-            _get_HTML_inside_element_by_id(born_country_select_id),
+            self.page.locator(f"#{born_country_select_id}").inner_html(),
             f"""
             <option value="" selected="">- Select an option -</option>
             <option value="{argentina.pk}" selected="">Argentina</option>
@@ -7352,81 +7222,66 @@ def _get_text_inside_element_by_selector(selector):
         )
         # Argentina isn't added to the living_country select nor selected by
         # the select2 widget.
-        self.assertEqual(
-            _get_text_inside_element_by_selector(f"#{living_country_select_id}"), ""
-        )
-        self.assertEqual(
-            _get_text_inside_element_by_selector(
-                f"#{living_country_select2_textbox_id}"
-            ),
-            "",
-        )
+        self.expect(self.page.locator(f"#{living_country_select_id}")).to_have_text("")
+        self.expect(
+            self.page.locator(f"#{living_country_select2_textbox_id}")
+        ).to_have_text("")
         # Argentina won't appear because favorite_country_to_vacation field has
         # limit_choices_to.
         self.assertHTMLEqual(
-            _get_HTML_inside_element_by_id(favorite_country_to_vacation_select_id),
+            self.page.locator(
+                f"#{favorite_country_to_vacation_select_id}"
+            ).inner_html(),
             '<option value="" selected="">- Select an option -</option>',
         )
 
         # Add new Country from the living_country select.
-        element = self.selenium.find_element(By.ID, f"add_{living_country_select_id}")
-        ActionChains(self.selenium).move_to_element(element).click(element).perform()
-        self.wait_for_and_switch_to_popup()
-        self.selenium.find_element(By.ID, "id_name").send_keys("Spain")
-        continent_select = Select(
-            self.selenium.find_element(By.ID, continent_select_id)
-        )
-        continent_select.select_by_visible_text("Europe")
-        self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        with self.page.expect_popup() as popup_info:
+            self.page.locator(f"#add_{living_country_select_id}").click()
+        popup = popup_info.value
+        popup.locator("#id_name").fill("Spain")
+        popup.locator(f"#{continent_select_id}").select_option(label="Europe")
+        with popup.expect_event("close"):
+            popup.locator('[type="submit"]').click()
 
         spain = Country.objects.get(name="Spain")
         self.assertHTMLEqual(
-            _get_HTML_inside_element_by_id(born_country_select_id),
+            self.page.locator(f"#{born_country_select_id}").inner_html(),
             f"""
             <option value="" selected="">- Select an option -</option>
             <option value="{argentina.pk}" selected="">Argentina</option>
             <option value="{spain.pk}">Spain</option>
             """,
         )
-
         # Spain is added to the living_country select and it's also selected by
         # the select2 widget.
-        self.assertEqual(
-            _get_text_inside_element_by_selector(f"#{living_country_select_id} option"),
-            "Spain",
-        )
-        self.assertEqual(
-            _get_text_inside_element_by_selector(
-                f"#{living_country_select2_textbox_id}"
-            ),
-            "Spain",
-        )
+        self.expect(
+            self.page.locator(f"#{living_country_select_id} option")
+        ).to_have_text("Spain")
+        self.expect(
+            self.page.locator(f"#{living_country_select2_textbox_id}")
+        ).to_have_text("Spain")
         # Spain won't appear because favorite_country_to_vacation field has
         # limit_choices_to.
         self.assertHTMLEqual(
-            _get_HTML_inside_element_by_id(favorite_country_to_vacation_select_id),
+            self.page.locator(
+                f"#{favorite_country_to_vacation_select_id}"
+            ).inner_html(),
             '<option value="" selected="">- Select an option -</option>',
         )
 
         # Edit second Country created from living_country select.
-        favorite_select = Select(
-            self.selenium.find_element(By.ID, living_country_select_id)
-        )
-        favorite_select.select_by_visible_text("Spain")
-        self.selenium.find_element(By.ID, f"change_{living_country_select_id}").click()
-        self.wait_for_and_switch_to_popup()
-        favorite_name_input = self.selenium.find_element(By.ID, "id_name")
-        favorite_name_input.clear()
-        favorite_name_input.send_keys("Italy")
-        self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        self.page.locator(f"#{living_country_select_id}").select_option(label="Spain")
+        with self.page.expect_popup() as popup_info:
+            self.page.locator(f"#change_{living_country_select_id}").click()
+        popup = popup_info.value
+        popup.locator("#id_name").fill("Italy")
+        with popup.expect_event("close"):
+            popup.locator('[type="submit"]').click()
 
         italy = spain
         self.assertHTMLEqual(
-            _get_HTML_inside_element_by_id(born_country_select_id),
+            self.page.locator(f"#{born_country_select_id}").inner_html(),
             f"""
             <option value="" selected="">- Select an option -</option>
             <option value="{argentina.pk}" selected="">Argentina</option>
@@ -7435,90 +7290,79 @@ def _get_text_inside_element_by_selector(selector):
         )
         # Italy is added to the living_country select and it's also selected by
         # the select2 widget.
-        self.assertEqual(
-            _get_text_inside_element_by_selector(f"#{living_country_select_id} option"),
-            "Italy",
-        )
-        self.assertEqual(
-            _get_text_inside_element_by_selector(
-                f"#{living_country_select2_textbox_id}"
-            ),
-            "Italy",
-        )
+        self.expect(
+            self.page.locator(f"#{living_country_select_id} option")
+        ).to_have_text("Italy")
+        self.expect(
+            self.page.locator(f"#{living_country_select2_textbox_id}")
+        ).to_have_text("Italy")
         # favorite_country_to_vacation field has no options.
         self.assertHTMLEqual(
-            _get_HTML_inside_element_by_id(favorite_country_to_vacation_select_id),
+            self.page.locator(
+                f"#{favorite_country_to_vacation_select_id}"
+            ).inner_html(),
             '<option value="" selected="">- Select an option -</option>',
         )
 
         # Add a new Asian country.
-        self.selenium.find_element(
-            By.ID, f"add_{favorite_country_to_vacation_select_id}"
-        ).click()
-        self.wait_for_and_switch_to_popup()
-        favorite_name_input = self.selenium.find_element(By.ID, "id_name")
-        favorite_name_input.send_keys("Qatar")
-        continent_select = Select(
-            self.selenium.find_element(By.ID, continent_select_id)
-        )
-        continent_select.select_by_visible_text("Asia")
-        self.selenium.find_element(By.CSS_SELECTOR, '[type="submit"]').click()
-        self.wait_until(lambda d: len(d.window_handles) == 1, 1)
-        self.selenium.switch_to.window(self.selenium.window_handles[0])
+        with self.page.expect_popup() as popup_info:
+            self.page.locator(f"#add_{favorite_country_to_vacation_select_id}").click()
+        popup = popup_info.value
+        popup.locator("#id_name").fill("Qatar")
+        popup.locator(f"#{continent_select_id}").select_option(label="Asia")
+        with popup.expect_event("close"):
+            popup.locator('[type="submit"]').click()
 
         # Submit the new Traveler.
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.CSS_SELECTOR, '[name="_save"]').click()
+        self.page.locator('[name="_save"]').click()
+        self.expect(self.page.locator(".messagelist .success")).to_contain_text(
+            "was added successfully."
+        )
         traveler = Traveler.objects.get()
         self.assertEqual(traveler.born_country.name, "Argentina")
         self.assertEqual(traveler.living_country.name, "Italy")
         self.assertEqual(traveler.favorite_country_to_vacation.name, "Qatar")
 
     def test_redirect_on_add_view_add_another_button(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         add_url = reverse("admin7:admin_views_section_add")
-        self.selenium.get(self.live_server_url + add_url)
-        name_input = self.selenium.find_element(By.ID, "id_name")
-        name_input.send_keys("Test section 1")
-        with self.wait_page_loaded():
-            self.selenium.find_element(
-                By.XPATH, '//input[@value="Save and add another"]'
-            ).click()
+        self.page.goto(self.live_server_url + add_url)
+        success_message = self.page.locator("ul.messagelist li.success")
+        self.page.locator("#id_name").fill("Test section 1")
+        self.page.locator('input[value="Save and add another"]').click()
+        # Success message, then redirect to the add form.
+        self.expect(success_message).to_have_text(
+            "The section “Test section 1” was added successfully. You may add another "
+            "section below."
+        )
         self.assertEqual(Section.objects.count(), 1)
-        name_input = self.selenium.find_element(By.ID, "id_name")
-        name_input.send_keys("Test section 2")
-        with self.wait_page_loaded():
-            self.selenium.find_element(
-                By.XPATH, '//input[@value="Save and add another"]'
-            ).click()
+        self.page.locator("#id_name").fill("Test section 2")
+        self.page.locator('input[value="Save and add another"]').click()
+        self.expect(success_message).to_have_text(
+            "The section “Test section 2” was added successfully. You may add another "
+            "section below."
+        )
         self.assertEqual(Section.objects.count(), 2)
 
     def test_redirect_on_add_view_continue_button(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         add_url = reverse("admin7:admin_views_section_add")
-        self.selenium.get(self.live_server_url + add_url)
-        name_input = self.selenium.find_element(By.ID, "id_name")
-        name_input.send_keys("Test section 1")
-        with self.wait_page_loaded():
-            self.selenium.find_element(
-                By.XPATH, '//input[@value="Save and continue editing"]'
-            ).click()
+        self.page.goto(self.live_server_url + add_url)
+        self.page.locator("#id_name").fill("Test section 1")
+        self.page.locator('input[value="Save and continue editing"]').click()
+        # Success message, then redirect to the change form.
+        self.expect(self.page.locator("ul.messagelist li.success")).to_have_text(
+            "The section “Test section 1” was added successfully. You may edit it "
+            "again below."
+        )
         self.assertEqual(Section.objects.count(), 1)
-        name_input = self.selenium.find_element(By.ID, "id_name")
-        name_input_value = name_input.get_attribute("value")
-        self.assertEqual(name_input_value, "Test section 1")
+        self.expect(self.page.locator("#id_name")).to_have_value("Test section 1")
 
     def test_use_fieldset_fields_render(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
@@ -7531,208 +7375,169 @@ def test_use_fieldset_fields_render(self):
             "Start datetime:",
         ]
         url = reverse("admin:admin_views_course_change", args=(course.pk,))
-        self.selenium.get(self.live_server_url + url)
-        fieldsets = self.selenium.find_elements(
-            By.CSS_SELECTOR, "fieldset.aligned fieldset"
-        )
-        self.assertEqual(len(fieldsets), len(expected_legend_tags_text))
-        for index, fieldset in enumerate(fieldsets):
-            legend = fieldset.find_element(By.TAG_NAME, "legend")
-            self.assertEqual(legend.text, expected_legend_tags_text[index])
+        self.page.goto(self.live_server_url + url)
+        fieldsets = self.page.locator("fieldset.aligned fieldset")
+        self.expect(fieldsets).to_have_count(len(expected_legend_tags_text))
+        for index, text in enumerate(expected_legend_tags_text):
+            legend = fieldsets.nth(index).locator("legend")
+            self.expect(legend).to_have_text(text)
 
         # FilteredSelectMultiple uses <fieldset>.
         url = reverse("admin:admin_views_camelcaserelatedmodel_add")
-        self.selenium.get(self.live_server_url + url)
-        fieldsets = self.selenium.find_elements(
-            By.CSS_SELECTOR, "fieldset.aligned fieldset"
-        )
-        self.assertEqual(len(fieldsets), 1)
-        for index, fieldset in enumerate(fieldsets):
-            legend = fieldset.find_element(By.TAG_NAME, "legend")
-            self.assertEqual(legend.text, "M2m:")
+        self.page.goto(self.live_server_url + url)
+        fieldsets = self.page.locator("fieldset.aligned fieldset")
+        self.expect(fieldsets).to_have_count(1)
+        legend = fieldsets.first.locator("legend")
+        self.expect(legend).to_have_text("M2m:")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_use_fieldset_with_grouped_fields(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_views_course_add")
-        )
-        multiline = self.selenium.find_element(
-            By.CSS_SELECTOR, "#content-main .field-difficulty, .form-multiline"
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_views_course_add"))
+        multiline = self.page.locator(
+            "#content-main .field-difficulty, .form-multiline"
+        ).first
         # Two field boxes.
-        field_boxes = multiline.find_elements(By.XPATH, "./*")
-        self.assertEqual(len(field_boxes), 2)
+        self.expect(multiline.locator("> *")).to_have_count(2)
         # One of them is under a <fieldset>.
-        under_fieldset = multiline.find_elements(By.TAG_NAME, "fieldset")
-        self.assertEqual(len(under_fieldset), 1)
+        under_fieldset = multiline.locator("fieldset")
+        self.expect(under_fieldset).to_have_count(1)
         self.take_screenshot("horizontal_fieldset")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     @override_settings(MESSAGE_LEVEL=10)
     def test_messages(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
-
         with override_settings(MESSAGE_LEVEL=10):
             self.admin_login(
-                username="super", password="secret", login_url=reverse("admin:index")
+                username="super",
+                password="secret",
+                login_url=reverse("admin:index"),
             )
             UserMessenger.objects.create()
             for level in ["warning", "info", "error", "success", "debug"]:
-                self.selenium.get(
+                self.page.goto(
                     self.live_server_url
                     + reverse("admin:admin_views_usermessenger_changelist"),
                 )
-                checkbox = self.selenium.find_element(
-                    By.CSS_SELECTOR, "tr input.action-select"
-                )
-                checkbox.click()
-                Select(self.selenium.find_element(By.NAME, "action")).select_by_value(
-                    f"message_{level}"
-                )
-                self.selenium.find_element(
-                    By.CSS_SELECTOR, 'button[name="index"]'
-                ).click()
-                message = self.selenium.find_element(
-                    By.CSS_SELECTOR, "ul.messagelist li"
+                self.page.locator("tr input.action-select").click()
+                self.page.locator('[name="action"]').select_option(
+                    value=f"message_{level}"
                 )
-                self.assertEqual(message.get_attribute("innerText"), f"Test {level}")
+                self.page.locator('button[name="index"]').click()
+                message = self.page.locator("ul.messagelist li")
+                self.expect(message.first).to_have_text(f"Test {level}")
                 self.take_screenshot(level)
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_list_editable_with_filter(self):
-        from selenium.webdriver.common.by import By
-
         Person.objects.create(name="Tom", gender=1)
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_person_changelist")
         )
-        save_button = self.selenium.find_element(By.NAME, "_save")
-        self.assertTrue(save_button.is_displayed())
+        save_button = self.page.locator('[name="_save"]')
+        self.expect(save_button).to_be_visible()
         self.take_screenshot("list_editable")
-
-        with self.wait_page_loaded():
-            save_button.click()
+        save_button.click()
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_object_tools(self):
-        from selenium.webdriver.common.by import By
-
         state = State.objects.create(name="Korea")
         city = City.objects.create(state=state, name="Gwangju")
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_city_changelist")
         )
-        object_tools = self.selenium.find_elements(
-            By.CSS_SELECTOR, "ul.object-tools li a"
-        )
-        self.assertEqual(len(object_tools), 1)
+        object_tools = self.page.locator("ul.object-tools li a")
+        self.expect(object_tools).to_have_count(1)
         self.take_screenshot("changelist")
 
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("admin:admin_views_city_change", args=(city.pk,))
         )
-        object_tools = self.selenium.find_elements(
-            By.CSS_SELECTOR, "ul.object-tools li a"
-        )
-        self.assertEqual(len(object_tools), 2)
+        object_tools = self.page.locator("ul.object-tools li a")
+        self.expect(object_tools).to_have_count(2)
         self.take_screenshot("changeform")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_long_header_with_object_tools_layout(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         s = Subscriber.objects.create(name="a " * 40, email="b " * 80)
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("admin:admin_views_subscriber_change", args=(s.pk,))
         )
-        header = self.selenium.find_element(By.CSS_SELECTOR, "div#content h2")
-        self.assertGreater(len(header.text), 100)
-        object_tools = self.selenium.find_elements(
-            By.CSS_SELECTOR, "div#content ul.object-tools li"
-        )
-        self.assertGreater(len(object_tools), 0)
+        header = self.page.locator("div#content h2")
+        header_text = header.text_content()
+        self.assertGreater(len(header_text), 100)
+        object_tools = self.page.locator("div#content ul.object-tools li")
+        self.assertGreater(object_tools.count(), 0)
         self.take_screenshot("change_form")
 
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_restaurant_changelist")
         )
-        header = self.selenium.find_element(By.CSS_SELECTOR, "div#content h1")
-        self.assertGreater(len(header.text), 100)
-        object_tools = self.selenium.find_elements(
-            By.CSS_SELECTOR, "div#content ul.object-tools li"
-        )
-        self.assertGreater(len(object_tools), 0)
+        header = self.page.locator("div#content h1")
+        header_text = header.text_content()
+        self.assertGreater(len(header_text), 100)
+        object_tools = self.page.locator("div#content ul.object-tools li")
+        self.assertGreater(object_tools.count(), 0)
         self.take_screenshot("change_list")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_pagination_layout(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         objects = [UnorderedObject(name=f"obj-{i}") for i in range(1, 23)]
         UnorderedObject.objects.bulk_create(objects)
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("admin:admin_views_unorderedobject_changelist")
         )
-        pages = self.selenium.find_elements(By.CSS_SELECTOR, "nav.paginator ul li")
-        self.assertGreater(len(pages), 1)
-        show_all = self.selenium.find_element(By.CSS_SELECTOR, "a.showall")
-        self.assertTrue(show_all.is_displayed())
+        pages = self.page.locator("nav.paginator ul li")
+        self.assertGreater(pages.count(), 1)
+        show_all = self.page.locator("a.showall")
+        self.expect(show_all).to_be_visible()
         self.take_screenshot("pagination")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_changelist_filter_sidebar_with_long_verbose_fields(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
         Person.objects.create(name="John", gender=1)
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_views_person_changelist")
         )
-        changelist_filter = self.selenium.find_element(By.ID, "changelist-filter")
-        self.assertTrue(changelist_filter.is_displayed())
+        changelist_filter = self.page.locator("#changelist-filter")
+        self.expect(changelist_filter).to_be_visible()
         self.take_screenshot("filter_sidebar")
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_form_errors_render_layout(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(
             username="super", password="secret", login_url=reverse("admin:index")
         )
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_views_language_add")
-        )
-
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.NAME, "_save").click()
-
-        form_rows = self.selenium.find_elements(By.CSS_SELECTOR, "div.form-row")
-        for row in form_rows:
-            error_list = row.find_element(By.CSS_SELECTOR, "ul.errorlist")
-            self.assertTrue(error_list.is_displayed())
+        self.page.goto(self.live_server_url + reverse("admin:admin_views_language_add"))
+        self.page.locator('[name="_save"]').click()
+        form_rows = self.page.locator("div.form-row")
+        self.expect(form_rows.first.locator("ul.errorlist").first).to_be_visible()
+        count = form_rows.count()
+        for i in range(count):
+            error_lists = form_rows.nth(i).locator("ul.errorlist")
+            self.expect(error_lists.first).to_be_visible()
+            for j in range(error_lists.count()):
+                self.expect(error_lists.nth(j)).to_be_visible()
         self.take_screenshot("error_list")
 
 
diff --git a/tests/admin_widgets/tests.py b/tests/admin_widgets/tests.py
index 0e4749563aad..d0a22774bc04 100644
--- a/tests/admin_widgets/tests.py
+++ b/tests/admin_widgets/tests.py
@@ -7,11 +7,12 @@
 from pathlib import Path
 from unittest import skipUnless
 
+from playwright_tests import AdminPlaywrightTestCase, screenshot_cases
+
 from django import forms
 from django.conf import settings
 from django.contrib import admin
 from django.contrib.admin import widgets
-from django.contrib.admin.tests import AdminSeleniumTestCase
 from django.contrib.auth.models import User
 from django.core.files.storage import default_storage
 from django.core.files.uploadedfile import SimpleUploadedFile
@@ -24,7 +25,6 @@
     UUIDField,
 )
 from django.test import SimpleTestCase, TestCase, override_settings
-from django.test.selenium import screenshot_cases
 from django.test.utils import requires_tz_support
 from django.urls import reverse
 from django.utils import translation
@@ -995,8 +995,8 @@ def test_non_select_widget_cant_change_delete_related(self):
 
 
 @override_settings(ROOT_URLCONF="admin_widgets.urls")
-class AdminWidgetSeleniumTestCase(AdminSeleniumTestCase):
-    available_apps = ["admin_widgets"] + AdminSeleniumTestCase.available_apps
+class AdminWidgetPlaywrightTestCase(AdminPlaywrightTestCase):
+    available_apps = ["admin_widgets"] + AdminPlaywrightTestCase.available_apps
 
     def setUp(self):
         self.u1 = User.objects.create_superuser(
@@ -1004,168 +1004,130 @@ def setUp(self):
         )
 
 
-class DateTimePickerSeleniumTests(AdminWidgetSeleniumTestCase):
+class DateTimePickerPlaywrightTests(AdminWidgetPlaywrightTestCase):
     def test_show_hide_date_time_picker_widgets(self):
         """
         Pressing the ESC key or clicking on a widget value closes the date and
         time picker widgets.
         """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.admin_login(username="super", password="secret", login_url="/")
         # Open a page that has a date and time picker widgets
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
 
         # First, with the date picker widget ---------------------------------
-        cal_icon = self.selenium.find_element(By.ID, "calendarlink0")
+        cal_icon = self.page.locator("#calendarlink0")
+        calendarbox = self.page.locator("#calendarbox0")
         # The date picker is hidden
-        self.assertFalse(
-            self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
-        )
+        self.expect(calendarbox).to_be_hidden()
         # Click the calendar icon
         cal_icon.click()
         # The date picker is visible
-        self.assertTrue(
-            self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
-        )
+        self.expect(calendarbox).to_be_visible()
         # Press the ESC key
-        self.selenium.find_element(By.TAG_NAME, "body").send_keys([Keys.ESCAPE])
+        self.page.keyboard.press("Escape")
         # The date picker is hidden again
-        self.assertFalse(
-            self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
-        )
+        self.expect(calendarbox).to_be_hidden()
         # Click the calendar icon, then on the 15th of current month
         cal_icon.click()
-        self.selenium.find_element(By.XPATH, "//a[contains(text(), '15')]").click()
-        self.assertFalse(
-            self.selenium.find_element(By.ID, "calendarbox0").is_displayed()
-        )
-        self.assertEqual(
-            self.selenium.find_element(By.ID, "id_birthdate_0").get_attribute("value"),
+        self.page.locator("#calendarbox0").get_by_text("15", exact=True).click()
+        self.expect(calendarbox).to_be_hidden()
+        self.expect(self.page.locator("#id_birthdate_0")).to_have_value(
             datetime.today().strftime("%Y-%m-") + "15",
         )
 
         # Then, with the time picker widget ----------------------------------
-        time_icon = self.selenium.find_element(By.ID, "clocklink0")
+        time_icon = self.page.locator("#clocklink0")
+        clockbox = self.page.locator("#clockbox0")
         # The time picker is hidden
-        self.assertFalse(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
+        self.expect(clockbox).to_be_hidden()
         # Click the time icon
         time_icon.click()
         # The time picker is visible
-        self.assertTrue(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
-        self.assertEqual(
-            [
-                x.text
-                for x in self.selenium.find_elements(
-                    By.XPATH, "//ul[@class='timelist']/li/a"
-                )
-            ],
+        self.expect(clockbox).to_be_visible()
+        self.expect(self.page.locator("ul.timelist li a")).to_have_text(
             ["Now", "Midnight", "6 a.m.", "Noon", "6 p.m."],
         )
         # Press the ESC key
-        self.selenium.find_element(By.TAG_NAME, "body").send_keys([Keys.ESCAPE])
+        self.page.keyboard.press("Escape")
         # The time picker is hidden again
-        self.assertFalse(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
+        self.expect(clockbox).to_be_hidden()
         # Click the time icon, then select the 'Noon' value
         time_icon.click()
-        self.selenium.find_element(By.XPATH, "//a[contains(text(), 'Noon')]").click()
-        self.assertFalse(self.selenium.find_element(By.ID, "clockbox0").is_displayed())
-        self.assertEqual(
-            self.selenium.find_element(By.ID, "id_birthdate_1").get_attribute("value"),
-            "12:00:00",
-        )
+        self.page.locator("#clockbox0").get_by_text("Noon").click()
+        self.expect(clockbox).to_be_hidden()
+        self.expect(self.page.locator("#id_birthdate_1")).to_have_value("12:00:00")
 
     def test_calendar_nonday_class(self):
         """
         Ensure cells that are not days of the month have the `nonday` CSS
         class. Refs #4574.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
         # Open a page that has a date and time picker widgets
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
 
         # fill in the birth date.
-        self.selenium.find_element(By.ID, "id_birthdate_0").send_keys("2013-06-01")
+        self.page.locator("#id_birthdate_0").fill("2013-06-01")
 
         # Click the calendar icon
-        self.selenium.find_element(By.ID, "calendarlink0").click()
+        self.page.locator("#calendarlink0").click()
 
         # get all the tds within the calendar
-        calendar0 = self.selenium.find_element(By.ID, "calendarin0")
-        tds = calendar0.find_elements(By.TAG_NAME, "td")
+        calendar0 = self.page.locator("#calendarin0")
+        tds = calendar0.locator("td").all()
 
         # make sure the first and last 6 cells have class nonday
         for td in tds[:6] + tds[-6:]:
-            self.assertEqual(td.get_attribute("class"), "nonday")
+            self.expect(td).to_have_class("nonday")
 
     def test_calendar_selected_class(self):
         """
         Ensure cell for the day in the input has the `selected` CSS class.
         Refs #4574.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
         # Open a page that has a date and time picker widgets
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
 
         # fill in the birth date.
-        self.selenium.find_element(By.ID, "id_birthdate_0").send_keys("2013-06-01")
+        self.page.locator("#id_birthdate_0").fill("2013-06-01")
 
         # Click the calendar icon
-        self.selenium.find_element(By.ID, "calendarlink0").click()
+        self.page.locator("#calendarlink0").click()
 
         # get all the tds within the calendar
-        calendar0 = self.selenium.find_element(By.ID, "calendarin0")
-        tds = calendar0.find_elements(By.TAG_NAME, "td")
+        calendar0 = self.page.locator("#calendarin0")
+        tds = calendar0.locator("td").all()
 
         # verify the selected cell
         selected = tds[6]
-        self.assertEqual(selected.get_attribute("class"), "selected")
+        self.expect(selected).to_have_class("selected")
 
-        self.assertEqual(selected.text, "1")
+        self.expect(selected).to_have_text("1")
 
     def test_calendar_no_selected_class(self):
         """
         Ensure no cells are given the selected class when the field is empty.
         Refs #4574.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
         # Open a page that has a date and time picker widgets
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
 
         # Click the calendar icon
-        self.selenium.find_element(By.ID, "calendarlink0").click()
+        self.page.locator("#calendarlink0").click()
 
         # get all the tds within the calendar
-        calendar0 = self.selenium.find_element(By.ID, "calendarin0")
-        tds = calendar0.find_elements(By.TAG_NAME, "td")
+        calendar0 = self.page.locator("#calendarin0")
 
         # verify there are no cells with the selected class
-        selected = [td for td in tds if td.get_attribute("class") == "selected"]
-
-        self.assertEqual(len(selected), 0)
+        self.expect(calendar0.locator("td.selected")).to_have_count(0)
 
     def test_calendar_show_date_from_input(self):
         """
         The calendar shows the date from the input field for every locale
         supported by Django.
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
 
         # Enter test data
@@ -1192,119 +1154,106 @@ def test_calendar_show_date_from_input(self):
 
                 # Get the expected caption.
                 may_translation = month_name
-                expected_caption = "{:s} {:d}".format(may_translation.upper(), 1984)
+                expected_caption = "{:s} {:d}".format(may_translation, 1984)
 
                 # Every locale.
                 with override_settings(LANGUAGE_CODE=language_code):
                     # Open a page that has a date picker widget.
-                    self.selenium.get(self.live_server_url + url)
+                    self.page.goto(self.live_server_url + url)
                     # Click on the calendar icon.
-                    self.selenium.find_element(By.ID, "calendarlink0").click()
+                    self.page.locator("#calendarlink0").click()
                     # The right month and year are displayed.
-                    self.wait_for_text("#calendarin0 caption", expected_caption)
+                    caption = self.page.locator("#calendarin0 caption")
+                    self.expect(caption).to_have_text(expected_caption)
+                    self.expect(caption).to_have_css("text-transform", "uppercase")
 
     def test_calendar_press_enter_focus_element(self):
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.admin_login(username="super", password="secret", login_url="/")
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
-        icon = self.selenium.find_element(By.ID, "calendarlink0")
-        expected_focus_element = self.selenium.find_element(
-            By.CSS_SELECTOR, "div#calendarin0 table td.today a"
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
+        icon = self.page.locator("#calendarlink0")
+        expected_focus = self.page.locator("div#calendarin0 table td.today a")
+        icon.press("Enter")
+        self.expect(expected_focus).to_be_focused()
+
+    def assertImmediatelyPrecedes(self, first, second):
+        self.assertTrue(
+            first.evaluate(
+                "(first, second) => first.nextElementSibling === second",
+                second.element_handle(),
+            )
         )
-        icon.send_keys(Keys.ENTER)
-        focused_element = self.selenium.switch_to.active_element
-        self.assertEqual(expected_focus_element, focused_element)
 
     @override_settings(TIME_ZONE="Asia/Seoul")
     def test_timezone_warning_message(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
 
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
 
-        datetime = self.selenium.find_element(By.CSS_SELECTOR, "p.datetime")
-        warnings = self.selenium.find_elements(
-            By.CSS_SELECTOR, "div.field-birthdate div.timezonewarning"
-        )
-        self.assertEqual(len(warnings), 1)
+        datetime_el = self.page.locator("p.datetime")
+        warnings = self.page.locator("div.field-birthdate div.timezonewarning")
+        self.expect(warnings).to_have_count(1)
 
-        warning = warnings[0]
-        self.assertTrue(warning.is_displayed())
-        next_element = warning.find_element(By.XPATH, "./following-sibling::*[1]")
+        warning = warnings.first
+        self.expect(warning).to_be_visible()
         # Warning messages are generally located just above the field block.
-        self.assertEqual(next_element, datetime)
+        self.assertImmediatelyPrecedes(warning, datetime_el)
 
-        date = datetime.find_element(By.TAG_NAME, "input")
-        date.send_keys("invalid")
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.NAME, "_save").click()
+        date = datetime_el.locator("input").first
+        date.fill("invalid")
+        self.page.locator("input[name='_save']").click()
 
-        errors = self.selenium.find_element(By.ID, "id_birthdate_error")
-        warning = self.selenium.find_element(
-            By.CSS_SELECTOR, "div.help.timezonewarning"
-        )
-        next_element = warning.find_element(By.XPATH, "./following-sibling::*[1]")
+        error = self.page.locator("#id_birthdate_error")
+        warning = self.page.locator("div.help.timezonewarning")
         # warning message appears above the error message.
-        self.assertEqual(next_element, errors)
+        self.assertImmediatelyPrecedes(warning, error)
 
 
 @requires_tz_support
-@override_settings(TIME_ZONE="Asia/Singapore")
-class DateTimePickerShortcutsSeleniumTests(AdminWidgetSeleniumTestCase):
+class DateTimePickerShortcutsPlaywrightTests(AdminWidgetPlaywrightTestCase):
+    @override_settings(TIME_ZONE="Asia/Singapore")
     def test_date_time_picker_shortcuts(self):
         """
         date/time/datetime picker shortcuts work in the current time zone.
         Refs #20663.
 
-        This test case is fairly tricky, it relies on selenium still running
+        This test case is fairly tricky, it relies on playwright still running
         the browser in the default time zone "America/Chicago" despite
         `override_settings` changing the time zone to "Asia/Singapore".
         """
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
 
         error_margin = timedelta(seconds=10)
 
         # If we are neighbouring a DST, we add an hour of error margin.
-        tz = zoneinfo.ZoneInfo("America/Chicago")
+        tz = zoneinfo.ZoneInfo(self.browser_timezone)
         utc_now = datetime.now(zoneinfo.ZoneInfo("UTC"))
         tz_yesterday = (utc_now - timedelta(days=1)).astimezone(tz).tzname()
         tz_tomorrow = (utc_now + timedelta(days=1)).astimezone(tz).tzname()
         if tz_yesterday != tz_tomorrow:
             error_margin += timedelta(hours=1)
 
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_member_add")
-        )
-
-        self.selenium.find_element(By.ID, "id_name").send_keys("test")
-
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_member_add"))
+        self.page.locator("#id_name").fill("test")
         # Click on the "today" and "now" shortcuts.
-        shortcuts = self.selenium.find_elements(
-            By.CSS_SELECTOR, ".field-birthdate .datetimeshortcuts"
-        )
+        shortcuts = self.page.locator(".field-birthdate .datetimeshortcuts")
 
         now = datetime.now()
-        for shortcut in shortcuts:
-            shortcut.find_element(By.TAG_NAME, "a").click()
+        for shortcut in shortcuts.all():
+            shortcut.locator("a").first.click()
 
         # There is a time zone mismatch warning.
         # Warning: This would effectively fail if the TIME_ZONE defined in the
         # settings has the same UTC offset as "Asia/Singapore" because the
         # mismatch warning would be rightfully missing from the page.
-        self.assertCountSeleniumElements(".field-birthdate .timezonewarning", 1)
+        self.expect(
+            self.page.locator(".field-birthdate .timezonewarning")
+        ).to_have_count(1)
 
         # Submit the form.
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.NAME, "_save").click()
+        self.page.locator("input[name='_save']").click()
+        self.expect(self.page.locator(".messagelist .success")).to_have_text(
+            "The member “test” was added successfully."
+        )
 
         # Make sure that "now" in JavaScript is within 10 seconds
         # from "now" on the server side.
@@ -1313,14 +1262,15 @@ def test_date_time_picker_shortcuts(self):
         self.assertLess(member.birthdate, now + error_margin)
 
 
-# The above tests run with Asia/Singapore which are on the positive side of
-# UTC. Here we test with a timezone on the negative side.
-@override_settings(TIME_ZONE="US/Eastern")
-class DateTimePickerAltTimezoneSeleniumTests(DateTimePickerShortcutsSeleniumTests):
-    pass
+class DateTimePickerAltTimezonePlaywrightTests(DateTimePickerShortcutsPlaywrightTests):
+    # The above tests run with Asia/Singapore which are on the positive side of
+    # UTC. Here we test with a timezone on the negative side.
+    @override_settings(TIME_ZONE="US/Eastern")
+    def test_date_time_picker_shortcuts(self):
+        super().test_date_time_picker_shortcuts()
 
 
-class HorizontalVerticalFilterSeleniumTests(AdminWidgetSeleniumTestCase):
+class HorizontalVerticalFilterPlaywrightTests(AdminWidgetPlaywrightTestCase):
     def setUp(self):
         super().setUp()
         self.lisa = Student.objects.create(name="Lisa")
@@ -1342,31 +1292,37 @@ def assertButtonsDisabled(
         choose_all_btn_disabled=False,
         remove_all_btn_disabled=False,
     ):
-        choose_button = "#id_%s_add" % field_name
-        choose_all_button = "#id_%s_add_all" % field_name
-        remove_button = "#id_%s_remove" % field_name
-        remove_all_button = "#id_%s_remove_all" % field_name
-        self.assertEqual(self.is_disabled(choose_button), choose_btn_disabled)
-        self.assertEqual(self.is_disabled(remove_button), remove_btn_disabled)
+        choose_button = self.page.locator("#id_%s_add" % field_name)
+        choose_all_button = self.page.locator("#id_%s_add_all" % field_name)
+        remove_button = self.page.locator("#id_%s_remove" % field_name)
+        remove_all_button = self.page.locator("#id_%s_remove_all" % field_name)
+        if choose_btn_disabled:
+            self.expect(choose_button).to_be_disabled()
+        else:
+            self.expect(choose_button).to_be_enabled()
+        if remove_btn_disabled:
+            self.expect(remove_button).to_be_disabled()
+        else:
+            self.expect(remove_button).to_be_enabled()
         if mode == "horizontal":
-            self.assertEqual(
-                self.is_disabled(choose_all_button), choose_all_btn_disabled
-            )
-            self.assertEqual(
-                self.is_disabled(remove_all_button), remove_all_btn_disabled
-            )
+            if choose_all_btn_disabled:
+                self.expect(choose_all_button).to_be_disabled()
+            else:
+                self.expect(choose_all_button).to_be_enabled()
+            if remove_all_btn_disabled:
+                self.expect(remove_all_button).to_be_disabled()
+            else:
+                self.expect(remove_all_button).to_be_enabled()
 
     def execute_basic_operations(self, mode, field_name):
-        from selenium.webdriver.common.by import By
-
-        original_url = self.selenium.current_url
+        original_url = self.page.url
 
         from_box = "#id_%s_from" % field_name
         to_box = "#id_%s_to" % field_name
-        choose_button = "id_%s_add" % field_name
-        choose_all_button = "id_%s_add_all" % field_name
-        remove_button = "id_%s_remove" % field_name
-        remove_all_button = "id_%s_remove_all" % field_name
+        choose_button = "#id_%s_add" % field_name
+        choose_all_button = "#id_%s_add_all" % field_name
+        remove_button = "#id_%s_remove" % field_name
+        remove_all_button = "#id_%s_remove_all" % field_name
 
         # Initial positions ---------------------------------------------------
         self.assertSelectOptions(
@@ -1392,15 +1348,16 @@ def execute_basic_operations(self, mode, field_name):
 
         # Click 'Choose all' --------------------------------------------------
         if mode == "horizontal":
-            self.selenium.find_element(By.ID, choose_all_button).click()
+            self.page.locator(choose_all_button).click()
         elif mode == "vertical":
-            # There 's no 'Choose all' button in vertical mode, so individually
+            # There's no 'Choose all' button in vertical mode, so individually
             # select all options and click 'Choose'.
-            for option in self.selenium.find_elements(
-                By.CSS_SELECTOR, from_box + " > option"
-            ):
-                option.click()
-            self.selenium.find_element(By.ID, choose_button).click()
+            all_values = [
+                el.get_attribute("value")
+                for el in self.page.locator(f"{from_box} > option").all()
+            ]
+            self.page.locator(from_box).select_option(value=all_values)
+            self.page.locator(choose_button).click()
         self.assertSelectOptions(from_box, [])
         self.assertSelectOptions(
             to_box,
@@ -1426,15 +1383,16 @@ def execute_basic_operations(self, mode, field_name):
 
         # Click 'Remove all' --------------------------------------------------
         if mode == "horizontal":
-            self.selenium.find_element(By.ID, remove_all_button).click()
+            self.page.locator(remove_all_button).click()
         elif mode == "vertical":
-            # There 's no 'Remove all' button in vertical mode, so individually
+            # There's no 'Remove all' button in vertical mode, so individually
             # select all options and click 'Remove'.
-            for option in self.selenium.find_elements(
-                By.CSS_SELECTOR, to_box + " > option"
-            ):
-                option.click()
-            self.selenium.find_element(By.ID, remove_button).click()
+            all_values = [
+                el.get_attribute("value")
+                for el in self.page.locator(f"{to_box} > option").all()
+            ]
+            self.page.locator(to_box).select_option(value=all_values)
+            self.page.locator(remove_button).click()
         self.assertSelectOptions(
             from_box,
             [
@@ -1459,20 +1417,23 @@ def execute_basic_operations(self, mode, field_name):
         )
 
         # Choose some options ------------------------------------------------
-        from_lisa_select_option = self.selenium.find_element(
-            By.CSS_SELECTOR, '{} > option[value="{}"]'.format(from_box, self.lisa.id)
+        from_lisa_option = self.page.locator(
+            '{} > option[value="{}"]'.format(from_box, self.lisa.id)
         )
 
         # Check the title attribute is there for tool tips: ticket #20821
-        self.assertEqual(
-            from_lisa_select_option.get_attribute("title"),
-            from_lisa_select_option.get_attribute("text"),
+        self.expect(from_lisa_option).to_have_attribute(
+            "title", from_lisa_option.inner_text()
         )
 
-        self.select_option(from_box, str(self.lisa.id))
-        self.select_option(from_box, str(self.jason.id))
-        self.select_option(from_box, str(self.bob.id))
-        self.select_option(from_box, str(self.john.id))
+        self.page.locator(from_box).select_option(
+            value=[
+                str(self.lisa.id),
+                str(self.jason.id),
+                str(self.bob.id),
+                str(self.john.id),
+            ]
+        )
         self.assertButtonsDisabled(
             mode,
             field_name,
@@ -1481,7 +1442,7 @@ def execute_basic_operations(self, mode, field_name):
             choose_all_btn_disabled=False,
             remove_all_btn_disabled=True,
         )
-        self.selenium.find_element(By.ID, choose_button).click()
+        self.page.locator(choose_button).click()
         self.assertButtonsDisabled(
             mode,
             field_name,
@@ -1511,17 +1472,17 @@ def execute_basic_operations(self, mode, field_name):
         )
 
         # Check the tooltip is still there after moving: ticket #20821
-        to_lisa_select_option = self.selenium.find_element(
-            By.CSS_SELECTOR, '{} > option[value="{}"]'.format(to_box, self.lisa.id)
+        to_lisa_option = self.page.locator(
+            '{} > option[value="{}"]'.format(to_box, self.lisa.id)
         )
-        self.assertEqual(
-            to_lisa_select_option.get_attribute("title"),
-            to_lisa_select_option.get_attribute("text"),
+        self.expect(to_lisa_option).to_have_attribute(
+            "title", to_lisa_option.inner_text()
         )
 
         # Remove some options -------------------------------------------------
-        self.select_option(to_box, str(self.lisa.id))
-        self.select_option(to_box, str(self.bob.id))
+        self.page.locator(to_box).select_option(
+            value=[str(self.lisa.id), str(self.bob.id)]
+        )
         self.assertButtonsDisabled(
             mode,
             field_name,
@@ -1530,7 +1491,7 @@ def execute_basic_operations(self, mode, field_name):
             choose_all_btn_disabled=False,
             remove_all_btn_disabled=False,
         )
-        self.selenium.find_element(By.ID, remove_button).click()
+        self.page.locator(remove_button).click()
         self.assertButtonsDisabled(
             mode,
             field_name,
@@ -1554,9 +1515,10 @@ def execute_basic_operations(self, mode, field_name):
         self.assertSelectOptions(to_box, [str(self.jason.id), str(self.john.id)])
 
         # Choose some more options --------------------------------------------
-        self.select_option(from_box, str(self.arthur.id))
-        self.select_option(from_box, str(self.cliff.id))
-        self.selenium.find_element(By.ID, choose_button).click()
+        self.page.locator(from_box).select_option(
+            value=[str(self.arthur.id), str(self.cliff.id)]
+        )
+        self.page.locator(choose_button).click()
 
         self.assertSelectOptions(
             from_box,
@@ -1578,58 +1540,56 @@ def execute_basic_operations(self, mode, field_name):
         )
 
         # Choose some more options --------------------------------------------
-        self.select_option(from_box, str(self.peter.id))
-        self.select_option(from_box, str(self.lisa.id))
+        self.page.locator(from_box).select_option(
+            value=[str(self.peter.id), str(self.lisa.id)]
+        )
 
         # Confirm they're selected after clicking inactive buttons: ticket
         # #26575
         self.assertSelectedOptions(from_box, [str(self.peter.id), str(self.lisa.id)])
-        self.selenium.find_element(By.ID, remove_button).click()
+        self.page.locator(remove_button).click(force=True)
         self.assertSelectedOptions(from_box, [str(self.peter.id), str(self.lisa.id)])
 
         # Unselect the options ------------------------------------------------
-        self.deselect_option(from_box, str(self.peter.id))
-        self.deselect_option(from_box, str(self.lisa.id))
+        self.page.locator(from_box).select_option([])
 
         # Choose some more options --------------------------------------------
-        self.select_option(to_box, str(self.jason.id))
-        self.select_option(to_box, str(self.john.id))
+        self.page.locator(to_box).select_option(
+            value=[str(self.jason.id), str(self.john.id)]
+        )
 
         # Confirm they're selected after clicking inactive buttons: ticket
         # #26575
         self.assertSelectedOptions(to_box, [str(self.jason.id), str(self.john.id)])
-        self.selenium.find_element(By.ID, choose_button).click()
+        self.page.locator(choose_button).click(force=True)
         self.assertSelectedOptions(to_box, [str(self.jason.id), str(self.john.id)])
 
         # Unselect the options ------------------------------------------------
-        self.deselect_option(to_box, str(self.jason.id))
-        self.deselect_option(to_box, str(self.john.id))
+        self.page.locator(to_box).select_option([])
 
         # Pressing buttons shouldn't change the URL.
-        self.assertEqual(self.selenium.current_url, original_url)
+        self.expect(self.page).to_have_url(original_url)
 
     def test_basic(self):
-        from selenium.webdriver.common.by import By
-
         self.school.students.set([self.lisa, self.peter])
         self.school.alumni.set([self.lisa, self.peter])
 
         with self.small_screen_size():
             self.admin_login(username="super", password="secret", login_url="/")
-            self.selenium.get(
+            self.page.goto(
                 self.live_server_url
                 + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
             )
 
-            self.wait_page_ready()
-            self.trigger_resize()
             self.execute_basic_operations("vertical", "students")
             self.execute_basic_operations("horizontal", "alumni")
 
             # Save, everything should be stored properly stored in the
             # database.
-            self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
-            self.wait_page_ready()
+            self.page.locator('input[value="Save"]').click()
+            self.expect(self.page.locator(".messagelist .success")).to_have_text(
+                "The school “School of Awesome” was changed successfully."
+            )
         self.school = School.objects.get(id=self.school.id)  # Reload from database
         self.assertEqual(
             list(self.school.students.all()),
@@ -1645,15 +1605,12 @@ def test_filter(self):
         Typing in the search box filters out options displayed in the 'from'
         box.
         """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.school.students.set([self.lisa, self.peter])
         self.school.alumni.set([self.lisa, self.peter])
 
         with self.small_screen_size():
             self.admin_login(username="super", password="secret", login_url="/")
-            self.selenium.get(
+            self.page.goto(
                 self.live_server_url
                 + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
             )
@@ -1661,9 +1618,9 @@ def test_filter(self):
             for field_name in ["students", "alumni"]:
                 from_box = "#id_%s_from" % field_name
                 to_box = "#id_%s_to" % field_name
-                choose_link = "id_%s_add" % field_name
-                remove_link = "id_%s_remove" % field_name
-                input = self.selenium.find_element(By.ID, "id_%s_input" % field_name)
+                choose_link = "#id_%s_add" % field_name
+                remove_link = "#id_%s_remove" % field_name
+                input = self.page.locator("#id_%s_input" % field_name)
                 # Initial values.
                 self.assertSelectOptions(
                     from_box,
@@ -1677,18 +1634,18 @@ def test_filter(self):
                     ],
                 )
                 # Typing in some characters filters out non-matching options.
-                input.send_keys("a")
+                input.press("a")
                 self.assertSelectOptions(
                     from_box, [str(self.arthur.id), str(self.jason.id)]
                 )
-                input.send_keys("R")
+                input.press("R")
                 self.assertSelectOptions(from_box, [str(self.arthur.id)])
                 # Clearing the text box makes the other options reappear.
-                input.send_keys([Keys.BACK_SPACE])
+                input.press("Backspace")
                 self.assertSelectOptions(
                     from_box, [str(self.arthur.id), str(self.jason.id)]
                 )
-                input.send_keys([Keys.BACK_SPACE])
+                input.press("Backspace")
                 self.assertSelectOptions(
                     from_box,
                     [
@@ -1702,12 +1659,12 @@ def test_filter(self):
                 )
 
                 # Choosing a filtered option sends it properly to the 'to' box.
-                input.send_keys("a")
+                input.press("a")
                 self.assertSelectOptions(
                     from_box, [str(self.arthur.id), str(self.jason.id)]
                 )
-                self.select_option(from_box, str(self.jason.id))
-                self.selenium.find_element(By.ID, choose_link).click()
+                self.page.locator(from_box).select_option(value=str(self.jason.id))
+                self.page.locator(choose_link).click()
                 self.assertSelectOptions(from_box, [str(self.arthur.id)])
                 self.assertSelectOptions(
                     to_box,
@@ -1718,8 +1675,8 @@ def test_filter(self):
                     ],
                 )
 
-                self.select_option(to_box, str(self.lisa.id))
-                self.selenium.find_element(By.ID, remove_link).click()
+                self.page.locator(to_box).select_option(value=str(self.lisa.id))
+                self.page.locator(remove_link).click()
                 self.assertSelectOptions(
                     from_box, [str(self.arthur.id), str(self.lisa.id)]
                 )
@@ -1727,7 +1684,7 @@ def test_filter(self):
                     to_box, [str(self.peter.id), str(self.jason.id)]
                 )
 
-                input.send_keys([Keys.BACK_SPACE])  # Clear text box
+                input.fill("")  # Clear text box
                 self.assertSelectOptions(
                     from_box,
                     [
@@ -1745,19 +1702,21 @@ def test_filter(self):
 
                 # Pressing enter on a filtered option sends it properly to
                 # the 'to' box.
-                self.select_option(to_box, str(self.jason.id))
-                self.selenium.find_element(By.ID, remove_link).click()
-                input.send_keys("ja")
+                self.page.locator(to_box).select_option(value=str(self.jason.id))
+                self.page.locator(remove_link).click()
+                input.press_sequentially("ja")
                 self.assertSelectOptions(from_box, [str(self.jason.id)])
-                input.send_keys([Keys.ENTER])
+                input.press("Enter")
                 self.assertSelectOptions(
                     to_box, [str(self.peter.id), str(self.jason.id)]
                 )
-                input.send_keys([Keys.BACK_SPACE, Keys.BACK_SPACE])
+                input.fill("")
 
             # Save, everything should be stored properly in the database.
-            with self.wait_page_loaded():
-                self.selenium.find_element(By.XPATH, '//input[@value="Save"]').click()
+            self.page.locator('input[value="Save"]').click()
+            self.expect(self.page.locator(".messagelist .success")).to_have_text(
+                "The school “School of Awesome” was changed successfully."
+            )
         self.school = School.objects.get(id=self.school.id)  # Reload from database
         self.assertEqual(list(self.school.students.all()), [self.jason, self.peter])
         self.assertEqual(list(self.school.alumni.all()), [self.jason, self.peter])
@@ -1768,18 +1727,16 @@ def test_back_button_bug(self):
         and then clicking the browser's back button would clear the
         filter_horizontal/filter_vertical widgets (#13614).
         """
-        from selenium.webdriver.common.by import By
-
         self.school.students.set([self.lisa, self.peter])
         self.school.alumni.set([self.lisa, self.peter])
         self.admin_login(username="super", password="secret", login_url="/")
         change_url = reverse(
             "admin:admin_widgets_school_change", args=(self.school.id,)
         )
-        self.selenium.get(self.live_server_url + change_url)
+        self.page.goto(self.live_server_url + change_url)
         # Navigate away and go back to the change form page.
-        self.selenium.find_element(By.LINK_TEXT, "Home").click()
-        self.selenium.back()
+        self.page.get_by_role("link", name="Home").click()
+        self.page.go_back()
         expected_unselected_values = [
             str(self.arthur.id),
             str(self.bob.id),
@@ -1807,49 +1764,41 @@ def test_refresh_page(self):
         change_url = reverse(
             "admin:admin_widgets_school_change", args=(self.school.id,)
         )
-        self.selenium.get(self.live_server_url + change_url)
+        self.page.goto(self.live_server_url + change_url)
 
-        self.assertCountSeleniumElements("#id_students_to > option", 2)
+        self.expect(self.page.locator("#id_students_to > option")).to_have_count(2)
 
-        # self.selenium.refresh() or send_keys(Keys.F5) does hard reload and
-        # doesn't replicate what happens when a user clicks the browser's
-        # 'Refresh' button.
-        with self.wait_page_loaded():
-            self.selenium.execute_script("location.reload()")
+        self.page.reload()
 
-        self.assertCountSeleniumElements("#id_students_to > option", 2)
+        self.expect(self.page.locator("#id_students_to > option")).to_have_count(2)
 
     def test_form_submission_via_enter_key_with_filter_horizontal(self):
         """
         The main form can be submitted correctly by pressing the enter key.
         There is no shadowing from other buttons inside the form.
         """
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.common.keys import Keys
-
         self.school.students.set([self.peter])
         self.school.alumni.set([self.lisa])
 
         self.admin_login(username="super", password="secret", login_url="/")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
         )
 
-        self.wait_page_ready()
-        self.select_option("#id_students_from", str(self.lisa.id))
-        self.selenium.find_element(By.ID, "id_students_add").click()
-        self.select_option("#id_alumni_from", str(self.peter.id))
-        self.selenium.find_element(By.ID, "id_alumni_add").click()
+        self.page.locator("#id_students_from").select_option(value=str(self.lisa.id))
+        self.page.locator("#id_students_add").click()
+        self.page.locator("#id_alumni_from").select_option(value=str(self.peter.id))
+        self.page.locator("#id_alumni_add").click()
 
         # Trigger form submission via Enter key on a text input field.
-        name_input = self.selenium.find_element(By.ID, "id_name")
+        name_input = self.page.locator("#id_name")
         name_input.click()
-        name_input.send_keys(Keys.ENTER)
+        name_input.press("Enter")
 
         # Form was submitted, success message should be shown.
-        self.wait_for_text(
-            "li.success", "The school “School of Awesome” was changed successfully."
+        self.expect(self.page.locator("li.success")).to_have_text(
+            "The school “School of Awesome” was changed successfully."
         )
 
         # Changes should be stored properly in the database.
@@ -1863,23 +1812,18 @@ def test_form_submission_via_enter_key_with_filter_horizontal(self):
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_vertical_arrow_buttons_layout(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url
             + reverse("admin:admin_widgets_school_change", args=(self.school.id,))
         )
-        students = self.selenium.find_element(By.CSS_SELECTOR, ".field-students")
-        self.selenium.execute_script("window.scrollTo(0, %s);" % students.location["y"])
-        buttons = self.selenium.find_element(
-            By.CSS_SELECTOR, "div.selector.stacked ul.selector-chooser"
-        )
-        self.assertTrue(buttons.is_displayed())
+        self.page.locator(".field-students").scroll_into_view_if_needed()
+        buttons = self.page.locator("div.selector.stacked ul.selector-chooser")
+        self.expect(buttons).to_be_visible()
         self.take_screenshot("arrow_buttons")
 
 
-class AdminRawIdWidgetSeleniumTests(AdminWidgetSeleniumTestCase):
+class AdminRawIdWidgetPlaywrightTests(AdminWidgetPlaywrightTestCase):
     def setUp(self):
         super().setUp()
         self.blues = Band.objects.create(name="Bogey Blues")
@@ -1887,159 +1831,135 @@ def setUp(self):
 
     @screenshot_cases(["desktop_size", "mobile_size", "rtl", "dark", "high_contrast"])
     def test_ForeignKey(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_event_add")
-        )
-        main_window = self.selenium.current_window_handle
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_event_add"))
         self.take_screenshot("raw_id_widget")
 
-        # No value has been selected yet
-        self.assertEqual(
-            self.selenium.find_element(By.ID, "id_main_band").get_attribute("value"), ""
-        )
+        main_band_input = self.page.locator("#id_main_band")
+
+        # No value has been selected yet.
+        self.expect(main_band_input).to_have_value("")
 
-        # Open the popup window and click on a band
-        self.selenium.find_element(By.ID, "lookup_id_main_band").click()
-        self.wait_for_and_switch_to_popup()
-        link = self.selenium.find_element(By.LINK_TEXT, "Bogey Blues")
-        self.assertIn(f"/band/{self.blues.pk}/", link.get_attribute("href"))
-        link.click()
+        # Open the popup window and click on a band.
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#lookup_id_main_band").click()
+        popup = popup_info.value
+        link = popup.get_by_role("link", name="Bogey Blues")
+        self.expect(link).to_have_attribute(
+            "href", re.compile(rf"/band/{self.blues.pk}/")
+        )
+        self.click_and_expect_popup_to_close(link)
 
-        # The field now contains the selected band's id
-        self.selenium.switch_to.window(main_window)
-        self.wait_for_value("#id_main_band", str(self.blues.pk))
+        # The field now contains the selected band's id.
+        self.expect(main_band_input).to_have_value(str(self.blues.pk))
 
-        # Reopen the popup window and click on another band
-        self.selenium.find_element(By.ID, "lookup_id_main_band").click()
-        self.wait_for_and_switch_to_popup()
-        link = self.selenium.find_element(By.LINK_TEXT, "Green Potatoes")
-        self.assertIn(f"/band/{self.potatoes.pk}/", link.get_attribute("href"))
-        link.click()
+        # Reopen the popup window and click on another band.
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#lookup_id_main_band").click()
+        popup = popup_info.value
+        link = popup.get_by_role("link", name="Green Potatoes")
+        self.expect(link).to_have_attribute(
+            "href", re.compile(rf"/band/{self.potatoes.pk}/")
+        )
+        self.click_and_expect_popup_to_close(link)
 
-        # The field now contains the other selected band's id
-        self.selenium.switch_to.window(main_window)
-        self.wait_for_value("#id_main_band", str(self.potatoes.pk))
+        # The field now contains the other selected band's id.
+        self.expect(main_band_input).to_have_value(str(self.potatoes.pk))
 
     def test_many_to_many(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
-        self.selenium.get(
-            self.live_server_url + reverse("admin:admin_widgets_event_add")
-        )
-        main_window = self.selenium.current_window_handle
+        self.page.goto(self.live_server_url + reverse("admin:admin_widgets_event_add"))
 
-        # No value has been selected yet
-        self.assertEqual(
-            self.selenium.find_element(By.ID, "id_supporting_bands").get_attribute(
-                "value"
-            ),
-            "",
-        )
+        supporting_bands_input = self.page.locator("#id_supporting_bands")
 
-        # Help text for the field is displayed
-        self.assertEqual(
-            self.selenium.find_element(
-                By.CSS_SELECTOR, ".field-supporting_bands div.help"
-            ).text,
-            "Supporting Bands.",
-        )
+        # No value has been selected yet.
+        self.expect(supporting_bands_input).to_have_value("")
 
-        # Open the popup window and click on a band
-        self.selenium.find_element(By.ID, "lookup_id_supporting_bands").click()
-        self.wait_for_and_switch_to_popup()
-        link = self.selenium.find_element(By.LINK_TEXT, "Bogey Blues")
-        self.assertIn(f"/band/{self.blues.pk}/", link.get_attribute("href"))
-        link.click()
+        # Help text for the field is displayed.
+        help_text = self.page.locator(".field-supporting_bands div.help")
+        self.expect(help_text).to_have_text("Supporting Bands.")
 
-        # The field now contains the selected band's id
-        self.selenium.switch_to.window(main_window)
-        self.wait_for_value("#id_supporting_bands", str(self.blues.pk))
+        # Open the popup window and click on a band.
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#lookup_id_supporting_bands").click()
+        popup = popup_info.value
+        link = popup.get_by_role("link", name="Bogey Blues")
+        self.expect(link).to_have_attribute(
+            "href", re.compile(rf"/band/{self.blues.pk}/")
+        )
+        self.click_and_expect_popup_to_close(link)
 
-        # Reopen the popup window and click on another band
-        self.selenium.find_element(By.ID, "lookup_id_supporting_bands").click()
-        self.wait_for_and_switch_to_popup()
-        link = self.selenium.find_element(By.LINK_TEXT, "Green Potatoes")
-        self.assertIn(f"/band/{self.potatoes.pk}/", link.get_attribute("href"))
-        link.click()
+        # The field now contains the selected band's id.
+        self.expect(supporting_bands_input).to_have_value(str(self.blues.pk))
 
-        # The field now contains the two selected bands' ids
-        self.selenium.switch_to.window(main_window)
-        self.wait_for_value(
-            "#id_supporting_bands", f"{self.blues.pk},{self.potatoes.pk}"
+        # Reopen the popup window and click on another band.
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#lookup_id_supporting_bands").click()
+        popup = popup_info.value
+        link = popup.get_by_role("link", name="Green Potatoes")
+        self.expect(link).to_have_attribute(
+            "href", re.compile(rf"/band/{self.potatoes.pk}/")
         )
+        self.click_and_expect_popup_to_close(link)
 
+        # The field now contains the two selected bands' ids.
+        self.expect(supporting_bands_input).to_have_value(
+            f"{self.blues.pk},{self.potatoes.pk}",
+        )
 
-class RelatedFieldWidgetSeleniumTests(AdminWidgetSeleniumTestCase):
-    def test_ForeignKey_using_to_field(self):
-        from selenium.webdriver import ActionChains
-        from selenium.webdriver.common.by import By
-        from selenium.webdriver.support.ui import Select
 
+class RelatedFieldWidgetPlaywrightTests(AdminWidgetPlaywrightTestCase):
+    def test_ForeignKey_using_to_field(self):
         self.admin_login(username="super", password="secret", login_url="/")
-        with self.wait_page_loaded():
-            self.selenium.get(
-                self.live_server_url + reverse("admin:admin_widgets_profile_add")
-            )
+        self.page.goto(
+            self.live_server_url + reverse("admin:admin_widgets_profile_add")
+        )
 
-        main_window = self.selenium.current_window_handle
         # Click the Add User button to add new
-        self.selenium.find_element(By.ID, "add_id_user").click()
-        self.wait_for_and_switch_to_popup()
-        password_field = self.selenium.find_element(By.ID, "id_password")
-        password_field.send_keys("password")
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#add_id_user").click()
+        popup = popup_info.value
+        popup.locator("#id_password").fill("password")
 
-        username_field = self.selenium.find_element(By.ID, "id_username")
         username_value = "newuser"
-        username_field.send_keys(username_value)
+        popup.locator("#id_username").fill(username_value)
 
         save_button_css_selector = ".submit-row > input[type=submit]"
-        self.selenium.find_element(By.CSS_SELECTOR, save_button_css_selector).click()
-        self.selenium.switch_to.window(main_window)
-        # The field now contains the new user
-        self.selenium.find_element(By.CSS_SELECTOR, "#id_user option[value=newuser]")
+        with popup.expect_event("close"):
+            popup.locator(save_button_css_selector).click()
 
-        self.selenium.find_element(By.ID, "view_id_user").click()
-        self.wait_for_value("#id_username", "newuser")
-        self.selenium.back()
+        # The field now contains the new user
+        self.page.locator("#view_id_user").click()
+        self.expect(self.page.locator("#id_username")).to_have_value("newuser")
+        self.page.go_back()
 
         # Chrome and Safari don't update related object links when selecting
         # the same option as previously submitted. As a consequence, the
         # "pencil" and "eye" buttons remain disable, so select
         # "- Select an option -" first.
-        select = Select(self.selenium.find_element(By.ID, "id_user"))
-        select.select_by_index(0)
-        select.select_by_value("newuser")
+        self.page.locator("#id_user").select_option(index=0)
+        self.page.locator("#id_user").select_option(value="newuser")
         # Click the Change User button to change it
-        self.selenium.find_element(By.ID, "change_id_user").click()
-        self.wait_for_and_switch_to_popup()
+        with self.page.expect_popup() as popup_info:
+            self.page.locator("#change_id_user").click()
+        popup = popup_info.value
 
-        username_field = self.selenium.find_element(By.ID, "id_username")
         username_value = "changednewuser"
-        username_field.clear()
-        username_field.send_keys(username_value)
+        popup.locator("#id_username").fill(username_value)
 
-        save_button_css_selector = ".submit-row > input[type=submit]"
-        self.selenium.find_element(By.CSS_SELECTOR, save_button_css_selector).click()
-        self.selenium.switch_to.window(main_window)
-        self.selenium.find_element(
-            By.CSS_SELECTOR, "#id_user option[value=changednewuser]"
-        )
+        with popup.expect_event("close"):
+            popup.locator(save_button_css_selector).click()
 
-        element = self.selenium.find_element(By.ID, "view_id_user")
-        ActionChains(self.selenium).move_to_element(element).click(element).perform()
-        self.wait_for_value("#id_username", "changednewuser")
-        self.selenium.back()
+        # The field now contains the changed user
+        self.page.locator("#view_id_user").click()
+        self.expect(self.page.locator("#id_username")).to_have_value("changednewuser")
+        self.page.go_back()
 
-        select = Select(self.selenium.find_element(By.ID, "id_user"))
-        select.select_by_value("changednewuser")
+        self.page.locator("#id_user").select_option(value="changednewuser")
         # Go ahead and submit the form to make sure it works
-        self.selenium.find_element(By.CSS_SELECTOR, save_button_css_selector).click()
-        self.wait_for_text(
-            "li.success", "The profile “changednewuser” was added successfully."
+        self.page.locator("input[name='_save']").click()
+        self.expect(self.page.locator("li.success")).to_have_text(
+            "The profile “changednewuser” was added successfully.",
         )
         profiles = Profile.objects.all()
         self.assertEqual(len(profiles), 1)
@@ -2047,92 +1967,72 @@ def test_ForeignKey_using_to_field(self):
 
 
 @skipUnless(Image, "Pillow not installed")
-class ImageFieldWidgetsSeleniumTests(AdminWidgetSeleniumTestCase):
+class ImageFieldWidgetsPlaywrightTests(AdminWidgetPlaywrightTestCase):
     name_input_id = "id_name"
     photo_input_id = "id_photo"
     tests_files_folder = "%s/files" % Path(__file__).parent.parent
     clear_checkbox_id = "photo-clear_id"
 
-    def _submit_and_wait(self):
-        from selenium.webdriver.common.by import By
-
-        with self.wait_page_loaded():
-            self.selenium.find_element(
-                By.CSS_SELECTOR, "input[value='Save and continue editing']"
-            ).click()
-
     def _run_image_upload_path(self):
-        from selenium.webdriver.common.by import By
-
         self.admin_login(username="super", password="secret", login_url="/")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("admin:admin_widgets_student_add"),
         )
         # Add a student.
-        name_input = self.selenium.find_element(By.ID, self.name_input_id)
-        name_input.send_keys("Joe Doe")
-        photo_input = self.selenium.find_element(By.ID, self.photo_input_id)
-        photo_input.send_keys(f"{self.tests_files_folder}/test.png")
-        self._submit_and_wait()
+        self.page.locator(f"#{self.name_input_id}").fill("Joe Doe")
+        self.page.locator(f"#{self.photo_input_id}").set_input_files(
+            f"{self.tests_files_folder}/test.png"
+        )
+        self.page.locator("input[value='Save and continue editing']").click()
+        self.expect(self.page.locator(".messagelist .success")).to_have_text(
+            "The student “Joe Doe” was added successfully. You may edit it "
+            "again below."
+        )
         student = Student.objects.last()
         self.assertEqual(student.name, "Joe Doe")
         self.assertRegex(student.photo.name, r"^photos\/(test|test_.+).png")
 
     def test_clearablefileinput_widget(self):
-        from selenium.webdriver.common.by import By
-
         self._run_image_upload_path()
-        self.selenium.find_element(By.ID, self.clear_checkbox_id).click()
-        self._submit_and_wait()
+        self.page.locator(f"#{self.clear_checkbox_id}").click()
+        self.page.locator("input[value='Save and continue editing']").click()
+        self.expect(self.page.locator(".messagelist .success")).to_have_text(
+            "The student “Joe Doe” was changed successfully. You may edit it "
+            "again below."
+        )
         student = Student.objects.last()
         self.assertEqual(student.name, "Joe Doe")
         self.assertEqual(student.photo.name, "")
         # "Currently" with "Clear" checkbox and "Change" are not shown.
-        photo_field_row = self.selenium.find_element(By.CSS_SELECTOR, ".field-photo")
-        self.assertNotIn("Currently", photo_field_row.text)
-        self.assertNotIn("Change", photo_field_row.text)
+        photo_field_row = self.page.locator(".field-photo")
+        self.expect(photo_field_row).not_to_contain_text("Currently")
+        self.expect(photo_field_row).not_to_contain_text("Change")
 
     def test_clearablefileinput_widget_invalid_file(self):
-        from selenium.webdriver.common.by import By
-
         self._run_image_upload_path()
-        # Uploading non-image files is not supported by Safari with Selenium,
-        # so upload a broken one instead.
-        photo_input = self.selenium.find_element(By.ID, self.photo_input_id)
-        photo_input.send_keys(f"{self.tests_files_folder}/brokenimg.png")
-        self._submit_and_wait()
-        self.assertEqual(
-            self.selenium.find_element(By.CSS_SELECTOR, ".errorlist li").text,
-            (
-                "Upload a valid image. The file you uploaded was either not an image "
-                "or a corrupted image."
-            ),
+        self.page.locator(f"#{self.photo_input_id}").set_input_files(
+            f"{self.tests_files_folder}/brokenimg.png"
+        )
+        self.page.locator("input[value='Save and continue editing']").click()
+        self.expect(self.page.locator(".errorlist li")).to_have_text(
+            "Upload a valid image. The file you uploaded was either not an image "
+            "or a corrupted image.",
         )
         # "Currently" with "Clear" checkbox and "Change" still shown.
-        photo_field_row = self.selenium.find_element(By.CSS_SELECTOR, ".field-photo")
-        self.assertIn("Currently", photo_field_row.text)
-        self.assertIn("Change", photo_field_row.text)
+        photo_field_row = self.page.locator(".field-photo")
+        self.expect(photo_field_row).to_contain_text("Currently")
+        self.expect(photo_field_row).to_contain_text("Change")
 
     def test_clearablefileinput_widget_preserve_clear_checkbox(self):
-        from selenium.webdriver.common.by import By
-
         self._run_image_upload_path()
         # "Clear" is not checked by default.
-        self.assertIs(
-            self.selenium.find_element(By.ID, self.clear_checkbox_id).is_selected(),
-            False,
-        )
+        self.expect(self.page.locator(f"#{self.clear_checkbox_id}")).not_to_be_checked()
         # "Clear" was checked, but a validation error is raised.
-        name_input = self.selenium.find_element(By.ID, self.name_input_id)
-        name_input.clear()
-        self.selenium.find_element(By.ID, self.clear_checkbox_id).click()
-        self._submit_and_wait()
-        self.assertEqual(
-            self.selenium.find_element(By.CSS_SELECTOR, ".errorlist li").text,
+        self.page.locator(f"#{self.name_input_id}").clear()
+        self.page.locator(f"#{self.clear_checkbox_id}").click()
+        self.page.locator("input[value='Save and continue editing']").click()
+        self.expect(self.page.locator(".errorlist li")).to_have_text(
             "This field is required.",
         )
         # "Clear" persists checked.
-        self.assertIs(
-            self.selenium.find_element(By.ID, self.clear_checkbox_id).is_selected(),
-            True,
-        )
+        self.expect(self.page.locator(f"#{self.clear_checkbox_id}")).to_be_checked()
diff --git a/tests/basic/models.py b/tests/basic/models.py
index 79a06763f270..32dbff6f7095 100644
--- a/tests/basic/models.py
+++ b/tests/basic/models.py
@@ -61,3 +61,29 @@ class PrimaryKeyWithFalseyDbDefault(models.Model):
 
 class ChildPrimaryKeyWithDefault(PrimaryKeyWithDefault):
     pass
+
+
+# RemovedInDjango70Warning.
+class FromDbOldSignature(models.Model):
+    name = models.CharField(max_length=20)
+
+    @classmethod
+    def from_db(cls, db, field_names, values):
+        instance = super().from_db(db, field_names, values)
+        instance._loaded_values = dict(zip(field_names, values))
+        return instance
+
+
+# RemovedInDjango70Warning.
+class FromDbOldSignatureRelated(models.Model):
+    old = models.ForeignKey(FromDbOldSignature, models.CASCADE)
+
+
+class FromDbNewSignature(models.Model):
+    name = models.CharField(max_length=20)
+
+    @classmethod
+    def from_db(cls, db, field_names, values, *, fetch_mode=None):
+        instance = super().from_db(db, field_names, values, fetch_mode=fetch_mode)
+        instance._from_db_fetch_mode = fetch_mode
+        return instance
diff --git a/tests/basic/tests.py b/tests/basic/tests.py
index a6609f0f30d8..2a8e596bf3c2 100644
--- a/tests/basic/tests.py
+++ b/tests/basic/tests.py
@@ -24,6 +24,7 @@
 )
 from django.test.utils import CaptureQueriesContext
 from django.utils.connection import ConnectionDoesNotExist
+from django.utils.deprecation import RemovedInDjango70Warning
 from django.utils.translation import gettext_lazy
 
 from .models import (
@@ -31,6 +32,9 @@
     ArticleSelectOnSave,
     ChildPrimaryKeyWithDefault,
     FeaturedArticle,
+    FromDbNewSignature,
+    FromDbOldSignature,
+    FromDbOldSignatureRelated,
     PrimaryKeyWithDbDefault,
     PrimaryKeyWithDefault,
     PrimaryKeyWithFalseyDbDefault,
@@ -1120,3 +1124,54 @@ def test_refresh_ignores_fetch_mode_if_no_instance_plucked(self):
         fa.refresh_from_db(from_queryset=from_queryset)
         self.assertEqual(fa._state.fetch_mode, models.FETCH_PEERS)
         self.assertEqual(fa.article._state.fetch_mode, models.FETCH_PEERS)
+
+
+class ModelFromDbTests(TestCase):
+    # RemovedInDjango70Warning: Remove the FromDbOldSignature tests when the
+    # deprecation ends.
+    deprecation_msg = (
+        "FromDbOldSignature.from_db() must accept a fetch_mode keyword "
+        "argument. Support for from_db() methods that do not accept it is "
+        "deprecated."
+    )
+
+    def test_old_signature_iteration(self):
+        obj = FromDbOldSignature.objects.create(name="test")
+        with self.assertWarnsMessage(RemovedInDjango70Warning, self.deprecation_msg):
+            instances = list(FromDbOldSignature.objects.all())
+        self.assertEqual(instances, [obj])
+        self.assertEqual(instances[0]._loaded_values, {"id": obj.pk, "name": "test"})
+
+    def test_old_signature_get(self):
+        obj = FromDbOldSignature.objects.create(name="test")
+        with self.assertWarnsMessage(RemovedInDjango70Warning, self.deprecation_msg):
+            fetched = FromDbOldSignature.objects.get(pk=obj.pk)
+        self.assertEqual(fetched._loaded_values, {"id": obj.pk, "name": "test"})
+
+    def test_old_signature_select_related(self):
+        obj = FromDbOldSignature.objects.create(name="test")
+        related = FromDbOldSignatureRelated.objects.create(old=obj)
+        with self.assertWarnsMessage(RemovedInDjango70Warning, self.deprecation_msg):
+            fetched = FromDbOldSignatureRelated.objects.select_related("old").get(
+                pk=related.pk
+            )
+        self.assertEqual(fetched.old._loaded_values, {"id": obj.pk, "name": "test"})
+
+    def test_old_signature_raw(self):
+        obj = FromDbOldSignature.objects.create(name="test")
+        with self.assertWarnsMessage(RemovedInDjango70Warning, self.deprecation_msg):
+            instances = list(
+                FromDbOldSignature.objects.raw("SELECT * FROM basic_fromdboldsignature")
+            )
+        self.assertEqual(instances, [obj])
+        self.assertEqual(instances[0]._loaded_values, {"id": obj.pk, "name": "test"})
+
+    def test_new_signature_receives_fetch_mode(self):
+        obj = FromDbNewSignature.objects.create(name="test")
+        fetched = FromDbNewSignature.objects.get(pk=obj.pk)
+        self.assertIs(fetched._from_db_fetch_mode, models.FETCH_ONE)
+
+    def test_new_signature_receives_fetch_mode_peers(self):
+        FromDbNewSignature.objects.create(name="test")
+        (fetched,) = FromDbNewSignature.objects.fetch_mode(models.FETCH_PEERS)
+        self.assertIs(fetched._from_db_fetch_mode, models.FETCH_PEERS)
diff --git a/tests/forms_tests/field_tests/test_floatfield.py b/tests/forms_tests/field_tests/test_floatfield.py
index 77b404102c11..5dbb9c4c7576 100644
--- a/tests/forms_tests/field_tests/test_floatfield.py
+++ b/tests/forms_tests/field_tests/test_floatfield.py
@@ -1,7 +1,8 @@
+from playwright_tests import PlaywrightTestCase
+
 from django.core.exceptions import ValidationError
 from django.forms import FloatField, NumberInput
 from django.test import SimpleTestCase
-from django.test.selenium import SeleniumTestCase
 from django.test.utils import override_settings
 from django.urls import reverse
 from django.utils import formats, translation
@@ -144,7 +145,7 @@ def test_floatfield_support_thousands_separator(self):
 
 
 @override_settings(ROOT_URLCONF="forms_tests.urls")
-class FloatFieldHTMLTest(SeleniumTestCase):
+class FloatFieldHTMLTest(PlaywrightTestCase):
     available_apps = ["forms_tests"]
 
     def test_float_field_rendering_passes_client_side_validation(self):
@@ -152,12 +153,8 @@ def test_float_field_rendering_passes_client_side_validation(self):
         Rendered widget allows non-integer value with the client-side
         validation.
         """
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(self.live_server_url + reverse("form_view"))
-        number_input = self.selenium.find_element(By.ID, "id_number")
-        number_input.send_keys("0.5")
-        is_valid = self.selenium.execute_script(
-            "return document.getElementById('id_number').checkValidity()"
-        )
-        self.assertTrue(is_valid)
+        self.page.goto(self.live_server_url + reverse("form_view"))
+        number_input = self.page.locator("#id_number")
+        number_input.fill("0.5")
+        self.expect(number_input).to_have_value("0.5")
+        self.expect(self.page.locator("#id_number:valid")).to_be_attached()
diff --git a/tests/forms_tests/tests/test_widgets.py b/tests/forms_tests/tests/test_widgets.py
index 674985982877..c71abc29a9d5 100644
--- a/tests/forms_tests/tests/test_widgets.py
+++ b/tests/forms_tests/tests/test_widgets.py
@@ -1,4 +1,5 @@
-from django.contrib.admin.tests import AdminSeleniumTestCase
+from playwright_tests import AdminPlaywrightTestCase
+
 from django.test import override_settings
 from django.urls import reverse
 
@@ -6,20 +7,18 @@
 
 
 @override_settings(ROOT_URLCONF="forms_tests.urls")
-class LiveWidgetTests(AdminSeleniumTestCase):
-    available_apps = ["forms_tests"] + AdminSeleniumTestCase.available_apps
+class LiveWidgetTests(AdminPlaywrightTestCase):
+    available_apps = ["forms_tests"] + AdminPlaywrightTestCase.available_apps
 
     def test_textarea_trailing_newlines(self):
         """
         A roundtrip on a ModelForm doesn't alter the TextField value
         """
-        from selenium.webdriver.common.by import By
-
         article = Article.objects.create(content="\nTst\n")
-        self.selenium.get(
+        self.page.goto(
             self.live_server_url + reverse("article_form", args=[article.pk])
         )
-        with self.wait_page_loaded():
-            self.selenium.find_element(By.ID, "submit").click()
+        self.page.locator("#submit").click()
+        self.page.wait_for_load_state("load")
         article = Article.objects.get(pk=article.pk)
         self.assertEqual(article.content, "\r\nTst\r\n")
diff --git a/tests/middleware/test_csp.py b/tests/middleware/test_csp.py
index fcdb9a1c1565..f0a4af2a7ced 100644
--- a/tests/middleware/test_csp.py
+++ b/tests/middleware/test_csp.py
@@ -1,10 +1,8 @@
-import time
-
+from playwright_tests import PlaywrightTestCase
 from utils_tests.test_csp import basic_config, basic_policy
 
 from django.contrib.staticfiles.testing import StaticLiveServerTestCase
 from django.test import SimpleTestCase
-from django.test.selenium import SeleniumTestCase
 from django.test.utils import modify_settings, override_settings
 from django.utils.csp import CSP
 
@@ -181,7 +179,7 @@ def test_csp_override_both_decorator(self):
 @modify_settings(
     MIDDLEWARE={"append": "django.middleware.csp.ContentSecurityPolicyMiddleware"}
 )
-class CSPSeleniumTestCase(SeleniumTestCase, StaticLiveServerTestCase):
+class CSPPlaywrightTestCase(PlaywrightTestCase, StaticLiveServerTestCase):
     available_apps = ["middleware"]
 
     def setUp(self):
@@ -190,8 +188,8 @@ def setUp(self):
 
     def test_reports_are_generated(self):
         url = self.live_server_url + "/csp-failure/"
-        self.selenium.get(url)
-        time.sleep(1)  # Allow time for the CSP report to be sent.
+        self.page.goto(url)
+        self.page.wait_for_load_state("networkidle")
         reports = sorted(
             (r["csp-report"]["document-uri"], r["csp-report"]["violated-directive"])
             for r in csp_reports
diff --git a/tests/playwright_tests/__init__.py b/tests/playwright_tests/__init__.py
new file mode 100644
index 000000000000..c3d07eb26660
--- /dev/null
+++ b/tests/playwright_tests/__init__.py
@@ -0,0 +1,9 @@
+from .admin import AdminPlaywrightTestCase
+from .base import PlaywrightTestCase, PlaywrightTestCaseMeta, screenshot_cases
+
+__all__ = (
+    "AdminPlaywrightTestCase",
+    "PlaywrightTestCase",
+    "PlaywrightTestCaseMeta",
+    "screenshot_cases",
+)
diff --git a/tests/playwright_tests/admin.py b/tests/playwright_tests/admin.py
new file mode 100644
index 000000000000..85e63964efdc
--- /dev/null
+++ b/tests/playwright_tests/admin.py
@@ -0,0 +1,125 @@
+from django.contrib.staticfiles.testing import StaticLiveServerTestCase
+from django.test import modify_settings, override_settings
+from django.utils.csp import CSP
+from django.utils.translation import gettext as _
+
+from .base import PlaywrightTestCase
+
+# Make unittest ignore frames in this module when reporting failures.
+__unittest = True
+
+
+@modify_settings(
+    MIDDLEWARE={"append": "django.middleware.csp.ContentSecurityPolicyMiddleware"}
+)
+@override_settings(
+    SECURE_CSP={
+        "default-src": [CSP.NONE],
+        "connect-src": [CSP.SELF],
+        "img-src": [CSP.SELF],
+        "script-src": [CSP.SELF],
+        "style-src": [CSP.SELF],
+    },
+)
+class AdminPlaywrightTestCase(PlaywrightTestCase, StaticLiveServerTestCase):
+    available_apps = [
+        "django.contrib.admin",
+        "django.contrib.auth",
+        "django.contrib.contenttypes",
+        "django.contrib.sessions",
+        "django.contrib.sites",
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        # Track CSP violations via SecurityPolicyViolationEvent.
+        cls._csp_violations = []
+        cls._browser_context.expose_function(
+            "cspviolation",
+            lambda violation: cls._csp_violations.append(violation),
+        )
+        cls._browser_context.add_init_script("""
+            document.addEventListener('securitypolicyviolation', (e) => {
+                window.cspviolation({
+                    blockedURI: e.blockedURI,
+                    violatedDirective: e.violatedDirective,
+                    effectiveDirective: e.effectiveDirective,
+                    originalPolicy: e.originalPolicy,
+                    documentURI: e.documentURI,
+                });
+            });
+        """)
+
+    def tearDown(self):
+        try:
+            # WebKit injects inline style during screenshot(), which triggers
+            # a style-src-elem CSP violation.
+            violations = [
+                violation
+                for violation in self._csp_violations
+                if not (
+                    self.browser == "webkit"
+                    and violation["effectiveDirective"] == "style-src-elem"
+                    and violation["blockedURI"] == "inline"
+                )
+            ]
+            # Ensure that no CSP violations were logged in the browser.
+            self.assertEqual(violations, [])
+        finally:
+            self._csp_violations.clear()
+            super().tearDown()
+
+    def admin_login(self, username, password, login_url="/admin/"):
+        """
+        Log in to the admin.
+        """
+        self.page.goto(f"{self.live_server_url}{login_url}")
+        self.page.locator('[name="username"]').fill(username)
+        self.page.locator('[name="password"]').fill(password)
+        login_text = _("Log in")
+        self.page.get_by_role("button", name=login_text).click()
+        self.page.wait_for_url(f"{self.live_server_url}{login_url}")
+
+    def click_and_expect_popup_to_close(self, locator):
+        """
+        Click a button that closes the popup and wait until the popup is
+        closed.
+        """
+        from playwright.sync_api import Error
+
+        popup = locator.page
+        with popup.expect_event("close"):
+            try:
+                locator.click(no_wait_after=True)
+            except Error:
+                # The popup may close before Playwright finishes the click.
+                # See https://github.com/microsoft/playwright/issues/26900
+                if not popup.is_closed():
+                    raise
+
+    def _assertOptionsValues(self, options_selector, values):
+        options = self.page.locator(options_selector)
+        if values:
+            actual_values = []
+            for option in options.all():
+                actual_values.append(option.get_attribute("value"))
+            self.assertEqual(values, actual_values)
+        else:
+            # Wait until no options match the selector, as expected after a
+            # DOM update that clears the <select>.
+            self.expect(options).to_have_count(0)
+
+    def assertSelectOptions(self, selector, values):
+        """
+        Assert that the <SELECT> widget identified by `selector` has the
+        options with the given `values`.
+        """
+        self._assertOptionsValues("%s > option" % selector, values)
+
+    def assertSelectedOptions(self, selector, values):
+        """
+        Assert that the <SELECT> widget identified by `selector` has the
+        selected options with the given `values`.
+        """
+        self._assertOptionsValues("%s > option:checked" % selector, values)
diff --git a/tests/playwright_tests/base.py b/tests/playwright_tests/base.py
new file mode 100644
index 000000000000..190f0792f5b9
--- /dev/null
+++ b/tests/playwright_tests/base.py
@@ -0,0 +1,246 @@
+import os
+import sys
+import unittest
+from contextlib import contextmanager
+from functools import wraps
+from pathlib import Path
+
+from django.conf import settings
+from django.test import LiveServerTestCase, override_settings, tag
+from django.utils.text import capfirst
+
+
+class PlaywrightTestCaseMeta(type(LiveServerTestCase)):
+    # List of browsers to dynamically create test classes for.
+    browsers = []
+    # Sentinel value to differentiate browser-specific instances.
+    browser = None
+    # Run browsers with a visible window when True.
+    headed = False
+    # Delay in milliseconds between Playwright operations.
+    slow_mo = 0
+
+    def __new__(cls, name, bases, attrs):
+        """
+        Dynamically create new classes and add them to the test module when
+        multiple browser specs are provided (e.g. --playwright=XXXX).
+        """
+        test_class = super().__new__(cls, name, bases, attrs)
+        # If the test class is either browser-specific or a test base, return
+        # it.
+        if test_class.browser or not any(
+            name.startswith("test") and callable(value) for name, value in attrs.items()
+        ):
+            return test_class
+        elif test_class.browsers:
+            # Reuse the created test class to make it browser-specific.
+            # We can't rename it to include the browser name or create a
+            # subclass like we do with the remaining browsers as it would
+            # either duplicate tests or prevent pickling of its instances.
+            first_browser = test_class.browsers[0]
+            test_class.browser = first_browser
+            # Create subclasses for each of the remaining browsers and expose
+            # them through the test's module namespace.
+            module = sys.modules[test_class.__module__]
+            for browser in test_class.browsers[1:]:
+                browser_test_class = cls.__new__(
+                    cls,
+                    "%s%s" % (capfirst(browser), name),
+                    (test_class,),
+                    {
+                        "browser": browser,
+                        "__module__": test_class.__module__,
+                    },
+                )
+                setattr(module, browser_test_class.__name__, browser_test_class)
+            return test_class
+        # If no browsers were specified, skip this class (it'll still be
+        # discovered).
+        return unittest.skip("No browsers specified.")(test_class)
+
+    @classmethod
+    def import_browser(cls, browser):
+        from playwright.sync_api import Playwright
+
+        if not hasattr(Playwright, browser):
+            raise ImportError(
+                "Playwright browser specification '%s' is not valid." % browser
+            )
+
+
+class ChangeViewportSize:
+    def __init__(self, width, height, page):
+        self.page = page
+        self.new_size = {"width": width, "height": height}
+
+    def __enter__(self):
+        self.old_size = self.page.viewport_size
+        self.page.set_viewport_size(self.new_size)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.old_size:
+            self.page.set_viewport_size(self.old_size)
+
+
+@tag("playwright")
+class PlaywrightTestCase(LiveServerTestCase, metaclass=PlaywrightTestCaseMeta):
+    default_timeout = 10000  # milliseconds
+    screenshots = False
+    browser_timezone = "America/Chicago"
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if not cls.screenshots:
+            return
+
+        for name, func in list(cls.__dict__.items()):
+            if not hasattr(func, "_screenshot_cases"):
+                continue
+            # Remove the main test.
+            delattr(cls, name)
+            # Add separate tests for each screenshot type.
+            for screenshot_case in getattr(func, "_screenshot_cases"):
+
+                @wraps(func)
+                def test(self, *args, _func=func, _case=screenshot_case, **kwargs):
+                    with getattr(self, _case)():
+                        return _func(self, *args, **kwargs)
+
+                test.__name__ = f"{name}_{screenshot_case}"
+                test.__qualname__ = f"{test.__qualname__}_{screenshot_case}"
+                test._screenshot_name = name
+                test._screenshot_case = screenshot_case
+                setattr(cls, test.__name__, test)
+
+    @classmethod
+    def setUpClass(cls):
+        # Playwright's sync API leaves an asyncio event loop running on the
+        # test thread, which would otherwise raise SynchronousOnlyOperation on
+        # ORM use.
+        cls._old_async_unsafe = os.environ.get("DJANGO_ALLOW_ASYNC_UNSAFE")
+        os.environ["DJANGO_ALLOW_ASYNC_UNSAFE"] = "true"
+        cls.addClassCleanup(cls._restore_async_unsafe)
+
+        from playwright.sync_api import expect, sync_playwright
+
+        cls.expect = staticmethod(expect)
+        cls._pw = sync_playwright().start()
+        cls.addClassCleanup(cls._quit_playwright)
+
+        super().setUpClass()
+
+        browser_type = getattr(cls._pw, cls.browser)
+        ignore_default_args = []
+        if cls.screenshots:
+            ignore_default_args = ["--hide-scrollbars"]
+        cls._browser = browser_type.launch(
+            headless=not cls.headed,
+            slow_mo=cls.slow_mo,
+            ignore_default_args=ignore_default_args,
+            # unittest.installHandler() in DiscoverRunner already handles
+            # SIGINT.
+            handle_sigint=False,
+        )
+        # Use a fixed browser timezone so browser-based tests don't depend on
+        # the local timezone of the machine running them.
+        cls._browser_context = cls._browser.new_context(
+            timezone_id=cls.browser_timezone
+        )
+        cls.page = cls._browser_context.new_page()
+        cls.page.set_default_timeout(cls.default_timeout)
+        cls.addClassCleanup(cls._close_browser)
+
+    @contextmanager
+    def desktop_size(self):
+        with ChangeViewportSize(1280, 720, self.page):
+            yield
+
+    @contextmanager
+    def small_screen_size(self):
+        with ChangeViewportSize(1024, 768, self.page):
+            yield
+
+    @contextmanager
+    def mobile_size(self):
+        with ChangeViewportSize(360, 800, self.page):
+            yield
+
+    @contextmanager
+    def rtl(self):
+        with self.desktop_size():
+            with override_settings(LANGUAGE_CODE=settings.LANGUAGES_BIDI[-1]):
+                yield
+
+    @contextmanager
+    def dark(self):
+        # Navigate to a page before reading/writing storage.
+        self.page.goto(self.live_server_url)
+        self.page.local_storage.set_item("theme", "dark")
+        with self.desktop_size():
+            try:
+                yield
+            finally:
+                self.page.local_storage.remove_item("theme")
+
+    @contextmanager
+    def high_contrast(self):
+        self.page.emulate_media(forced_colors="active")
+        with self.desktop_size():
+            try:
+                yield
+            finally:
+                self.page.emulate_media(forced_colors="none")
+
+    def take_screenshot(self, name):
+        if not self.screenshots:
+            return
+        test = getattr(self, self._testMethodName)
+        filename = f"{test._screenshot_name}--{name}--{test._screenshot_case}.png"
+        path = Path.cwd() / "screenshots" / filename
+        path.parent.mkdir(exist_ok=True, parents=True)
+        self.page.screenshot(path=path)
+
+    @classmethod
+    def _close_browser(cls):
+        # Close resources before attempting to terminate and join the
+        # single-threaded LiveServerThread to avoid a dead lock if the browser
+        # kept a connection alive.
+        if hasattr(cls, "page"):
+            cls.page.close()
+            del cls.page
+        if hasattr(cls, "_browser_context"):
+            cls._browser_context.close()
+            del cls._browser_context
+        if hasattr(cls, "_browser"):
+            cls._browser.close()
+            del cls._browser
+
+    @classmethod
+    def _quit_playwright(cls):
+        cls._close_browser()
+        if hasattr(cls, "_pw"):
+            cls._pw.stop()
+            del cls._pw
+
+    @classmethod
+    def _restore_async_unsafe(cls):
+        if cls._old_async_unsafe is None:
+            os.environ.pop("DJANGO_ALLOW_ASYNC_UNSAFE", None)
+        else:
+            os.environ["DJANGO_ALLOW_ASYNC_UNSAFE"] = cls._old_async_unsafe
+
+
+def screenshot_cases(method_names):
+    if isinstance(method_names, str):
+        method_names = method_names.split(",")
+
+    def wrapper(func):
+        func._screenshot_cases = method_names
+        setattr(
+            func, "tags", {"playwright_screenshot"}.union(getattr(func, "tags", set()))
+        )
+        return func
+
+    return wrapper
diff --git a/tests/requirements/py3-free-threading.txt b/tests/requirements/py3-free-threading.txt
index 4a63a8debcd7..ac76e0f81d0f 100644
--- a/tests/requirements/py3-free-threading.txt
+++ b/tests/requirements/py3-free-threading.txt
@@ -17,7 +17,7 @@ Pillow >= 10.1.0; python_version >= '3.14'
 pymemcache >= 3.4.0
 PyYAML >= 6.0.2; python_version >= '3.14'
 redis >= 5.1.0
-selenium >= 4.23.0
+playwright >= 1.62.0
 sqlparse >= 0.5.0
 tblib >= 3.0.0
 tzdata
diff --git a/tests/requirements/py3.txt b/tests/requirements/py3.txt
index 18fefe8a453c..5fe92f814f1d 100644
--- a/tests/requirements/py3.txt
+++ b/tests/requirements/py3.txt
@@ -14,7 +14,7 @@ pymemcache >= 3.4.0
 pywatchman; sys_platform != 'win32'
 PyYAML >= 6.0.2
 redis >= 5.1.0
-selenium >= 4.23.0
+playwright >= 1.62.0
 sqlparse >= 0.5.0
 tblib >= 3.0.0
 tzdata
diff --git a/tests/runtests.py b/tests/runtests.py
index c24481f8cb5c..10a44b040943 100755
--- a/tests/runtests.py
+++ b/tests/runtests.py
@@ -6,7 +6,6 @@
 import multiprocessing
 import os
 import shutil
-import socket
 import subprocess
 import sys
 import tempfile
@@ -20,13 +19,14 @@
         "Django module not found, reference tests/README.rst for instructions."
     ) from e
 else:
+    from playwright_tests import PlaywrightTestCase, PlaywrightTestCaseMeta
+
     from django.apps import apps
     from django.conf import settings
     from django.core.exceptions import ImproperlyConfigured
     from django.db import connection, connections
     from django.test import TestCase, TransactionTestCase
     from django.test.runner import get_max_test_processes, parallel_type
-    from django.test.selenium import SeleniumTestCase, SeleniumTestCaseBase
     from django.test.utils import NullTimeKeeper, TimeKeeper, get_runner
     from django.utils.deprecation import (
         RemovedAfterNextVersionWarning,
@@ -73,7 +73,7 @@
 # This is a dict mapping RUNTESTS_DIR subdirectory to subdirectories of that
 # directory to skip when searching for test modules.
 SUBDIRS_TO_SKIP = {
-    "": {"import_error_package", "test_runner_apps"},
+    "": {"import_error_package", "playwright_tests", "test_runner_apps"},
     "gis_tests": {"data"},
 }
 
@@ -323,23 +323,24 @@ def teardown_run_tests(state):
     del os.environ["RUNNING_DJANGOS_TEST_SUITE"]
 
 
-class ActionSelenium(argparse.Action):
+class ActionPlaywright(argparse.Action):
     """
     Validate the comma-separated list of requested browsers.
     """
 
     def __call__(self, parser, namespace, values, option_string=None):
         try:
-            import selenium  # NOQA
+            from playwright.sync_api import sync_playwright  # noqa
         except ImportError as e:
-            raise ImproperlyConfigured(f"Error loading selenium module: {e}")
+            raise ImproperlyConfigured(f"Error loading playwright module: {e}")
         browsers = values.split(",")
         for browser in browsers:
             try:
-                SeleniumTestCaseBase.import_webdriver(browser)
+                PlaywrightTestCaseMeta.import_browser(browser)
             except ImportError:
                 raise argparse.ArgumentError(
-                    self, "Selenium browser specification '%s' is not valid." % browser
+                    self,
+                    "Playwright browser specification '%s' is not valid." % browser,
                 )
         setattr(namespace, self.dest, browsers)
 
@@ -593,32 +594,27 @@ def paired_tests(paired_test, options, test_labels, start_at, start_after):
         "test side effects not apparent with normal execution lineup.",
     )
     parser.add_argument(
-        "--selenium",
-        action=ActionSelenium,
+        "--playwright",
+        action=ActionPlaywright,
         metavar="BROWSERS",
-        help="A comma-separated list of browsers to run the Selenium tests against.",
+        help="A comma-separated list of browsers to run the Playwright tests against.",
     )
     parser.add_argument(
         "--screenshots",
         action="store_true",
-        help="Take screenshots during selenium tests to capture the user interface.",
+        help="Take screenshots during Playwright tests to capture the user interface.",
     )
     parser.add_argument(
-        "--headless",
+        "--headed",
         action="store_true",
-        help="Run selenium tests in headless mode, if the browser supports the option.",
-    )
-    parser.add_argument(
-        "--selenium-hub",
-        help="A URL for a selenium hub instance to use in combination with --selenium.",
+        help="Run Playwright tests in headed mode (with a visible browser window).",
     )
     parser.add_argument(
-        "--external-host",
-        default=socket.gethostname(),
-        help=(
-            "The external host that can be reached by the selenium hub instance when "
-            "running Selenium tests via Selenium Hub."
-        ),
+        "--slowmo",
+        type=int,
+        default=0,
+        metavar="MS",
+        help="Slow down Playwright operations by the specified number of milliseconds.",
     )
     parser.add_argument(
         "--debug-sql",
@@ -696,15 +692,12 @@ def paired_tests(paired_test, options, test_labels, start_at, start_after):
 
     options = parser.parse_args()
 
-    using_selenium_hub = options.selenium and options.selenium_hub
-    if options.selenium_hub and not options.selenium:
-        parser.error(
-            "--selenium-hub and --external-host require --selenium to be used."
-        )
-    if using_selenium_hub and not options.external_host:
-        parser.error("--selenium-hub and --external-host must be used together.")
-    if options.screenshots and not options.selenium:
-        parser.error("--screenshots require --selenium to be used.")
+    if options.screenshots and not options.playwright:
+        parser.error("--screenshots require --playwright to be used.")
+    if options.headed and not options.playwright:
+        parser.error("--headed requires --playwright to be used.")
+    if options.slowmo and not options.playwright:
+        parser.error("--slowmo requires --playwright to be used.")
     if options.screenshots and options.tags:
         parser.error("--screenshots and --tag are mutually exclusive.")
 
@@ -742,27 +735,25 @@ def paired_tests(paired_test, options, test_labels, start_at, start_after):
         os.environ.setdefault("DJANGO_SETTINGS_MODULE", "test_sqlite")
         options.settings = os.environ["DJANGO_SETTINGS_MODULE"]
 
-    if options.selenium:
+    if options.playwright:
         if (
             multiprocessing.get_start_method() in {"spawn", "forkserver"}
             and options.parallel != 1
         ):
             parser.error(
-                "You cannot use --selenium with parallel tests on this system. "
-                "Pass --parallel=1 to use --selenium."
+                "You cannot use --playwright with parallel tests on this system. "
+                "Pass --parallel=1 to use --playwright."
             )
         if not options.tags:
-            options.tags = ["selenium"]
-        elif "selenium" not in options.tags:
-            options.tags.append("selenium")
-        if options.selenium_hub:
-            SeleniumTestCaseBase.selenium_hub = options.selenium_hub
-            SeleniumTestCaseBase.external_host = options.external_host
-        SeleniumTestCaseBase.headless = options.headless
-        SeleniumTestCaseBase.browsers = options.selenium
+            options.tags = ["playwright"]
+        elif "playwright" not in options.tags:
+            options.tags.append("playwright")
+        PlaywrightTestCaseMeta.headed = options.headed
+        PlaywrightTestCaseMeta.slow_mo = options.slowmo
+        PlaywrightTestCaseMeta.browsers = options.playwright
         if options.screenshots:
-            options.tags = ["screenshot"]
-            SeleniumTestCase.screenshots = options.screenshots
+            options.tags = ["playwright_screenshot"]
+            PlaywrightTestCase.screenshots = options.screenshots
 
     if options.bisect:
         bisect_tests(
diff --git a/tests/schema/tests.py b/tests/schema/tests.py
index 292df448e7eb..62c85634a785 100644
--- a/tests/schema/tests.py
+++ b/tests/schema/tests.py
@@ -656,7 +656,11 @@ def test_fk_alter_on_delete_python_level_noop(self):
             editor.alter_field(Book, new_field, old_field, strict=True)
 
     @isolate_apps("schema")
-    @skipUnlessDBFeature("supports_foreign_keys", "can_introspect_foreign_keys")
+    @skipUnlessDBFeature(
+        "supports_foreign_keys",
+        "can_introspect_foreign_keys",
+        "supports_on_delete_db_cascade",
+    )
     def test_fk_alter_on_delete_db_level(self):
         class DBOnDeleteParent(Model):
             class Meta:
diff --git a/tests/view_tests/tests/test_i18n.py b/tests/view_tests/tests/test_i18n.py
index f4ba5249a204..8af8779fc58c 100644
--- a/tests/view_tests/tests/test_i18n.py
+++ b/tests/view_tests/tests/test_i18n.py
@@ -3,6 +3,8 @@
 from os import path
 from unittest import mock
 
+from playwright_tests import PlaywrightTestCase
+
 from django.conf import settings
 from django.test import (
     RequestFactory,
@@ -11,7 +13,6 @@
     modify_settings,
     override_settings,
 )
-from django.test.selenium import SeleniumTestCase
 from django.urls import reverse
 from django.utils.translation import get_language, override
 from django.views.i18n import JavaScriptCatalog, get_formats
@@ -526,7 +527,7 @@ def test_template_encoding(self):
 
 
 @override_settings(ROOT_URLCONF="view_tests.urls")
-class I18nSeleniumTests(SeleniumTestCase):
+class I18nPlaywrightTests(PlaywrightTestCase):
     # The test cases use fixtures & translations from these apps.
     available_apps = [
         "django.contrib.admin",
@@ -537,26 +538,15 @@ class I18nSeleniumTests(SeleniumTestCase):
 
     @override_settings(LANGUAGE_CODE="de")
     def test_javascript_gettext(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(self.live_server_url + "/jsi18n_template/")
-        elem = self.selenium.find_element(By.ID, "gettext")
-        self.assertEqual(elem.text, "Entfernen")
-        elem = self.selenium.find_element(By.ID, "ngettext_sing")
-        self.assertEqual(elem.text, "1 Element")
-        elem = self.selenium.find_element(By.ID, "ngettext_plur")
-        self.assertEqual(elem.text, "455 Elemente")
-        elem = self.selenium.find_element(By.ID, "ngettext_onnonplural")
-        self.assertEqual(elem.text, "Bild")
-        elem = self.selenium.find_element(By.ID, "pgettext")
-        self.assertEqual(elem.text, "Kann")
-        elem = self.selenium.find_element(By.ID, "npgettext_sing")
-        self.assertEqual(elem.text, "1 Resultat")
-        elem = self.selenium.find_element(By.ID, "npgettext_plur")
-        self.assertEqual(elem.text, "455 Resultate")
-        elem = self.selenium.find_element(By.ID, "formats")
-        self.assertEqual(
-            elem.text,
+        self.page.goto(self.live_server_url + "/jsi18n_template/")
+        self.expect(self.page.locator("#gettext")).to_have_text("Entfernen")
+        self.expect(self.page.locator("#ngettext_sing")).to_have_text("1 Element")
+        self.expect(self.page.locator("#ngettext_plur")).to_have_text("455 Elemente")
+        self.expect(self.page.locator("#ngettext_onnonplural")).to_have_text("Bild")
+        self.expect(self.page.locator("#pgettext")).to_have_text("Kann")
+        self.expect(self.page.locator("#npgettext_sing")).to_have_text("1 Resultat")
+        self.expect(self.page.locator("#npgettext_plur")).to_have_text("455 Resultate")
+        self.expect(self.page.locator("#formats")).to_have_text(
             "DATE_INPUT_FORMATS is an object; DECIMAL_SEPARATOR is a string; "
             "FIRST_DAY_OF_WEEK is a number;",
         )
@@ -564,14 +554,10 @@ def test_javascript_gettext(self):
     @modify_settings(INSTALLED_APPS={"append": ["view_tests.app1", "view_tests.app2"]})
     @override_settings(LANGUAGE_CODE="fr")
     def test_multiple_catalogs(self):
-        from selenium.webdriver.common.by import By
-
-        self.selenium.get(self.live_server_url + "/jsi18n_multi_catalogs/")
-        elem = self.selenium.find_element(By.ID, "app1string")
-        self.assertEqual(
-            elem.text, "il faut traduire cette chaîne de caractères de app1"
+        self.page.goto(self.live_server_url + "/jsi18n_multi_catalogs/")
+        self.expect(self.page.locator("#app1string")).to_have_text(
+            "il faut traduire cette chaîne de caractères de app1",
         )
-        elem = self.selenium.find_element(By.ID, "app2string")
-        self.assertEqual(
-            elem.text, "il faut traduire cette chaîne de caractères de app2"
+        self.expect(self.page.locator("#app2string")).to_have_text(
+            "il faut traduire cette chaîne de caractères de app2",
         )