pi-lean-dimension 0.1.0 → 0.2.1

package/node_modules/pi-lean-portal/backends/python-base/tests/conftest.py

@@ -0,0 +1,95 @@
+"""Shared fixtures and helpers for Python bridge unit tests."""
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+
+# ── Bridge loading ─────────────────────────────────────────────
+
+_BACKEND_CLASSES = {
+    "chromium-py": "ChromiumPyBridge",
+    "firefox-py": "FirefoxPyBridge",
+}
+
+
+def _load_bridge_class(backend_name: str):
+    """Load a bridge class by backend name (chromium-py, firefox-py)."""
+    dir_name = backend_name.replace("-", "_")
+    bridge_path = (
+        Path(__file__).resolve().parents[3]
+        / "backends"
+        / backend_name
+        / "bridge.py"
+    )
+    assert bridge_path.exists(), f"bridge.py not found at {bridge_path}"
+    spec = importlib.util.spec_from_file_location(
+        f"{dir_name}_bridge", bridge_path
+    )
+    assert spec is not None, f"Could not create spec for {bridge_path}"
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)  # type: ignore[union-attr]
+    return getattr(module, _BACKEND_CLASSES[backend_name])
+
+
+@pytest.fixture(params=["chromium-py", "firefox-py"])
+def bridge_factory(request):
+    """Parametrized fixture yielding (backend_name, bridge_instance)."""
+    backend_name = request.param
+    cls = _load_bridge_class(backend_name)
+    return backend_name, cls()
+
+
+# ── Shared constants ──────────────────────────────────────────
+
+METHOD_NAMES = [
+    "browser.navigate",
+    "browser.snapshot",
+    "browser.click",
+    "browser.type",
+    "browser.scroll",
+    "browser.goBack",
+    "browser.press",
+    "browser.screenshot",
+    "browser.getConsoleMessages",
+    "browser.clearConsole",
+    "browser.evaluate",
+    "browser.cleanup",
+]
+
+
+# ── Mock objects ──────────────────────────────────────────────
+
+
+class _MockConsolePage:
+    """Mock Playwright page that records ``page.on("console")`` handlers.
+
+    Lets us invoke captured handlers directly without a real browser.
+    """
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, list] = {}
+
+    def on(self, event: str, handler) -> None:
+        self._handlers.setdefault(event, []).append(handler)
+
+    def fire_console(self, text: str) -> None:
+        """Simulate a console event by calling all 'console' handlers."""
+        for handler in self._handlers.get("console", []):
+            handler(_FakeConsoleMessage(text))
+
+
+class _FakeConsoleMessage:
+    """Duck-typed substitute for Playwright's ConsoleMessage."""
+
+    def __init__(self, text: str) -> None:
+        self._text = text
+
+    @property
+    def type(self) -> str:
+        return "log"
+
+    @property
+    def text(self) -> str:
+        return self._text

package/node_modules/pi-lean-portal/backends/python-base/tests/test_accessibility.py

@@ -16,39 +16,11 @@ from pi_browser_bridge.accessibility import (
     parse_snapshot,
     build_locator_args,
     _parse_line,
-    _count_leading_spaces,
-    _role_icon,
-    _truncate,
     INTERACTIVE_ROLES,
     INFORMATIONAL_ROLES,
 )
 
 
-# ═════════════════════════════════════════════════════════════════════
-#  _count_leading_spaces
-# ═════════════════════════════════════════════════════════════════════
-
-
-class TestCountLeadingSpaces:
-    def test_zero(self) -> None:
-        assert _count_leading_spaces("foo") == 0
-
-    def test_two_spaces(self) -> None:
-        assert _count_leading_spaces("  foo") == 2
-
-    def test_four_spaces(self) -> None:
-        assert _count_leading_spaces("    foo") == 4
-
-    def test_tab(self) -> None:
-        assert _count_leading_spaces("\tfoo") == 1
-
-    def test_empty(self) -> None:
-        assert _count_leading_spaces("") == 0
-
-    def test_only_spaces(self) -> None:
-        assert _count_leading_spaces("   ") == 3
-
-
 # ═════════════════════════════════════════════════════════════════════
 #  _parse_line
 # ═════════════════════════════════════════════════════════════════════
