tests/playwright: resolve shim target through shell-script shims on macOS

Two playwright tests assert ``loaded_abspath.resolve()`` lands inside
``playwright_root/cache``. On Linux the shim is a plain symlink so
``.resolve()`` follows naturally. On macOS chromium ships inside a
``.app`` bundle and the shim is a shell script (``exec '<path>'``)
instead -- ``.resolve()`` on a regular file just returns the file
itself, failing the ``in updated_target.parents`` assertion.

Add ``_resolve_shim_target()`` that falls back to parsing the ``exec``
line from the shell script when ``.resolve()`` doesn't follow. Also
update ``copy_seeded_playwright_root()`` to rewrite the shell script's
hardcoded absolute path from the seeded root to the per-test copy
(previously it only repointed symlinks), so the pre-``load()`` shim
state is consistent across both shim flavors.

Author: claude

tests/test_playwrightprovider.py

@@ -1,4 +1,5 @@
 import os
+import re
 import shutil
 import tempfile
 from pathlib import Path
@@ -8,6 +9,29 @@
 from abxpkg import Binary, PlaywrightProvider
 
 
+def _resolve_shim_target(shim: Path) -> Path:
+    """Resolve a managed bin_dir shim to its real browser target.
+
+    On Linux the shim is a symlink, so ``.resolve()`` naturally follows
+    it. On macOS the shim is a shell script that ``exec``s the binary
+    inside a ``.app`` bundle (a symlink would leave the browser launching
+    without bundle context), so ``.resolve()`` just returns the script
+    path. Parse the ``exec <path>`` line to recover the target in that
+    case.
+    """
+    resolved = shim.resolve()
+    if resolved != shim:
+        return resolved
+    try:
+        script = shim.read_text(encoding="utf-8")
+    except OSError:
+        return resolved
+    match = re.search(r"exec '([^']+)'", script)
+    if not match:
+        return resolved
+    return Path(match.group(1)).resolve()
+
+
 @pytest.fixture(scope="module")
 def seeded_playwright_root():
     with tempfile.TemporaryDirectory() as temp_dir:
@@ -35,15 +59,37 @@ def copy_seeded_playwright_root(
         copied_bin_dir = install_root / "bin"
         if not copied_bin_dir.is_dir():
             return
+        seeded_resolved = seeded_playwright_root.resolve()
         for link_path in copied_bin_dir.iterdir():
-            if not link_path.is_symlink():
+            if link_path.is_symlink():
+                link_target = link_path.resolve(strict=False)
+                if seeded_resolved not in link_target.parents:
+                    continue
+                relative_target = link_target.relative_to(seeded_resolved)
+                link_path.unlink()
+                link_path.symlink_to(install_root / relative_target)
+                continue
+            # macOS chrome/chromium shims are shell scripts that hardcode
+            # the seeded install_root path; rewrite them so they exec the
+            # copy under this test's install_root instead.
+            if not link_path.is_file():
                 continue
-            link_target = link_path.resolve(strict=False)
-            if seeded_playwright_root.resolve() not in link_target.parents:
+            try:
+                script = link_path.read_text(encoding="utf-8")
+            except OSError:
                 continue
-            relative_target = link_target.relative_to(seeded_playwright_root.resolve())
-            link_path.unlink()
-            link_path.symlink_to(install_root / relative_target)
+            match = re.search(r"exec '([^']+)'", script)
+            if not match:
+                continue
+            target_path = Path(match.group(1))
+            if seeded_resolved not in target_path.resolve().parents:
+                continue
+            relative_target = target_path.resolve().relative_to(seeded_resolved)
+            new_target = install_root / relative_target
+            link_path.write_text(
+                script.replace(str(target_path), str(new_target)),
+                encoding="utf-8",
+            )
 
     def test_chromium_install_puts_real_browser_into_managed_bin_dir(
         self,
@@ -70,9 +116,9 @@ def test_chromium_install_puts_real_browser_into_managed_bin_dir(
             assert provider.bin_dir is not None
             assert installed.loaded_abspath.parent == provider.bin_dir
             assert installed.loaded_abspath == provider.bin_dir / "chromium"
-            # The symlink resolves into ``playwright_root/cache`` (the
+            # The shim resolves into ``playwright_root/cache`` (the
             # managed ``PLAYWRIGHT_BROWSERS_PATH`` for this provider).
-            real_target = installed.loaded_abspath.resolve()
+            real_target = _resolve_shim_target(installed.loaded_abspath)
             assert (playwright_root / "cache").resolve() in real_target.parents
             # Playwright lays out chromium builds as chromium-<build>/.
             assert any(
@@ -374,12 +420,12 @@ def test_update_refreshes_chromium_in_place(
             )
             assert updated is not None
             assert updated.loaded_abspath is not None
-            # The symlink resolves to a chromium build that actually
+            # The shim resolves to a chromium build that actually
             # exists on disk after update (whether the build-id moved
             # depends on the current playwright release, but the
             # resolved target must always exist and still live inside
             # ``playwright_root``).
-            updated_target = updated.loaded_abspath.resolve()
+            updated_target = _resolve_shim_target(updated.loaded_abspath)
             assert updated_target.exists()
             assert (playwright_root / "cache").resolve() in updated_target.parents
             assert any(