Affirmer qu'une méthode a été appelée dans un test unitaire Python

Supposons que j'ai le code suivant dans un test unitaire Python:

aw = aps.Request("nv1")
aw2 = aps.Request("nv2", aw)

Existe-t-il un moyen simple d'affirmer qu'une méthode particulière (dans mon cas aw.Clear()) a été appelée au cours de la deuxième ligne du test? par exemple, y a-t-il quelque chose comme ça:

#pseudocode:
assertMethodIsCalled(aw.Clear, lambda: aps.Request("nv2", aw))

J'utilise Mock (qui est maintenant unittest.mock sur py3.3 +) pour cela:

from mock import patch
from PyQt4 import Qt


@patch.object(Qt.QMessageBox, 'aboutQt')
def testShowAboutQt(self, mock):
    self.win.actionAboutQt.trigger()
    self.assertTrue(mock.called)

Pour votre cas, cela pourrait ressembler à ceci:

import mock
from mock import patch


def testClearWasCalled(self):
   aw = aps.Request("nv1")
   with patch.object(aw, 'Clear') as mock:
       aw2 = aps.Request("nv2", aw)

   mock.assert_called_with(42) # or mock.assert_called_once_with(42)

Mock prend en charge de nombreuses fonctionnalités utiles, notamment des moyens de patcher un objet ou un module, ainsi que la vérification que la bonne chose a été appelée, etc.

Caveat emptor! (Attention l'acheteur!)

Si vous vous trompez de saisie assert_called_with(à assert_called_onceou assert_called_wiht), votre test peut toujours s'exécuter, car Mock pensera qu'il s'agit d'une fonction simulée et suivra avec plaisir, à moins que vous n'utilisiez autospec=true. Pour plus d'informations, lisez assert_called_once: Threat or Menace .

Oui si vous utilisez Python 3.3+. Vous pouvez utiliser la unittest.mockméthode intégrée pour assert appelée. Pour Python 2.6+, utilisez le rollback backport Mock, qui est la même chose.

Voici un exemple rapide dans votre cas:

from unittest.mock import MagicMock
aw = aps.Request("nv1")
aw.Clear = MagicMock()
aw2 = aps.Request("nv2", aw)
assert aw.Clear.called

Je ne connais rien de intégré. C'est assez simple à mettre en œuvre:

class assertMethodIsCalled(object):
    def __init__(self, obj, method):
        self.obj = obj
        self.method = method

    def called(self, *args, **kwargs):
        self.method_called = True
        self.orig_method(*args, **kwargs)

    def __enter__(self):
        self.orig_method = getattr(self.obj, self.method)
        setattr(self.obj, self.method, self.called)
        self.method_called = False

    def __exit__(self, exc_type, exc_value, traceback):
        assert getattr(self.obj, self.method) == self.called,
            "method %s was modified during assertMethodIsCalled" % self.method

        setattr(self.obj, self.method, self.orig_method)

        # If an exception was thrown within the block, we've already failed.
        if traceback is None:
            assert self.method_called,
                "method %s of %s was not called" % (self.method, self.obj)

class test(object):
    def a(self):
        print "test"
    def b(self):
        self.a()

obj = test()
with assertMethodIsCalled(obj, "a"):
    obj.b()

Cela nécessite que l'objet lui-même ne modifie pas self.b, ce qui est presque toujours vrai.

Oui, je peux vous donner le contour mais mon Python est un peu rouillé et je suis trop occupé pour l'expliquer en détail.

Fondamentalement, vous devez mettre un proxy dans la méthode qui appellera l'original, par exemple:

 class fred(object):
   def blog(self):
     print "We Blog"


 class methCallLogger(object):
   def __init__(self, meth):
     self.meth = meth

   def __call__(self, code=None):
     self.meth()
     # would also log the fact that it invoked the method

 #example
 f = fred()
 f.blog = methCallLogger(f.blog)

Cette réponse StackOverflow sur Callable peut vous aider à comprendre ce qui précède.

Plus en détail:

Bien que la réponse ait été acceptée, en raison de la discussion intéressante avec Glenn et du fait de disposer de quelques minutes de libre, je voulais développer ma réponse:

# helper class defined elsewhere
class methCallLogger(object):
   def __init__(self, meth):
     self.meth = meth
     self.was_called = False

   def __call__(self, code=None):
     self.meth()
     self.was_called = True

#example
class fred(object):
   def blog(self):
     print "We Blog"

f = fred()
g = fred()
f.blog = methCallLogger(f.blog)
g.blog = methCallLogger(g.blog)
f.blog()
assert(f.blog.was_called)
assert(not g.blog.was_called)

Vous pouvez vous moquer aw.Clear, soit manuellement, soit en utilisant un cadre de test comme pymox . Manuellement, vous le feriez en utilisant quelque chose comme ceci:

class MyTest(TestCase):
  def testClear():
    old_clear = aw.Clear
    clear_calls = 0
    aw.Clear = lambda: clear_calls += 1
    aps.Request('nv2', aw)
    assert clear_calls == 1
    aw.Clear = old_clear

En utilisant pymox, vous le feriez comme ceci:

class MyTest(mox.MoxTestBase):
  def testClear():
    aw = self.m.CreateMock(aps.Request)
    aw.Clear()
    self.mox.ReplayAll()
    aps.Request('nv2', aw)