@@ -411,7 +383,7 @@ class TestBuildLocatorArgs:
         role, kwargs = build_locator_args(node)
         assert role == "button"
         assert kwargs["name"] == "Click"
-        assert kwargs["exact"] is True
+        assert kwargs["exact"] == True
         assert kwargs["occurrenceIndex"] == 0
 
     def test_heading_with_level(self) -> None:
@@ -437,7 +409,7 @@ class TestBuildLocatorArgs:
             raw='- checkbox "Agree" [checked]',
         )
         role, kwargs = build_locator_args(node)
-        assert kwargs["checked"] is True
+        assert kwargs["checked"] == True
 
     def test_mixed_checkbox(self) -> None:
         node = AriaCachedNode(
@@ -461,7 +433,7 @@ class TestBuildLocatorArgs:
             raw='- treeitem "Node" [expanded=true]',
         )
         role, kwargs = build_locator_args(node)
-        assert kwargs["expanded"] is True
+        assert kwargs["expanded"] == True
 
     def test_collapsed(self) -> None:
         node = AriaCachedNode(
@@ -473,8 +445,8 @@ class TestBuildLocatorArgs:
             raw='- treeitem "Node" [expanded=false, selected]',
         )
         role, kwargs = build_locator_args(node)
-        assert kwargs["expanded"] is False
-        assert kwargs["selected"] is True
+        assert kwargs["expanded"] == False
+        assert kwargs["selected"] == True
 
     def test_disabled(self) -> None:
         node = AriaCachedNode(
@@ -486,7 +458,7 @@ class TestBuildLocatorArgs:
             raw='- button "Save" [disabled]',
         )
         role, kwargs = build_locator_args(node)
-        assert kwargs["disabled"] is True
+        assert kwargs["disabled"] == True
 
     def test_pressed(self) -> None:
         node = AriaCachedNode(
@@ -498,7 +470,7 @@ class TestBuildLocatorArgs:
             raw='- button "Toggle" [pressed]',
         )
         role, kwargs = build_locator_args(node)
-        assert kwargs["pressed"] is True
+        assert kwargs["pressed"] == True
 
     def test_pressed_mixed(self) -> None:
         node = AriaCachedNode(
@@ -524,7 +496,7 @@ class TestBuildLocatorArgs:
         )
         role, kwargs = build_locator_args(node)
         assert kwargs["name"] == long
-        assert kwargs["exact"] is False
+        assert kwargs["exact"] == False
 
     def test_includes_occurrence_index_unique(self) -> None:
         """build_locator_args includes occurrenceIndex=0 for unique elements."""
@@ -641,99 +613,3 @@ class TestParseSnapshotOccurrenceIndex:
         assert result.elements["e1"].occurrence_index == 0  # first link
         assert result.elements["e2"].occurrence_index == 1  # second link
 
