Встроенная форма в таблице и AJAX не работает должным образом

Мне всегда нужно снова смотреть это снова и снова, так что вот мой ответ.

Утверждение нескольких вызовов методов на разных объектах одного и того же класса

Предположим, что мы имеем класс большой нагрузки (который мы хотим высмеять):

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))
   ...:  

вот какой-то код, который использует два экземпляра класса HeavyDuty:

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

Теперь, вот тестовый пример для heavy_work:

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)
   ...:  

Мы издеваемся над классом HeavyDuty с MockHeavyDuty. Чтобы утверждать вызовы методов, исходящие из каждого экземпляра HeavyDuty, мы должны ссылаться на MockHeavyDuty.return_value.assert_has_calls вместо MockHeavyDuty.assert_has_calls. Кроме того, в списке expected_calls мы должны указать, какое имя метода мы заинтересованы в утверждении вызовов. Поэтому наш список состоит из вызовов call.do_work, а не просто call.

Выполнение тестового примера показывает, что он успешный:

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

Если мы изменим функцию heavy_work, тест завершится неудачно и даст полезную информацию сообщение об ошибке:

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

Утверждение нескольких вызовов функции

Чтобы контрастировать с вышесказанным, приведен пример, который показывает, как издеваться над несколькими вызовами к функции:

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

Существуют два основных отличия. Первый заключается в том, что при издевательстве функции мы устанавливаем наши ожидаемые вызовы с помощью call вместо использования call.some_method. Второй - это то, что мы назовем assert_has_calls на mock_work_function, а не на mock_work_function.return_value.