async def start(self, options: Dict = None, **kwargs: Any) -> None:
'Start coverage measurement.'
options = merge_dict(options, kwargs)
if self._enabled:
raise PageError('JSCoverage is always enabled.')
self._resetOnNavigation = (True if ('resetOnNavigation' not in options)
else bool(options['resetOnNavigation']))
self._enabled = True
self._scriptURLs.clear()
self._scriptSources.clear()
self._eventListeners = [
helper.addEventListener(
self._client, 'Debugger.scriptParsed',
(lambda e: asyncio.ensure_future(self._onScriptParsed(e)))),
helper.addEventListener(self._client,
'Runtime.executionContextsCleared',
self._onExecutionContextsCleared)
]
(await self._client.send('Profiler.enable'))
(await self._client.send('Profiler.startPreciseCoverage', {
'callCount': False,
'detailed': True,
}))
(await self._client.send('Debugger.enable'))
(await self._client.send('Debugger.setSkipAllPauses', {
'skip': True,
}))
def __init__(self,
frameManager: FrameManager,
frame: Frame,
timeout: int,
options: Dict = None,
**kwargs: Any) -> None:
'Make new navigator watcher.'
options = merge_dict(options, kwargs)
self._validate_options(options)
self._frameManager = frameManager
self._frame = frame
self._initialLoaderId = frame._loaderId
self._timeout = timeout
self._hasSameDocumentNavigation = False
self._eventListeners = [
helper.addEventListener(self._frameManager,
FrameManager.Events.LifecycleEvent,
self._checkLifecycleComplete),
helper.addEventListener(
self._frameManager,
FrameManager.Events.FrameNavigatedWithinDocument,
self._navigatedWithinDocument),
helper.addEventListener(self._frameManager,
FrameManager.Events.FrameDetached,
self._checkLifecycleComplete)
]
self._loop = self._frameManager._client._loop
self._lifecycleCompletePromise = self._loop.create_future()
self._navigationPromise = self._loop.create_task(
asyncio.wait(
[self._lifecycleCompletePromise,
self._createTimeoutPromise()],
return_when=concurrent.futures.FIRST_COMPLETED))
self._navigationPromise.add_done_callback(
(lambda fut: self._cleanup()))
def __init__(self, frameManager: FrameManager, frame: Frame, timeout: int,
options: Dict = None, **kwargs: Any) -> None:
"""Make new navigator watcher."""
options = merge_dict(options, kwargs)
self._validate_options(options)
self._frameManeger = frameManager
self._frame = frame
self._initialLoaderId = frame._loaderId
self._timeout = timeout
self._eventListeners = [
helper.addEventListener(
self._frameManeger,
FrameManager.Events.LifecycleEvent,
self._checkLifecycleComplete,
),
helper.addEventListener(
self._frameManeger,
FrameManager.Events.FrameDetached,
self._checkLifecycleComplete,
),
]
loop = asyncio.get_event_loop()
self._lifecycleCompletePromise = loop.create_future()
self._navigationPromise = asyncio.ensure_future(asyncio.wait([
self._lifecycleCompletePromise,
self._createTimeoutPromise(),
], return_when=concurrent.futures.FIRST_COMPLETED))
self._navigationPromise.add_done_callback(
lambda fut: self._cleanup())
async def start(self, options: Dict = None, **kwargs: Any) -> None:
"""Start coverage measurement."""
options = merge_dict(options, kwargs)
if self._enabled:
raise PageError('JSCoverage is always enabled.')
self._resetOnNavigation = (True if 'resetOnNavigation' not in options
else bool(options['resetOnNavigation']))
self._reportAnonymousScript = bool(
options.get('reportAnonymousScript')) # noqa: E501
self._enabled = True
self._scriptURLs.clear()
self._scriptSources.clear()
self._eventListeners = [
helper.addEventListener(
self._client, 'Debugger.scriptParsed',
lambda e: self._client._loop.create_task(
self._onScriptParsed(e))),
helper.addEventListener(self._client,
'Runtime.executionContextsCleared',
self._onExecutionContextsCleared),
]
await self._client.send('Profiler.enable')
await self._client.send('Profiler.startPreciseCoverage', {
'callCount': False,
'detailed': True
})
await self._client.send('Debugger.enable')
await self._client.send('Debugger.setSkipAllPauses', {'skip': True})
def __init__(self,
frameManager: FrameManager,
frame: Frame,
timeout: int,
options: Dict = None,
**kwargs: Any) -> None:
"""Make new navigator watcher."""
options = merge_dict(options, kwargs)
self._validate_options(options)
self._frameManeger = frameManager
self._frame = frame
self._initialLoaderId = frame._loaderId
self._timeout = timeout
self._eventListeners = [
helper.addEventListener(
self._frameManeger,
FrameManager.Events.LifecycleEvent,
self._checkLifecycleComplete,
),
helper.addEventListener(
self._frameManeger,
FrameManager.Events.FrameDetached,
self._checkLifecycleComplete,
),
]
loop = asyncio.get_event_loop()
self._lifecycleCompletePromise = loop.create_future()
self._navigationPromise = asyncio.ensure_future(
asyncio.wait([
self._lifecycleCompletePromise,
self._createTimeoutPromise(),
],
return_when=concurrent.futures.FIRST_COMPLETED))
self._navigationPromise.add_done_callback(lambda fut: self._cleanup())
def __init__(self, frameManager: FrameManager, frame: Frame,
waitUntil: str, timeout: int) -> None:
if isinstance(waitUntil, list):
waitUntil = waitUntil[::]
elif isinstance(waitUntil, str):
waitUntil = [waitUntil]
if "documentloaded" in waitUntil:
logging.getLogger(__name__).warning(
'`documentloaded` option is no longer supported. '
'Use `domcontentloaded` instead.')
self._hasSameDocumentNavigation = False
self._expectedLifecycle: List[str] = []
for value in waitUntil:
protocolEvent = pyppeteerToProtocolLifecycle.get(value)
if protocolEvent is None:
raise ValueError(
f'Unknown value for options.waitUntil: {value}')
self._expectedLifecycle.append(protocolEvent)
self._maximumTimer = None
self._timeoutOrTermination = None
self._frameManager = frameManager
self._loop = self._frameManager._client._loop
self._frame = frame
self._initialLoaderId = frame._loaderId
self._timeout = timeout
self._navigationRequest = None
self._eventListeners = [
helper.addEventListener(frameManager._client,
CDPSession.Events.Disconnected,
lambda: self._terminate(NetworkError(
'Navigation failed because browser has disconnected!'))
),
helper.addEventListener(self._frameManager,
FrameManager.Events.LifecycleEvent,
self._checkLifecycleComplete),
helper.addEventListener(self._frameManager,
FrameManager.Events.FrameNavigatedWithinDocument,
self._navigatedWithinDocument),
helper.addEventListener(self._frameManager,
FrameManager.Events.FrameDetached,
self._onFrameDetached),
helper.addEventListener(self._frameManager.NetworkManager,
NetworkManager.Events.Request,
self._onRequest),
]
self._timeoutPromise = self._createTimeoutPromise()
self._sameDocumentNavigationPromise = self._loop.create_future()
self._lifecyclePromise = self._loop.create_future()
self._newDocumentNavigationPromise = self._loop.create_future()
self._terminationPromise = self._loop.create_future()
self._checkLifecycleComplete()
async def start(self, options: Dict = None, **kwargs: Any) -> None:
'Start coverage measurement.'
options = merge_dict(options, kwargs)
if self._enabled:
raise PageError('CSSCoverage is already enabled.')
self._resetOnNavigation = (True if (
'resetOnNavigation' not in options) else bool(options['resetOnNavigation']))
self._enabled = True
self._stylesheetURLs.clear()
self._stylesheetSources.clear()
self._eventListeners = [helper.addEventListener(self._client, 'CSS.styleSheetAdded', (lambda e: self._client._loop.create_task(
self._onStyleSheet(e)))), helper.addEventListener(self._client, 'Runtime.executionContextsCleared', self._onExecutionContextsCleared)]
(await self._client.send('DOM.enable'))
(await self._client.send('CSS.enable'))
(await self._client.send('CSS.startRuleUsageTracking'))
async def waitForNavigation(self,
options: dict = None,
**kwargs: Any) -> Optional[Response]:
"""Wait for navigation.
Available options are same as :meth:`goto` method.
"""
options = merge_dict(options, kwargs)
mainFrame = self._frameManager.mainFrame
if mainFrame is None:
raise PageError('No main frame.')
timeout = options.get('timeout', self._defaultNavigationTimeout)
watcher = NavigatorWatcher(self._frameManager, mainFrame, timeout,
options)
responses: Dict[str, Response] = dict()
listener = helper.addEventListener(
self._networkManager, NetworkManager.Events.Response,
lambda response: responses.__setitem__(response.url, response))
result = await watcher.navigationPromise()
helper.removeEventListeners([listener])
error = result[0].pop().exception()
if error:
raise error
response = responses.get(self.url, None)
return response
async def waitForNavigation(self, options: dict = None, **kwargs: Any
) -> Optional[Response]:
"""Wait for navigation.
Available options are same as :meth:`goto` method.
"""
options = merge_dict(options, kwargs)
mainFrame = self._frameManager.mainFrame
if mainFrame is None:
raise PageError('No main frame.')
timeout = options.get('timeout', self._defaultNavigationTimeout)
watcher = NavigatorWatcher(self._frameManager, mainFrame, timeout,
options)
responses: Dict[str, Response] = dict()
listener = helper.addEventListener(
self._networkManager,
NetworkManager.Events.Response,
lambda response: responses.__setitem__(response.url, response)
)
result = await watcher.navigationPromise()
helper.removeEventListeners([listener])
error = result[0].pop().exception()
if error:
raise error
response = responses.get(self.url, None)
return response
async def goto(self,
url: str,
options: dict = None,
**kwargs: Any) -> Optional[Response]:
"""Go to the url.
:arg string url: URL to go.
"""
options = merge_dict(options, kwargs)
referrer = self._networkManager.extraHTTPHeaders().get('referer', '')
requests: Dict[str, Request] = dict()
eventListeners = [
helper.addEventListener(
self._networkManager, NetworkManager.Events.Request,
lambda request: requests.__setitem__(request.url, request))
]
mainFrame = self._frameManager.mainFrame
if mainFrame is None:
raise PageError('No main frame.')
watcher = NavigatorWatcher(self._frameManager, mainFrame, options)
result = await self._navigate(url, referrer)
if result is not None:
raise PageError(result)
result = await watcher.navigationPromise()
watcher.cancel()
helper.removeEventListeners(eventListeners)
error = result[0].pop().exception() # type: ignore
if error:
raise error
request = requests.get(mainFrame.url)
return request.response if request else None
async def goto(self,
url: str,
options: dict = None,
**kwargs: Any) -> Optional[Response]:
"""Got to url."""
if options is None:
options = dict()
options.update(kwargs)
watcher = NavigatorWatcher(self._client, self._ignoreHTTPSErrors,
options)
responses: Dict[str, Response] = dict()
listener = helper.addEventListener(
self._networkManager, NetworkManager.Events.Response,
lambda response: responses.__setitem__(response.url, response))
navigationPromise = watcher.waitForNavigation()
referrer = self._networkManager.extraHTTPHeaders().get('referer', '')
try:
await self._client.send('Page.navigate',
dict(url=url, referrer=referrer))
except Exception:
watcher.cancel()
helper.removeEventListeners([listener])
raise
error = await navigationPromise
helper.removeEventListeners([listener])
if error:
raise error
if self._frameManager.isMainFrameLoadingFailed():
raise PageError('Failed to navigate: ' + url)
return responses.get(self.url)
async def waitForNavigation(self) -> None:
"""Wait until navigatoin completes."""
self._requestIds: Set[str] = set()
self._eventListeners: List[dict] = list()
navigationPromises = list()
loop = asyncio.get_event_loop()
def watchdog_cb(fut: Awaitable) -> None:
self._raise_error(asyncio.TimeoutError(
'Navigation Timeout Exceeded: {} ms exceeded'.format(
self._timeout)
))
watchdog: asyncio.Future = asyncio.ensure_future(
asyncio.sleep(self._timeout / 1000))
self._maximumTimer = watchdog
watchdog.add_done_callback(watchdog_cb)
navigationPromises.append(watchdog)
if not self._ignoreHTTPSErrors:
certificateError = loop.create_future()
self._eventListeners.append(
helper.addEventListener(
self._client, 'Security.certificateError',
lambda event: certificateError.set_exception(
NetworkError('SSL Certificate error: ' +
str(event.get('errorType')))
)
)
)
navigationPromises.append(certificateError)
if self._waitUntil == 'load':
loadEventFired = loop.create_future()
self._eventListeners.append(
helper.addEventListener(
self._client, 'Page.loadEventFired',
lambda event: loadEventFired.set_result(None)
)
)
navigationPromises.append(loadEventFired)
else:
self._eventListeners.extend((
helper.addEventListener(self._client, 'Network.requestWillBeSent', self._onLoadingStarted), # noqa
helper.addEventListener(self._client, 'Network.loadingFinished', self._onLoadingCompleted), # noqa
helper.addEventListener(self._client, 'Network.loadingFailed', self._onLoadingCompleted), # noqa
helper.addEventListener(self._client, 'Network.webSocketCreated', self._onLoadingStarted), # noqa
helper.addEventListener(self._client, 'Network.webSocketClosed', self._onLoadingCompleted), # noqa
))
networkIdle = loop.create_future()
self._networkIdleCallback = lambda f: networkIdle.set_result(None)
navigationPromises.append(networkIdle)
await asyncio.wait(navigationPromises,
return_when=concurrent.futures.FIRST_COMPLETED)
if not watchdog.done():
watchdog.remove_done_callback(watchdog_cb)
self._cleanup()
async def goto(self,
url: str,
options: dict = None,
**kwargs: Any) -> Optional[Response]:
"""Go to the ``url``.
:arg string url: URL to navigate page to. The url should include
scheme, e.g. ``https://``.
Available options are:
* ``timeout`` (int): Maximum navigation time in milliseconds, defaults
to 30 seconds, pass ``0`` to desable timeout. The default value can
be changed by using the :meth:`setDefaultNavigationTimeout` method.
* ``waitUntil`` (str|List[str]): When to consider navigation succeeded,
defaults to ``load``. Given a list of event strings, navigation is
considered to be successful after all events have been fired. Events
can be either:
* ``load``: when ``load`` event is fired.
* ``documentloaded``: when the ``DOMContentLoaded`` event is fired.
* ``networkidle0``: when there are no more than 0 network connections
for at least 500 ms.
* ``networkidle0``: when there are no more than 2 network connections
for at least 500 ms.
"""
options = merge_dict(options, kwargs)
referrer = self._networkManager.extraHTTPHeaders().get('referer', '')
requests: Dict[str, Request] = dict()
eventListeners = [
helper.addEventListener(
self._networkManager, NetworkManager.Events.Request,
lambda request: requests.__setitem__(request.url, request))
]
mainFrame = self._frameManager.mainFrame
if mainFrame is None:
raise PageError('No main frame.')
timeout = options.get('timeout', self._defaultNavigationTimeout)
watcher = NavigatorWatcher(self._frameManager, mainFrame, timeout,
options)
result = await self._navigate(url, referrer)
if result is not None:
raise PageError(result)
result = await watcher.navigationPromise()
watcher.cancel()
helper.removeEventListeners(eventListeners)
error = result[0].pop().exception() # type: ignore
if error:
raise error
request = requests.get(mainFrame.url)
return request.response if request else None
async def start(self, options: Dict = None, **kwargs: Any) -> None:
"""Start coverage measurement."""
options = merge_dict(options, kwargs)
if self._enabled:
raise PageError('CSSCoverage is already enabled.')
self._resetOnNavigation = (True if 'resetOnNavigation' not in options
else bool(options['resetOnNavigation']))
self._enabled = True
self._stylesheetURLs.clear()
self._stylesheetSources.clear()
self._eventListeners = [
helper.addEventListener(
self._client, 'CSS.styleSheetAdded',
lambda e: asyncio.ensure_future(self._onStyleSheet(e))),
helper.addEventListener(
self._client, 'Runtime.executionContextsCleared',
self._onExecutionContextsCleared),
]
await self._client.send('DOM.enable')
await self._client.send('CSS.enable')
await self._client.send('CSS.startRuleUsageTracking')
async def goto(self, url: str, options: dict = None, **kwargs: Any
) -> Optional[Response]:
"""Go to the ``url``.
:arg string url: URL to navigate page to. The url should include
scheme, e.g. ``https://``.
Available options are:
* ``timeout`` (int): Maximum navigation time in milliseconds, defaults
to 30 seconds, pass ``0`` to desable timeout. The default value can
be changed by using the :meth:`setDefaultNavigationTimeout` method.
* ``waitUntil`` (str|List[str]): When to consider navigation succeeded,
defaults to ``load``. Given a list of event strings, navigation is
considered to be successful after all events have been fired. Events
can be either:
* ``load``: when ``load`` event is fired.
* ``documentloaded``: when the ``DOMContentLoaded`` event is fired.
* ``networkidle0``: when there are no more than 0 network connections
for at least 500 ms.
* ``networkidle2``: when there are no more than 2 network connections
for at least 500 ms.
"""
options = merge_dict(options, kwargs)
referrer = self._networkManager.extraHTTPHeaders().get('referer', '')
requests: Dict[str, Request] = dict()
eventListeners = [helper.addEventListener(
self._networkManager, NetworkManager.Events.Request,
lambda request: requests.__setitem__(request.url, request)
)]
mainFrame = self._frameManager.mainFrame
if mainFrame is None:
raise PageError('No main frame.')
timeout = options.get('timeout', self._defaultNavigationTimeout)
watcher = NavigatorWatcher(self._frameManager, mainFrame, timeout,
options)
result = await self._navigate(url, referrer)
if result is not None:
raise PageError(result)
result = await watcher.navigationPromise()
watcher.cancel()
helper.removeEventListeners(eventListeners)
error = result[0].pop().exception() # type: ignore
if error:
raise error
request = requests.get(mainFrame.url)
return request.response if request else None
async def start(self, options: Dict = None, **kwargs: Any) -> None:
"""Start coverage measurement."""
options = merge_dict(options, kwargs)
if self._enabled:
raise PageError('JSCoverage is always enabled.')
self._resetOnNavigation = (True if 'resetOnNavigation' not in options
else bool(options['resetOnNavigation']))
self._enabled = True
self._scriptURLs.clear()
self._scriptSources.clear()
self._eventListeners = [
helper.addEventListener(
self._client, 'Debugger.scriptParsed',
lambda e: asyncio.ensure_future(self._onScriptParsed(e))),
helper.addEventListener(
self._client, 'Runtime.executionContextsCleared',
self._onExecutionContextsCleared),
]
await self._client.send('Profiler.enable')
await self._client.send('Profiler.startPreciseCoverage',
{'callCount': False, 'detailed': True})
await self._client.send('Debugger.enable')
await self._client.send('Debugger.setSkipAllPauses', {'skip': True})
async def ensureInitialPage(self, browser: Browser) -> None:
'Wait for initial page target to be created.'
for target in browser.targets():
if (target.type == 'page'):
return
initialPagePromise = self._loop.create_future()
def initialPageCallback() -> None:
initialPagePromise.set_result(True)
def check_target(target: Target) -> None:
if (target.type == 'page'):
initialPageCallback()
listeners = [addEventListener(browser, 'targetcreated', check_target)]
(await initialPagePromise)
removeEventListeners(listeners)
async def waitForNavigation(self, options: dict = None, **kwargs: Any
) -> Optional[Response]:
"""Wait navigation completes."""
if options is None:
options = dict()
options.update(kwargs)
watcher = NavigatorWatcher(self._client, self._ignoreHTTPSErrors,
options)
responses: Dict[str, Response] = dict()
listener = helper.addEventListener(
self._networkManager,
NetworkManager.Events.Response,
lambda response: responses.__setitem__(response.url, response)
)
await watcher.waitForNavigation()
helper.removeEventListeners([listener])
return responses.get(self.url)
async def ensureInitialPage(self, browser: Browser) -> None:
"""Wait for initial page target to be created."""
for target in browser.targets():
if target.type == 'page':
return
initialPagePromise = self._loop.create_future()
def initialPageCallback() -> None:
initialPagePromise.set_result(True)
def check_target(target: Target) -> None:
if target.type == 'page':
initialPageCallback()
listeners = [addEventListener(browser, 'targetcreated', check_target)]
await initialPagePromise
removeEventListeners(listeners)
