如何测试 PyQt/PySide 信号？

Question

I'm trying to test a class that takes "events" from another library and re-dispatches them as Signals/pyqtSignals.

I'm trying to test it by:

1. Connecting a handler.
2. Performing some action that should trigger the event (and thus, the Signal/pyqtSignal to be emitted, which should call the handler).
3. Checking to see if the handler was called.

But the handler never gets called. Or at least it's not getting called by the time I check for it. If I run the lines of the test function one-by-one in a console, the test is successful.

I think the problem is that the Signals aren't getting processed until after the test function completes, but if that's the case, how would I go about testing them?

Here is an example of how I'm trying to test:

from mock import Mock


def test_object():
    obj = MyObject()
    handler = Mock()

    # This connects handler to a Signal/pyqtSignal
    obj.connect('event_type', handler)

    # This should trigger that signal
    obj.do_some_stuff()

    # This fails (call_count is 0)
    assert handler.call_count = 1

    # This will also fail (call_count is 0)
    QtCore.QCoreApplication.instance().processEvents()
    assert handler.call_count = 1

Answer 1

You might need to run a local event loop when waiting for the signals to be dispatched.

Since you seem to be using pytest (if not, you should consider to!), I'd recommend the pytest-qt plugin. With it, you could write your test like this:

def test_object(qtbot):
    obj = MyObject()

    with qtbot.waitSignal(obj.event_type, raising=True):
        obj.do_some_stuff()

Answer 2

The objects you are connecting might be garbage-collected before the signal is received because they are created in the scope of the test_object function and might not have time to complete.

EDIT: example code:

from PySide import QtCore, QtGui

class MyObject(QtCore.QObject):
    fired = QtCore.Signal()
    def __init__(self, parent=None):
        super(MyObject, self).__init__(parent)

    def do_some_stuff(self):
        self.fired.emit()

class Mock(object):
    def __init__(self, parent=None):
        self.call_count = 0

    def signalReceived(self):
        self.call_count+=1
        print "Signal received, call count: %d" % self.call_count

def test_object():
    obj = MyObject()
    handler = Mock()
    obj.fired.connect(handler.signalReceived)
    obj.do_some_stuff()
    assert handler.call_count == 1
    QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents, 50)


test_object()

Answer 3

The application is not even instantiated when you call do_some_stuff(). If there is no app, then it will be created when you first call QCoreApplication.instance()

So all you have to do is insert a line at the beginning of the function to instantiate the application. You wont event need the process event method, becouse Signals are not events. Events are gui events. Signals at least by default are called immediatelly.

this is from Qt documentation:

When a signal is emitted, the slots connected to it are usually executed immediately, just like a normal function call. When this happens, the signals and slots mechanism is totally independent of any GUI event loop. Execution of the code following the emit statement will occur once all slots have returned. The situation is slightly different when using queued connections; in such a case, the code following the emit keyword will continue immediately, and the slots will be executed later.

http://doc.qt.io/qt-5/signalsandslots.html

def test_object():
    app = QtCore.QCoreApplication.instance() # isntantiate the app
    obj = MyObject()
    handler = Mock()

    # This connects handler to a Signal/pyqtSignal
    obj.connect('event_type', handler)

    # This should trigger that signal
    obj.do_some_stuff()

    # This fails (call_count is 0)
    assert handler.call_count = 1

    # This will also fail (call_count is 0)
    assert handler.call_count = 1

Why don't you use python's unittest module? I just wanted to test PySide signals as well and subclassed the TestCase class to support that. You can subclass this and use the assertSignalReceived method, to test if a signal was called. It also tests for arguments. Let me know it it works for you! I haven't used it much yet.

example:

class TestMySignals(UsesQSignals):
    def test_my_signal(self):
        with self.assertSignalReceived(my_signal, expected_args):
            my_signal.emit(args)

UsesQSignal class, has a little context manager

