Objetos burlones

3.1 método doReturn()

Ahora viene la magia...

Digamos que creó un objeto simulado falso, pero necesita que funcione de alguna manera. Cuando se llamaron a ciertos métodos, se hizo algo importante o los métodos devolvieron un resultado determinado. ¿Qué hacer?

La biblioteca Mockito le permite agregar el comportamiento deseado a un objeto simulado.

Si desea que un objeto simulado devuelva un determinado resultado cuando se llama a un determinado método, entonces esta "regla" se puede agregar al objeto usando el código:

Mockito.doReturn(result).when(an object).method name();

Verá, al final de la llamada al método, method name?en realidad no hay ninguna llamada en curso aquí. El método doReturn()devuelve un objeto proxy especial con la ayuda del cual supervisa las llamadas de los métodos del objeto y, por lo tanto, se escribe la regla.

De nuevo. Es una forma tan inteligente de escribir una regla para agregar a un objeto simulado . Se necesita cierta habilidad para interpretar correctamente ese código en tu cabeza cuando lo ves. Viene con la experiencia.

Creo que se necesita un ejemplo concreto. Vamos a crear un objeto de clase simulada ArrayListy pedirle a su método size()que devuelva el número 10. El código completo se verá así:

@ExtendWith(MockitoExtension.class)
class DoReturnTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation () {
         //create a rule: return 10 when calling the size method
        Mockito.doReturn(10).when(mockList).size();

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

Sí, este código funcionará, la prueba no fallará.

3.2 método when()

Hay otra forma de agregar una regla de comportamiento a un objeto simulado: llamando al Mockito.when(). Se parece a esto:

Mockito.when(an object.method name()).thenReturn(result);

Esta es la misma forma de escribir una regla de comportamiento de objeto simulada que la anterior. Comparar:

Mockito.doReturn(result).when(an object).method name();

Aquí sucede exactamente lo mismo: la construcción de una nueva regla.

Es cierto que el primer ejemplo tiene dos desventajas:

• la llamada es muy confusa.an object.method name()
• no funcionará si el método methodname()regresa void.

Bueno, escribamos nuestro ejemplo favorito usandoMockito.when()

@ExtendWith(MockitoExtension.class)
class WhenTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        //create a rule: return 10 when calling the size method
        Mockito.when(mockList.size() ).thenReturn(10);

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

3.3 método doThrow()

Descubrimos cómo hacer que un método de objeto simulado devuelva un resultado específico. ¿Cómo puedo hacer que arroje una excepción específica? Enviarlo a doReturn()?

Para evitar que el método regrese, es decir, lanzar una excepción, debe establecer la regla mediante el método doThrow().

Mockito.doThrow(exception.class).when(an object).method name();

Y luego la segunda opción:

Mockito.when(an object.method name()).thenThrow(exception.class);

Un poco esperado, ¿verdad?

Bueno, ya ves, ya estás empezando a entender. Arreglemoslo con un ejemplo:

@ExtendWith(MockitoExtension.class)
class DoThrowTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        Mockito.when(mockList.size() ).thenThrow(IllegalStateException.class);
        mockList.size(); //an exception will be thrown here
    }
}

Si necesita lanzar un objeto de excepción específico, use la construcción del formulario:

Mockito.doThrow(new Exception()).when(an object).method name();

Simplemente pase doThrow()un objeto de excepción al método y se lanzará durante la llamada al método.