-
-# ═════════════════════════════════════════════════════════════════════
-#  _role_icon
-# ═════════════════════════════════════════════════════════════════════
-
-
-class TestRoleIcon:
-    def test_known_role(self) -> None:
-        assert _role_icon("button") == "\U0001f518 "
-
-    def test_unknown_role(self) -> None:
-        assert _role_icon("bogus") == ""
-
-    def test_all_interactive_have_icons(self) -> None:
-        for role in sorted(INTERACTIVE_ROLES):
-            icon = _role_icon(role)
-            assert icon != "", f"{role} is missing an icon"
-            assert icon.endswith(" "), f"{role} icon should end with space"
-            assert "\ufe0f " not in icon or icon.endswith(" "), (
-                f"{role} icon '{icon}' should end with plain space after \\ufe0f"
-            )
-
-    def test_all_informational_have_icons(self) -> None:
-        for role in sorted(INFORMATIONAL_ROLES):
-            icon = _role_icon(role)
-            assert icon != "", f"{role} is missing an icon"
-            assert icon.endswith(" "), f"{role} icon should end with space"
-
-
-# ═════════════════════════════════════════════════════════════════════
-#  _truncate
-# ═════════════════════════════════════════════════════════════════════
-
-
-class TestTruncate:
-    def test_short_string(self) -> None:
-        assert _truncate("hello", 10) == "hello"
-
-    def test_exact_length(self) -> None:
-        assert _truncate("hello", 5) == "hello"
-
-    def test_long_string(self) -> None:
-        result = _truncate("hello world", 8)
-        assert len(result) == 8
-        assert result.endswith("\u2026")  # ellipsis
-
-    def test_empty_string(self) -> None:
-        assert _truncate("", 5) == ""
-
-
-# ═════════════════════════════════════════════════════════════════════
-#  Role set completeness — every role has a classification
-# ═════════════════════════════════════════════════════════════════════
-
-# Common ARIA roles that should be classified (not an exhaustive list)
-COMMON_ARIA_ROLES = {
-    "button", "link", "textbox", "searchbox", "combobox",
-    "checkbox", "radio", "heading", "listbox", "option",
-    "menuitem", "tab", "switch", "slider", "spinbutton",
-    "progressbar", "meter", "scrollbar", "gridcell", "cell",
-    "columnheader", "rowheader", "tabpanel", "img", "figure",
-    "listitem", "dialog", "alertdialog", "tooltip", "navigation",
-    "banner", "form", "search", "toolbar", "menu", "menubar",
-    "note", "alert", "status", "list", "table", "grid",
-    "treegrid", "article", "section", "blockquote", "code",
-    "paragraph", "text", "group", "region", "main",
-    "complementary", "contentinfo", "definition", "term",
-    "math", "marquee", "timer", "log", "deletion", "insertion",
-    "mark", "suggestion", "comment",
-}
-
-
-class TestRoleSets:
-    def test_no_role_in_both_sets(self) -> None:
-        overlap = INTERACTIVE_ROLES & INFORMATIONAL_ROLES
-        assert overlap == set(), f"Roles in both sets: {overlap}"
-
-    def test_all_known_roles_classified(self) -> None:
-        """Every role we know about should be in exactly one set."""
-        union = INTERACTIVE_ROLES | INFORMATIONAL_ROLES
-        unclassified = COMMON_ARIA_ROLES - union
-        assert unclassified == set(), f"Unclassified roles: {unclassified}"
-
-    def test_intersection_with_typescript_roles(self) -> None:
-        """The INTERACTIVE_ROLES set should match the TypeScript one.
-
-        If this test fails, run the TypeScript test to see what changed.
-        """
-        # As of Phase A / B, the Python and TS sets should be identical.
-        # Count is the canonical cross-check:
-        assert len(INTERACTIVE_ROLES) == 50, (
-            f"Expected 50 interactive roles, got {len(INTERACTIVE_ROLES)}"
-        )
-        assert len(INFORMATIONAL_ROLES) == 18, (
-            f"Expected 18 informational roles, got {len(INFORMATIONAL_ROLES)}"
-        )

package/node_modules/pi-lean-portal/backends/python-base/tests/test_bot_detection.py

@@ -41,27 +41,17 @@ class TestCheckBotDetection:
     def test_normal_page_not_detected(self):
         """A normal page with no bot signals returns False."""
         page = _MockPage(title="Example Domain", body_text="Welcome to Example")
-        assert check_bot_detection(page) is False
+        assert check_bot_detection(page) == False
 
     def test_cloudflare_in_title(self):
         """'cloudflare' in the title triggers bot detection."""
         page = _MockPage(title="Just a moment... | Cloudflare")
-        assert check_bot_detection(page) is True
-
-    def test_just_a_moment_in_title(self):
-        """'just a moment' in the title triggers bot detection."""
-        page = _MockPage(title="Just a moment...")
-        assert check_bot_detection(page) is True
-
-    def test_checking_browser_in_title(self):
-        """'checking your browser' in the title triggers bot detection."""
-        page = _MockPage(title="Checking your browser before accessing")
-        assert check_bot_detection(page) is True
+        assert check_bot_detection(page) == True
 
     def test_verify_human_in_title(self):
         """'verify you are human' in the title triggers bot detection."""
         page = _MockPage(title="Verify you are human")