class SignalReceiver:
    def __init__(self, test, signal, *args):
        self.test = test
        self.signal = signal
        self.called = False
        self.expected_args = args

    def slot(self, *args):
        self.actual_args = args
        self.called = True

    def __enter__(self):
        self.signal.connect(self.slot)

    def __exit__(self, e, msg, traceback):
        if e: 
            raise e, msg
        self.test.assertTrue(self.called, "Signal not called!")
        self.test.assertEqual(self.expected_args, self.actual_args, """Signal arguments don't match!
            actual:   {}
            expected: {}""".format(self.actual_args, self.expected_args))


class UsesQSignals(unittest.TestCase):
    def setUp(self):
        from PySide.QtGui import QApplication

        '''Creates the QApplication instance'''
        _instance = QApplication.instance()
        if not _instance:
            _instance = QApplication([])
        self.app = _instance

    def tearDown(self):
        '''Deletes the reference owned by self'''
        del self.app

    def assertSignalReceived(self, signal, args):
        return SignalReceiver(self, signal, args)

Answer 4

I ran into the same issue, but am not using pytest and so cannot use the recommended plugin.

My hacky solution which worked better than expected was to set up the widget under test how I want it, actually launch the app, then have a special option in the widget to call QApplication.quit() when the method is done being tested. So far I have unit tests where I call a function using pyqt5 signals 10s of times using this method without issue.

For me this is testing a data loading class which uses workers and signals. Here is a cut down version of the code. First the class under test is below.

from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtCore import QTimer


class LoadWidget(QWidget):
    def __init__(self, *args, test_mode=False, **kwargs):
        super(LoadWidget, self).__init__(*args, **kwargs)
        self.obj = ''

        if test_mode:
            self.timer = QTimer()
            self.timer.setSingleShot(True)
            self.timer.timeout.connect(lambda: QApplication.quit())
            self.timer.start(100)

    def load(fname):
        # The following two lines happens in a worker and a signal calls  
        # another class method on completion to deposit the loaded data  
        # in self.obj, but for brevity I will just write it out here
        with open(fname) as f:
            self.obj = f.read()

Then the test itself.

import unittest
import random
import string
from PyQt5.QtWidgets import QApplication


ctx = QApplication([])


class LoadTests(unittest.TestCase):
    def test_load_file(self):
        test_dat = ''.join(random.choice(string.ascii_lowercase) for _ in range(10))
        with open("test.txt", 'w') as f:
            f.write(test_dat)
        w = LoadWidget(test_mode=True)
        w.load("test.txt")
        ctx.exec_()
        self.assertEqual(test_dat, w.obj)

Edit: Just after getting this working in my example, I ran into another problem where the event loop isn't getting called because the load function doesn't end until calling application quit. This affected some of my tests. This can be mitigated by adding the quit call to a timer and I'm updating my code to reflect that.

Further Edit: The timer must be called in single-shot mode otherwise it will keep calling across further tests and cause difficult to diagnose issues. Since it is a timer it can be set in the class constructor which allows it to be shared across multiple methods.

Final Note: Having the QApplication be created in setUp caused weird crashes when I started running many tests in a suite and spawning many applications. This was solved by moving it into the main body of the file and just calling the global version.

Final Final Note Using a timer to kill the application doesn't even require modification of the widget being tested. You can simply create a function to stick a timer to it before launching the application in your test. This simplifies things and allows for functions involving signals to be run more than once on a single instance by launching the app multiple times.

import unittest
import random
import string
from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import QTimer


ctx = QApplication([])


def add_timer(w):
    w.timer = QTimer()
    w.timer.setSingleShot(True)
    w.timer.timeout.connect(lambda: QApplication.quit())
    w.timer.start(100)


class LoadTests(unittest.TestCase):
    def test_load_file(self):
        test_dat = ''.join(random.choice(string.ascii_lowercase) for _ in range(10))
        with open("test.txt", 'w') as f:
            f.write(test_dat)
        w = LoadWidget(test_mode=True)

        # Load the file
        w.load("test.txt")
        add_timer(w)
        ctx.exec_()

        # Demonstrate how one would load multiple times
        w.load("test.txt")
        add_timer(w)
        ctx.exec_()

        self.assertEqual(test_dat, w.obj)