Creando Tu Cuchillo Suizo en la Pila de Pruebas de Java

Las garantías de prueba de código aseguran varios puntos excelentes en un diseño de código eficiente, como la mantenibilidad; ayuda con la documentación y facilita la refactorización y la construcción de un diseño/arquitectura evolutiva. No hay duda al respecto, pero ¿cuál es una buena pila de pruebas para comenzar un proyecto? Este video explicará la pila mínima de pruebas para comenzar tu proyecto con Java.

El primer punto a entender cuando hablamos de lo mínimo es que no hay pólvora mágica en la pila de pruebas. Eventualmente, necesitamos incluir o eliminar dependencias, especialmente cuando hablamos de código heredado. Dado eso, voy a dar cuál es mi pila de pruebas favorita en Java, y la uso y recomiendo como mínimo para comenzar desde cero:

• JUnit-Jupiter: La quinta versión de JUnit rompe la compatibilidad con la versión anterior; sin embargo, vale la pena porque trae varias características, principalmente para crear extensiones personalizadas.

• Mockito: Un marco de prueba muy popular con Java. Esta popularidad y gran comunidad permiten varias extensiones, como con JUnit-Jupiter.

• AssertJ: Si te encanta la API fluida como a mí, entonces, AssertJ es una librería extraordinaria para ti.  

Usando el proyecto maven, puedes agregar las dependencias de esas librerías:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>${mockito.verson}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>${mockito.verson}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>${assertj.verson}</version>
    <scope>test</scope>
</dependency>

Dado un contexto de liga de campeonato de fútbol, donde tenemos un equipo que debe tener once jugadores, cada nombre debe ser único en el campeonato. Podemos explorar pruebas en él.

Comenzando con JMockito y pruebas, necesitamos probar el servicio donde debemos verificar si el nombre existe en la base de datos para proceder con la lógica. En este punto, no lo necesitamos y no queremos crear una prueba de integración. 

Queremos centrarnos en los negocios, por lo que no queremos probar la base de datos o el marco, sino solo mi código. Entonces, simularemos el repositorio con dos escenarios, cuando hay un nombre y cuando no lo hay.

Usando Mockito integrado con JUnit-Jupiter puedes inyectar simulaciones solo usando anotaciones. El código a continuación muestra la prueba usando JMockito, donde no necesitamos tener una base de datos ni salir del enfoque para probar los negocios.

@ExtendWith(MockitoExtension.class)
class ChampionshipServiceTest {

    @Mock
    private ChampionRepository repository;

    @InjectMocks
    private ChampionshipService service;

    @Test
    public void shouldRegister() {
        Mockito.when(repository.existByName("Bahia")).thenReturn(false);
        Team bahia = Team.of("Bahia");
        service.register(bahia);

        Mockito.verify(repository).existByName("Bahia");
    }
    @Test
    @DisplayName("should return an exception when there is a team with a name")
    public void shouldThrownAnExceptionWhenTeamNameExists() {
        Mockito.when(repository.existByName("Bahia")).thenReturn(true);
        Team bahia = Team.of("Bahia");
        Assertions.assertThrows(IllegalArgumentException.class, () ->
                service.register(bahia));

        Mockito.verify(repository).existByName("Bahia");
    }
}

AssertJ facilita la comprensión de las afirmaciones gracias a la API fluida que soporta la biblioteca. Puedes probar colecciones, mapas o una sola instancia. Por ejemplo, podemos verificar la adición de un jugador al equipo usando esta herramienta.

@Test
public void shouldCreatePlayers() {
    Team bahia = Team.of("Bahia");
    bahia.add(Player.of("Neymar", "Santos", 10));
    bahia.add(Player.of("Cristiano Ronaldo", "Lisbon", 10));

    org.assertj.core.api.Assertions.assertThat(bahia.players())
            .hasSize(2)
            .map(Player::name)
            .contains("Neymar", "Cristiano Ronaldo");
}

Consigue esta y más información en este video.

Aprendizajes:

• A minimum test stack to start Java

• Aprende más sobre JUnit y por qué es una buena opción

• Conoce los mocks explorando con JMockito

• Haz que tus pruebas sean hermosas con la API fluida Assert: AssertJ