¿Cómo probar los métodos de interfaz de la lista Java usando Mockito?

Mockito es un marco de prueba de código abierto que se utiliza para la prueba unitaria de aplicaciones Java. Desempeña un papel vital en el desarrollo de aplicaciones comprobables. Mockito se usa para simular interfaces para que se pueda agregar una funcionalidad ficticia a una interfaz simulada que se puede usar en pruebas unitarias. La interfaz List en Java proporciona una forma de almacenar la colección ordenada. Es una interfaz secundaria de Collection. Es una colección ordenada de objetos en los que se pueden almacenar valores duplicados. Hay muchos métodos disponibles en la interfaz de lista de Java como 

• agregar()
• establecer()
• retirar()
• Talla()
• get() y muchos más.

Entonces, en este artículo, vamos a probar algunos de los métodos con la ayuda del marco Mockito y Junit. 

Implementación paso a paso

Paso 1: Creación de un proyecto Maven 

Cree un proyecto maven en su IDE de Java favorito (en este artículo estamos usando IntelliJ IDEA)

Paso 2: cuando haya creado con éxito un proyecto maven, debe agregar algunas dependencias en su archivo pom.xml. Debe agregar la siguiente dependencia en su archivo pom.xml.

La dependencia de Mockito es la siguiente :

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>2.0.2-beta</version>
</dependency>

La dependencia de Junit es la siguiente : 

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.8.2</version>
</dependency>

Implementación: a continuación se muestra el código completo para el archivo pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
  
    <groupId>org.example</groupId>
    <artifactId>mockito-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
  
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-all</artifactId>
            <version>2.0.2-beta</version>
        </dependency>
    </dependencies>
  
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
  
</project>

Paso 3: Prueba de los métodos de interfaz de la lista de Java

Para probar los métodos de interfaz de la lista Java, tenemos que crear una clase de prueba dentro de la carpeta src> test> java> right-click> New> Java Class como se muestra en la imagen a continuación. Aquí hemos nombrado la clase como JavaListMock .

Paso 4:   Ahora vamos a escribir los casos de prueba para los métodos de la interfaz de lista de Java.

Método de prueba list.size()

4.1: Mockito nos proporciona el método mock() para simular la clase List.

List mockList = mock(List.class);

4.2: Mockito nos proporciona otros dos métodos when() y thenReturn() . when() se usa cuando queremos simular para devolver valores específicos cuando se llama a métodos particulares y los métodos thenReturn() le permiten definir el valor de retorno cuando se llama a un método particular del objeto simulado. 

when(mockList.size()).thenReturn(2);

4.3: Junit nos proporciona assertEquals() que se utiliza para comprobar si dos objetos están igualmente definidos o no.

assertEquals(2, mockList.size());

4.4: Uno tiene que escribir las 3 líneas superiores dentro de un método public void y tiene que anotar el método con @Test . La anotación @Test le dice a JUnit que el método public void en el que se usa puede ejecutarse como un caso de prueba.

@Test
public void mockListSizeMethod(){
  // Your test code
}

Ejemplo: 

// Java Program to Test code for the list.size() Method
  
// @Test tells the JUnit that the public void method
// in which it is used can run as a test case
@Test public void mockListSizeMethod()
{
  
    // Mock the List Class
    List mockList = mock(List.class);
  
    // when is used when we want to mock to return specific
    // values when particular methods are called and
    // thenReturn() methods lets you define the return value
    // when a particular method of the mocked object is been
    // called
    when(mockList.size()).thenReturn(2);
  
    // assertEquals is used to check if
    // two objects is equally defined or not
    assertEquals(2, mockList.size());
}

Por ahora, hemos probado con éxito el método list.size(), por lo que pasamos al siguiente 

Método de prueba list.size() con múltiples valores

También podemos probar el método list.size() con valor múltiple.

Ejemplo

@Test
public void mockListSizeMethod_multipleValues(){
        List mockList = mock(List.class);
        when(mockList.size()).thenReturn(2).thenReturn(3);
        assertEquals(2, mockList.size());
        assertEquals(3, mockList.size());
    }

Método de prueba list.get()

Ilustración A:

@Test
public void mockListGetMethod(){
        List mockList = mock(List.class);
        // Argument Matcher
        when(mockList.get(anyInt())).thenReturn(2);
        assertEquals(2, mockList.get(anyInt()));
    }

También se puede lanzar una excepción y probar su método.

Ilustración B:  lanzar una excepción

@Test(expected = RuntimeException.class)
public void mockListGetMethod_throwAnException(){
        List mockList = mock(List.class);
        when(mockList.get(anyInt())).thenThrow(new RuntimeException("Something Wrong"));
        mockList.get(anyInt());
    }

Implementación: 

// Java Program to Illustrate JavaListMock File
  
// Importing required classes
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
  
import java.util.List;
import org.junit.Test;
  
// Class
public class JavaListMock {
  
    // @Test annotation tells the JUnit that
    // the public void method
    // in which it is used can run as a test case
    @Test public void mockListSizeMethod()
    {
        // Mock the List Class
        List mockList = mock(List.class);
  
        // when is used when we want to mock to return
        // specific values when particular methods are
        // called and thenReturn() methods lets you define
        // the return value when a particular method of the
        // mocked object is been called
        when(mockList.size()).thenReturn(2);
  
        // assertEquals is used to check if
        // two objects is equally defined or not
        assertEquals(2, mockList.size());
    }
  
    // Method
    @Test public void mockListSizeMethod_multipleValues()
    {
        List mockList = mock(List.class);
        when(mockList.size()).thenReturn(2).thenReturn(3);
        assertEquals(2, mockList.size());
        assertEquals(3, mockList.size());
    }
  
    // Method
    @Test public void mockListGetMethod()
    {
        List mockList = mock(List.class);
        // Argument Matcher
        when(mockList.get(anyInt())).thenReturn(2);
        assertEquals(2, mockList.get(anyInt()));
    }
  
    // Method
    @Test(expected = RuntimeException.class)
    public void mockListGetMethod_throwAnException()
    {
        List mockList = mock(List.class);
        when(mockList.get(anyInt()))
            .thenThrow(
                new RuntimeException("Something Wrong"));
        mockList.get(anyInt());
    }
}

Paso 5: ejecutar casos de prueba

Ahora vamos a ejecutar nuestros casos de prueba. Para ejecutar sus casos de prueba, puede hacer clic en el botón Probar todos los métodos o probar todos los métodos con un solo clic. Y si desea probar cada método por separado, puede hacer clic en el botón Probar un solo método. En la pestaña Ejecutar, puede ver que todos sus casos de prueba han sido aprobados.