Burlarse de una clase: Mock() o parche()?

Question

Estoy usando mock con Python y me preguntaba cuál de esos dos enfoques es mejor (léase: más pitónico).

Método uno: Solo crea un objeto falso y úsalo. El código es el siguiente:

def test_one (self): 
    mock = Mock() 
    mock.method.return_value = True 
    self.sut.something(mock) # This should called mock.method and checks the result. 
    self.assertTrue(mock.method.called) 

Método dos: El uso de parches para crear una maqueta. El código es el siguiente:

@patch("MyClass") 
def test_two (self, mock): 
    instance = mock.return_value 
    instance.method.return_value = True 
    self.sut.something(instance) # This should called mock.method and checks the result. 
    self.assertTrue(instance.method.called) 

Ambos métodos hacen lo mismo. No estoy seguro de las diferencias.

¿Alguien podría aclararme?

Answer 1

mock.patch es una criatura muy diferente de mock.Mock. patchreemplaza la clase con un objeto simulado y te permite trabajar con la instancia simulada. Echar un vistazo a este fragmento:

>>> class MyClass(object): 
... def __init__(self): 
...  print 'Created MyClass@{0}'.format(id(self)) 
... 
>>> def create_instance(): 
... return MyClass() 
... 
>>> x = create_instance() 
Created MyClass@4299548304 
>>> 
>>> @mock.patch('__main__.MyClass') 
... def create_instance2(MyClass): 
... MyClass.return_value = 'foo' 
... return create_instance() 
... 
>>> i = create_instance2() 
>>> i 
'foo' 
>>> def create_instance(): 
... print MyClass 
... return MyClass() 
... 
>>> create_instance2() 
<mock.Mock object at 0x100505d90> 
'foo' 
>>> create_instance() 
<class '__main__.MyClass'> 
Created MyClass@4300234128 
<__main__.MyClass object at 0x100505d90> 

patch reemplaza MyClass de una manera que le permite controlar el uso de la clase de funciones que realice la llamada. Una vez que parchee una clase, las referencias a la clase se reemplazan por completo por la instancia simulada.

mock.patch se usa generalmente cuando prueba algo que crea una nueva instancia de una clase dentro de la prueba. mock.Mock las instancias son más claras y preferidas. Si su método self.sut.something creó una instancia de MyClass en lugar de recibir una instancia como parámetro, entonces mock.patch sería apropiado aquí.

Answer 2

Tengo un YouTube video en esto.

Respuesta corta: Usa mock cuando pases en lo que quieras burlado, y patch si no lo eres. De los dos, el simulacro es muy preferido porque significa que estás escribiendo código con una inyección de dependencia adecuada.

ejemplo tonto:

# Use a mock to test this. 
my_custom_tweeter(twitter_api, sentence): 
    sentence.replace('cks','x') # We're cool and hip. 
    twitter_api.send(sentence) 

# Use a patch to mock out twitter_api. You have to patch the Twitter() module/class 
# and have it return a mock. Much uglier, but sometimes necessary. 
my_badly_written_tweeter(sentence): 
    twitter_api = Twitter(user="XXX", password="YYY") 
    sentence.replace('cks','x') 
    twitter_api.send(sentence)