Merge pull request #28 from scivisum/bug/RD-37592_dont_let_flushmessages_block

Bug/rd 37592 dont let flushmessages block

Author: erustusagutu

browserdebuggertools/chrome/interface.py

@@ -84,7 +84,7 @@ def set_timeout(self, value):
         """ Switches the timeout to the given value.
         """
         _timeout = self._socket_handler.timeout
-        self._socket_handler.timeout = value
+        self._socket_handler.timer.timeout = value
         try:
             yield
         finally:

browserdebuggertools/exceptions.py

@@ -14,6 +14,10 @@ class DevToolsTimeoutException(DevToolsException):
     pass
 
 
+class TimerException(DevToolsException):
+    pass
+
+
 class TabNotFoundError(NotFoundError):
     pass
 

browserdebuggertools/sockethandler.py

@@ -1,3 +1,4 @@
+import contextlib
 import json
 import logging
 import socket
@@ -14,7 +15,7 @@
 from browserdebuggertools.exceptions import (
     DevToolsException, ResultNotFoundError, TabNotFoundError, MaxRetriesException,
     DevToolsTimeoutException, DomainNotEnabledError,
-    MethodNotFoundError, UnknownError, ResourceNotFoundError
+    MethodNotFoundError, UnknownError, ResourceNotFoundError, TimerException
 )
 
 
@@ -33,6 +34,42 @@ def retry_if_exception(socket_handler_instance, *args, **kwargs):
     return retry_if_exception
 
 
+class _Timer(object):
+
+    def __init__(self, timeout):
+        """
+        :param timeout: <int> seconds elapsed until considered timed out.
+        """
+        self.timeout = timeout
+        self._start = None
+
+    def start(self):
+        """
+        Capture the start time, cannot be called again without first calling clear().
+        """
+        if self._start:
+            raise TimerException("You cannot start a timer that's already started")
+        self._start = time.time()
+
+    def clear(self):
+        """
+        Make the timer object ready to be used again.
+        """
+        self._start = None
+
+    @property
+    def timed_out(self):
+        """
+        :return: <bool> True if the time from start to now is greater than the timeout threshold
+        """
+        if not self._start:
+            raise TimerException("Timer must have started for there to have been a timeout")
+
+        if (time.time() - self._start) > self.timeout:
+            return True
+        return False
+
+
 class SocketHandler(object):
 
     MAX_CONNECTION_RETRIES = 3
@@ -42,6 +79,7 @@ class SocketHandler(object):
     def __init__(self, port, timeout, domains=None):
 
         self.timeout = timeout
+        self.timer = _Timer(self.timeout)
 
         if not domains:
             domains = {}
