diff --git a/AGENTS.md b/AGENTS.md index 87665ec..7d4e767 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -44,7 +44,7 @@ request; never edit the version or the changelog by hand. expiring is terminal for that page's connection; retries require a new page. - Never block the asyncio loop with file I/O. - Keep strong references to background tasks until completion. -- Sync callbacks run on the callback dispatcher, never the bridge loop. +- Sync callbacks run on their page's callback dispatcher, never the bridge loop. ## Commands diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1693a6a..a2e3d1e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -86,6 +86,14 @@ Ruff has a minimum version rather than an exact pin; use the same version when comparing generated output across environments, and run the formatting and codegen drift checks above before submitting changes. +Refresh the offline parity snapshot from the same published package version as +the schema, and commit `tests/fixtures/bap_ts_parity.json` with the schema: + +```bash +npm pack @browserless.io/bap-ts@ +python scripts/bap_ts_parity.py --package browserless.io-bap-ts-.tgz +``` + ## API reference The generated Python API reference is published at diff --git a/README.md b/README.md index 5d0cec2..08ad4e4 100644 --- a/README.md +++ b/README.md @@ -287,3 +287,14 @@ resuming handoffs. Handoffs remain unavailable during this cutover. To roll back pause and drain again and restore both the previous server and previous clients; rolling back only one side leaves an incompatible pair. No mixed-version compatibility path is provided by this SDK. + +## Sync API events + +Callbacks run on a background thread per page, in event order for that page. +A slow callback delays only its own page. Each page buffers up to 1,024 pending +callbacks; beyond that it drops the newest callback with a logged warning. +A `once` listener stays registered until one event is actually queued. +`browser.get_pages()` returns the same page objects, so `off()` works through any +reference to that page. +Register listeners before closing the page or browser; registering on a closed +object does not restart callback delivery. diff --git a/pyproject.toml b/pyproject.toml index e97ccb8..941cbee 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -73,6 +73,7 @@ exclude = ["src/browserless_bap/mutations.graphql"] [tool.pytest.ini_options] addopts = "--timeout=60 --timeout-method=thread" asyncio_mode = "auto" +asyncio_default_fixture_loop_scope = "function" filterwarnings = ["error::RuntimeWarning"] markers = ["e2e: tests that require a live Browserless service"] diff --git a/scripts/bap_ts_parity.py b/scripts/bap_ts_parity.py new file mode 100644 index 0000000..d186af5 --- /dev/null +++ b/scripts/bap_ts_parity.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +"""Extract an offline parity snapshot from the published bap-ts npm package.""" + +from __future__ import annotations + +import argparse +import difflib +import json +import re +import sys +import tarfile +from collections.abc import Callable +from hashlib import sha256 +from pathlib import Path +from typing import Any + +TARGET = Path(__file__).resolve().parents[1] / "tests/fixtures/bap_ts_parity.json" +PACKAGE = "@browserless.io/bap-ts" + + +def extract(read: Callable[[str], bytes]) -> dict[str, Any]: + metadata = json.loads(read("package.json")) + if metadata.get("name") != PACKAGE: + raise ValueError(f"Expected package {PACKAGE}") + js = read("dist/graphql/mutations.js").decode("utf-8") + + def table(name: str, *, nested: bool = False) -> dict[str, Any]: + block = re.search(rf"export const {name.upper()} = {{(.*?)\n}};", js, re.S) + if not block: + raise ValueError(f"Missing table: {name}") + if nested: + result = { + key: dict(re.findall(r"(\w+): '([^']*)'", values)) + for key, values in re.findall(r"^\s+(\w+): \{(.*)\},?$", block[1], re.M) + } + else: + result = dict(re.findall(r"^\s+(\w+): '([^']*)',", block[1], re.M)) + if not result: + raise ValueError(f"Empty table: {name}") + return result + + readme = read("README.md").decode("utf-8") + block = re.search( + r"(.*?)", + readme, + re.S, + ) + methods = sorted(re.findall(r"^\| `([^`]+)` \|", block[1] if block else "", re.M)) + if not methods: + raise ValueError("Empty table: methods") + cushioned = sorted( + { + name + for file in ("dist/page-generated.js", "dist/page.js") + for name, remainder in re.findall( + r"this\.execute\(\s*'(\w+)'(.*?)\);\n", + read(file).decode("utf-8"), + re.S, + ) + if "this.transportTimeout(" in remainder + } + ) + if not cushioned: + raise ValueError("Empty table: cushioned_mutations") + return { + "package": metadata["name"], + "version": metadata["version"], + "schema_sha256": sha256(read("src/mutations.graphql")).hexdigest(), + "methods": methods, + "response_fields": table("response_fields"), + "optional_fields": table("optional_fields", nested=True), + "arg_types": table("arg_types", nested=True), + "cushioned_mutations": cushioned, + } + + +def snapshot(package: Path) -> dict[str, Any]: + if package.is_dir(): + return extract(lambda name: (package / name).read_bytes()) + with tarfile.open(package, "r:*") as archive: + + def read(name: str) -> bytes: + member = archive.extractfile(f"package/{name}") + if member is None: + raise ValueError(f"Missing package file: {name}") + with member: + return member.read() + + return extract(read) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--package", type=Path, required=True) + parser.add_argument("--check", action="store_true") + args = parser.parse_args() + try: + rendered = json.dumps(snapshot(args.package), sort_keys=True, indent=2) + "\n" + if args.check: + current = TARGET.read_text(encoding="utf-8") if TARGET.exists() else "" + if current != rendered: + print( + "".join( + difflib.unified_diff( + current.splitlines(keepends=True), + rendered.splitlines(keepends=True), + fromfile="committed snapshot", + tofile="package snapshot", + ) + ), + end="", + ) + return 1 + else: + TARGET.parent.mkdir(parents=True, exist_ok=True) + TARGET.write_text(rendered, encoding="utf-8") + except (OSError, ValueError, KeyError, tarfile.TarError) as error: + print(f"Parity extraction failed: {error}", file=sys.stderr) + return 1 + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/browserless_bap/page.py b/src/browserless_bap/page.py index dc868ee..666ae4c 100644 --- a/src/browserless_bap/page.py +++ b/src/browserless_bap/page.py @@ -52,6 +52,8 @@ WaitForResponseResponse, ) +_ASYNC_PREDICATE = re.compile(r"\s*async\b") + @dataclass class _LiveHandoff: @@ -430,7 +432,9 @@ async def wait_for_function( complete_on_promise_resolution: bool | UnsetType = UNSET, ) -> WaitForFunction: predicate = expression - if complete_on_promise_resolution is True: + if complete_on_promise_resolution is True and _ASYNC_PREDICATE.match( + expression + ): predicate = f"async () => {{ await ({expression})(); return true; }}" args = _drop_unset( { diff --git a/src/browserless_bap/sync_api/_bridge.py b/src/browserless_bap/sync_api/_bridge.py index 2392f6a..db82e4c 100644 --- a/src/browserless_bap/sync_api/_bridge.py +++ b/src/browserless_bap/sync_api/_bridge.py @@ -15,7 +15,8 @@ import threading import time import warnings -from collections.abc import Awaitable, Callable, Coroutine +import weakref +from collections.abc import Awaitable, Callable, Coroutine, Iterable from contextlib import suppress from typing import Protocol, TypeVar, cast @@ -116,7 +117,7 @@ def _run(self) -> None: finally: self._queue.task_done() - def close(self) -> None: + def close(self, *, wait: bool = True) -> None: if self._closed.is_set(): return self._closed.set() @@ -134,9 +135,19 @@ def close(self) -> None: self._queue.put_nowait(None) except queue.Full: return - if threading.current_thread() is not self._thread: + if wait and threading.current_thread() is not self._thread: self._thread.join(timeout=2) + @staticmethod + def close_all(dispatchers: Iterable[CallbackDispatcher | None]) -> None: + workers = tuple(worker for worker in dispatchers if worker is not None) + deadline = time.monotonic() + 2 + for worker in workers: + worker.close(wait=False) + for worker in workers: + if threading.current_thread() is not worker._thread: + worker._thread.join(timeout=max(0, deadline - time.monotonic())) + class LoopThread: """Own an asyncio loop on a dedicated daemon thread.""" @@ -152,21 +163,25 @@ def __init__(self) -> None: self._pending: set[cf.Future[object]] = set() self._tracked_lock = threading.Lock() self._tracked_browsers: dict[int, object] = {} + self._dispatchers: weakref.WeakSet[CallbackDispatcher] = weakref.WeakSet() self._thread = threading.Thread( target=self._thread_main, name="bap-sync-loop", daemon=True, ) - self._dispatcher = CallbackDispatcher() self._thread.start() if not self._ready.wait(timeout=5): raise RuntimeError("bap sync event loop failed to start") if self._loop is None: raise RuntimeError("bap sync event loop failed during startup") - @property - def dispatcher(self) -> CallbackDispatcher: - return self._dispatcher + def new_dispatcher(self, *, max_queue_size: int = 1024) -> CallbackDispatcher: + with self._tracked_lock: + if self._stopping or self._closed.is_set(): + raise RuntimeError("the bap sync event loop is shutting down") + dispatcher = CallbackDispatcher(max_queue_size=max_queue_size) + self._dispatchers.add(dispatcher) + return dispatcher def _thread_main(self) -> None: loop = asyncio.new_event_loop() @@ -300,11 +315,14 @@ def untrack_browser(self, browser: object) -> None: def close(self) -> None: if self._closed.is_set(): - self._dispatcher.close() + with self._tracked_lock: + dispatchers = tuple(self._dispatchers) + CallbackDispatcher.close_all(dispatchers) return - if self._stopping: - return - self._stopping = True + with self._tracked_lock: + if self._stopping: + return + self._stopping = True if ( threading.current_thread() is not self._thread and self._loop is not None @@ -312,7 +330,9 @@ def close(self) -> None: ): with suppress(BaseException): self.run(self._close_tracked_browsers(), timeout=5) - self._dispatcher.close() + with self._tracked_lock: + dispatchers = tuple(self._dispatchers) + CallbackDispatcher.close_all(dispatchers) loop = self._loop if loop is not None and loop.is_running(): loop.call_soon_threadsafe(loop.stop) diff --git a/src/browserless_bap/sync_api/browser.py b/src/browserless_bap/sync_api/browser.py index febbfd9..3a3815b 100644 --- a/src/browserless_bap/sync_api/browser.py +++ b/src/browserless_bap/sync_api/browser.py @@ -4,18 +4,44 @@ from collections.abc import Iterator from contextlib import contextmanager +from threading import Lock from typing import Any, Self from ._base import SyncBase +from ._bridge import CallbackDispatcher, LoopThread from .page import Page class Browser(SyncBase[Any]): + def __init__(self, impl: Any, bridge: LoopThread | None = None) -> None: + super().__init__(impl, bridge) + self._pages: dict[int, Page] = {} + self._pages_lock = Lock() + + def _wrap_page(self, impl: Any) -> Page: + self._prune_pages() + with self._pages_lock: + page = self._pages.get(id(impl)) + if page is None or page._impl is not impl: + page = self._pages[id(impl)] = Page(impl, self._bridge) + return page + def new_page(self) -> Page: - return Page(self._invoke("new_page"), self._bridge) + return self._wrap_page(self._invoke("new_page")) + + def _prune_pages(self) -> None: + with self._pages_lock: + stale = [page for page in self._pages.values() if page.closed] + for page in stale: + del self._pages[id(page._impl)] + CallbackDispatcher.close_all( + page._close_dispatcher(wait=False) for page in stale + ) def get_pages(self) -> list[Page]: - return [Page(page, self._bridge) for page in self._invoke("get_pages")] + self._prune_pages() + impls = self._invoke("get_pages") + return [self._wrap_page(impl) for impl in impls] def pages(self) -> list[Page]: return self.get_pages() @@ -28,12 +54,23 @@ def page(self) -> Iterator[Page]: try: yield page finally: - page.close() + try: + page.close() + finally: + with self._pages_lock: + if self._pages.get(id(page._impl)) is page: + del self._pages[id(page._impl)] def close(self) -> None: try: self._invoke("close") finally: + with self._pages_lock: + pages = list(self._pages.values()) + self._pages.clear() + CallbackDispatcher.close_all( + page._close_dispatcher(wait=False) for page in pages + ) self._bridge.untrack_browser(self._impl) def __enter__(self) -> Self: diff --git a/src/browserless_bap/sync_api/page.py b/src/browserless_bap/sync_api/page.py index 02ec3b0..99bd849 100644 --- a/src/browserless_bap/sync_api/page.py +++ b/src/browserless_bap/sync_api/page.py @@ -2,6 +2,7 @@ from __future__ import annotations +import threading from collections.abc import Callable, Mapping, Sequence from pathlib import Path from typing import Any, Self, cast @@ -31,17 +32,22 @@ WaitForResponseResponse, ) from ._base import SyncBase +from ._bridge import CallbackDispatcher from ._page_generated import PageGenerated from .element_handle import ElementHandle Callback = Callable[[object], object] _SUBSCRIPTION_START_TIMEOUT = 5.0 +_CALLBACK_QUEUE_SIZE = 1024 class Page(PageGenerated, SyncBase[Any]): def __init__(self, impl: Any, bridge: Any = None) -> None: SyncBase.__init__(self, impl, bridge) self._event_wrappers: dict[tuple[str, Callback, bool], Callback] = {} + self._listeners_lock = threading.Lock() + self._dispatcher: CallbackDispatcher | None = None + self._dispatcher_closed = False @property def closed(self) -> bool: @@ -93,9 +99,6 @@ def _callback_wrapper( once: bool = False, ) -> Callback: key = (event, callback, once) - existing = self._event_wrappers.get(key) - if existing is not None: - return existing def route_error(error: BaseException) -> None: async def emit_error() -> None: @@ -104,17 +107,29 @@ async def emit_error() -> None: self._bridge.submit(emit_error()) def dispatch(payload: object) -> None: - if once: - self._event_wrappers.pop(key, None) - self._impl.off(event, dispatch) - self._bridge.dispatcher.submit( - callback, - payload, - on_error=route_error if event != "error" else None, - ) - - self._event_wrappers[key] = dispatch - return dispatch + with self._listeners_lock: + if once and key not in self._event_wrappers: + return + dispatcher = self._dispatcher + queued = dispatcher is not None and dispatcher.submit( + callback, + payload, + on_error=route_error if event != "error" else None, + ) + if once and queued: + self._event_wrappers.pop(key, None) + self._impl.off(event, dispatch) + + with self._listeners_lock: + existing = self._event_wrappers.get(key) + if existing is not None: + return existing + if self._dispatcher is None and not self._dispatcher_closed: + self._dispatcher = self._bridge.new_dispatcher( + max_queue_size=_CALLBACK_QUEUE_SIZE + ) + self._event_wrappers[key] = dispatch + return dispatch def _wait_for_subscription(self, event: str) -> None: waiter = getattr(self._impl, "_wait_subscription_started", None) @@ -143,12 +158,13 @@ def once(self, event: str, callback: Callback) -> Self: return self def off(self, event: str, callback: Callback) -> Self: - keys = [key for key in self._event_wrappers if key[:2] == (event, callback)] - wrappers = [ - wrapper - for wrapper in (self._event_wrappers.pop(key, None) for key in keys) - if wrapper is not None - ] + with self._listeners_lock: + keys = [key for key in self._event_wrappers if key[:2] == (event, callback)] + wrappers = [ + wrapper + for wrapper in (self._event_wrappers.pop(key, None) for key in keys) + if wrapper is not None + ] for wrapper in wrappers or [callback]: self._invoke("off", event, wrapper) return self @@ -157,11 +173,12 @@ def emit(self, event: str, payload: object) -> bool: return bool(self._invoke("emit", event, payload)) def remove_all_listeners(self, event: str | None = None) -> Self: - if event is None: - self._event_wrappers.clear() - else: - for key in [key for key in self._event_wrappers if key[0] == event]: - self._event_wrappers.pop(key, None) + with self._listeners_lock: + if event is None: + self._event_wrappers.clear() + else: + for key in [key for key in self._event_wrappers if key[0] == event]: + self._event_wrappers.pop(key, None) self._invoke("remove_all_listeners", event) return self @@ -376,7 +393,17 @@ def close(self) -> None: try: self._invoke("close") finally: - self._event_wrappers.clear() + with self._listeners_lock: + self._event_wrappers.clear() + self._close_dispatcher() + + def _close_dispatcher(self, *, wait: bool = True) -> CallbackDispatcher | None: + with self._listeners_lock: + dispatcher, self._dispatcher = self._dispatcher, None + self._dispatcher_closed = True + if dispatcher is not None: + dispatcher.close(wait=wait) + return dispatcher def __enter__(self) -> Self: return self diff --git a/tests/e2e/test_config.py b/tests/e2e/test_config.py index fafcf57..b64ed78 100644 --- a/tests/e2e/test_config.py +++ b/tests/e2e/test_config.py @@ -131,5 +131,5 @@ def test_live_suite_needs_explicit_e2e_selection(selection: list[str]) -> None: ) assert result.returncode == 0, result.stdout - assert "7 skipped" in result.stdout + assert "8 skipped" in result.stdout assert "requires -m e2e" in result.stdout diff --git a/tests/e2e/test_live.py b/tests/e2e/test_live.py index b164fb9..e3047d6 100644 --- a/tests/e2e/test_live.py +++ b/tests/e2e/test_live.py @@ -8,6 +8,7 @@ import browserless_bap as bap import browserless_bap.sync_api as bap_sync +from browserless_bap.errors import BrowserQLError from .config import LiveConfig, assert_secret_absent @@ -287,3 +288,33 @@ async def test_opt_in_fields_live( assert [item.outer_html for item in children] == ["opt"] captured = capsys.readouterr() assert_secret_absent(live_config.token, [captured.out, captured.err]) + + +@pytest.mark.e2e +async def test_wait_for_function_promise_flag_waits_for_plain_predicate( + live_config: LiveConfig, + capsys: CaptureFixture[str], +) -> None: + async with bap.Browserless.connect( + browser_ws_endpoint=live_config.url, + token=live_config.token, + timeout=live_config.timeout_ms, + ) as browser: + async with browser.page() as page: + await page.goto(EXAMPLE_URL, timeout=live_config.timeout_ms) + with pytest.raises(BrowserQLError) as error: + await page.wait_for_function( + "() => window.__bapNeverReady === true", + timeout=1500, + complete_on_promise_resolution=True, + ) + result = await page.wait_for_function( + "async () => { await new Promise(r => setTimeout(r, 100)); " + "return false; }", + timeout=3000, + complete_on_promise_resolution=True, + ) + assert "time" in result + + captured = capsys.readouterr() + assert_secret_absent(live_config.token, [error.value, captured.out, captured.err]) diff --git a/tests/fixtures/bap_ts_parity.json b/tests/fixtures/bap_ts_parity.json new file mode 100644 index 0000000..6738595 --- /dev/null +++ b/tests/fixtures/bap_ts_parity.json @@ -0,0 +1,520 @@ +{ + "arg_types": { + "addScriptTag": { + "content": "String", + "id": "String", + "type": "String", + "url": "String" + }, + "addStyleTag": { + "content": "String", + "url": "String" + }, + "authenticate": { + "origin": "String", + "password": "String!", + "username": "String!" + }, + "back": { + "timeout": "Float", + "waitUntil": "WaitUntilHistory" + }, + "checkbox": { + "checked": "Boolean!", + "scroll": "Boolean", + "selector": "String!", + "timeout": "Float", + "visible": "Boolean", + "wait": "Boolean" + }, + "click": { + "scroll": "Boolean", + "selector": "String!", + "timeout": "Float", + "visible": "Boolean", + "wait": "Boolean" + }, + "closeLiveURL": { + "liveURLId": "String!" + }, + "content": { + "html": "String!", + "timeout": "Float", + "waitUntil": "WaitUntilHistory", + "waitUntilAll": "[WaitUntilHistory!]" + }, + "cookies": { + "cookies": "[CookieInput]" + }, + "emulateMediaType": { + "type": "MediaType!" + }, + "evaluate": { + "content": "String", + "timeout": "Float", + "url": "String" + }, + "forward": { + "timeout": "Float", + "waitUntil": "WaitUntilHistory" + }, + "fulfill": { + "base64Body": "String", + "body": "String", + "contentType": "String", + "headers": "[HeaderInput]", + "method": "[Method]", + "operator": "OperatorTypes", + "regex": "[String]", + "status": "Int", + "type": "[ResourceType]", + "url": "[String]" + }, + "goto": { + "referer": "String", + "referrerPolicy": "String", + "timeout": "Float", + "url": "String!", + "waitUntil": "WaitUntilGoto", + "waitUntilAll": "[WaitUntilGoto!]" + }, + "hover": { + "scroll": "Boolean", + "selector": "String", + "timeout": "Float", + "visible": "Boolean", + "wait": "Boolean", + "x": "Float", + "y": "Float" + }, + "html": { + "clean": "CleanInput", + "rewrite": "HTMLRewriteInput", + "selector": "String", + "timeout": "Float", + "visible": "Boolean" + }, + "if": { + "operator": "OperatorTypes", + "request": "RequestInput", + "response": "ResponseInput", + "selector": "String", + "visible": "Boolean" + }, + "ifnot": { + "operator": "OperatorTypes", + "request": "RequestInput", + "response": "ResponseInput", + "selector": "String" + }, + "javaScriptEnabled": { + "enabled": "Boolean" + }, + "liveURL": { + "captureScale": "Int", + "compressed": "Boolean", + "currentStep": "Int", + "doneLabel": "String", + "emulateComponents": "Boolean", + "failLabel": "String", + "instructions": "StringOrInstructions", + "instructionsFormat": "InstructionsFormat", + "instructionsLayout": "InstructionsLayout", + "instructionsTitle": "String", + "interactable": "Boolean", + "quality": "Int", + "requesterName": "String", + "resizable": "Boolean", + "showBrowserInterface": "Boolean", + "steps": "[String!]", + "timeout": "Float", + "type": "LiveURLStreamType" + }, + "loadSecret": { + "ref": "String!", + "selector": "String" + }, + "mapSelector": { + "selector": "String!", + "timeout": "Float", + "wait": "Boolean" + }, + "markdown": { + "selector": "String", + "timeout": "Float", + "visible": "Boolean" + }, + "pdf": { + "displayHeaderFooter": "Boolean", + "footerTemplate": "String", + "format": "PDFPageFormat", + "fullPage": "Boolean", + "generateDocumentOutline": "Boolean", + "generateTaggedPDF": "Boolean", + "headerTemplate": "String", + "height": "FloatOrString", + "landscape": "Boolean", + "marginBottom": "FloatOrString", + "marginLeft": "FloatOrString", + "marginRight": "FloatOrString", + "marginTop": "FloatOrString", + "omitBackground": "Boolean", + "pageRanges": "String", + "preferCSSPageSize": "Boolean", + "printBackground": "Boolean", + "scale": "Float", + "timeout": "Float", + "transferMode": "String", + "waitForFonts": "Boolean", + "waitForImages": "Boolean", + "width": "FloatOrString" + }, + "preferences": { + "timeout": "Float" + }, + "proxy": { + "city": "String", + "country": "CountryType", + "method": "[Method]", + "network": "ProxyNetwork", + "operator": "OperatorTypes", + "preset": "String", + "server": "String", + "state": "String", + "sticky": "Boolean", + "type": "[ResourceType]", + "url": "[String]" + }, + "querySelector": { + "selector": "String!", + "timeout": "Float", + "visible": "Boolean" + }, + "querySelectorAll": { + "selector": "String!", + "timeout": "Float", + "visible": "Boolean" + }, + "reconnect": { + "timeout": "Float" + }, + "reject": { + "enabled": "Boolean", + "method": "[Method]", + "operator": "OperatorTypes", + "regex": "[String]", + "type": "[ResourceType]", + "url": "[String]" + }, + "reload": { + "timeout": "Float", + "waitUntil": "WaitUntilHistory" + }, + "request": { + "method": "[Method]", + "operator": "OperatorTypes", + "timeout": "Float", + "type": "[ResourceType]", + "url": "[String]", + "wait": "Boolean" + }, + "response": { + "method": "[Method]", + "operator": "OperatorTypes", + "status": "[Int]", + "timeout": "Float", + "type": "[ResourceType]", + "url": "[String]", + "wait": "Boolean" + }, + "screenshot": { + "captureBeyondViewport": "Boolean", + "clip": "ScreenshotClip", + "fromSurface": "Boolean", + "fullPage": "Boolean", + "omitBackground": "Boolean", + "optimizeForSpeed": "Boolean", + "quality": "Float", + "selector": "String", + "timeout": "Float", + "type": "ScreenshotType", + "waitForImages": "Boolean" + }, + "scroll": { + "selector": "String", + "throughPage": "Boolean", + "timeout": "Float", + "visible": "Boolean", + "wait": "Boolean", + "x": "Float", + "y": "Float" + }, + "select": { + "scroll": "Boolean", + "selector": "String!", + "timeout": "Float", + "value": "StringOrArray!", + "visible": "Boolean", + "wait": "Boolean" + }, + "setExtraHTTPHeaders": { + "headers": "[HeaderInput]" + }, + "solve": { + "timeout": "Float", + "type": "CaptchaTypes", + "wait": "Boolean" + }, + "solveImageCaptcha": { + "captchaSelector": "String!", + "inputSelector": "String!", + "timeout": "Float" + }, + "switchToWindow": { + "newest": "Boolean", + "timeout": "Float", + "title": "String", + "url": "String", + "waitUntil": "WaitUntilGoto" + }, + "text": { + "clean": "CleanInput", + "selector": "String", + "timeout": "Float", + "visible": "Boolean" + }, + "type": { + "delay": "[Int]", + "interactable": "Boolean", + "scroll": "Boolean", + "selector": "String!", + "text": "String!", + "timeout": "Float", + "visible": "Boolean", + "wait": "Boolean" + }, + "userAgent": { + "userAgent": "String!" + }, + "verify": { + "timeout": "Float", + "type": "VerifyTypes!", + "wait": "Boolean" + }, + "viewport": { + "deviceScaleFactor": "Float", + "hasTouch": "Boolean", + "height": "Float!", + "landscape": "Boolean", + "mobile": "Boolean", + "width": "Float!" + }, + "waitForEvent": { + "event": "String!", + "timeout": "Float" + }, + "waitForFunction": { + "fn": "String!", + "polling": "Float", + "pollingType": "WaitForFunctionPolling", + "timeout": "Float" + }, + "waitForNavigation": { + "timeout": "Float", + "waitUntil": "WaitUntilGoto" + }, + "waitForNetworkIdle": { + "concurrency": "Int", + "idleTime": "Float", + "timeout": "Float" + }, + "waitForRequest": { + "method": "Method", + "operator": "OperatorTypes", + "timeout": "Float", + "url": "String" + }, + "waitForResponse": { + "codes": "[Int]", + "operator": "OperatorTypes", + "statuses": "[Int]", + "url": "String" + }, + "waitForSelector": { + "hidden": "Boolean", + "selector": "String!", + "timeout": "Float", + "visible": "Boolean" + }, + "waitForTimeout": { + "time": "Float!" + }, + "watchEvent": { + "event": "String!" + } + }, + "cushioned_mutations": [ + "back", + "checkbox", + "click", + "content", + "evaluate", + "forward", + "goto", + "hover", + "html", + "liveURL", + "mapSelector", + "markdown", + "preferences", + "querySelector", + "querySelectorAll", + "reconnect", + "reload", + "request", + "response", + "scroll", + "solve", + "solveImageCaptcha", + "switchToWindow", + "text", + "type", + "waitForEvent", + "waitForFunction", + "waitForNavigation", + "waitForNetworkIdle", + "waitForRequest", + "waitForSelector" + ], + "methods": [ + "$", + "$$", + "$$eval", + "$eval", + "addScriptTag", + "addStyleTag", + "authenticate", + "check", + "click", + "close", + "closeLiveURL", + "content", + "cookies", + "emulateMediaType", + "evaluate", + "fulfill", + "goBack", + "goForward", + "goto", + "hover", + "html", + "liveURL", + "loadSecret", + "mapSelector", + "markdown", + "pdf", + "preferences", + "proxy", + "reconnect", + "reject", + "reload", + "request", + "response", + "screenshot", + "scroll", + "select", + "send", + "setContent", + "setCookie", + "setExtraHTTPHeaders", + "setJavaScriptEnabled", + "setUserAgent", + "setViewport", + "solve", + "solveImageCaptcha", + "stopSessionRecording", + "switchToWindow", + "text", + "title", + "type", + "uncheck", + "url", + "waitForEvent", + "waitForFunction", + "waitForLiveComplete", + "waitForNavigation", + "waitForNetworkIdle", + "waitForRequest", + "waitForResponse", + "waitForSelector", + "waitForTimeout", + "watchEvent" + ], + "optional_fields": { + "HTTPResponse": { + "remoteMetadata": "ip port" + }, + "QuerySelectorResponse": { + "html": "innerHTML outerHTML" + }, + "ResponseResponse": { + "body": "body", + "bodyEncoding": "body base64Encoded" + } + }, + "package": "@browserless.io/bap-ts", + "response_fields": { + "AddScriptTagResponse": "time", + "AddStyleTagResponse": "time", + "Attribute": "name value", + "CaptchaResponse": "found solved time token error", + "ClickResponse": "selector time x y", + "CloseLiveURLResponse": "liveURLId", + "ConsoleMessage": "type text args location { url lineNumber columnNumber } timestamp", + "ConsoleMessageLocation": "url lineNumber columnNumber", + "CookieResponse": "cookies { domain expires httpOnly name path sameSite secure value url } time", + "DefaultResponse": "timeout", + "EmulateMediaTypeResponse": "type time", + "EvaluateResponse": "time value", + "FulfillResponse": "time", + "HTMLResponse": "html time", + "HTTPHeaders": "name value", + "HTTPHeadersResponse": "headers { name value } time", + "HTTPResponse": "status time text url", + "HoverResponse": "selector time x y", + "JavaScriptResponse": "enabled time", + "LiveURLCompleteEvent": "liveURLId reason", + "LiveURLResponse": "liveURLId liveURL timeout", + "LoadSecretResponse": "ok error message time", + "MapSelectorResponse": "innerHTML innerText id class", + "MarkdownResponse": "markdown time", + "PDFResponse": "base64 size time", + "ProxyResponse": "time", + "QuerySelectorResponse": "childElementCount className id innerText localName", + "ReconnectionResponse": "browserQLEndpoint browserWSEndpoint devtoolsFrontendUrl webSocketDebuggerUrl", + "RejectResponse": "time enabled", + "RequestHeader": "name value", + "RequestResponse": "url method type headers { name value }", + "ResponseResponse": "status url method type headers { name value }", + "ScreenshotResponse": "base64 format time", + "ScrollResponse": "selector time x y", + "SelectResponse": "selector time value", + "StandardCookie": "domain expires httpOnly name path sameSite secure value url", + "StopSessionRecordingResponse": "success error", + "SwitchWindowResponse": "success error title url navigation { status time text url }", + "TextResponse": "text time", + "TitleResponse": "title", + "TypeResponse": "selector text time x y", + "URLResponse": "url", + "UserAgentResponse": "userAgent time", + "ViewportResponse": "width height deviceScaleFactor mobile hasTouch landscape time", + "WaitForEvent": "time", + "WaitForFunction": "time", + "WaitForRequestResponse": "time url", + "WaitForResponseResponse": "time status url", + "WaitForSelectorResponse": "height selector time y x width", + "WaitForTimeoutResponse": "time" + }, + "schema_sha256": "56c404249f64c9e3f781e7b5035c0ff98f9437c42541660b4f2dc7f8f42bdbde", + "version": "2.2.0" +} diff --git a/tests/sync/test_wrappers.py b/tests/sync/test_wrappers.py index f7deb6d..8465dbb 100644 --- a/tests/sync/test_wrappers.py +++ b/tests/sync/test_wrappers.py @@ -1,8 +1,12 @@ from __future__ import annotations import asyncio +import gc import threading -from collections.abc import Callable +import time +import weakref +from collections.abc import Callable, Iterator +from functools import partial from typing import Any, cast import pytest @@ -213,7 +217,8 @@ def cancelled(_payload: object) -> None: assert ("console", callback, True) in page._event_wrappers bridge.run(impl.fire("console", "first")) bridge.run(impl.fire("console", "second")) - bridge.dispatcher.submit(drained.set) + assert page._dispatcher is not None + page._dispatcher.submit(drained.set) assert drained.wait(timeout=2) assert delivered == ["first"] assert ("console", callback, True) not in page._event_wrappers @@ -222,7 +227,7 @@ def cancelled(_payload: object) -> None: page.off("console", cancelled) bridge.run(impl.fire("console", "ignored")) drained.clear() - bridge.dispatcher.submit(drained.set) + page._dispatcher.submit(drained.set) assert drained.wait(timeout=2) assert delivered == ["first"] assert ("console", cancelled, True) not in page._event_wrappers @@ -251,7 +256,8 @@ def callback(payload: object) -> None: assert ("console", callback, True) in page._event_wrappers bridge.run(impl.fire("console", "first")) bridge.run(impl.fire("console", "second")) - bridge.dispatcher.submit(drained.set) + assert page._dispatcher is not None + page._dispatcher.submit(drained.set) assert drained.wait(timeout=2) assert delivered.count("first") == 2 @@ -373,3 +379,323 @@ def test_browser_context_manager_closes_pages() -> None: assert browser.get_pages() == [] finally: bridge.close() + + +def test_slow_callback_on_one_page_does_not_delay_another() -> None: + bridge = LoopThread() + impl_a, impl_b = AsyncPage(), AsyncPage() + page_a, page_b = Page(impl_a, bridge), Page(impl_b, bridge) + started, release, delivered = (threading.Event() for _ in range(3)) + threads: list[threading.Thread] = [] + + def slow(_payload: object) -> None: + threads.append(threading.current_thread()) + started.set() + release.wait(timeout=5) + + def fast(_payload: object) -> None: + threads.append(threading.current_thread()) + delivered.set() + + try: + page_a.on("console", slow) + page_b.on("console", fast) + bridge.run(impl_a.fire("console", "a")) + assert started.wait(timeout=2) + bridge.run(impl_b.fire("console", "b")) + assert delivered.wait(timeout=1) + assert threads[0] is not threads[1] + finally: + release.set() + bridge.close() + + +def test_once_survives_full_queue(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr(page_module, "_CALLBACK_QUEUE_SIZE", 1, raising=False) + bridge = LoopThread() + impl = AsyncPage() + page = Page(impl, bridge) + started, release, drained = (threading.Event() for _ in range(3)) + delivered: list[str] = [] + + def callback(payload: object) -> None: + delivered.append(str(payload)) + + def block() -> None: + started.set() + release.wait(timeout=5) + + try: + page.once("console", callback) + dispatcher = page._dispatcher + assert dispatcher is not None + assert dispatcher.submit(block) + assert started.wait(timeout=2) + assert dispatcher.submit(lambda: None) + bridge.run(impl.fire("console", "first")) + assert ("console", callback, True) in page._event_wrappers + assert len(impl.listeners["console"]) == 1 + release.set() + dispatcher._queue.join() + bridge.run(impl.fire("console", "second")) + dispatcher._queue.join() + bridge.run(impl.fire("console", "third")) + assert dispatcher.submit(drained.set) + assert drained.wait(timeout=2) + assert delivered == ["second"] + finally: + release.set() + bridge.close() + + +def test_get_pages_returns_same_page_and_off_works_through_it() -> None: + bridge = LoopThread() + browser = Browser(AsyncBrowser(), bridge) + try: + page = browser.new_page() + + def callback(_payload: object) -> None: + pass + + page.on("console", callback) + assert browser.get_pages()[0] is page + assert browser.pages()[0] is page + browser.get_pages()[0].off("console", callback) + assert page._impl.listeners["console"] == [] + page.close() + assert browser.get_pages() == [] + finally: + browser.close() + bridge.close() + + +def test_get_pages_preserves_page_created_after_snapshot( + monkeypatch: pytest.MonkeyPatch, +) -> None: + bridge = LoopThread() + browser = Browser(AsyncBrowser(), bridge) + snapshot, resume = threading.Event(), threading.Event() + invoke = browser._invoke + listings: list[list[Page]] = [] + + def paused_invoke(method: str, *args: object, **kwargs: object) -> Any: + result = invoke(method, *args, **kwargs) + if method == "get_pages" and not snapshot.is_set(): + snapshot.set() + assert resume.wait(timeout=2) + return result + + monkeypatch.setattr(browser, "_invoke", paused_invoke) + reader = threading.Thread(target=lambda: listings.append(browser.get_pages())) + try: + reader.start() + assert snapshot.wait(timeout=2) + page = browser.new_page() + page.on("console", callback := lambda _payload: None) + resume.set() + reader.join(timeout=2) + assert not reader.is_alive() + assert listings == [[]] + assert browser.get_pages() == [page] + browser.get_pages()[0].off("console", callback) + assert page._impl.listeners["console"] == [] + dispatcher = page._dispatcher + assert dispatcher is not None + browser.close() + dispatcher._thread.join(timeout=2) + assert not dispatcher._thread.is_alive() + finally: + resume.set() + reader.join(timeout=2) + browser.close() + bridge.close() + + +@pytest.mark.parametrize("close_error", [False, True]) +def test_page_context_releases_closed_wrapper( + close_error: bool, monkeypatch: pytest.MonkeyPatch +) -> None: + bridge = LoopThread() + browser = Browser(AsyncBrowser(), bridge) + + def close() -> None: + if close_error: + raise ValueError("close failed") + + try: + try: + with browser.page() as page: + reference = weakref.ref(page) + monkeypatch.setattr(page, "close", close) + except ValueError: + assert close_error + monkeypatch.undo() + del page + gc.collect() + assert reference() is None + finally: + browser.close() + bridge.close() + + +def test_off_waits_for_once_dispatch_instead_of_racing() -> None: + bridge = LoopThread() + impl = AsyncPage() + page = Page(impl, bridge) + delivered: list[object] = [] + helpers: list[threading.Thread] = [] + + class RacingWrappers( + dict[tuple[str, Callable[[object], object], bool], Callable[[object], object]] + ): + raced = False + + def __iter__(self) -> Iterator[tuple[str, Callable[[object], object], bool]]: + iterator = super().__iter__() + if not self.raced: + self.raced = True + first = next(iterator) + helper = threading.Thread( + target=lambda: bridge.run(impl.fire("console", "x")) + ) + helpers.append(helper) + helper.start() + helper.join(timeout=0.5) + yield first + yield from iterator + + try: + page.once("console", delivered.append) + page._event_wrappers = RacingWrappers(page._event_wrappers) + page.off("console", lambda _payload: None) + for helper in helpers: + helper.join(timeout=2) + assert not helper.is_alive() + dispatcher = page._dispatcher + assert dispatcher is not None + dispatcher._queue.join() + assert delivered == ["x"] + finally: + bridge.close() + + +def test_new_page_prunes_closed_wrappers() -> None: + bridge = LoopThread() + browser = Browser(AsyncBrowser(), bridge) + references: list[weakref.ReferenceType[Page]] = [] + try: + for _ in range(5): + page = browser.new_page() + references.append(weakref.ref(page)) + page.close() + del page + current = browser.new_page() + gc.collect() + assert len(browser._pages) == 1 + assert all(reference() is None for reference in references) + assert browser.get_pages() == [current] + finally: + browser.close() + bridge.close() + + +@pytest.mark.parametrize("during_close", [False, True]) +def test_listener_registration_cannot_start_worker_after_shutdown( + during_close: bool, monkeypatch: pytest.MonkeyPatch +) -> None: + from browserless_bap.sync_api._bridge import CallbackDispatcher + + bridge = LoopThread() + page = Page(AsyncPage(), bridge) + snapshot, resume = threading.Event(), threading.Event() + close_all = CallbackDispatcher.close_all + + def paused_close(dispatchers: Any) -> None: + snapshot.set() + assert resume.wait(timeout=5) + close_all(dispatchers) + + closer = threading.Thread(target=bridge.close) + try: + if during_close: + monkeypatch.setattr(CallbackDispatcher, "close_all", paused_close) + closer.start() + assert snapshot.wait(timeout=2) + else: + bridge.close() + workers = { + thread + for thread in threading.enumerate() + if thread.name == "bap-sync-events" + } + with pytest.raises(RuntimeError): + page.on("console", lambda _payload: None) + assert { + thread + for thread in threading.enumerate() + if thread.name == "bap-sync-events" + } == workers + finally: + resume.set() + if during_close: + closer.join(timeout=5) + assert not closer.is_alive() + page._close_dispatcher() + bridge.close() + + +@pytest.mark.parametrize("close_owner", ["browser", "bridge"]) +def test_close_shares_callback_worker_deadline(close_owner: str) -> None: + bridge = LoopThread() + browser = Browser(AsyncBrowser(), bridge) + bridge.track_browser(browser._impl) + release = threading.Event() + started = [threading.Event() for _ in range(4)] + workers: list[threading.Thread] = [] + + def busy(ready: threading.Event, _payload: object) -> None: + workers.append(threading.current_thread()) + ready.set() + release.wait(timeout=15) + + try: + for ready in started: + page = browser.new_page() + page.on("console", partial(busy, ready)) + page.emit("console", "busy") + assert all(ready.wait(timeout=2) for ready in started) + before = time.monotonic() + {"browser": browser.close, "bridge": bridge.close}[close_owner]() + elapsed = time.monotonic() - before + assert elapsed < 3, f"closing four busy pages took {elapsed:.2f}s" + finally: + release.set() + for worker in workers: + worker.join(timeout=2) + assert not worker.is_alive() + if close_owner == "browser": + browser.close() + bridge.close() + + +@pytest.mark.parametrize("close_owner", ["page", "browser", "bridge", "implementation"]) +def test_close_stops_page_dispatcher(close_owner: str) -> None: + bridge = LoopThread() + browser = Browser(AsyncBrowser(), bridge) + page = browser.new_page() + try: + page.on("console", lambda _payload: None) + dispatcher = page._dispatcher + assert dispatcher is not None + close = {"page": page.close, "browser": browser.close, "bridge": bridge.close} + if close_owner == "implementation": + bridge.run(page._impl.close()) + assert browser.get_pages() == [] + else: + close[close_owner]() + dispatcher._thread.join(timeout=2) + assert not dispatcher._thread.is_alive() + if close_owner == "page": + assert page._dispatcher is None + finally: + bridge.close() diff --git a/tests/test_bap_ts_parity_script.py b/tests/test_bap_ts_parity_script.py new file mode 100644 index 0000000..b648d49 --- /dev/null +++ b/tests/test_bap_ts_parity_script.py @@ -0,0 +1,123 @@ +from __future__ import annotations + +import io +import json +import subprocess +import sys +import tarfile +from hashlib import sha256 +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +SCRIPT = ROOT / "scripts/bap_ts_parity.py" + + +@pytest.fixture +def package(tmp_path: Path) -> Path: + files = { + "package.json": '{"name":"@browserless.io/bap-ts","version":"2.2.0"}', + "src/mutations.graphql": "type Mutation { click: String }\n", + "README.md": "\n" + "| `click` | description |\n", + "dist/graphql/mutations.js": "export const RESPONSE_FIELDS = {\n" + " ClickResponse: 'x y',\n};\n" + "export const OPTIONAL_FIELDS = {\n" + " ClickResponse: {extra: 'z'},\n};\n" + "export const ARG_TYPES = {\n" + " click: {timeout: 'Float', selector: 'String!'},\n};\n", + "dist/page-generated.js": "this.execute(\n'click', {}, " + "this.transportTimeout(timeout));\nthis.execute('plain', {});\n", + "dist/page.js": "this.execute('click', {}, this.transportTimeout(timeout));\n", + } + for name, text in files.items(): + path = tmp_path / "package" / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text, encoding="utf-8") + return tmp_path / "package" + + +def run_script( + package: Path, cwd: Path, *args: str +) -> subprocess.CompletedProcess[str]: + # Copy the script so its default output stays inside the temporary project. + script = cwd / "scripts/bap_ts_parity.py" + script.parent.mkdir(exist_ok=True) + script.write_bytes(SCRIPT.read_bytes()) + return subprocess.run( + [sys.executable, str(script), "--package", str(package), *args], + cwd=cwd, + text=True, + capture_output=True, + check=False, + ) + + +def test_extract_directory_tarball_and_check(package: Path, tmp_path: Path) -> None: + result = run_script(package, tmp_path) + assert result.returncode == 0, result.stderr + output = tmp_path / "tests/fixtures/bap_ts_parity.json" + original = output.read_text() + snapshot = json.loads(original) + assert snapshot == { + "package": "@browserless.io/bap-ts", + "version": "2.2.0", + "schema_sha256": sha256( + (package / "src/mutations.graphql").read_bytes() + ).hexdigest(), + "methods": ["click"], + "response_fields": {"ClickResponse": "x y"}, + "optional_fields": {"ClickResponse": {"extra": "z"}}, + "arg_types": {"click": {"selector": "String!", "timeout": "Float"}}, + "cushioned_mutations": ["click"], + } + assert original == json.dumps(snapshot, sort_keys=True, indent=2) + "\n" + archive = tmp_path / "package.tgz" + with tarfile.open(archive, "w:gz") as tar: + tar.add(package, arcname="package") + # An unrelated archive member must never be extracted. + member = tarfile.TarInfo("../escape") + member.size = 1 + tar.addfile(member, io.BytesIO(b"x")) + assert run_script(archive, tmp_path, "--check").returncode == 0 + assert not (tmp_path.parent / "escape").exists() + snapshot["version"] = "changed" + output.write_text(json.dumps(snapshot)) + result = run_script(archive, tmp_path, "--check") + assert result.returncode == 1 + assert "version" in result.stdout + assert json.loads(output.read_text())["version"] == "changed" + + +@pytest.mark.parametrize( + "table", + [ + "methods", + "response_fields", + "optional_fields", + "arg_types", + "cushioned_mutations", + ], +) +def test_empty_collection_fails_loudly( + package: Path, tmp_path: Path, table: str +) -> None: + if table == "methods": + (package / "README.md").write_text("") + elif table == "cushioned_mutations": + for name in ("page.js", "page-generated.js"): + (package / "dist" / name).write_text("") + else: + path = package / "dist/graphql/mutations.js" + path.write_text(path.read_text().replace(table.upper(), "REMOVED")) + result = run_script(package, tmp_path) + assert result.returncode != 0 + assert table in result.stderr + + +def test_rejects_wrong_package(package: Path, tmp_path: Path) -> None: + (package / "package.json").write_text('{"name":"other","version":"2.2.0"}') + result = run_script(package, tmp_path) + assert result.returncode != 0 + assert "@browserless.io/bap-ts" in result.stderr diff --git a/tests/test_codegen_parity.py b/tests/test_codegen_parity.py index 991cc01..a278ab4 100644 --- a/tests/test_codegen_parity.py +++ b/tests/test_codegen_parity.py @@ -1,13 +1,22 @@ from __future__ import annotations -import re +import json import sys +from collections.abc import Callable, Mapping +from hashlib import sha256 from pathlib import Path +from typing import Any, cast -import pytest +from graphql import FieldNode, OperationDefinitionNode, SelectionSetNode, parse import browserless_bap as bap import browserless_bap.sync_api +from browserless_bap.graphql.mutations import ( + ARG_TYPES, + OPTIONAL_FIELDS, + RESPONSE_FIELDS, +) +from browserless_bap.transport import MessageListener, Transport ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) @@ -18,19 +27,66 @@ from scripts.codegen.model import build_models # noqa: E402 from scripts.codegen.schema import Schema # noqa: E402 -TS_README = ROOT.parent / "bap-ts/README.md" +SNAPSHOT = json.loads((ROOT / "tests/fixtures/bap_ts_parity.json").read_text()) +# Fields Python still fetches by default; remove entries when they become opt-in. +KNOWN_DEFAULT_SELECTION_GAPS: dict[str, set[str]] = {} +# These lack bap-ts's 5-second headroom; remove each entry as it gains it. +KNOWN_TIMEOUT_GAPS: set[str] = set() +TIMEOUT_NOT_MEASURED = { + "liveURL": "needs the completion subscription; covered by the live-URL tests", +} +CALLS: dict[str, tuple[str, tuple[Any, ...], dict[str, Any]]] = { + "back": ("go_back", (), {}), + "checkbox": ("check", ("#a",), {}), + "click": ("click", ("#a",), {}), + "content": ("set_content", ("

