Créer votre couteau suisse sur Java Test Stack

Les testabilités du code garantissent plusieurs points excellents dans une conception de code efficace, comme la maintenabilité ; il aide à la documentation et facilite la refactorisation et la construction d’une conception/architecture évolutive. Cela ne fait aucun doute, mais qu’est-ce qu’une bonne pile de test pour démarrer un projet ? Cette vidéo explique la pile de test minimale pour démarrer votre projet avec Java.

Le premier point à comprendre quand on parle du minimum est qu’il n’y a pas de solution miracle sur la pile de test. Finalement, nous devons inclure ou supprimer des dépendances, en particulier lorsque nous parlons de code hérité. Compte tenu de cela, je vais donner quelle est ma pile de test préférée sur Java, et je l’utilise et recommande au minimum pour repartir de zéro :

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

• Mockito : Un framework fictif super populaire avec Java. Cette popularité et cette énorme communauté permettent plusieurs extensions, comme avec JUnit-Jupiter.

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

À l’aide du 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 le contexte d’une ligue de championnat de football, où nous avons une équipe qui devrait avoir onze joueurs, chaque nom doit être unique dans la ligue de championnat. Nous pouvons explorer des tests dessus.

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

Nous voulons nous concentrer sur l’entreprise, nous ne voulons donc pas tester la base de données ou le framework, mais uniquement mon code. Donc, nous allons simuler le référentiel avec deux scénarios, quand il y a le nom et quand il n’y en a pas.

En utilisant l’intégration de Mockito avec JUnit-Jupiter, vous pouvez injecter une simulation uniquement à l’aide d’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 l’entreprise.

@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 prise en charge par la bibliothèque. Vous pouvez tester des collections, des cartes ou une seule instance. Par exemple, nous pouvons vérifier l’ajout d’un joueur à l’équipe qui l’utilise.

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

Prenez ceci et plus d’informations sur cette vidéo.

Plats à emporter :

• Une pile de test minimale pour démarrer Java

• En savoir plus sur JUnit et pourquoi c’est un bon choix

• En savoir plus sur les simulations d’exploration avec JMockito

• Rendez votre test magnifique avec l’Assert fluent-API : AssertJ