-        assert check_bot_detection(page) is True
+        assert check_bot_detection(page) == True
 
     def test_captcha_in_title_not_detected(self):
         """'captcha' in the title does NOT trigger bot detection.
@@ -71,20 +61,7 @@ class TestCheckBotDetection:
         CAPTCHAs in passing (e.g. Wikipedia, tech blogs).
         """
         page = _MockPage(title="CAPTCHA Challenge")
-        assert check_bot_detection(page) is False
-
-    def test_cf_ray_in_body_not_detected(self):
-        """'cf-ray' in body does NOT trigger bot detection.
-
-        'cf-ray' is an HTTP response header that rarely appears in
-        rendered body text. The TypeScript reference (bot-detection.ts)
-        does not include this signal.
-        """
-        page = _MockPage(
-            title="Access Denied",
-            body_text="cf-ray: abc123\nserver: cloudflare",
-        )
-        assert check_bot_detection(page) is False
+        assert check_bot_detection(page) == False
 
     def test_akamai_reference_in_body(self):
         """Akamai-style reference codes in body trigger bot detection."""
@@ -92,7 +69,7 @@ class TestCheckBotDetection:
             title="Error",
             body_text="Access denied. Reference #18.abc.def",
         )
-        assert check_bot_detection(page) is True
+        assert check_bot_detection(page) == True
 
     def test_recaptcha_in_html(self):
         """'recaptcha' in HTML triggers bot detection."""
@@ -101,89 +78,7 @@ class TestCheckBotDetection:
             body_text="Submit the form",
             html='<div><script src="recaptcha/api.js"></script></div>',
         )
-        assert check_bot_detection(page) is True
-
-    def test_hcaptcha_in_html(self):
-        """'hcaptcha' in HTML triggers bot detection."""
-        page = _MockPage(
-            title="Login",
-            body_text="Login form",
-            html='<div data-sitekey="abc" class="hcaptcha"></div>',
-        )
-        assert check_bot_detection(page) is True
-
-    def test_turnstile_in_html(self):
-        """Cloudflare challenge markers in body trigger bot detection."""
-        page = _MockPage(
-            title="Challenge",
-            body_text="_cf_chl_opt",
-        )
-        assert check_bot_detection(page) is True
-
-    def test_privacy_pass_in_title_not_detected(self):
-        """'privacy pass' in title does NOT trigger detection.
-
-        This signal is not present in the TypeScript reference
-        (bot-detection.ts) and was removed to align with it.
-        """
-        page = _MockPage(title="Privacy Pass Challenge")
-        assert check_bot_detection(page) is False
-
-    def test_automated_access_in_title_not_detected(self):
-        """'automated access' in title does NOT trigger detection.
-
-        This signal is not present in the TypeScript reference
-        (bot-detection.ts) and was removed to align with it.
-        """
-        page = _MockPage(title="Automated Access Blocked")
-        assert check_bot_detection(page) is False
-
-    def test_browser_check_in_title_not_detected(self):
-        """'browser check' in title does NOT trigger detection.
-
-        This signal is not present in the TypeScript reference
-        (bot-detection.ts) and was removed to align with it.
-        """
-        page = _MockPage(title="Browser Check")
-        assert check_bot_detection(page) is False
-
-    def test_wikipedia_captcha_not_false_positive(self):
-        """Wikipedia's 'captcha' mention in body text is NOT detected.
-
-        This test validates that bot detection is title-level only for
-        the CAPTCHA signal, preventing false positives from sites that
-        simply mention CAPTCHA in their content.
-        """
-        page = _MockPage(
-            title="Wikipedia - The Free Encyclopedia",
-            body_text=(
-                "CAPTCHA is a type of challenge-response test used in computing"
-            ),
-        )
-        # 'captcha' is not in the title, so it should NOT trigger
-        assert check_bot_detection(page) is False
-
-    def test_blank_page_not_detected(self):
-        """An empty or blank page does not trigger bot detection."""
-        page = _MockPage(title="", body_text="", html="")
-        assert check_bot_detection(page) is False
-
-    def test_bot_signal_in_body_not_mistaken_if_not_high_specificity(self):
-        """Generic phrases in body don't trigger unless high-specificity."""
-        page = _MockPage(
-            title="Blog",
-            body_text="This page requires JavaScript to work properly. "
-                      "Please enable JavaScript.",
-        )
-        assert check_bot_detection(page) is False
-
-    def test_data_sitekey_in_html(self):
-        """'data-sitekey' (reCAPTCHA) in HTML triggers bot detection."""
-        page = _MockPage(
-            title="Contact",
-            html='<div class="g-recaptcha" data-sitekey="abc123"></div>',
-        )
-        assert check_bot_detection(page) is True
+        assert check_bot_detection(page) == True
 
     def test_exception_during_title_safe(self):
         """If title() raises, bot detection still checks body and HTML."""
