¡Hola!

Claro, aquí tienes algunas de las principales anotaciones que puedes utilizar para
hacer testing en Java con Mockito, JUnit 5 y Spring Boot:

1. Mockito:
o @Mock: Crea un objeto simulado para una clase o interfaz.
o @Spy: Crea un objeto simulado que también mantiene el comportamiento
original de la clase.
o @InjectMocks: Inyecta automáticamente los mocks o spies creados en la
clase bajo prueba.
o @Captor: Captura los argumentos pasados a los métodos simulados para
su posterior verificación.
2. JUnit 5:
o @Test: Indica que un método es un método de prueba.
o @BeforeEach: Anotación para un método que se ejecuta antes de cada
método de prueba para realizar tareas de inicialización.
o @AfterEach: Anotación para un método que se ejecuta después de cada
método de prueba para realizar tareas de limpieza.
o @BeforeAll: Anotación para un método estático que se ejecuta una vez
antes de todos los métodos de prueba en una clase.
o @AfterAll: Anotación para un método estático que se ejecuta una vez
después de todos los métodos de prueba en una clase.
o @DisplayName: Proporciona un nombre personalizado para un método o
clase de prueba que se mostrará en los informes de ejecución.
o @ParameterizedTest: Indica que un método es un método de prueba
parametrizado.
3. Spring Boot:
o @SpringBootTest: Inicia el contexto de Spring para las pruebas de
integración.
o @WebMvcTest: Inicia el contexto de Spring específicamente para las
pruebas de controladores web.
o @DataJpaTest: Inicia el contexto de Spring específicamente para las
pruebas de repositorios JPA.
o @MockBean: Crea un mock de un bean de Spring para su uso en pruebas.
o @Autowired: Inyecta dependencias en una clase de prueba.
o @TestConfiguration: Anotación utilizada para configurar una clase de
configuración específica para pruebas.

Estas son solo algunas de las anotaciones más comunes que puedes utilizar al realizar
pruebas en Java con Mockito, JUnit 5 y Spring Boot. Hay muchas otras anotaciones
disponibles, pero estas deberían ser un buen punto de partida para tus pruebas. Recuerda
consultar la documentación oficial de cada herramienta para obtener más detalles y
ejemplos específicos.

2/2
¡Por supuesto! A continuación, te proporciono ejemplos específicos de cómo usar estas
anotaciones en pruebas unitarias y de integración con Mockito, JUnit 5 y Spring Boot.

1. Ejemplo con Mockito:

Supongamos que tenemos una clase Calculator con un método add que queremos
probar. Vamos a simular la dependencia de otra clase MathUtils utilizando Mockito.

2/2

¡Por supuesto! A continuación, te proporciono ejemplos específicos de cómo usar estas

anotaciones en pruebas unitarias y de integración con Mockito, JUnit 5 y Spring Boot.

1. Ejemplo con Mockito:

Supongamos que tenemos una clase Calculator con un método add que queremos
probar. Vamos a simular la dependencia de otra clase MathUtils utilizando Mockito.

java
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class Calculator {
private MathUtils mathUtils;

public Calculator(MathUtils mathUtils) {

this.mathUtils = mathUtils;
}

public int add(int a, int b) {

return a + b;
}
}

class MathUtils {
public int add(int a, int b) {
return a + b;
}
}

class CalculatorTest {
@Test
void testAdd() {
// Arrange
MathUtils mathUtils = mock(MathUtils.class);
when(mathUtils.add(2, 3)).thenReturn(5);
Calculator calculator = new Calculator(mathUtils);

// Act
int result = calculator.add(2, 3);

// Assert
assertEquals(5, result);
}
}

2. Ejemplo con JUnit 5:

Supongamos que tenemos una clase StringUtils con un método reverse que
queremos probar.

3. Ejemplo con Spring Boot y Mockito:

Supongamos que tenemos un controlador UserController que queremos probar.

Vamos a simular el servicio UserService utilizando Mockito y Spring Boot.
2/2

¡Por supuesto! A continuación, te proporciono ejemplos específicos de cómo usar estas

anotaciones en pruebas unitarias y de integración con Mockito, JUnit 5 y Spring Boot.

1. Ejemplo con Mockito:

Supongamos que tenemos una clase Calculator con un método add que queremos
probar. Vamos a simular la dependencia de otra clase MathUtils utilizando Mockito.

java
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class Calculator {
private MathUtils mathUtils;

public Calculator(MathUtils mathUtils) {

this.mathUtils = mathUtils;
}

public int add(int a, int b) {

return a + b;
}
}

class MathUtils {
public int add(int a, int b) {
return a + b;
}
}
class CalculatorTest {
@Test
void testAdd() {
// Arrange
MathUtils mathUtils = mock(MathUtils.class);
when(mathUtils.add(2, 3)).thenReturn(5);
Calculator calculator = new Calculator(mathUtils);

// Act
int result = calculator.add(2, 3);

// Assert
assertEquals(5, result);
}
}

2. Ejemplo con JUnit 5:

Supongamos que tenemos una clase StringUtils con un método reverse que
queremos probar.

java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class StringUtils {
public String reverse(String input) {
return new StringBuilder(input).reverse().toString();
}
}

