usa - que hace la funcion return en python

Verificación de orden de llamadas a través de múltiples simulacros

Question

Tengo tres funciones que estoy tratando de probar el orden de llamada de.

Digamos que en el módulo module.py tengo los siguientes

# module.py    

def a(*args):
    # do the first thing

def b(*args):
    # do a second thing

def c(*args):
    # do a third thing


def main_routine():
    a_args = (''a'')
    b_args = (''b'')
    c_args = (''c'')

    a(*a_args)
    b(*b_args)
    c(*c_args)

Quiero comprobar que se llama b después de a, y antes de c. Así que obtener un simulacro para cada uno de a, byc es fácil:

# tests.py

@mock.patch(''module.a'')
@mock.patch(''module.b'')
@mock.patch(''module.c'')
def test_main_routine(c_mock, b_mock, a_mock):
    # test all the things here

Verificar que cada una de las simulaciones individuales se llame también es fácil. ¿Cómo verifico el orden de las llamadas entre sí?

call_args_list no funcionará ya que se mantiene por separado para cada simulacro.

He intentado usar un efecto secundario para registrar cada una de las llamadas:

calls = []
def register_call(*args):
    calls.append(mock.call(*args))
    return mock.DEFAULT

a_mock.side_effect = register_call
b_mock.side_effect = register_call
c_mock.side_effect = register_call

Pero esto solo me da el argumento de que los mocks se llamaron, pero no el mock real contra el que se hizo la llamada. Puedo añadir un poco más de lógica:

# tests.py
from functools import partial

def register_call(*args, **kwargs):
    calls.append(kwargs.pop(''caller'', None), mock.call(*args, **kwargs))
    return mock.DEFAULT

a_mock.side_effect = partial(register_call, caller=''a'')
b_mock.side_effect = partial(register_call, caller=''b'')
c_mock.side_effect = partial(register_call, caller=''c'')

Y eso parece hacer el trabajo ... ¿Pero hay una mejor manera? Se siente como que ya debería haber algo en la API que pueda hacer esto que me estoy perdiendo.

Answer 1

Defina un administrador de Mock y adjúntele attach_mock() mediante attach_mock() . A continuación, compruebe los mock_calls :

@patch(''module.a'')
@patch(''module.b'')
@patch(''module.c'')
def test_main_routine(c, b, a):
    manager = Mock()
    manager.attach_mock(a, ''a'')
    manager.attach_mock(b, ''b'')
    manager.attach_mock(c, ''c'')

    module.main_routine()

    expected_calls = [call.a(''a''), call.b(''b''), call.c(''c'')]
    assert manager.mock_calls == expected_calls

Solo para probar que funciona, cambie el orden de las llamadas a funciones en la función main_routine() vea que lanza AssertionError .

Ver más ejemplos en Seguimiento del orden de las llamadas y aserciones de llamadas menos detalladas.

Espero que ayude.