@@ -199,7 +94,7 @@ class TestCheckBotDetection:
                     return ""
                 return ""
 
-        assert check_bot_detection(_BrokenPage()) is True
+        assert check_bot_detection(_BrokenPage()) == True
 
     def test_exception_during_evaluate_safe(self):
         """If evaluate() raises, bot detection returns False gracefully."""
@@ -211,38 +106,4 @@ class TestCheckBotDetection:
             def evaluate(self, expression: str, *args: Any) -> str:
                 raise RuntimeError("evaluate failed")
 
-        assert check_bot_detection(_BrokenEvalPage()) is False
-
-    def test_cloudflare_nginx_in_body_not_detected(self):
-        """'cloudflare-nginx' in body does NOT trigger detection.
-
-        This signal is not present in the TypeScript reference
-        (bot-detection.ts) and was removed to align with it.
-        """
-        page = _MockPage(
-            title="Error 503",
-            body_text="Server: cloudflare-nginx",
-        )
-        assert check_bot_detection(page) is False
-
-    def test_reference_hash_in_body(self):
-        """'reference #' in body triggers bot detection."""
-        page = _MockPage(
-            title="Blocked",
-            body_text="Reference #18.abcde12345",
-        )
-        assert check_bot_detection(page) is True
-
-    def test_blocked_request_in_body_not_detected(self):
-        """'blocked request' in body does NOT trigger detection.
-
-        This signal is not present in the TypeScript reference
-        (bot-detection.ts) — more specific variants like
-        'you have been blocked' and 'your request has been blocked'
-        are used instead.
-        """
-        page = _MockPage(
-            title="403 Forbidden",
-            body_text="Blocked request",
-        )
-        assert check_bot_detection(page) is False
+        assert check_bot_detection(_BrokenEvalPage()) == False

package/node_modules/pi-lean-portal/backends/python-base/tests/test_browser_data.py