@@ -163,9 +201,11 @@ def _flush_messages(self):
         """
         try:
             message = self._recv()
-            while message:
+            while not self.timer.timed_out and message:
                 self._append(message)
                 message = self._recv()
+            if self.timer.timed_out:
+                raise DevToolsTimeoutException("Timed out flushing messages")
         except socket.error:
             return
 
@@ -226,7 +266,9 @@ def get_events(self, domain, clear=False):
                 'The domain "%s" is not enabled, try enabling it via the interface.' % domain
             )
 
-        self._flush_messages()
+        with self.timed_method():
+            self._flush_messages()
+
         events = self._events[domain]
         if clear:
             self._events[domain] = []
@@ -243,18 +285,28 @@ def reset(self):
         self._results = {}
         self._next_result_id = 0
 
+    @contextlib.contextmanager
+    def timed_method(self):
+
+        self.timer.start()
+        try:
+            yield
+
+        finally:
+            self.timer.clear()
+
     def _wait_for_result(self):
         """ Waits for a result to complete within the timeout duration then returns it.
             Raises a DevToolsTimeoutException if it cannot find the result.
 
         :return: The result.
           """
-        start = time.time()
-        while not self.timeout or (time.time() - start) < self.timeout:
-            try:
-                return self._find_next_result()
-            except ResultNotFoundError:
-                time.sleep(0.01)
+        with self.timed_method():
+            while not self.timer.timed_out:
+                try:
+                    return self._find_next_result()
+                except ResultNotFoundError:
+                    time.sleep(0.01)
         raise DevToolsTimeoutException(
             "Reached timeout limit of {}, waiting for a response message".format(self.timeout)
         )

setup.py

@@ -13,7 +13,7 @@
 
 setup(
     name="browserdebuggertools",
-    version="5.1.0",
+    version="5.2.0",
     packages=PACKAGES,
     install_requires=requires,
     license="GNU General Public License v3",

tests/e2etests/chrome/test_interface.py

@@ -121,9 +121,12 @@ def test_take_screenshot_incomplete_main_exchange(self):
 
         assert isinstance(self, ChromeInterfaceTest)
 
-        self.devtools_client.navigate(
-            url="http://localhost:%s?main_exchange_response_time=10" % self.testSite.port
-        )
+        with self.devtools_client.set_timeout(30):
+
+            self.devtools_client.navigate(
+                url="http://localhost:%s?main_exchange_response_time=10" % self.testSite.port
+            )
+
         self.devtools_client.take_screenshot(self.file_path)
         self.assertTrue(os.path.exists(self.file_path))
         self.assertTrue(os.path.getsize(self.file_path) >= 5000)
@@ -184,9 +187,10 @@ def test_take_screenshot_incomplete_main_exchange(self):
 
         assert isinstance(self, ChromeInterfaceTest)
 
-        self.devtools_client.navigate(
-            url="http://localhost:%s?main_exchange_response_time=10" % self.testSite.port
-        )
+        with self.devtools_client.set_timeout(30):
+            self.devtools_client.navigate(
+                url="http://localhost:%s?main_exchange_response_time=10" % self.testSite.port
+            )
         self.devtools_client.navigate(url="http://localhost:%s" % self.testSite.port)
         self._assert_dom_complete()
         self.assertEqual("complete", self.devtools_client.get_document_readystate())

tests/integrationtests/test_sockethandler.py

@@ -1,118 +1,98 @@
+import json
 import socket
 from unittest import TestCase
 
 from mock import MagicMock
 
+from browserdebuggertools.exceptions import DevToolsTimeoutException
 from browserdebuggertools.sockethandler import SocketHandler
 
 MODULE_PATH = "browserdebuggertools.sockethandler."
 
 
-class MockSocketHandler(SocketHandler):
+class Test_SocketHandler_get_events(TestCase):
 
-    def __init__(self):
-        self._websocket = MagicMock()
+    class _DummyWebsocket(object):
 
-        self._next_result_id = 0
-        self._domains = []
-        self._results = {}
-        self._events = {}
-        self._internal_events = {}
+        def __init__(self):
+            self._result_id = -1
 
+        def recv(self):
+            self._result_id += 1
+            return json.dumps({"method": "Network.Something", "params": {}})
 
-class SocketHandlerTest(TestCase):
+    class MockSocketHandler(SocketHandler):
 
-    def setUp(self):
-        self.socket_handler = MockSocketHandler()
-
-
-class Test_SocketHandler_can_get_messages(SocketHandlerTest):
+        def __init__(self):
+            SocketHandler.__init__(self, 1234, 30)
 
-    def test_get_results(self):
-        mock_result = {"key": "value"}
-        mock_message = '{"id": 1, "result": {"key": "value"}}'
-        self.socket_handler._websocket.recv.side_effect = [mock_message, None]
+        def _get_websocket_url(self, port):
+            return "ws://localhost:1234/devtools/page/test"
 
-        self.socket_handler._flush_messages()
+        def _setup_websocket(self):
+            return MagicMock()
 
-        self.assertEqual(mock_result, self.socket_handler._results[1])
-
-    def test_get_errors(self):
-        mock_error = {"error": {"key": "value"}}
-        mock_message = '{"id": 1, "error": {"key": "value"}}'
-        self.socket_handler._websocket.recv.side_effect = [mock_message, None]
+    def setUp(self):
+        self.socket_handler = self.MockSocketHandler()
 
-        self.socket_handler._flush_messages()
+    def test_timeout_when_getting_events(self):
 
-        self.assertEqual(mock_error, self.socket_handler._results[1])
+        self.socket_handler._websocket = self._DummyWebsocket()
+        self.socket_handler.timer.timeout = 1
+        self.socket_handler._domains = {"Network": []}
 
-    def test_get_events(self):
-        mock_event = {"method": "MockDomain.mockEvent", "params": {"key": "value"}}
-        mock_message = '{"method": "MockDomain.mockEvent", "params": {"key": "value"}}'
-        self.socket_handler._events["MockDomain"] = []
-        self.socket_handler._websocket.recv.side_effect = [mock_message, None]
+        with self.assertRaises(DevToolsTimeoutException):
+            self.socket_handler.get_events("Network")
 
-        self.socket_handler._flush_messages()
 
-        self.assertIn(mock_event, self.socket_handler._events["MockDomain"])
+class Test_SocketHandler_wait_for_result(TestCase):
 
-    def test_get_mixed(self):
-        mock_result = {"key": "value"}
-        mock_error = {"error": {"key": "value"}}
-        mock_event = {"method": "MockDomain.mockEvent", "params": {"key": "value"}}
-        mock_result_message = '{"id": 1, "result": {"key": "value"}}'
-        mock_error_message = '{"id": 2, "error": {"key": "value"}}'
-        mock_event_message = '{"method": "MockDomain.mockEvent", "params": {"key": "value"}}'
+    class _DummyWebsocket(object):
 
-        self.socket_handler._events["MockDomain"] = []
-        self.socket_handler._websocket.recv.side_effect = [
-            mock_result_message, mock_error_message, mock_event_message, None
-        ]
+        def __init__(self):
+            self._result_id = -1
 
-        self.socket_handler._flush_messages()
+        def recv(self):
+            self._result_id += 1
+            return json.dumps({"method": "Network.Something", "params": {}})
 
-        self.assertEqual(mock_result, self.socket_handler._results[1])
-        self.assertEqual(mock_error, self.socket_handler._results[2])
-        self.assertIn(mock_event, self.socket_handler._events["MockDomain"])
+    class MockSocketHandler(SocketHandler):
 
-    def test_get_messages_then_except(self):
-        mock_result = {"key": "value"}
-        mock_message = '{"id": 1, "result": {"key": "value"}}'
-        self.socket_handler._websocket.recv.side_effect = [mock_message, socket.error]
+        def __init__(self):
+            SocketHandler.__init__(self, 1234, 30)
 
-        self.socket_handler._flush_messages()
+        def _get_websocket_url(self, port):
+            return "ws://localhost:1234/devtools/page/test"
 
-        self.assertEqual(mock_result, self.socket_handler._results[1])
+        def _setup_websocket(self):
+            return MagicMock()
 
+    def setUp(self):
+        self.socket_handler = self.MockSocketHandler()
 
-class Test_SocketHandler_get_events(SocketHandlerTest):
+    def test_no_messages_with_result_timeout(self):
 
-    def test_get_events_returns_copy(self):
-        mock_message = '{"method": "MockDomain.mockEvent", "params": {"key": "value"}}'
-        self.socket_handler._domains = ["MockDomain"]
-        self.socket_handler._events["MockDomain"] = []
-        self.socket_handler._websocket.recv.side_effect = [mock_message, None, None]
+        self.socket_handler._websocket = MagicMock(recv=MagicMock(side_effect=socket.error()))
+        self.socket_handler.timer.timeout = 1
+        self.socket_handler._next_result_id = 2
 
-        events = self.socket_handler.get_events("MockDomain")
+        with self.assertRaises(DevToolsTimeoutException):
+            self.socket_handler._wait_for_result()
 
-        events[0] = ""
+    def test_message_spamming_with_result_timeout(self):
 
-        self.assertEqual(
-            {"method": "MockDomain.mockEvent", "params": {"key": "value"}},
-            self.socket_handler.get_events("MockDomain")[0]
-        )
+        self.socket_handler._websocket = self._DummyWebsocket()
+        self.socket_handler.timer.timeout = 1
+        self.socket_handler._next_result_id = -1
 
-    def test_get_events_clear(self):
-        mock_message = '{"method": "MockDomain.mockEvent", "params": {"key": "value"}}'
-        self.socket_handler._domains = ["MockDomain"]
-        self.socket_handler._events["MockDomain"] = []
-        self.socket_handler._websocket.recv.side_effect = [mock_message, None, None]
+        with self.assertRaises(DevToolsTimeoutException):
+            self.socket_handler._wait_for_result()
 
-        events = self.socket_handler.get_events("MockDomain")
+    def test_message_spamming_with_result_found(self):
 
-        events[0] = ""
+        self.socket_handler._websocket = self._DummyWebsocket()
+        self.socket_handler.timer.timeout = 1
+        self.socket_handler._next_result_id = 2
 
-        self.assertEqual(
-            {"method": "MockDomain.mockEvent", "params": {"key": "value"}},
-            self.socket_handler.get_events("MockDomain")[0]
-        )
+        with self.assertRaises(DevToolsTimeoutException):
+            self.socket_handler._wait_for_result()