async def stop(self) -> List:
"""Stop coverage measurement and return results."""
if not self._enabled:
raise PageError('CSSCoverage is not enabled.')
self._enabled = False
result = await self._client.send('CSS.stopRuleUsageTracking')
await self._client.send('CSS.disable')
await self._client.send('DOM.disable')
helper.removeEventListeners(self._eventListeners)
# aggregate by styleSheetId
styleSheetIdToCoverage: Dict = {}
for entry in result['ruleUsage']:
ranges = styleSheetIdToCoverage.get(entry['styleSheetId'])
if not ranges:
ranges = []
styleSheetIdToCoverage[entry['styleSheetId']] = ranges
ranges.append({
'startOffset': entry['startOffset'],
'endOffset': entry['endOffset'],
'count': 1 if entry['used'] else 0
})
coverage = []
for styleSheetId in self._stylesheetURLs:
url = self._stylesheetURLs.get(styleSheetId)
text = self._stylesheetSources.get(styleSheetId)
ranges = convertToDisjointRanges(
styleSheetIdToCoverage.get(styleSheetId, []))
coverage.append({'url': url, 'ranges': ranges, 'text': text})
return coverage
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 stop(self) -> List:
'Stop coverage measurement and return results.'
if (not self._enabled):
raise PageError('JSCoverage is not enabled.')
self._enabled = False
result = (await self._client.send('Profiler.takePreciseCoverage'))
(await self._client.send('Profiler.stopPreciseCoverage'))
(await self._client.send('Profiler.disable'))
(await self._client.send('Debugger.disable'))
helper.removeEventListeners(self._eventListeners)
coverage = []
for entry in result.get('result', []):
url = self._scriptURLs.get(entry.get('scriptId'))
text = self._scriptSources.get(entry.get('scriptId'))
if ((text is None) or (url is None)):
continue
flattenRanges = []
for func in entry.get('functions', []):
flattenRanges.extend(func.get('ranges', []))
ranges = convertToDisjointRanges(flattenRanges)
coverage.append({
'url': url,
'ranges': ranges,
'text': text,
})
return coverage
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 stop(self) -> List:
"""Stop coverage measurement and return results."""
if not self._enabled:
raise PageError('CSSCoverage is not enabled.')
self._enabled = False
result = await self._client.send('CSS.stopRuleUsageTracking')
await self._client.send('CSS.disable')
await self._client.send('DOM.disable')
helper.removeEventListeners(self._eventListeners)
# aggregate by styleSheetId
styleSheetIdToCoverage: Dict = {}
for entry in result['ruleUsage']:
ranges = styleSheetIdToCoverage.get(entry['styleSheetId'])
if not ranges:
ranges = []
styleSheetIdToCoverage[entry['styleSheetId']] = ranges
ranges.append({
'startOffset': entry['startOffset'],
'endOffset': entry['endOffset'],
'count': 1 if entry['used'] else 0
})
coverage = []
for styleSheetId in self._stylesheetURLs:
url = self._stylesheetURLs.get(styleSheetId)
text = self._stylesheetSources.get(styleSheetId)
ranges = convertToDisjointRanges(
styleSheetIdToCoverage.get(styleSheetId, [])
)
coverage.append({'url': url, 'ranges': ranges, 'text': text})
return coverage
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 stop(self) -> List:
"""Stop coverage measurement and return results."""
if not self._enabled:
raise PageError('JSCoverage is not enabled.')
self._enabled = False
result = await self._client.send('Profiler.takePreciseCoverage')
await self._client.send('Profiler.stopPreciseCoverage')
await self._client.send('Profiler.disable')
await self._client.send('Debugger.disable')
helper.removeEventListeners(self._eventListeners)
coverage: List = []
for entry in result.get('result', []):
url = self._scriptURLs.get(entry.get('scriptId'))
if not url and self._reportAnonymousScript:
url = f'debugger://VM{entry.get("scriptId")}'
text = self._scriptSources.get(entry.get('scriptId'))
if text is None or url is None:
continue
flattenRanges: List = []
for func in entry.get('functions', []):
flattenRanges.extend(func.get('ranges', []))
ranges = convertToDisjointRanges(flattenRanges)
coverage.append({'url': url, 'ranges': ranges, 'text': text})
return coverage
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 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 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)
async def stop(self) -> List:
"""Stop coverage measurement and return results."""
if not self._enabled:
raise PageError('JSCoverage is not enabled.')
self._enabled = False
result = await self._client.send('Profiler.takePreciseCoverage')
await self._client.send('Profiler.stopPreciseCoverage')
await self._client.send('Profiler.disable')
await self._client.send('Debugger.disable')
helper.removeEventListeners(self._eventListeners)
coverage: List = []
for entry in result.get('result', []):
url = self._scriptURLs.get(entry.get('scriptId'))
text = self._scriptSources.get(entry.get('scriptId'))
if text is None or url is None:
continue
flattenRanges: List = []
for func in entry.get('functions', []):
flattenRanges.extend(func.get('ranges', []))
ranges = convertToDisjointRanges(flattenRanges)
coverage.append({'url': url, 'ranges': ranges, 'text': text})
return coverage
def dispose(self):
self._maximumTimer.cancel()
self._timeout_timer.cancel()
helper.removeEventListeners(self._eventListeners)
def _cleanup(self) -> None:
helper.removeEventListeners(self._eventListeners)
self._lifecycleCompletePromise.cancel()
self._maximumTimer.cancel()
self._timeout_timer.cancel()
def _cleanup(self, ) -> None:
helper.removeEventListeners(self._eventListeners)
clearTimeout(self._idleTimer)
clearTimeout(self._maximumTimer)
def _cleanup(self) -> None:
helper.removeEventListeners(self._eventListeners)
self._lifecycleCompletePromise.cancel()
self._maximumTimer.cancel()
self._timeout_timer.cancel()
