Assert, dass ein Verfahren in einem Python Unit-Test

Question

Angenommen, ich habe den folgenden Code in einem Python-Unit-Test genannt:

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

Gibt es eine einfache Möglichkeit, dass ein bestimmtes Verfahren geltend zu machen (in meinem Fall aw.Clear()) wurde während der zweiten Zeile des Tests aufgerufen? z.B. so etwas wie das ist es:

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

Answer 1

Ich benutze Mock 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, es könnte wie folgt aussehen:

import mock 

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 eine ganze Reihe von nützlichen Funktionen, einschließlich der Möglichkeiten, ein Objekt oder ein Modul zu patchen , sowie überprüfen, dass das Richtige aufgerufen wurde, usw.

Caveat emptor! (Käufer Vorsicht!)

Wenn Sie assert_called_with vertippen (zu assert_called_once oder assert_called_wiht) Ihr Test noch laufen kann, wie Mock wird denken, dies ist eine Funktion verspottet und glücklich geht zusammen, es sei denn, Sie autospec=true verwenden. Für weitere Informationen lesen Sie assert_called_once: Threat or Menace.

Answer 2

Sie verspotten können aw.Clear, entweder manuell oder ein Test-Framework wie pymox verwenden. Manuell, können Sie es so etwas wie dies mit tun würde:

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 

pymox verwenden, würden Sie es wie folgt tun:

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

Answer 3

Ja, kann ich Ihnen die Umrisse geben, aber meine Python ist ein etwas rostig und ich bin zu beschäftigt, um im Detail zu erklären.

Grundsätzlich müssen Sie einen Proxy in dem Verfahren stellen, die das Original rufen, zB:

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 answer über aufrufbare kann Ihnen helfen, die oben verstehen.

Im Detail:

Obwohl die Antwort akzeptiert wurde, aufgrund der interessanten Diskussion mit Glenn und ein paar Minuten frei hat, wollte ich auf meine Antwort vergrößern:

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

Answer 4

I mir ist nichts 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 ändern wird, was fast immer der Fall ist.

Answer 5

Ja, wenn Sie Python 3.3+ verwenden. Sie können die eingebaute unittest.mock Methode zum Aufrufen der Methode verwenden. Für Python 2.6+ benutzen Sie den Rollbackport , was 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