twierdzą, że metoda została wywołana w badanej jednostki Python

Question

Załóżmy, że mam następujący kod w badanej jednostki Python:

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

Czy istnieje prosty sposób, aby twierdzić, że w szczególny sposób (w moim przypadku aw.Clear()) został wywołany podczas drugiej linii testu? na przykład jest tam coś takiego:

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

Answer 1

używam Mock na to:

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) 

Twoim przypadku, może to wyglądać tak:

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 obsługuje sporo przydatnych funkcji, w tym sposobów łata przedmiot lub moduł , a także sprawdzanie, czy została wywołana właściwa funkcja itp.

Caveat emptor! (Kupujący strzeżcie się!)

Jeśli błędnie assert_called_with (do assert_called_once lub assert_called_wiht) swój test może nadal działać, jak Mock będzie, że jest to funkcja wyśmiewany i szczęśliwie iść, chyba że używasz autospec=true. Aby uzyskać więcej informacji, przeczytaj assert_called_once: Threat or Menace.

Answer 2

Można kpić z aw.Clear, ręcznie lub za pomocą ramy testowania jak pymox. Ręcznie, można to zrobić za pomocą mniej więcej tak:

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 

Korzystanie pymox, że zrobisz to tak:

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

Answer 3

Tak, mogę ci dać zarys ale mój Python jest trochę zardzewiały i jestem zbyt zajęty, aby szczegółowo wyjaśnić.

Zasadniczo trzeba umieścić pełnomocnictwa w sposób, który nazywamy oryginalne, np:

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) 

Ten StackOverflow answer o wpłacone mogą pomóc w zrozumieniu powyższych.

Bardziej szczegółowo:

Chociaż odpowiedź została przyjęta ze względu na ciekawą dyskusję z Glenn i posiadające kilka minut za darmo, chciałem, aby powiększyć na moją odpowiedź:

# 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 nie jestem świadomy niczego wbudowanego. Jest to dość proste do wykonania:

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

Wymaga to, że sam obiekt nie będzie modyfikować self.b, który jest prawie zawsze prawdziwe.

Answer 5

Tak, jeśli używasz Pythona 3.3+. Możesz użyć wbudowanego unittest.mock do potwierdzenia metody o nazwie. W przypadku Pythona 2.6 lub nowszego użyj ruchomego backportu Mock, czyli tego samego.

Oto krótki przykład w przypadku:

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