Création de votre couteau suisse sur la pile de tests Java

Les garanties de testabilité assurent plusieurs points excellents dans une conception de code efficace, telles que la maintenabilité ; elles facilitent la documentation et rendent plus aisé le refactoring et la construction d’une conception/architecture évolutive. Il ne fait aucun doute, mais quel est un bon ensemble de tests pour démarrer un projet ? Cette vidéo expliquera l’ensemble de tests minimum pour démarrer votre projet avec Java.

Le premier point à comprendre lorsque nous parlons de minimum est qu’il n’y a pas de solutions miracles pour l’ensemble de tests. Finalement, nous devons inclure ou supprimer des dépendances, surtout lorsque nous parlons de code hérité. Étant donné cela, je vais partager quel est mon ensemble de tests préféré en Java, et je l’utilise et le recommande comme minimum pour démarrer à partir de zéro :

• JUnit-Jupiter : La cinquième version de JUnit rompt la compatibilité avec la version précédente ; cependant, elle en vaut la peine car elle apporte de nombreuses fonctionnalités, principalement pour créer des extensions personnalisées.

• Mockito : Un cadre de simulation très populaire avec Java. Cette popularité et cette grande communauté permettent de nombreuses extensions, telles que celles avec JUnit-Jupiter.

• AssertJ: Si vous aimez les API fluides comme moi, alors, AssertJ est une bibliothèque exceptionnelle pour vous.

En utilisant le projet Maven, vous pouvez ajouter les dépendances de ces bibliothèques :

<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>

Dans un contexte de championnat de football, où nous avons une équipe qui devrait avoir onze joueurs, chaque nom doit être unique dans le championnat. Nous pouvons explorer des tests dessus.

En commençant par JMockito et les tests, nous devons tester le service où nous devons vérifier si le nom existe dans la base de données pour procéder à la logique. À ce stade, nous n’en avons pas besoin et ne voulons pas créer un test d’intégration. 

Nous voulons nous concentrer sur les affaires, donc nous ne voulons pas tester la base de données ou le cadriciel mais seulement mon code. Ainsi, nous allons simuler le référentiel avec deux scénarios, lorsqu’il y a le nom et lorsqu’il n’y en a pas.

En utilisant Mockito intégré à JUnit-Jupiter, vous pouvez injecter des simulations uniquement en utilisant des annotations. Le code ci-dessous montre le test utilisant JMockito, où nous n’avons pas besoin d’avoir une base de données ou de sortir du focus pour tester les affaires.

@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 facilite la compréhension des assertions grâce à l’API fluide que la bibliothèque prend en charge. Vous pouvez tester des collections, des cartes ou une seule instance. Par exemple, nous pouvons vérifier l’ajout d’un joueur à une équipe en l’utilisant.

@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");
}

Consultez cette vidéo et plus d’informations à ce sujet.

Points clés :

• A minimum test stack to start Java

• En savoir plus sur JUnit et pourquoi c’est une bonne option

• Découvrez les mockups en explorant avec JMockito

• Rendez votre test beau avec l’API fluide Assert : AssertJ