Add a raising parameter to waitSignal.

Author: The-Compiler

pytestqt/_tests/test_wait_signal.py

@@ -18,38 +18,53 @@ def test_signal_blocker_exception(qtbot):
         qtbot.waitSignal(None, None).wait()
 
 
-def explicit_wait(qtbot, signal, timeout):
+def explicit_wait(qtbot, signal, timeout, raising, raises):
     """
     Explicit wait for the signal using blocker API.
     """
-    blocker = qtbot.waitSignal(signal, timeout)
+    blocker = qtbot.waitSignal(signal, timeout, raising=raising)
     assert not blocker.signal_triggered
-    blocker.wait()
+    if raises:
+        with pytest.raises(qtbot.SignalTimeout):
+            blocker.wait()
+    else:
+        blocker.wait()
     return blocker
 
 
-def context_manager_wait(qtbot, signal, timeout):
+def context_manager_wait(qtbot, signal, timeout, raising, raises):
     """
     Waiting for signal using context manager API.
     """
-    with qtbot.waitSignal(signal, timeout) as blocker:
-        pass
+    if raises:
+        with pytest.raises(qtbot.SignalTimeout):
+            with qtbot.waitSignal(signal, timeout, raising=raising) as blocker:
+                pass
+    else:
+        with qtbot.waitSignal(signal, timeout, raising=raising) as blocker:
+            pass
     return blocker
 
 
 @pytest.mark.parametrize(
-    ('wait_function', 'emit_delay', 'timeout', 'expected_signal_triggered'),
+    ('wait_function', 'emit_delay', 'timeout', 'expected_signal_triggered',
+     'raising'),
     [
-        (explicit_wait, 500, 2000, True),
-        (explicit_wait, 500, None, True),
-        (context_manager_wait, 500, 2000, True),
-        (context_manager_wait, 500, None, True),
-        (explicit_wait, 2000, 500, False),
-        (context_manager_wait, 2000, 500, False),
+        (explicit_wait, 500, 2000, True, False),
+        (explicit_wait, 500, None, True, False),
+        (context_manager_wait, 500, 2000, True, False),
+        (context_manager_wait, 500, None, True, False),
+        (explicit_wait, 2000, 500, False, False),
+        (context_manager_wait, 2000, 500, False, False),
+
+        (explicit_wait, 2000, 500, False, True),
+        (context_manager_wait, 2000, 500, False, True),
+        (explicit_wait, 2000, 500, False, True),
+        (context_manager_wait, 2000, 500, False, True),
     ] * 2  # Running all tests twice to catch a QTimer segfault, see #42/#43.
 )
 def test_signal_triggered(qtbot, wait_function, emit_delay, timeout,
-                          expected_signal_triggered):
+                          expected_signal_triggered, raising):
     """
     Testing for a signal in different conditions, ensuring we are obtaining
     the expected results.
@@ -62,7 +77,9 @@ def test_signal_triggered(qtbot, wait_function, emit_delay, timeout,
 
     # block signal until either signal is emitted or timeout is reached
     start_time = time.time()
-    blocker = wait_function(qtbot, signaller.signal, timeout)
+    raises = raising and not expected_signal_triggered
+    blocker = wait_function(qtbot, signaller.signal, timeout, raising=raising,
+                            raises=raises)
 
     # Check that event loop exited.
     assert not blocker._loop.isRunning()

pytestqt/plugin.py

@@ -161,6 +161,15 @@ class QtBot(object):
 
     """
 
+    class SignalTimeout(Exception):
+        """
+        .. versionadded:: 1.4
+
+        The exception thrown by :meth:`QtBot.waitSignal` if the *raising*
+        parameter has been given and there was a timeout.
+        """
+        pass
+
     def __init__(self):
         self._widgets = []  # list of weakref to QWidget instances
 
@@ -233,10 +242,10 @@ def stopForInteraction(self):
 
     stop = stopForInteraction
 
-    def waitSignal(self, signal=None, timeout=1000):
+    def waitSignal(self, signal=None, timeout=1000, raising=False):
         """
         .. versionadded:: 1.2
-        
+
         Stops current test until a signal is triggered.
 
         Used to stop the control flow of a test until a signal is emitted, or
@@ -255,18 +264,24 @@ def waitSignal(self, signal=None, timeout=1000):
            long_function_that_calls_signal()
            blocker.wait()
 
+        .. versionadded:: 1.4
+           The *raising* parameter.
+
         :param Signal signal:
             A signal to wait for. Set to ``None`` to just use timeout.
         :param int timeout:
             How many milliseconds to wait before resuming control flow.
+        :param bool raising:
+            If :class:`QtBot.TimeoutError` should be raised if a timeout
+            occured.
         :returns:
             ``SignalBlocker`` object. Call ``SignalBlocker.wait()`` to wait.
 
         .. note::
            Cannot have both ``signals`` and ``timeout`` equal ``None``, or
            else you will block indefinitely. We throw an error if this occurs.
         """
-        blocker = SignalBlocker(timeout=timeout)
+        blocker = SignalBlocker(timeout=timeout, raising=raising)
         if signal is not None:
             blocker.connect(signal)
         return blocker
@@ -288,13 +303,17 @@ class SignalBlocker(object):
     :ivar bool signal_triggered: set to ``True`` if a signal was triggered, or
         ``False`` if timeout was reached instead. Until :meth:`wait` is called,
         this is set to ``None``.
+
+    :ivar bool raising:
+        If :class:`QtBot.TimeoutError` should be raised if a timeout occured.
     """
 
-    def __init__(self, timeout=1000):
+    def __init__(self, timeout=1000, raising=False):
         self._loop = QtCore.QEventLoop()
         self._signals = []
         self.timeout = timeout
         self.signal_triggered = False
+        self.raising = raising
 
     def wait(self):
         """
@@ -308,7 +327,7 @@ def wait(self):
         if self.timeout is None and len(self._signals) == 0:
             raise ValueError("No signals or timeout specified.")
         if self.timeout is not None:
-            QtCore.QTimer.singleShot(self.timeout, self._loop.quit)
+            QtCore.QTimer.singleShot(self.timeout, self._quit_loop_by_timeout)
         self._loop.exec_()
 
     def connect(self, signal):
@@ -328,6 +347,17 @@ def _quit_loop_by_signal(self):
         self.signal_triggered = True
         self._loop.quit()
 
+    def _quit_loop_by_timeout(self):
+        """
+        quits the event loop and marks that we finished because of a timeout.
+        """
+        assert not self.signal_triggered
+        self._loop.quit()
+        if self.raising:
+            raise QtBot.SignalTimeout("Didn't get signal after %sms." %
+                                      self.timeout)
+
+
     def __enter__(self):
         return self
 
@@ -435,4 +465,4 @@ def pytest_configure(config):
 
 
 def pytest_report_header():
-    return ['qt-api: %s' % QT_API]
+    return ['qt-api: %s' % QT_API]