sdk/platform-tools/systrace/catapult/telemetry/telemetry/internal/backends/chrome_inspector/inspector_websocket_unittest.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import errno
   6 import socket
   7 import unittest
   8
   9 from telemetry import decorators
  10 from telemetry.internal.backends.chrome_inspector import inspector_websocket
  11 from telemetry.internal.backends.chrome_inspector import websocket
  12 from telemetry.testing import fakes
  13
  14
  15 class FakeSocket(object):
  16   """A fake websocket that allows test to send random data."""
  17   def __init__(self, fake_timer):
  18     self._fake_timer = fake_timer
  19     self._responses = []
  20     self._timeout = None
  21
  22   def AddResponse(self, response, time):
  23     if self._responses:
  24       assert self._responses[-1][1] < time, (
  25           'Current response is scheduled earlier than previous response.')
  26     self._responses.append((response, time))
  27
  28   def send(self, data):
  29     pass
  30
  31   def recv(self):
  32     if not self._responses:
  33       raise Exception('No more recorded responses.')
  34
  35     response, time = self._responses.pop(0)
  36     current_time = self._fake_timer.time()
  37     if self._timeout is not None and time - current_time > self._timeout:
  38       self._fake_timer.SetTime(current_time + self._timeout + 1)
  39       raise websocket.WebSocketTimeoutException()
  40
  41     self._fake_timer.SetTime(time)
  42     if isinstance(response, Exception):
  43       raise response
  44     return response
  45
  46   def settimeout(self, timeout):
  47     self._timeout = timeout
  48
  49
  50 def _DoNothingHandler(elapsed_time):
  51   del elapsed_time  # unused
  52
  53
  54 class InspectorWebsocketUnittest(unittest.TestCase):
  55
  56   def setUp(self):
  57     self._fake_timer = fakes.FakeTimer()
  58
  59   def tearDown(self):
  60     self._fake_timer.Restore()
  61
  62   @decorators.Disabled('chromeos', 'mac')  # crbug.com/483212, crbug.com/498950
  63   def testDispatchNotification(self):
  64     inspector = inspector_websocket.InspectorWebsocket()
  65     fake_socket = FakeSocket(self._fake_timer)
  66     # pylint: disable=protected-access
  67     inspector._socket = fake_socket
  68
  69     results = []
  70     def OnTestEvent(result):
  71       results.append(result)
  72
  73     inspector.RegisterDomain('Test', OnTestEvent)
  74     fake_socket.AddResponse('{"method": "Test.foo"}', 5)
  75     inspector.DispatchNotifications(10)
  76     self.assertEqual(1, len(results))
  77     self.assertEqual('Test.foo', results[0]['method'])
  78
  79   @decorators.Disabled('chromeos')  # crbug.com/483212
  80   def testDispatchNotificationTimedOut(self):
  81     inspector = inspector_websocket.InspectorWebsocket()
  82     fake_socket = FakeSocket(self._fake_timer)
  83     # pylint: disable=protected-access
  84     inspector._socket = fake_socket
  85
  86     results = []
  87     def OnTestEvent(result):
  88       results.append(result)
  89
  90     inspector.RegisterDomain('Test', OnTestEvent)
  91     fake_socket.AddResponse('{"method": "Test.foo"}', 11)
  92     with self.assertRaises(
  93         websocket.WebSocketTimeoutException):
  94       inspector.DispatchNotifications(timeout=10)
  95     self.assertEqual(0, len(results))
  96
  97   @decorators.Disabled('chromeos')  # crbug.com/483212
  98   def testUnregisterDomain(self):
  99     inspector = inspector_websocket.InspectorWebsocket()
 100     fake_socket = FakeSocket(self._fake_timer)
 101     # pylint: disable=protected-access
 102     inspector._socket = fake_socket
 103
 104     results = []
 105     def OnTestEvent(result):
 106       results.append(result)
 107
 108     inspector.RegisterDomain('Test', OnTestEvent)
 109     inspector.RegisterDomain('Test2', OnTestEvent)
 110     inspector.UnregisterDomain('Test')
 111
 112     fake_socket.AddResponse('{"method": "Test.foo"}', 5)
 113     fake_socket.AddResponse('{"method": "Test2.foo"}', 10)
 114
 115     inspector.DispatchNotifications(10)
 116     self.assertEqual(0, len(results))
 117
 118     inspector.DispatchNotifications(10)
 119     self.assertEqual(1, len(results))
 120     self.assertEqual('Test2.foo', results[0]['method'])
 121
 122   @decorators.Disabled('chromeos')  # crbug.com/483212
 123   def testUnregisterDomainWithUnregisteredDomain(self):
 124     inspector = inspector_websocket.InspectorWebsocket()
 125     with self.assertRaises(AssertionError):
 126       inspector.UnregisterDomain('Test')
 127
 128   def testAsyncRequest(self):
 129     inspector = inspector_websocket.InspectorWebsocket()
 130     fake_socket = FakeSocket(self._fake_timer)
 131     # pylint: disable=protected-access
 132     inspector._socket = fake_socket
 133     response_count = [0]
 134
 135     def callback0(response):
 136       response_count[0] += 1
 137       self.assertEqual(2, response_count[0])
 138       self.assertEqual('response1', response['result']['data'])
 139
 140     def callback1(response):
 141       response_count[0] += 1
 142       self.assertEqual(1, response_count[0])
 143       self.assertEqual('response2', response['result']['data'])
 144
 145     request1 = {'method': 'Test.foo'}
 146     inspector.AsyncRequest(request1, callback0)
 147     request2 = {'method': 'Test.foo'}
 148     inspector.AsyncRequest(request2, callback1)
 149     fake_socket.AddResponse('{"id": 5555555, "result": {}}', 1)
 150     inspector.DispatchNotifications(10)
 151     self.assertEqual(0, response_count[0])
 152     fake_socket.AddResponse(
 153         '{"id": %d, "result": {"data": "response2"}}' % request2['id'], 1)
 154     fake_socket.AddResponse(
 155         '{"id": %d, "result": {"data": "response1"}}' % request1['id'], 2)
 156     inspector.DispatchNotifications(10)
 157     inspector.DispatchNotifications(10)
 158     self.assertEqual(2, response_count[0])
 159     fake_socket.AddResponse('{"id": 6666666, "result": {}}', 1)
 160     inspector.DispatchNotifications(10)
 161     self.assertEqual(2, response_count[0])
 162
 163   def testEAGAIN(self):
 164     inspector = inspector_websocket.InspectorWebsocket()
 165     fake_socket = FakeSocket(self._fake_timer)
 166     # pylint: disable=protected-access
 167     inspector._socket = fake_socket
 168
 169     error = socket.error(errno.EAGAIN, "error string")
 170     fake_socket.AddResponse(error, 4)
 171     fake_socket.AddResponse('{"asdf": "qwer"}', 5)
 172
 173     result = inspector._Receive(10)
 174     self.assertEqual(result, {"asdf" : "qwer"})
 175
 176   def testSocketErrorOtherThanEAGAIN(self):
 177     inspector = inspector_websocket.InspectorWebsocket()
 178     fake_socket = FakeSocket(self._fake_timer)
 179     # pylint: disable=protected-access
 180     inspector._socket = fake_socket
 181
 182     error = socket.error(errno.EPIPE, "error string")
 183     fake_socket.AddResponse(error, 4)
 184
 185     with self.assertRaises(socket.error):
 186       inspector._Receive(10)