Potwierdzanie kolejnych wywołań metody pozorowanej

Mock ma pomocną assert_called_with()metodę . Jednak, o ile rozumiem, sprawdza to tylko ostatnie wywołanie metody.
Jeśli mam kod, który wywołuje symulowaną metodę 3 razy z rzędu, za każdym razem z innymi parametrami, w jaki sposób mogę potwierdzić te 3 wywołania z ich określonymi parametrami?

assert_has_calls to inne podejście do tego problemu.

Z dokumentów:

assert_has_calls (połączenia, any_order = False)

potwierdzić, że mock został wywołany z określonymi wywołaniami. Lista mock_calls jest sprawdzana pod kątem połączeń.

Jeśli any_order ma wartość False (wartość domyślna), wywołania muszą być sekwencyjne. Mogą być dodatkowe połączenia przed lub po określonych połączeniach.

Jeśli any_order ma wartość True, wtedy wywołania mogą być w dowolnej kolejności, ale wszystkie muszą pojawić się w mock_calls.

Przykład:

>>> from unittest.mock import call, Mock
>>> mock = Mock(return_value=None)
>>> mock(1)
>>> mock(2)
>>> mock(3)
>>> mock(4)
>>> calls = [call(2), call(3)]
>>> mock.assert_has_calls(calls)
>>> calls = [call(4), call(2), call(3)]
>>> mock.assert_has_calls(calls, any_order=True)

Źródło: https://docs.python.org/3/library/unittest.mock.html#unittest.mock.Mock.assert_has_calls

Zwykle nie obchodzi mnie kolejność połączeń, tylko to, że się wydarzyły. W takim przypadku łączę się assert_any_callz twierdzeniem o call_count.

>>> import mock
>>> m = mock.Mock()
>>> m(1)
<Mock name='mock()' id='37578160'>
>>> m(2)
<Mock name='mock()' id='37578160'>
>>> m(3)
<Mock name='mock()' id='37578160'>
>>> m.assert_any_call(1)
>>> m.assert_any_call(2)
>>> m.assert_any_call(3)
>>> assert 3 == m.call_count
>>> m.assert_any_call(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "[python path]\lib\site-packages\mock.py", line 891, in assert_any_call
    '%s call not found' % expected_string
AssertionError: mock(4) call not found

Uważam, że zrobienie tego w ten sposób jest łatwiejsze do odczytania i zrozumienia niż duża lista wywołań przekazywana do jednej metody.

Jeśli zależy Ci na porządku lub spodziewasz się wielu identycznych połączeń, assert_has_callsmoże być bardziej odpowiednie.

Edytować

Odkąd opublikowałem tę odpowiedź, przemyślałem ogólnie swoje podejście do testowania. Myślę, że warto wspomnieć, że jeśli twój test staje się tak skomplikowany, możesz testować niewłaściwie lub masz problem z projektem. Makiety są przeznaczone do testowania komunikacji między obiektami w projekcie zorientowanym obiektowo. Jeśli Twój projekt nie jest zorientowany na zastrzeżenia (np. Bardziej proceduralny lub funkcjonalny), próba może być całkowicie nieodpowiednia. Być może w metodzie dzieje się zbyt wiele lub możesz testować wewnętrzne szczegóły, które najlepiej pozostawić niezablokowane. Opracowałem strategię wspomnianą w tej metodzie, gdy mój kod nie był zbyt zorientowany obiektowo i uważam, że testowałem również wewnętrzne szczegóły, które najlepiej byłoby pozostawić niezamokowane.

Możesz użyć Mock.call_args_listatrybutu, aby porównać parametry z poprzednimi wywołaniami metod. To w połączeniu z Mock.call_countatrybutem powinno dać Ci pełną kontrolę.

Zawsze muszę to raz sprawdzać, więc oto moja odpowiedź.

Asserting wielu wywołań metod na różnych obiektach tej samej klasy

Załóżmy, że mamy klasę heavy duty (którą chcemy kpić):

In [1]: class HeavyDuty(object):
   ...:     def __init__(self):
   ...:         import time
   ...:         time.sleep(2)  # <- Spends a lot of time here
   ...:     
   ...:     def do_work(self, arg1, arg2):
   ...:         print("Called with %r and %r" % (arg1, arg2))
   ...:  

tutaj jest kod, który używa dwóch instancji HeavyDutyklasy:

In [2]: def heavy_work():
   ...:     hd1 = HeavyDuty()
   ...:     hd1.do_work(13, 17)
   ...:     hd2 = HeavyDuty()
   ...:     hd2.do_work(23, 29)
   ...:    

Oto przypadek testowy dla heavy_workfunkcji:

In [3]: from unittest.mock import patch, call
   ...: def test_heavy_work():
   ...:     expected_calls = [call.do_work(13, 17),call.do_work(23, 29)]
   ...:     
   ...:     with patch('__main__.HeavyDuty') as MockHeavyDuty:
   ...:         heavy_work()
   ...:         MockHeavyDuty.return_value.assert_has_calls(expected_calls)
   ...:  

Kpimy z HeavyDutyklasy MockHeavyDuty. Aby potwierdzić wywołania metod pochodzące z każdej HeavyDutyinstancji, musimy odwoływać się MockHeavyDuty.return_value.assert_has_callszamiast MockHeavyDuty.assert_has_calls. Ponadto na liście expected_callsmusimy określić, dla której nazwy metody jesteśmy zainteresowani potwierdzaniem wywołań. Tak więc nasza lista składa się z połączeń do call.do_work, a nie po prostu call.

Ćwiczenie przypadku testowego pokazuje nam, że się udało:

In [4]: print(test_heavy_work())
None

Jeśli zmodyfikujemy heavy_workfunkcję, test zakończy się niepowodzeniem i wyświetli pomocny komunikat o błędzie:

In [5]: def heavy_work():
   ...:     hd1 = HeavyDuty()
   ...:     hd1.do_work(113, 117)  # <- call args are different
   ...:     hd2 = HeavyDuty()
   ...:     hd2.do_work(123, 129)  # <- call args are different
   ...:     

In [6]: print(test_heavy_work())
---------------------------------------------------------------------------
(traceback omitted for clarity)

AssertionError: Calls not found.
Expected: [call.do_work(13, 17), call.do_work(23, 29)]
Actual: [call.do_work(113, 117), call.do_work(123, 129)]

Potwierdzanie wielu wywołań funkcji

W przeciwieństwie do powyższego, oto przykład, który pokazuje, jak mockować wiele wywołań funkcji:

In [7]: def work_function(arg1, arg2):
   ...:     print("Called with args %r and %r" % (arg1, arg2))

In [8]: from unittest.mock import patch, call
   ...: def test_work_function():
   ...:     expected_calls = [call(13, 17), call(23, 29)]    
   ...:     with patch('__main__.work_function') as mock_work_function:
   ...:         work_function(13, 17)
   ...:         work_function(23, 29)
   ...:         mock_work_function.assert_has_calls(expected_calls)
   ...:    

In [9]: print(test_work_function())
None

Istnieją dwie główne różnice. Pierwszą z nich jest to, że podczas mockowania funkcji konfigurujemy nasze oczekiwane wywołania za pomocą callzamiast używać call.some_method. Drugim jest to, że możemy zadzwonić assert_has_callsna mock_work_function, zamiast na mock_work_function.return_value.