def expect_response(
self,
urlOrPredicate: URLMatchResponse,
timeout: float = None,
) -> EventContextManagerImpl[Response]:
return EventContextManagerImpl(
self.waitForResponse(urlOrPredicate, timeout))
def expect_event(
self,
event: str,
predicate: Callable = None,
timeout: float = None,
) -> EventContextManagerImpl:
return EventContextManagerImpl(self.wait_for_event(event, predicate, timeout))
def expect_popup(
self,
predicate: Callable[["Page"], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl["Page"]:
return EventContextManagerImpl(
self.waitForEvent("popup", predicate, timeout))
def expect_file_chooser(
self,
predicate: Callable[[FileChooser], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl[FileChooser]:
return EventContextManagerImpl(
self.waitForEvent("filechooser", predicate, timeout))
def expect_dialog(
self,
predicate: Callable[[Dialog], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl[Dialog]:
return EventContextManagerImpl(
self.waitForEvent("dialog", predicate, timeout))
def expect_download(
self,
predicate: Callable[[Download], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl[Download]:
return EventContextManagerImpl(
self.waitForEvent("download", predicate, timeout))
def expect_event(
self,
event: str,
predicate: Callable[[Any], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl:
return EventContextManagerImpl(self.waitForEvent(event, predicate, timeout))
def expect_worker(
self,
predicate: Callable[["Worker"], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl["Worker"]:
return EventContextManagerImpl(
self.waitForEvent("worker", predicate, timeout))
def expect_load_state(
self,
state: DocumentLoadState = None,
timeout: float = None,
) -> EventContextManagerImpl[Optional[Response]]:
return EventContextManagerImpl(self.wait_for_load_state(
state, timeout))
def expect_page(
self,
predicate: Callable[[Page], bool] = None,
timeout: float = None,
) -> EventContextManagerImpl[Page]:
return EventContextManagerImpl(
self.wait_for_event("page", predicate, timeout))
def expect_request(
self,
urlOrPredicate: URLMatchRequest,
timeout: float = None,
) -> EventContextManagerImpl[Request]:
return EventContextManagerImpl(
self.wait_for_request(urlOrPredicate, timeout))
def expect_console_message(
self,
predicate: Callable[[ConsoleMessage], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl[ConsoleMessage]:
return EventContextManagerImpl(
self.waitForEvent("console", predicate, timeout))
def expect_navigation(
self,
url: URLMatch = None,
waitUntil: DocumentLoadState = None,
timeout: int = None,
) -> EventContextManagerImpl[Optional[Response]]:
return EventContextManagerImpl(
self.waitForNavigation(url, waitUntil, timeout))
def expect_navigation(
self,
url: URLMatch = None,
waitUntil: DocumentLoadState = None,
timeout: float = None,
) -> EventContextManagerImpl:
return EventContextManagerImpl(
self.wait_for_navigation(url, waitUntil, timeout))
def expect_response(
self,
url: URLMatch = None,
predicate: Callable[[Request], bool] = None,
timeout: int = None,
) -> EventContextManagerImpl[Response]:
return EventContextManagerImpl(
self.waitForResponse(url, predicate, timeout))
def expect_navigation(
self,
url: URLMatch = None,
wait_until: DocumentLoadState = None,
timeout: float = None,
) -> EventContextManagerImpl[Response]:
if not wait_until:
wait_until = "load"
if timeout is None:
timeout = self._page._timeout_settings.navigation_timeout()
deadline = monotonic_time() + timeout
wait_helper = self._setup_navigation_wait_helper("expect_navigation", timeout)
to_url = f' to "{url}"' if url else ""
wait_helper.log(f"waiting for navigation{to_url} until '{wait_until}'")
matcher = (
URLMatcher(self._page._browser_context._options.get("baseURL"), url)
if url
else None
)
def predicate(event: Any) -> bool:
# Any failed navigation results in a rejection.
if event.get("error"):
return True
wait_helper.log(f' navigated to "{event["url"]}"')
return not matcher or matcher.matches(event["url"])
wait_helper.wait_for_event(
self._event_emitter,
"navigated",
predicate=predicate,
)
async def continuation() -> Optional[Response]:
event = await wait_helper.result()
if "error" in event:
raise Error(event["error"])
if wait_until not in self._load_states:
t = deadline - monotonic_time()
if t > 0:
await self._wait_for_load_state_impl(state=wait_until, timeout=t)
if "newDocument" in event and "request" in event["newDocument"]:
request = from_channel(event["newDocument"]["request"])
return await request.response()
return None
return EventContextManagerImpl(asyncio.create_task(continuation()))
def expect_event(
self,
event: str,
predicate: Callable = None,
timeout: float = None,
) -> EventContextManagerImpl:
if timeout is None:
timeout = self._timeout_settings.timeout()
wait_helper = WaitHelper(self._loop)
wait_helper.reject_on_timeout(
timeout, f'Timeout while waiting for event "{event}"')
if event != BrowserContext.Events.Close:
wait_helper.reject_on_event(self, BrowserContext.Events.Close,
Error("Context closed"))
wait_helper.wait_for_event(self, event, predicate)
return EventContextManagerImpl(wait_helper.result())
def expect_event(
self,
event: str,
predicate: Callable = None,
timeout: float = None,
) -> EventContextManagerImpl:
if timeout is None:
timeout = self._timeout_settings.timeout()
wait_helper = WaitHelper(self, f"page.expect_event({event})")
wait_helper.reject_on_timeout(
timeout, f'Timeout while waiting for event "{event}"'
)
if event != Page.Events.Crash:
wait_helper.reject_on_event(self, Page.Events.Crash, Error("Page crashed"))
if event != Page.Events.Close:
wait_helper.reject_on_event(self, Page.Events.Close, Error("Page closed"))
wait_helper.wait_for_event(self, event, predicate)
return EventContextManagerImpl(wait_helper.result())
def expect_event(
self,
event: str,
predicate: Callable = None,
timeout: float = None,
) -> EventContextManagerImpl:
if timeout is None:
timeout = cast(Any, self._parent)._timeout_settings.timeout()
wait_helper = WaitHelper(self, f"web_socket.expect_event({event})")
wait_helper.reject_on_timeout(
timeout, f'Timeout while waiting for event "{event}"')
if event != WebSocket.Events.Close:
wait_helper.reject_on_event(self, WebSocket.Events.Close,
Error("Socket closed"))
if event != WebSocket.Events.Error:
wait_helper.reject_on_event(self, WebSocket.Events.Error,
Error("Socket error"))
wait_helper.reject_on_event(self._parent, "close",
Error("Page closed"))
wait_helper.wait_for_event(self, event, predicate)
return EventContextManagerImpl(wait_helper.result())