@@ -0,0 +1,131 @@
+"""
+Tests for shared ``browser-data.json`` loading.
+
+Verifies that the shared data file is valid JSON and that the Python
+loaders in ``bot_detection``, ``accessibility``, and ``playwright_base``
+can parse it correctly.  A break here means both the TS and Python
+sides are broken in the same way.
+
+Pure-logic tests — no Playwright browser required.
+"""
+
+import json
+import os
+
+import pytest
+from pi_browser_bridge.bot_detection import _BLOCK_SIGNALS, _BODY_ONLY_SIGNALS, _BODY_ONLY_PATTERNS, _HTML_SIGNALS
+from pi_browser_bridge.accessibility import INTERACTIVE_ROLES, INFORMATIONAL_ROLES, _role_icon
+
+# Path to the shared JSON file (relative to this test file)
+# tests/ -> python-base/ -> backends/ -> pi-lean-portal/ -> core/shared/browser-data.json
+_SHARED_JSON = os.path.join(
+    os.path.dirname(__file__),
+    "..", "..", "..",
+    "core", "shared", "browser-data.json",
+)
+
+
+@pytest.fixture(scope="module")
+def shared_data() -> dict:
+    """Load and parse browser-data.json once per module."""
+    try:
+        with open(_SHARED_JSON, "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        pytest.fail(f"Shared data file not found: {_SHARED_JSON}")
+    except json.JSONDecodeError as exc:
+        pytest.fail(f"Shared data file is not valid JSON: {exc}")
+    except OSError as exc:
+        pytest.fail(f"Failed to read shared data file: {exc}")
+
+
+# ═════════════════════════════════════════════════════════════════════
+#  JSON file validity
+# ═════════════════════════════════════════════════════════════════════
+
+
+class TestSharedJsonValidity:
+    def test_json_is_valid(self, shared_data: dict) -> None:
+        """The file parses as valid JSON with a version field."""
+        assert isinstance(shared_data, dict)
+        assert shared_data["version"] == 1
+
+    def test_has_expected_top_level_keys(self, shared_data: dict) -> None:
+        """All three top-level sections are present."""
+        assert "botSignals" in shared_data
+        assert "accessibility" in shared_data
+        assert "navSettle" in shared_data
+
+    def test_bot_signals_has_expected_keys(self, shared_data: dict) -> None:
+        bot = shared_data["botSignals"]
+        assert "blockSignals" in bot
+        assert "bodyOnlySignals" in bot
+        assert "bodyOnlyPatterns" in bot
+        assert "htmlSignals" in bot
+
+    def test_accessibility_has_expected_keys(self, shared_data: dict) -> None:
+        a11y = shared_data["accessibility"]
+        assert "interactiveRoles" in a11y
+        assert "informationalRoles" in a11y
+        assert "roleIcons" in a11y
+
+    def test_nav_settle_has_expected_keys(self, shared_data: dict) -> None:
+        ns = shared_data["navSettle"]
+        assert "navTimeoutMs" in ns
+        assert "settleTimeoutMs" in ns
+        assert "settleRaceMs" in ns
+        assert "domStabilizationJs" in ns
+
+
+# ═════════════════════════════════════════════════════════════════════
+#  Python-side loaders match the JSON data
+# ═════════════════════════════════════════════════════════════════════
+
+
+class TestBotDetectionLoader:
+    """Verify bot_detection.py loaded its signals from the shared JSON."""
+
+    def test_block_signals_match_json(self, shared_data: dict) -> None:
+        expected = tuple(shared_data["botSignals"]["blockSignals"])
+        assert _BLOCK_SIGNALS == expected
+
+    def test_body_only_signals_match_json(self, shared_data: dict) -> None:
+        expected = tuple(shared_data["botSignals"]["bodyOnlySignals"])
+        assert _BODY_ONLY_SIGNALS == expected
+
+    def test_html_signals_match_json(self, shared_data: dict) -> None:
+        expected = tuple(shared_data["botSignals"]["htmlSignals"])
+        assert _HTML_SIGNALS == expected
+
+    def test_body_only_patterns_count(self, shared_data: dict) -> None:
+        """The number of compiled patterns matches the source strings."""
+        expected_count = len(shared_data["botSignals"]["bodyOnlyPatterns"])
+        assert len(_BODY_ONLY_PATTERNS) == expected_count
+
+    def test_reference_code_pattern_matches(self) -> None:
+        """The compiled reference# pattern matches expected input."""
+        assert len(_BODY_ONLY_PATTERNS) >= 1
+        pattern = _BODY_ONLY_PATTERNS[0]
+        assert pattern.search("reference #abc123.def") is not None
+        assert pattern.search("Reference#abc.def") is not None
+        assert pattern.search("normal text") is None
+
+
+class TestAccessibilityLoader:
+    """Verify accessibility.py loaded its data from the shared JSON."""
+
+    def test_interactive_roles_match_json(self, shared_data: dict) -> None:
+        expected = set(shared_data["accessibility"]["interactiveRoles"])
+        assert INTERACTIVE_ROLES == expected
+
+    def test_informational_roles_match_json(self, shared_data: dict) -> None:
+        expected = set(shared_data["accessibility"]["informationalRoles"])
+        assert INFORMATIONAL_ROLES == expected
+
+    def test_role_icons_match_json(self, shared_data: dict) -> None:
+        icons = shared_data["accessibility"]["roleIcons"]
+        for role, expected_icon in icons.items():
+            assert _role_icon(role) == expected_icon, f"Icon mismatch for role '{role}'"
+
+    def test_role_icon_unknown_returns_empty(self) -> None:
+        assert _role_icon("nonexistent_role") == ""