class StringUtilsTest {
@Test
void testReverse() {
// Arrange
StringUtils stringUtils = new StringUtils();
String input = "hello";

// Act
String result = stringUtils.reverse(input);

// Assert
assertEquals("olleh", result);
}
}

3. Ejemplo con Spring Boot y Mockito:

Supongamos que tenemos un controlador UserController que queremos probar.

Vamos a simular el servicio UserService utilizando Mockito y Spring Boot.

java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
 private UserService userService;

@Autowired
public UserController(UserService userService) {
this.userService = userService;
}

@GetMapping("/users")
public List<User> getUsers() {
return userService.getUsers();
}
}

class UserService {
public List<User> getUsers() {
// Aquí iría la lógica para obtener usuarios desde una base de
datos u otra fuente
return List.of(new User("John"), new User("Jane"));
}
}

class UserControllerTest {
@MockBean
private UserService userService;

@Autowired
private MockMvc mockMvc;

@Test
void testGetUsers() throws Exception {
// Arrange
when(userService.getUsers()).thenReturn(List.of(new
User("TestUser")));

// Act
mockMvc.perform(get("/users"))
.andExpect(status().isOk())
.andExpect(jsonPath("$", hasSize(1)))
.andExpect(jsonPath("$[0].name").value("TestUser"));
}
}

Estos ejemplos te dan una idea de cómo usar las anotaciones de Mockito, JUnit 5 y
Spring Boot en pruebas unitarias y de integración. Puedes modificarlos según tus
necesidades y ajustarlos a tus clases y métodos específicos que desees probar.

La clase Assert proporciona una serie de métodos estáticos que puedes utilizar para
realizar afirmaciones en tus pruebas unitarias. Estos métodos te permiten verificar que
ciertas condiciones se cumplan y, en caso contrario, lanzarán una excepción si la
afirmación falla.

Aquí tienes algunos ejemplos de cómo utilizar los métodos de Assert en tus pruebas:
Estos son solo algunos ejemplos de los métodos disponibles en Assert. Puedes explorar
la documentación de JUnit 5 y la clase Assert para obtener una lista completa de los
métodos disponibles y sus diferentes variaciones.

Recuerda que las aserciones son fundamentales para verificar que el comportamiento de
tu código sea el esperado y que los resultados obtenidos durante las pruebas se ajusten a
tus expectativas.

La documentación oficial de JUnit 5 está disponible en el sitio web de JUnit:

 Documentación de JUnit 5: https://junit.org/junit5/docs/current/user-guide/

La documentación de JUnit 5 proporciona una guía completa sobre cómo utilizar el

framework JUnit 5 para escribir pruebas unitarias en Java. Incluye información sobre la
configuración del entorno, la sintaxis de las pruebas, las anotaciones y las aserciones
disponibles, la ejecución de pruebas parametrizadas, la integración con otras
herramientas y mucho más.

En el sitio web de JUnit también puedes encontrar información sobre versiones

anteriores de JUnit y otros recursos relacionados, como blogs y tutoriales.

Recuerda que la documentación oficial es una fuente confiable y actualizada para

obtener información detallada sobre el uso de JUnit 5.
La documentación oficial de Mockito se encuentra en su sitio web:

 Documentación de Mockito:
https://javadoc.io/doc/org.mockito/mockito-core/latest/index.html

En la documentación de Mockito, encontrarás una guía completa sobre cómo utilizar

Mockito para simular objetos y realizar pruebas en Java. La documentación incluye
información detallada sobre las características de Mockito, las API disponibles, las
mejores prácticas, ejemplos de código y más.

Además de la documentación oficial, Mockito también cuenta con una comunidad

activa que proporciona recursos adicionales, como tutoriales, blogs y ejemplos de uso
en diferentes escenarios.

Recuerda que la documentación oficial de Mockito es una fuente confiable y actualizada

para obtener información detallada sobre el uso de esta biblioteca en tus pruebas de
Java.

Mis disculpas por la confusión anterior. Mockito no tiene anotaciones propias. En su

lugar, utiliza la anotación @Mock de la biblioteca Mockito para crear mocks de objetos.
Esta anotación se utiliza para marcar un campo o parámetro como un objeto simulado
en una prueba.

Aquí tienes un ejemplo de cómo se utiliza la anotación @Mock en Mockito:

En el ejemplo anterior, se utiliza la anotación @Mock para crear un mock de la clase
MyDependency. Luego, se utiliza el método when() de Mockito para establecer un
comportamiento simulado para el método someMethod() del mock. Finalmente, se
verifica que el resultado de invocar someMethod() sea el esperado.

Recuerda que para utilizar las anotaciones de Mockito, debes asegurarte de tener las
dependencias correctas en tu proyecto y haber configurado correctamente tu entorno de
prueba.

Utiliza tu mock en tus pruebas y verifica su comportamiento. Puedes utilizar métodos de

aserción para verificar que el comportamiento esperado se haya producido, como
assertEquals(), assertTrue(), verify(), entre otros.

Utiliza tu mock en tus pruebas y verifica su comportamiento. Puedes utilizar métodos de

aserción para verificar que el comportamiento esperado se haya producido, como
assertEquals(), assertTrue(), verify(), entre otros.