added SignalBlocker.signal_triggered attribute and docs

Author: nicoddemus

docs/index.rst

@@ -132,7 +132,8 @@ ensuring the results are correct::
         app = Application()
         app.worker.start()
 
-        with qtbot.waitSignal(app.worker.finished, timeout=10000):
+        with qtbot.waitSignal(app.worker.finished, timeout=10000) as blocker:
+            assert blocker.signal_triggered
             assert_application_results(app)
 
 

pytestqt/_tests/test_wait_signal.py

@@ -23,42 +23,49 @@ def explicit_wait(qtbot, signal, timeout):
     Explicit wait for the signal using blocker API.
     """
     blocker = qtbot.waitSignal(signal, timeout)
-    start_time = time.time()
+    assert blocker.signal_triggered is None
     blocker.wait()
-    return blocker._loop, start_time
+    return blocker
 
 
 def context_manager_wait(qtbot, signal, timeout):
     """
     Waiting for signal using context manager API.
     """
     with qtbot.waitSignal(signal, timeout) as blocker:
-        start_time = time.time()
-    return blocker._loop, start_time
+        pass
+    return blocker
 
 
 @pytest.mark.parametrize(
-    ('wait_function', 'emit_delay', 'timeout'),
+    ('wait_function', 'emit_delay', 'timeout', 'expected_signal_triggered'),
     [
-        (explicit_wait, 500, 2000),
-        (explicit_wait, 500, None),
-        (context_manager_wait, 500, 2000),
-        (context_manager_wait, 500, None),
+        (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),
     ]
 )
-def test_signal_triggered(qtbot, wait_function, emit_delay, timeout):
+def test_signal_triggered(qtbot, wait_function, emit_delay, timeout,
+                          expected_signal_triggered):
     """
-    Ensure that a signal being triggered before timeout expires makes the
-    loop quitting early.
+    Testing for a signal in different conditions, ensuring we are obtaining
+    the expected results.
     """
     signaller = Signaller()
     QtCore.QTimer.singleShot(emit_delay, signaller.signal.emit)
 
     # block signal until either signal is emitted or timeout is reached
-    loop, start_time = wait_function(qtbot, signaller.signal, timeout)
+    start_time = time.time()
+    blocker = wait_function(qtbot, signaller.signal, timeout)
 
     # Check that event loop exited.
-    assert not loop.isRunning()
+    assert not blocker._loop.isRunning()
+
+    # ensure that either signal was triggered or timeout occurred
+    assert blocker.signal_triggered == expected_signal_triggered
 
     # Check that we exited by the earliest parameter; timeout = None means
     # wait forever, so ensure we waited at most 4 times emit-delay

pytestqt/plugin.py

@@ -259,12 +259,17 @@ class SignalBlocker(object):
 
     :ivar int timeout: maximum time to wait for a signal to be triggered. Can
         be changed before :meth:`wait` is called.
+
+    :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``.
     """
 
     def __init__(self, timeout=1000):
         self._loop = QtCore.QEventLoop()
         self._signals = []
         self.timeout = timeout
+        self.signal_triggered = None
 
     def wait(self):
         """
@@ -278,6 +283,7 @@ def wait(self):
             raise ValueError("No signals or timeout specified.")
         if self.timeout is not None:
             QtCore.QTimer.singleShot(self.timeout, self._loop.quit)
+        self.signal_triggered = False
         self._loop.exec_()
 
     def connect(self, signal):
@@ -287,9 +293,17 @@ def connect(self, signal):
 
         :param signal: QtCore.Signal
         """
-        signal.connect(self._loop.quit)
+        signal.connect(self._quit_loop_by_signal)
         self._signals.append(signal)
 
+
+    def _quit_loop_by_signal(self):
+        """
+        quits the event loop and marks that we finished because of a signal.
+        """
+        self.signal_triggered = True
+        self._loop.quit()
+
     def __enter__(self):
         # Return self for testing purposes. Generally not needed.
         return self