Stellen Sie sicher, dass eine Methode in einem Python-Komponententest aufgerufen wurde

Angenommen, ich habe den folgenden Code in einem Python-Komponententest:

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

Gibt es eine einfache Möglichkeit zu behaupten, dass eine bestimmte Methode (in meinem Fall aw.Clear()) in der zweiten Zeile des Tests aufgerufen wurde? zB gibt es so etwas:

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

Ich benutze Mock (das ist jetzt unittest.mock auf py3.3 +) dafür:

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)

Für Ihren Fall könnte es so aussehen:

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 unterstützt einige nützliche Funktionen, einschließlich Möglichkeiten zum Patchen eines Objekts oder Moduls sowie zum Überprüfen, ob das Richtige aufgerufen wurde, usw. usw.

Vorbehalt Emptor! (Käufer aufgepasst!)

Wenn Sie assert_called_with(zu assert_called_onceoder assert_called_wiht) falsch tippen , wird Ihr Test möglicherweise noch ausgeführt, da Mock dies für eine verspottete Funktion hält und gerne mitmacht , es sei denn, Sie verwenden autospec=true. Weitere Informationen finden Sie unter assert_called_once: Bedrohung oder Bedrohung .

Ja, wenn Sie Python 3.3+ verwenden. Sie können die integrierte unittest.mockMethode verwenden, um die aufgerufene Methode zu bestätigen. Verwenden Sie für Python 2.6+ den rollierenden Backport Mock, der dasselbe ist.

Hier ist ein kurzes Beispiel in Ihrem Fall:

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

Mir ist nichts Eingebautes bekannt. Es ist ziemlich einfach zu implementieren:

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()

Dies erfordert, dass das Objekt selbst self.b nicht ändert, was fast immer der Fall ist.

Ja, ich kann Ihnen den Umriss geben, aber mein Python ist etwas verrostet und ich bin zu beschäftigt, um es im Detail zu erklären.

Grundsätzlich müssen Sie einen Proxy in die Methode einfügen, der das Original aufruft, z.

 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)

Diese StackOverflow-Antwort zu callable kann Ihnen helfen, die oben genannten Punkte zu verstehen.

Genauer:

Obwohl die Antwort aufgrund der interessanten Diskussion mit Glenn und der Tatsache, dass ich ein paar Minuten Zeit hatte, akzeptiert wurde, wollte ich meine Antwort erweitern:

# 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)

Sie können aw.Clearentweder manuell oder mit einem Testframework wie pymox verspotten . Manuell würden Sie es mit so etwas tun:

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

Mit Pymox würden Sie es so machen:

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