Simulación de la función de Python basada en argumentos de entrada

hemos estado usando Imitar para python por un tiempo.

Ahora, tenemos una situación en la que queremos simular una función.

def foo(self, my_param):
    #do something here, assign something to my_result
    return my_result

Normalmente, la forma de burlarse de esto sería (suponiendo que foo sea parte de un objeto)

self.foo = MagicMock(return_value="mocked!")

Incluso, si llamo a foo() un par de veces, puedo usar

self.foo = MagicMock(side_effect=["mocked once", "mocked twice!"])

Ahora, me enfrento a una situación en la que quiero devolver un valor fijo cuando el parámetro de entrada tiene un valor particular. Entonces, si digamos que “my_param” es igual a “algo”, entonces quiero devolver “my_cool_mock”

Esto parece estar disponible en maqueta para python

when(dummy).foo("something").thenReturn("my_cool_mock")

He estado buscando cómo lograr lo mismo con Mock sin éxito.

¿Algunas ideas?

Si side_effect_func es una función, entonces lo que devuelva esa función es lo que llama al retorno simulado. los side_effect_func La función se llama con los mismos argumentos que el simulacro. Esto le permite variar el valor de retorno de la llamada dinámicamente, según la entrada:

>>> def side_effect_func(value):
...     return value + 1
...
>>> m = MagicMock(side_effect=side_effect_func)
>>> m(1)
2
>>> m(2)
3
>>> m.mock_calls
[call(1), call(2)]

http://www.voidspace.org.uk/python/mock/mock.html#calling

Como se indica en el objeto Python Mock con el método llamado varias veces

Una solución es escribir mi propio efecto secundario

def my_side_effect(*args, **kwargs):
    if args[0] == 42:
        return "Called with 42"
    elif args[0] == 43:
        return "Called with 43"
    elif kwargs['foo'] == 7:
        return "Foo is seven"

mockobj.mockmethod.side_effect = my_side_effect

eso hace el truco

El efecto secundario tiene una función (que también puede ser un función lambda), por lo que para casos simples puede usar:

m = MagicMock(side_effect=(lambda x: x+1))

Si usted “quiero devolver un valor fijo cuando el parámetro de entrada tiene un valor particular”tal vez ni siquiera necesites un simulacro y te vendría bien un dict junto con su get método:

foo = {'input1': 'value1', 'input2': 'value2'}.get

foo('input1')  # value1
foo('input2')  # value2

Esto funciona bien cuando la salida de su falsificación es un cartografía de entrada cuando es un función de entrada que sugeriría usar side_effect según Ámbarla respuesta

También puede utilizar una combinación de ambos si desea conservar Mockcapacidades de (assert_called_once, call_count etc):

self.mock.side_effect = {'input1': 'value1', 'input2': 'value2'}.get

He terminado aquí buscando “cómo simular una función basada en argumentos de entrada” y finalmente resolví esto creando una función auxiliar simple:

def mock_responses(responses, default_response=None):
  return lambda input: responses[input] if input in responses else default_response

Ahora:

my_mock.foo.side_effect = mock_responses(
  {
    'x': 42, 
    'y': [1,2,3]
  })
my_mock.goo.side_effect = mock_responses(
  {
    'hello': 'world'
  }, 
  default_response="hi")
...

my_mock.foo('x') # => 42
my_mock.foo('y') # => [1,2,3]
my_mock.foo('unknown') # => None

my_mock.goo('hello') # => 'world'
my_mock.goo('ey') # => 'hi'

¡Espero que esto ayude a alguien!

A pesar de que side_effect puede lograr el objetivo, no es tan conveniente configurar side_effect función para cada caso de prueba.

escribo un peso ligero Imitar (que se llama NextMock) para mejorar el simulacro incorporado para abordar este problema, aquí hay un ejemplo simple:

from nextmock import Mock

m = Mock()

m.with_args(1, 2, 3).returns(123)

assert m(1, 2, 3) == 123
assert m(3, 2, 1) != 123

También es compatible con el comparador de argumentos:

from nextmock import Arg, Mock

m = Mock()

m.with_args(1, 2, Arg.Any).returns(123)

assert m(1, 2, 1) == 123
assert m(1, 2, "123") == 123

Espero que este paquete pueda hacer que las pruebas sean más agradables. Siéntase libre de dar cualquier comentario.

También puedes usar partial de functools si quiere usar una función que toma parámetros pero la función de la que se está burlando no. Por ejemplo, así:

def mock_year(year):
    return datetime.datetime(year, 11, 28, tzinfo=timezone.utc)

@patch('django.utils.timezone.now', side_effect=partial(mock_year, year=2020))

Esto devolverá un invocable que no acepta parámetros (como timezone.now() de Django), pero mi función mock_year sí.