CodeGym /Cursos /All lectures for ES purposes /Anotaciones básicas de Mockito

Anotaciones básicas de Mockito

All lectures for ES purposes
Nivel 1 , Lección 323
Disponible

2.1 @Anotación simulada

Hay dos formas de trabajar con objetos simulados en Mockito. El primero es crear un objeto completamente virtual , el segundo es envolver un objeto existente en un envoltorio. Comencemos con el primero.

Para crear un objeto completamente virtual, debe escribir el código:

ClassName variable name = Mockito.mock(ClassName.class);

Vamos a crear una clase ArrayList simulada como ejemplo:

@ExtendWith(MockitoExtension.class)
class MockTest {
 @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
 List mockList = Mockito.mock(ArrayList.class);
        //these methods won't do anything - they are stubs
 mockList.add("one");
 mockList.add("two");
    }
}

En este ejemplo, creamos una ArrayList falsa y almacenamos una referencia a ella en la variable mockList. Los métodos de este objeto no hacen nada.

Por cierto, este código se puede escribir aún más corto, ya que hay una anotación especial para esto @Mock.

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

 @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        //these methods won't do anything - they are stubs
 mockList.add("one");
 mockList.add("two");
    }
}

En el segundo caso, MockitoExtensionanalizará el propio código de la clase y creará los stubs necesarios. No es necesario llamar al método Mockito.mock(). Una anotación y el objeto virtual está listo. Belleza.

2.2 Anotación @Spy

El segundo tipo importante de objetos en Mockito son los envoltorios sobre objetos existentes. Permiten, por un lado, utilizar clases existentes y, por otro lado, interceptar llamadas a todos los métodos y variables de dichos objetos: para corregir su trabajo cuando sea necesario. Se utilizan con la misma frecuencia que los objetos simulados.

Para crear un contenedor sobre un objeto, debe escribir el código:

ClassName variable name = Mockito.spy(an object);

Un ejemplo con un contenedor alrededor de la clase ArrayList:

@ExtendWith(MockitoExtension.class)
class SpyTest {
 @Test
    public void whenMockAnnotation() {
 List<String> mockList = Mockito.spy(new ArrayList<String>()); //these methods will work!  mockList.add("one");  mockList.add("two"); } } 

En su forma más simple, una llamada a un objeto contenedor simplemente redirige las llamadas al objeto original, cuya referencia guarda dentro de sí mismo . Todo funcionará igual que con el objeto original.

También puede crear un contenedor usando la anotación - @Spy.

@ExtendWith(MockitoExtension.class)
class SpyTest {
 @Spy
 List mockList = new ArrayList<String>();

 @Test
    public void whenMockAnnotation() {
        // these methods will work!
 mockList.add("one");
 mockList.add("two");
    }
}

Estos dos ejemplos de código son equivalentes.

Comentarios (1)
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION
Antonio Lopez Nivel 81 Expert
28 diciembre 2023
Que son los stubs: Cuando tenemos código que sera escrito, en vez de ese código los stubs pueden usarse para simular una respuesta en consola o devolver un valor, para hacer pruebas.