Si cree que el contenido de este blog es útil o inspirador para usted, siga mi blog para obtener los últimos artículos técnicos y tutoriales lo antes posible. Al mismo tiempo, también puedes dejar un mensaje en el área de comentarios para compartir tus pensamientos y sugerencias. ¡Gracias por tu apoyo!
Mockito es un popular marco de burla de Java para burlarse y probar el comportamiento de los objetos stub al escribir código de prueba unitaria. El comportamiento de las clases e interfaces de Java se puede simular fácilmente para ayudar a los evaluadores y desarrolladores a diseñar y ejecutar mejor las pruebas unitarias.
Con Mockito, los desarrolladores pueden burlarse de un objeto para que muestre ciertos comportamientos esperados sin utilizar el objeto real. Esta técnica se utiliza a menudo para probar código sin utilizar entornos de prueba de integración complejos. Mockito puede ayudar con pruebas unitarias, pruebas de integración y desarrollo impulsado por el comportamiento (BDD).
1. Conocimientos básicos de Mockito
1. Ventajas de Mockito
- Fácil de usar: la API de Mockito es sencilla, fácil de aprender y usar.
- Admite múltiples escenarios: Mockito admite varios escenarios de prueba, como pruebas unitarias, pruebas de integración y BDD, etc.
- Buena documentación: Mockito tiene documentación completa y una comunidad de usuarios que proporciona muchos escenarios y ejemplos de uso.
2. Limitaciones de Mockito
- No se admite la burla de métodos estáticos y finales.
- Puede usarse en exceso, lo que hace que el código de prueba sea más difícil de mantener.
3. Conceptos comunes de Mockito
- Mock: Se refiere a la implementación virtual de un objeto, que tiene los mismos métodos y propiedades que el objeto real, pero en realidad no ejecuta los métodos.
- Stub: se refiere al código que proporciona un valor de retorno predefinido para una llamada a un método, generalmente utilizado para controlar la ruta del código en la prueba.
- Verificar: Se refiere a verificar que el objeto simulado interactúe como se espera. Verificar se puede utilizar para verificar que el método del objeto simulado se llame un número específico de veces y se pasen los parámetros esperados.
4. Uso común de Mockito
Crear un objeto simulado
List mockList = mock(List.class);Llamada al método auxiliar
when(mockList.get(0)).thenReturn("first");Verificar llamada al método
verify(mockList).add("one");El método simulado arroja una excepción
when(mockList.get(anyInt())).thenThrow(new RuntimeException());Simular llamadas continuas
when(mockList.get(anyInt())).thenReturn("one", "two", "three");Mockito proporciona muchas otras funciones, como ArgumentMatchers para hacer coincidir parámetros de llamadas a métodos, Anotaciones para anotar objetos simulados, Spy para monitorear objetos reales y más. Al aprender y dominar el uso de Mockito, las pruebas unitarias y de integración se pueden realizar de manera más eficiente.
Segundo, use Mockito para simulación.
1. Pasos y ejemplos del uso de Mockito para simulación.
Mockito puede probar código simulando objetos, los pasos son los siguientes:
- Importe la biblioteca Mockito. Agregue las siguientes dependencias al archivo pom.xml:
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.12.4</version>
<scope>test</scope>
</dependency>- Crear clases y métodos para probar.
public class UserService {
private UserDao userDao;
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public User getUserById(int id) {
return userDao.getUserById(id);
}
}
public interface UserDao {
User getUserById(int id);
}- Crear un objeto simulado
UserDao userDao = mock(UserDao.class);- Establecer el comportamiento de los objetos simulados.
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));- ejecutar código de prueba
@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}2. Usar cuando()
El método when() de Mockito se puede utilizar para establecer el comportamiento de objetos simulados, por ejemplo:
when(mockObject.someMethod()).thenReturn(someValue);Código de muestra:
@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}3. Utilice doReturn()
El método doReturn() es similar al método when() y puede usarse para establecer el comportamiento del objeto simulado, por ejemplo:
doReturn(someValue).when(mockObject).someMethod();Código de muestra:
@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
doReturn(new User(1, "John")).when(userDao).getUserById(1);
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}4. Utilice el método simulado () para crear un objeto simulado.
El método simulado() se puede utilizar para crear objetos simulados, por ejemplo:
SomeClass mockObject = mock(SomeClass.class);Código de muestra:
@Test
public void testGetUserById() {
UserDao userDao = mock(UserDao.class);
when(userDao.getUserById(1)).thenReturn(new User(1, "John"));
UserService userService = new UserService(userDao);
User user = userService.getUserById(1);
assertEquals(user.getId(), 1);
assertEquals(user.getName(), "John");
}4. Cree un objeto simulado usando la anotación @Mock
Además de usar mock()el método para crear un objeto simulado, también puedes usar @Mockla anotación para crear un objeto simulado.
Primero debe @RunWith(MockitoJUnitRunner.class)anotar , para que el objeto simulado se inicialice automáticamente cuando se ejecute la prueba.
Luego use @Mockla anotación , de la siguiente manera:
@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
@Mock
private UserDao userDao;
@Test
public void testGetUserById() {
UserService userService = new UserService(userDao);
// ...
}
}Al utilizar @Mockanotaciones para crear un objeto simulado, debe prestar atención a los siguientes puntos:
- La variable modificada por la
@Mockanotación no puede ser un archivonull. - La variable modificada
@Mockpor la anotación tiene por defecto@Mock(answer = RETURNS_DEFAULTS). - Un retorno inteligente se puede especificar
@Mock(answer = Answers.RETURNS_SMART_NULLS)explícitamentenull.
Cuando se utiliza @Mockla anotación para crear un objeto simulado, Mockito creará e inicializará automáticamente el objeto simulado y lo inyectará en la clase de prueba.
Tenga en cuenta que el objeto simulado creado con @Mockla anotación debe usarse en la clase de prueba; de lo contrario, UnnecessaryStubbingExceptionse generará una excepción.
5. Utilice la anotación @Spy para la simulación parcial de objetos simulados.
Además de utilizar la anotación @Mock para crear un objeto simulado completo, Mockito también proporciona la anotación @Spy para crear un objeto simulado parcial, que puede simular otros comportamientos conservando algunos comportamientos del objeto real.
El siguiente es un ejemplo del uso de la anotación @Spy:
public class ExampleServiceTest {
@Spy
private ExampleServiceImpl exampleServiceSpy;
@Test
public void testSomeMethod() {
// 对exampleServiceSpy进行部分模拟，保留真实对象的部分行为
Mockito.doCallRealMethod().when(exampleServiceSpy).someMethod();
// 对someOtherMethod进行模拟
Mockito.when(exampleServiceSpy.someOtherMethod()).thenReturn("mocked result");
// 执行测试代码，调用exampleServiceSpy.someMethod()方法
exampleServiceSpy.someMethod();
// 验证someMethod()方法中是否调用了someOtherMethod()方法
Mockito.verify(exampleServiceSpy).someOtherMethod();
}
}En este ejemplo, hemos utilizado la anotación @Spy para crear una simulación parcial del objeto EjemploServiceImpl. Luego, Mockito.doCallRealMethod().when(exampleServiceSpy).someMethod();solíamos conservar el comportamiento real del método someMethod() en el objeto exampleServiceSpy, mientras nos burlábamos del método someOtherMethod(). Finalmente, llamamos al método exampleServiceSpy.someMethod() y verificamos que se llamó al método someOtherMethod().
3. Utilice Mockito para probar talones
1. La función y el escenario de la pila de prueba.
El uso de Mockito para códigos auxiliares de prueba puede simular el valor de retorno de un método o generar una excepción en una prueba unitaria para probar el comportamiento del código bajo prueba en diversas situaciones. Los escenarios de uso comunes incluyen:
- Pruebe el comportamiento del código bajo prueba en condiciones excepcionales. A través del código auxiliar de prueba, puede simular la escena donde el método genera una excepción y probar si el código bajo prueba puede manejar correctamente la excepción en una situación anormal.
- Pruebe el comportamiento del código bajo prueba en circunstancias específicas. Por ejemplo, para probar el comportamiento de un método cuando la entrada es nula, puede utilizar un código auxiliar de prueba para simular el escenario en el que la entrada del método es nula.
- Pruebe la interacción del código bajo prueba con dependencias externas. Al burlarse de los valores de retorno o generar excepciones de dependencias externas, puede probar el comportamiento del código bajo prueba al interactuar con dependencias externas.
- Pruebe las condiciones de contorno del código bajo prueba. Al simular el valor de retorno de dependencias o métodos externos, es posible probar el comportamiento del código bajo prueba en varios casos extremos, como el caso en el que la entrada es el valor máximo o mínimo.
En resumen, los resguardos de prueba ayudan a los desarrolladores a crear varios escenarios de prueba para garantizar que el código bajo prueba se comporte correctamente.
2. Pasos y ejemplos del uso de Mockito para probar stubs
El uso de Mockito para códigos auxiliares de prueba puede simular valores de retorno requeridos o excepciones para probar los escenarios requeridos en las pruebas. Estos son los pasos y ejemplos para probar stubs con Mockito:
- Cree un objeto o interfaz que deba ser eliminado:
public interface UserService {
User getUserById(int userId);
}- Utilice Mockito para resguardos de prueba, como simular el método getUserById para devolver el objeto Usuario especificado:
@Test
public void testGetUserById() {
UserService userService = Mockito.mock(UserService.class);
User expectedUser = new User("Alice", 20);
Mockito.when(userService.getUserById(Mockito.anyInt())).thenReturn(expectedUser);
User actualUser = userService.getUserById(1);
Assert.assertEquals(expectedUser, actualUser);
}En este ejemplo, usamos el método Mockito.mock() para crear un objeto simulado userService del objeto UserService, y usamos el método Mockito.when() para probar el método getUserById, especificando que cuando se pasa cualquier número entero, se especifica un uno se devuelve objeto de usuario. Luego usamos el objeto simulado userService para llamar al método getUserById y afirmar si el objeto Usuario devuelto es el valor que esperamos.
- Utilice un código auxiliar de prueba para simular el lanzamiento de una excepción:
@Test(expected = UserNotFoundException.class)
public void testGetUserByIdWhenUserNotFound() {
UserService userService = Mockito.mock(UserService.class);
Mockito.when(userService.getUserById(Mockito.anyInt())).thenThrow(UserNotFoundException.class);
userService.getUserById(1);
}En este ejemplo, cortamos el método getUserById usando el método Mockito.when(), especificando que se debe generar una excepción UserNotFoundException cuando se pasa cualquier número entero. Luego usamos el objeto simulado userService para llamar al método getUserById y esperamos detectar la excepción UserNotFoundException.
3. Utilice el método thenReturn() para establecer el valor de la pila.
Además de usar el método doReturn() para el método stub, también podemos usar el método thenReturn() para establecer el valor del stub. Cuando el método stub devuelve un valor, podemos usar el método thenReturn() para especificar el valor. Por ejemplo:
@Test
public void testGetPerson() {
// 创建模拟对象
PersonDao personDao = mock(PersonDao.class);
// 设置桩方法并返回模拟数据
when(personDao.getPerson(1)).thenReturn(new Person("Alice", 20));
// 执行被测试方法
PersonService personService = new PersonService(personDao);
Person person = personService.getPerson(1);
// 验证方法的返回值是否正确
assertEquals("Alice", person.getName());
assertEquals(20, person.getAge());
}En este ejemplo, configuramos el método stub a través del método when() y usamos el método thenReturn() para especificar los datos simulados que deben devolverse cuando el método getPerson() pasa el parámetro 1. Luego, ejecutamos el método bajo prueba y usamos el método afirmarEquals() para verificar que el valor de retorno del método sea correcto. Si el método devuelve los datos simulados que esperábamos, entonces la prueba pasa.
4. Utilice el método thenThrow() para generar una excepción.
El método thenThrow() de Mockito se puede utilizar para configurar el método de código auxiliar de prueba para que genere una excepción específica durante la ejecución. Esto es muy útil para probar el comportamiento de su código bajo ciertas condiciones inusuales.
Usar el método thenThrow() es muy simple: solo necesita llamar al método thenThrow() después del método stub y pasar el tipo de excepción que se lanzará. Aquí hay un ejemplo:
@Test
public void testDoSomething() throws Exception {
SomeObject mockObject = mock(SomeObject.class);
when(mockObject.doSomething()).thenThrow(new RuntimeException("test exception"));
// 确保调用 doSomething() 时会抛出 RuntimeException
assertThrows(RuntimeException.class, () -> {
mockObject.doSomething();
});
}En el ejemplo anterior, combinamos when()el método con doSomething()el método, luego llamamos thenThrow()al método y le pasamos un RuntimeExceptionobjeto. Luego llamamos doSomething()al método , que genera una excepción de tiempo de ejecución. Finalmente, usamos assertThrows()el método para verificar que el método efectivamente arrojó una excepción de tiempo de ejecución.
En general, utilizar thenThrow()el método puede ayudarnos a probar cómo se comporta nuestro código en situaciones excepcionales.
5. Utilice el método doAnswer() para personalizar el método stub
En algunos casos, puede ser necesario personalizar el método de código auxiliar para satisfacer las necesidades de la prueba. En este momento, puede utilizar el método doAnswer () de Mockito para lograrlo.
El método doAnswer() es el siguiente:
public <T> OngoingStubbing<T> doAnswer(Answer<?> answer)El parámetro del método doAnswer() es un objeto Answer, que representa el comportamiento del método stub personalizado. Hay un método en la answer()interfaz que devuelve un objeto genérico que representa el valor de retorno del método simulado.
A continuación se muestra un ejemplo de un método stub personalizado que utiliza el método doAnswer():
List<String> list = mock(List.class);
doAnswer(invocation -> {
Object[] args = invocation.getArguments();
String result = (String) args[0] + "Mockito";
return result;
}).when(list).get(anyInt());En este ejemplo, personalizamos el método get de List y cambiamos su valor de retorno a la cadena del parámetro de entrada seguida de "Mockito". Se puede ver que en el método doAnswer(), implementamos answer()el método y usamos el objeto Invocation para obtener los parámetros entrantes y los valores de retorno. Finalmente, el método stub se aplica utilizando el método when().
6. Utilice la anotación @Captor para capturar parámetros.
Mockito proporciona la anotación @Captor para capturar los parámetros pasados en la llamada al método del objeto simulado. Esta anotación puede declarar un parámetro en el caso de prueba y anotarlo como @Captor. Mockito inyectará automáticamente los parámetros en la llamada al método del objeto simulado en este parámetro para que podamos realizar afirmaciones u otras operaciones.
Los pasos y ejemplos de captura de parámetros utilizando la anotación @Captor son los siguientes:
- Cree la anotación @Captor en la clase de caso de prueba e inicialice un parámetro, por ejemplo:
@Captor
private ArgumentCaptor<String> captor;- Utilice un objeto simulado para llamar al método en un caso de prueba y pase parámetros al objeto simulado, por ejemplo:
mockObject.doSomething("test");- Utilice el método Mockito.verify() para verificar la llamada del método del objeto simulado y utilice la anotación @Captor para capturar los parámetros pasados cuando se llama al método, por ejemplo:
verify(mockObject).doSomething(captor.capture());- Realice afirmaciones u otras operaciones sobre parámetros capturados, por ejemplo:
assertEquals("test", captor.getValue());De esta manera, la anotación @Captor se puede utilizar para la captura de parámetros, lo cual nos resulta conveniente para afirmar y otras operaciones sobre parámetros de métodos en casos de prueba.
4. Uso avanzado de Mockito
1. Utilice Mockito para pruebas asincrónicas
En la programación asincrónica, a menudo necesitamos probar métodos asincrónicos para asegurarnos de que funcionen como se espera. Mockito proporciona algunos métodos para manejar escenarios de pruebas asincrónicas, incluidas devoluciones de llamadas asincrónicas y espera de resultados asincrónicos.
A continuación se muestran algunos escenarios comunes y ejemplos de pruebas asincrónicas con Mockito.
simulacro de devolución de llamada asincrónica
En una devolución de llamada asincrónica, cuando se completa una operación asincrónica, llama a una función de devolución de llamada para notificar a la persona que llama. Mockito proporciona Answerla interfaz , que se puede utilizar para simular funciones de devolución de llamada asincrónicas.
Ejemplo:
@Test
public void testAsyncCallback() {
MyAsyncService service = mock(MyAsyncService.class);
when(service.doSomethingAsync(anyString(), any(Consumer.class))).thenAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
String arg1 = (String) args[0];
Consumer<String> callback = (Consumer<String>) args[1];
callback.accept(arg1 + " is done");
return null;
}
});
MyAsyncClient client = new MyAsyncClient(service);
String result = client.doSomething("test");
assertEquals("test is done", result);
}En este ejemplo, utilizamos Answerla interfaz para simular una función de devolución de llamada asincrónica. Cuando se llama service.doSomethingAsyncal método , obtenemos la función de devolución de llamada del parámetro y la ejecutamos, luego devolvemos el archivo null. En la prueba verificamos que los resultados devueltos por el cliente asincrónico sean correctos.
esperar el resultado asíncrono
En la programación asincrónica, a menudo necesitamos esperar a que se complete la operación asincrónica para obtener el resultado. Para probar un método asíncrono, debemos esperar a que se complete la operación asíncrona antes de afirmar el resultado. Mockito proporciona algunos métodos para manejar este escenario.
Ejemplo:
@Test
public void testAsyncResult() throws Exception {
MyAsyncService service = mock(MyAsyncService.class);
CompletableFuture<String> future = new CompletableFuture<>();
when(service.doSomethingAsync(anyString())).thenReturn(future);
MyAsyncClient client = new MyAsyncClient(service);
CompletableFuture<String> result = client.doSomethingAsync("test");
assertFalse(result.isDone()); // 验证异步方法还未完成
future.complete("test is done");
assertTrue(result.isDone()); // 验证异步方法已完成
assertEquals("test is done", result.get()); // 验证异步方法的结果是否正确
}En este ejemplo, utilizamos CompletableFuturepara simular el resultado de un método asincrónico. Cuando se llama service.doSomethingAsyncal método , devolvemos un CompletableFutureobjeto. En la prueba, verificamos que el método asíncrono se haya iniciado, luego finalizamos manualmente CompletableFutureel objeto y verificamos que el resultado sea correcto.
Cabe señalar que cuando utilizamos CompletableFutureel objeto para pruebas asincrónicas, debemos esperar a que se complete la operación asincrónica antes de obtener el resultado. Podemos usar isDone()el método para juzgar si la operación asincrónica se completó y usar get()el método para obtener el resultado de la operación asincrónica.
2. Utilice Mockito para hacer coincidir parámetros
Cuando usamos Mockito para pruebas unitarias, generalmente necesitamos probar el método bajo prueba pasando diferentes parámetros. Pero a veces queremos probar solo una combinación específica de parámetros, entonces necesitamos usar la coincidencia de parámetros.
Mockito proporciona una serie de comparadores de parámetros, que pueden hacer coincidir parámetros según su tipo y valor. Los comparadores de parámetros más utilizados son:
- any(): coincide con cualquier objeto, por ejemplo, any(String.class) coincide con cualquier parámetro de tipo String.
- eq(): coincide con el objeto especificado, por ejemplo, eq("abc") coincide con el parámetro cuyo valor de parámetro es "abc".
- isA(): Coincide con parámetros del tipo especificado, por ejemplo, isA(String.class) coincide con parámetros cuyo tipo de parámetro es String.
- anyXxx(): coincide con el tipo de datos básico del tipo especificado, por ejemplo, anyInt() coincide con cualquier parámetro de tipo int.
El siguiente es un código de muestra para la coincidencia de parámetros usando Mockito:
// 定义被测类
public class UserService {
private UserDao userDao;
public UserService(UserDao userDao) {
this.userDao = userDao;
}
public User getUserByName(String name) {
return userDao.getUserByName(name);
}
}
// 定义 UserDao 接口
public interface UserDao {
User getUserByName(String name);
}
// 定义测试类
@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
@Mock
private UserDao userDao;
@InjectMocks
private UserService userService;
@Test
public void testGetUserByName() {
// 设置桩方法
when(userDao.getUserByName(any(String.class)))
.thenReturn(new User("Tom"));
// 调用被测方法
User user = userService.getUserByName("Tom");
// 验证返回值
assertEquals("Tom", user.getName());
}
}En el código de muestra anterior, utilizamos el método any() para hacer coincidir los parámetros del método getUserByName(), de modo que cualquier parámetro de tipo cadena pueda coincidir sin especificar el valor del parámetro. Esto hace que el código de prueba sea más flexible y genérico.
Además de los comparadores de parámetros presentados anteriormente, Mockito también proporciona muchos otros comparadores de parámetros. Para obtener más información, consulte la documentación oficial de Mockito.
3. Utilice Mockito para el método stub y la verificación del método nulo.
Mockito se puede usar para detectar métodos y verificar métodos nulos. A continuación se presentará cómo usar Mockito para detectar métodos y verificar métodos nulos.
método de trozo del método vacío
Hay dos métodos en Mockito que se pueden usar para métodos auxiliares de métodos nulos, a saber, doNothing() y doThrow().
- doNothing(): Indica que cuando se llama al método void, no se hace nada.
- doThrow(): indica que cuando se llama al método void, se lanza una excepción específica.
Aquí está el código de ejemplo:
// 创建一个mock对象
List<String> mockList = mock(List.class);
// 对void方法进行桩方法，表示当调用add方法时，不做任何事情
doNothing().when(mockList).add(anyString());
// 对void方法进行桩方法，表示当调用clear方法时，抛出一个RuntimeException异常
doThrow(new RuntimeException()).when(mockList).clear();Validación de métodos nulos.
El método verificar () se usa en Mockito para verificar si se llama al método void, que es similar al método verificar () mencionado anteriormente, excepto que no es necesario establecer el valor de retorno.
Aquí está el código de ejemplo:
// 创建一个mock对象
List<String> mockList = mock(List.class);
// 调用void方法
mockList.clear();
// 验证clear方法是否被调用过一次
verify(mockList).clear();El método stub y la verificación del método void usando Mockito son similares al método común: solo necesita usar los métodos doNothing () y doThrow () para el método stub, y usar el método verificar () para la verificación.
4. Utilice Mockito para simular métodos estáticos y métodos finales.
Mockito no puede simular directamente métodos estáticos y métodos finales porque no se pueden subclasificar ni sobrecargar, pero Mockito se puede usar junto con PowerMock y otros marcos simulados para simular métodos estáticos y métodos finales.
PowerMock es un marco de código abierto de Java que combina las características de EasyMock y Mockito y agrega soporte para métodos estáticos, métodos finales, métodos privados, constructores y bloques de inicialización estáticos.
Los siguientes son los pasos y ejemplos del uso de PowerMock y Mockito para simular métodos estáticos y métodos finales:
1 Agregue dependencias de PowerMock y Mockito en el archivo Maven POM:
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-core</artifactId>
<version>2.0.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>2.0.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.2.4</version>
<scope>test</scope>
</dependency>2 Utilice las anotaciones @RunWith(PowerMockRunner.class) y @PrepareForTest para preparar clases que requieran Mock:
@RunWith(PowerMockRunner.class)
@PrepareForTest({ClassToMock.class})
public class MyClassTest {
...
}3 Utilice el método PowerMockito.mockStatic(ClassToMock.class) para simular el método estático:
PowerMockito.mockStatic(ClassToMock.class);
Mockito.when(ClassToMock.staticMethod()).thenReturn(expectedValue);4 Utilice el método PowerMockito.whenNew(ClassToMock.class) para simular el constructor:
PowerMockito.whenNew(ClassToMock.class).withArguments(argument1, argument2).thenReturn(mockInstance);5 Utilice el método PowerMockito.spy(mockInstance) para crear un objeto Spy:
ClassToMock mockInstance = PowerMockito.spy(new ClassToMock());
Mockito.when(mockInstance.finalMethod()).thenReturn(expectedValue);6 Utilice el método PowerMockito.doCallRealMethod().when(mockInstance).nonFinalMethod() para simular un método no final:
PowerMockito.doCallRealMethod().when(mockInstance).nonFinalMethod();
Mockito.when(mockInstance.nonFinalMethod()).thenReturn(expectedValue);7 En el método de prueba, utilice el método PowerMockito.verifyStatic(ClassToMock.class) para verificar la llamada al método estático y el método PowerMockito.verifyNew(ClassToMock.class) para verificar la llamada al constructor:
PowerMockito.verifyStatic(ClassToMock.class);
ClassToMock.staticMethod();
PowerMockito.verifyNew(ClassToMock.class).withArguments(argument1, argument2);Cabe señalar que los métodos estáticos simulados y los métodos finales pueden afectar la capacidad de mantenimiento y legibilidad del código, y deben evitarse tanto como sea posible. Úselos solo cuando sea necesario y debe elegir un marco de referencia apropiado para mantener su código limpio y legible.
V. Resumen
Mockito es un popular marco de burla de Java que ayuda a los desarrolladores a escribir pruebas unitarias para verificar mejor la corrección de su código. Mockito proporciona algunos métodos de uso común, como objetos simulados, resguardos de prueba, coincidencia de parámetros, pruebas asincrónicas, etc. Estos métodos pueden simplificar enormemente la escritura y el mantenimiento de códigos de prueba. Las ventajas de Mockito incluyen facilidad de aprendizaje y uso, amplio soporte y documentación rica, pero también existen limitaciones, como no admitir métodos finales simulados. Para los desarrolladores, usar Mockito para pruebas unitarias puede mejorar la calidad del código y reducir los costos de mantenimiento del código, lo cual es una habilidad que vale la pena dominar.