def testDispatchNotificationsUntilDone(self):
inspector = inspector_websocket.InspectorWebsocket(
error_handler=_ReraiseExceptionErrorHandler)
fake_socket = FakeSocket(self._mock_timer)
# pylint: disable=protected-access
inspector._socket = fake_socket
results = []
def OnTestEvent(result):
results.append(result)
return len(results) > 2
inspector.RegisterDomain('Test', OnTestEvent, _DoNothingHandler)
# Even though it takes 70 seconds to receive all the data, the call below
# will succeed since there are no interval which the previous data package
# received and the next failed data receiving attempt was greater than
# 30 seconds.
fake_socket.AddResponse('{"method": "Test.foo"}', 10)
fake_socket.AddResponse('{"method": "Test.bar"}', 20)
fake_socket.AddResponse('{"method": "Test.baz"}', 35)
fake_socket.AddResponse('{"method": "Test.qux"}', 50)
fake_socket.AddResponse('{"method": "Test.baz"}', 60)
fake_socket.AddResponse('{"method": "Test.foo"}', 70)
inspector.DispatchNotificationsUntilDone(31)
self.assertEqual(3, len(results))
self.assertEqual('Test.baz', results[2]['method'])
def __init__(self, app, devtools_client, context, timeout=60):
self._websocket = inspector_websocket.InspectorWebsocket(self._HandleError)
self._websocket.RegisterDomain(
'Inspector', self._HandleInspectorDomainNotification)
self._app = app
self._devtools_client = devtools_client
# Be careful when using the context object, since the data may be
# outdated since this is never updated once InspectorBackend is
# created. Consider an updating strategy for this. (For an example
# of the subtlety, see the logic for self.url property.)
self._context = context
logging.debug('InspectorBackend._Connect() to %s', self.debugger_url)
try:
self._websocket.Connect(self.debugger_url)
except (websocket.WebSocketException, util.TimeoutException) as e:
raise InspectorException(e.msg)
self._console = inspector_console.InspectorConsole(self._websocket)
self._memory = inspector_memory.InspectorMemory(self._websocket)
self._page = inspector_page.InspectorPage(
self._websocket, timeout=timeout)
self._runtime = inspector_runtime.InspectorRuntime(self._websocket)
self._timeline = inspector_timeline.InspectorTimeline(self._websocket)
self._network = inspector_network.InspectorNetwork(self._websocket)
self._timeline_model = None
def testUnregisterDomain(self):
inspector = inspector_websocket.InspectorWebsocket(
error_handler=_ReraiseExceptionErrorHandler)
fake_socket = FakeSocket(self._mock_timer)
# pylint: disable=protected-access
inspector._socket = fake_socket
results = []
def OnTestEvent(result):
results.append(result)
inspector.RegisterDomain('Test', OnTestEvent, _DoNothingHandler)
inspector.RegisterDomain('Test2', OnTestEvent, _DoNothingHandler)
inspector.UnregisterDomain('Test')
fake_socket.AddResponse('{"method": "Test.foo"}', 5)
fake_socket.AddResponse('{"method": "Test2.foo"}', 10)
inspector.DispatchNotifications()
self.assertEqual(0, len(results))
inspector.DispatchNotifications()
self.assertEqual(1, len(results))
self.assertEqual('Test2.foo', results[0]['method'])
def __init__(self, devtools_port):
self._inspector_websocket = inspector_websocket.InspectorWebsocket()
self._inspector_websocket.RegisterDomain('Tracing',
self._NotificationHandler)
self._inspector_websocket.Connect(
'ws://127.0.0.1:%i/devtools/browser' % devtools_port)
self._trace_events = []
self._is_tracing_running = False
self._has_received_all_tracing_data = False
def __init__(self, devtools_port, chrome_browser_backend):
self._inspector_websocket = inspector_websocket.InspectorWebsocket(
self._ErrorHandler)
self._inspector_websocket.RegisterDomain(
'Tracing', self._NotificationHandler)
self._inspector_websocket.Connect(
'ws://127.0.0.1:%i/devtools/browser' % devtools_port)
self._tracing_data = []
self._is_tracing_running = False
self._chrome_browser_backend = chrome_browser_backend
def testDispatchNotificationTimedOut(self):
inspector = inspector_websocket.InspectorWebsocket()
fake_socket = FakeSocket(self._mock_timer)
# pylint: disable=protected-access
inspector._socket = fake_socket
results = []
def OnTestEvent(result):
results.append(result)
inspector.RegisterDomain('Test', OnTestEvent)
fake_socket.AddResponse('{"method": "Test.foo"}', 11)
with self.assertRaises(websocket.WebSocketTimeoutException):
inspector.DispatchNotifications(timeout=10)
self.assertEqual(0, len(results))
def testDispatchNotification(self):
inspector = inspector_websocket.InspectorWebsocket()
fake_socket = FakeSocket(self._mock_timer)
# pylint: disable=protected-access
inspector._socket = fake_socket
results = []
def OnTestEvent(result):
results.append(result)
inspector.RegisterDomain('Test', OnTestEvent)
fake_socket.AddResponse('{"method": "Test.foo"}', 5)
inspector.DispatchNotifications()
self.assertEqual(1, len(results))
self.assertEqual('Test.foo', results[0]['method'])
def GetSystemInfo(self, timeout=10):
req = {'method': 'SystemInfo.getInfo'}
websocket = inspector_websocket.InspectorWebsocket()
try:
if self._page:
websocket.Connect('ws://127.0.0.1:%i/devtools/page/%i' %
(self._port, self._page))
else:
websocket.Connect('ws://127.0.0.1:%i/devtools/browser' %
self._port)
res = websocket.SyncRequest(req, timeout)
finally:
websocket.Disconnect()
if 'error' in res:
return None
return system_info.SystemInfo.FromDict(
camel_case.ToUnderscore(res['result']))
def testRegisterDomainWillCloseHandler(self):
inspector = inspector_websocket.InspectorWebsocket(
error_handler=_ReraiseExceptionErrorHandler)
results = []
def OnClose():
results.append(1)
results2 = []
def OnClose2():
results2.append(1)
inspector.RegisterDomain('Test', _DoNothingHandler, OnClose)
inspector.RegisterDomain('Test2', _DoNothingHandler, OnClose2)
inspector.RegisterDomain('Test3', _DoNothingHandler)
inspector.Disconnect()
self.assertEqual(1, len(results))
self.assertEqual(1, len(results2))
def testDispatchNotificationsUntilDoneTimedOut(self):
inspector = inspector_websocket.InspectorWebsocket(
error_handler=_ReraiseExceptionErrorHandler)
fake_socket = FakeSocket(self._mock_timer)
# pylint: disable=protected-access
inspector._socket = fake_socket
results = []
def OnTestEvent(result):
results.append(result)
inspector.RegisterDomain('Test', OnTestEvent, _DoNothingHandler)
fake_socket.AddResponse('{"method": "Test.foo"}', 5)
fake_socket.AddResponse('{"method": "Test.bar"}', 16)
fake_socket.AddResponse('{"method": "Test.baz"}', 20)
with self.assertRaises(inspector_websocket.
DispatchNotificationsUntilDoneTimeoutException):
inspector.DispatchNotificationsUntilDone(10)
self.assertEqual(1, len(results))
def testDispatchNotificationUntilDoneTimedOut2(self):
inspector = inspector_websocket.InspectorWebsocket(
error_handler=_ReraiseExceptionErrorHandler)
fake_socket = FakeSocket(self._mock_timer)
inspector._socket = fake_socket # pylint: disable=W0212
results = []
def OnTestEvent(result):
results.append(result)
inspector.RegisterDomain('Test', OnTestEvent, _DoNothingHandler)
# The third call to socket.recv() will take 15 seconds without any data
# received, hence the below call will raise a
# DispatchNotificationsUntilDoneTimeoutException.
fake_socket.AddResponse('{"method": "Test.foo"}', 10)
fake_socket.AddResponse('{"method": "Test.bar"}', 20)
fake_socket.AddResponse('{"method": "Test.baz"}', 35)
with self.assertRaises(inspector_websocket.
DispatchNotificationsUntilDoneTimeoutException):
inspector.DispatchNotificationsUntilDone(12)
self.assertEqual(2, len(results))
def testUnregisterDomainWithUnregisteredDomain(self):
inspector = inspector_websocket.InspectorWebsocket(
error_handler=_ReraiseExceptionErrorHandler)
with self.assertRaises(AssertionError):
inspector.UnregisterDomain('Test')
def testUnregisterDomainWithUnregisteredDomain(self):
inspector = inspector_websocket.InspectorWebsocket()
with self.assertRaises(AssertionError):
inspector.UnregisterDomain('Test')
