PyQt & unittest - Test du signal et des emplacements

Question

J'ai une application pyqt pour laquelle j'écris des tests unitaires, et elle dépend fortement des signaux et des slots. Pour le tester correctement, je dois vérifier que les signaux corrects sont envoyés.

Quelle est la meilleure façon de faire cela? Je vois que la bibliothèque Qt a un QSignalSpy, mais je ne trouve aucune référence à cela dans PyQt. La seule option à laquelle je peux penser est de simuler l'émission, par ex.

import testedmodule 

def myemit(signal): 
    .... 

testedmodule.QObject.emit = myemit 

mais j'espère qu'il y a un meilleur moyen. Mon module est exécuté en tant que thread, dans ce cas, le remplacement d'une instance ne fonctionne plus après le démarrage du thread, donc j'ai mis à jour le code ci-dessus pour refléter cela.

Answer 1

Vous pouvez essayer de connecter un slot à votre signal, préparer votre test, puis appeler qApp.processEvents() pour laisser le signal se propager. Mais je ne pense pas que ce soit 100% fiable.

Il est dommage que QSignalSpy ne fasse pas partie de PyQt en effet.

Answer 2

Ceci est une version plus élaborée de ce que je me suis proposé, pas nécessairement la meilleure solution pour unittest, mais je pense qu'il sera intéressant pour les autres qui viennent à travers ceci:

Publié par Carlos Scheidegger sur le pyqt liste de diffusion (http://thread.gmane.org/gmane.comp.python.pyqt-pykde/9242/focus=9245)

_oldConnect = QtCore.QObject.connect 
_oldDisconnect = QtCore.QObject.disconnect 
_oldEmit = QtCore.QObject.emit 

def _wrapConnect(callableObject): 
    """Returns a wrapped call to the old version of QtCore.QObject.connect""" 
    @staticmethod 
    def call(*args): 
     callableObject(*args) 
     _oldConnect(*args) 
    return call 

def _wrapDisconnect(callableObject): 
    """Returns a wrapped call to the old version of QtCore.QObject.disconnect""" 
    @staticmethod 
    def call(*args): 
     callableObject(*args) 
     _oldDisconnect(*args) 
    return call 

def enableSignalDebugging(**kwargs): 
    """Call this to enable Qt Signal debugging. This will trap all 
    connect, and disconnect calls.""" 

    f = lambda *args: None 
    connectCall = kwargs.get('connectCall', f) 
    disconnectCall = kwargs.get('disconnectCall', f) 
    emitCall = kwargs.get('emitCall', f) 

    def printIt(msg): 
     def call(*args): 
      print msg, args 
     return call 
    QtCore.QObject.connect = _wrapConnect(connectCall) 
    QtCore.QObject.disconnect = _wrapDisconnect(disconnectCall) 

    def new_emit(self, *args): 
     emitCall(self, *args) 
     _oldEmit(self, *args) 

    QtCore.QObject.emit = new_emit 

il suffit d'appeler enableSignalDebugging (emitCall = toto) et espionne vos signaux jusqu'à ce que vous êtes malade à votre estomac :)

Answer 3

Remarque QSignalSpy est available comme QtTest.QSignalSpy dans PyQt5.