",), {}), + "evaluate": ("evaluate", ("1",), {}), + "forward": ("go_forward", (), {}), + "goto": ("goto", ("https://example.com",), {}), + "hover": ("hover", ("#a",), {}), + "html": ("html", (), {}), + "mapSelector": ("map_selector", ("#a",), {}), + "markdown": ("markdown", (), {}), + "preferences": ("preferences", (), {}), + "querySelector": ("query_selector", ("#a",), {}), + "querySelectorAll": ("query_selector_all", ("#a",), {}), + "reconnect": ("reconnect", (), {}), + "reload": ("reload", (), {}), + "request": ("request", (), {}), + "response": ("response", (), {}), + "scroll": ("scroll", (), {}), + "solve": ("solve", (), {}), + "solveImageCaptcha": ( + "solve_image_captcha", + (), + {"captcha_selector": "#c", "input_selector": "#i"}, + ), + "switchToWindow": ("switch_to_window", (), {}), + "text": ("text", (), {}), + "type": ("type", ("#a", "t"), {}), + "waitForEvent": ("wait_for_event", ("load",), {}), + "waitForFunction": ("wait_for_function", ("() => 1",), {}), + "waitForNavigation": ("wait_for_navigation", (), {}), + "waitForNetworkIdle": ("wait_for_network_idle", (), {}), + "waitForRequest": ("wait_for_request", ("https://example.com",), {}), + "waitForSelector": ("wait_for_selector", ("#a",), {}), +} + + +def test_snapshot_matches_vendored_schema() -> None: + assert ( + SNAPSHOT["schema_sha256"] + == sha256( + (ROOT / "src/browserless_bap/mutations.graphql").read_bytes() + ).hexdigest() + ), ( + "Re-run scripts/bap_ts_parity.py for the bap-ts version " + "the schema was synced from" + ) -@pytest.mark.skipif(not TS_README.exists(), reason="sibling bap-ts is absent") def test_every_bap_ts_method_has_a_python_name() -> None: - readme = TS_README.read_text(encoding="utf-8") - block = readme.split("", 1)[1].split( - "", 1 - )[0] - ts_methods = { - match.group(1) - for match in re.finditer(r"^\| `([^`]+)` \|", block, re.MULTILINE) - } + ts_methods = set(SNAPSHOT["methods"]) expected = {method_name(name) for name in ts_methods} schema = Schema.load(ROOT / "src/browserless_bap/mutations.graphql") @@ -41,5 +97,106 @@ def test_every_bap_ts_method_has_a_python_name() -> None: assert all(hasattr(bap.sync_api.Page, name) for name in expected) +def test_arg_types_match_bap_ts() -> None: + assert {key: value for key, value in ARG_TYPES.items() if value} == SNAPSHOT[ + "arg_types" + ] + + +def selection_paths(fields: str) -> set[str]: + def paths(selections: SelectionSetNode, prefix: str = "") -> set[str]: + result = set() + for field in selections.selections: + assert isinstance(field, FieldNode) + path = prefix + field.name.value + result.add(path) + if field.selection_set is not None: + result |= paths(field.selection_set, path + ".") + return result + + operation = parse("{" + fields + "}").definitions[0] + assert isinstance(operation, OperationDefinitionNode) + return paths(operation.selection_set) + + +def test_response_fields_match_bap_ts() -> None: + assert set(RESPONSE_FIELDS) == set(SNAPSHOT["response_fields"]) + for name, fields in SNAPSHOT["response_fields"].items(): + python = selection_paths(RESPONSE_FIELDS[name]) + for group in OPTIONAL_FIELDS.get(name, {}).values(): + python |= selection_paths(group) + typescript = selection_paths(fields) + for group in SNAPSHOT["optional_fields"].get(name, {}).values(): + typescript |= selection_paths(group) + assert python == typescript, name + + +def test_default_selection_gaps_are_exactly_known() -> None: + actual = {} + for name, fields in SNAPSHOT["response_fields"].items(): + python, typescript = ( + selection_paths(RESPONSE_FIELDS[name]), + selection_paths(fields), + ) + assert not typescript - python, name + if python - typescript: + actual[name] = python - typescript + assert actual == KNOWN_DEFAULT_SELECTION_GAPS + + +class _Stop(Exception): + pass + + +class DeadlineTransport: + closed = False + deadline: float | None = None + + def on_message(self, _listener: MessageListener) -> Callable[[], None]: + return lambda: None + + def operation_timeout(self, timeout: float | None, cushion: float = 0) -> float: + resolved = 30_000 if timeout is None else timeout + return resolved + cushion if resolved > 0 else resolved + + async def send( + self, + query: str, + variables: Mapping[str, Any] | None = None, + timeout: float | None = None, # noqa: ASYNC109 + ) -> dict[str, Any]: + self.deadline = self.operation_timeout(timeout) + raise _Stop + + async def close(self) -> None: + self.closed = True + + +async def test_timeout_cushion_matches_bap_ts() -> None: + cushioned = set(SNAPSHOT["cushioned_mutations"]) + assert set(TIMEOUT_NOT_MEASURED) <= cushioned + assert set(CALLS) == cushioned - set(TIMEOUT_NOT_MEASURED) + gaps = set() + for mutation in sorted(cushioned - set(TIMEOUT_NOT_MEASURED)): + name, args, kwargs = CALLS[mutation] + transport = DeadlineTransport() + page = bap.Page(cast(Transport, transport)) + try: + try: + await getattr(page, name)(*args, timeout=1000, **kwargs) + except _Stop: + pass + else: + raise AssertionError(f"{mutation} did not reach Transport.send") + finally: + await page.close() + assert transport.deadline == ( + 1000 if mutation in KNOWN_TIMEOUT_GAPS else 6000 + ), mutation + if transport.deadline != 6000: + gaps.add(mutation) + assert gaps == KNOWN_TIMEOUT_GAPS + + def test_generated_outputs_are_declared_and_present() -> None: assert all((ROOT / output).is_file() for output in GENERATED_OUTPUTS) diff --git a/tests/test_package.py b/tests/test_package.py index d403551..c427f4d 100644 --- a/tests/test_package.py +++ b/tests/test_package.py @@ -4,6 +4,7 @@ from importlib.metadata import version from pathlib import Path +import pytest from graphql import parse import browserless_bap as bap @@ -17,6 +18,10 @@ def test_version_matches_metadata_and_release_manifest() -> None: assert manifest["."] == bap.__version__ +def test_pytest_asyncio_loop_scope_is_pinned(pytestconfig: pytest.Config) -> None: + assert pytestconfig.getini("asyncio_default_fixture_loop_scope") == "function" + + def test_vendored_schema_is_locked_but_not_public() -> None: assert not hasattr(bap, "schema_source") schema = ( diff --git a/tests/test_page_overrides.py b/tests/test_page_overrides.py index 8732195..725726c 100644 --- a/tests/test_page_overrides.py +++ b/tests/test_page_overrides.py @@ -244,16 +244,39 @@ async def test_wait_for_function_rewrite_preserves_raw_timeout() -> None: @pytest.mark.asyncio -async def test_wait_for_function_awaits_plain_promise_factory() -> None: +@pytest.mark.parametrize( + "expression", + [ + "() => window.ready", + "() => fetch('/')", + "function () { return 1 }", + "asyncReady", + ], +) +async def test_wait_for_function_leaves_non_async_predicates_unwrapped( + expression: str, +) -> None: page = RecordingPage() await page.wait_for_function( - "() => fetch('/')", + expression, complete_on_promise_resolution=True, ) args = page.calls[0][1] assert args is not None - assert args["fn"] == ("async () => { await (() => fetch('/'))(); return true; }") + assert args["fn"] == expression + await page.close() + + +@pytest.mark.asyncio +async def test_wait_for_function_wraps_async_predicate_with_leading_whitespace() -> ( + None +): + page = RecordingPage() + await page.wait_for_function(" async () => 1", complete_on_promise_resolution=True) + args = page.calls[0][1] + assert args is not None + assert args["fn"].startswith("async () => { await (") await page.close()