Les outils du monde Java

---

Les Frameworks

Il existe de nombreux frameworks qui améliorent la productivité des développeurs et testeurs Java.

Mockito

Mockit est la dernière bibliothèque active pour l'écriture de mocks avec Java. Elle est aujourd'hui incontournable.

Site

AssertJ

Cette bibliothèque est extrêmement utile pour l'écriture de vos assertions. Via un puissant DSL, ce framework simplifie l'écriture des assertions en fournissant des méthodes spécialisées en fonction du type de données que vous souhaitez évaluer.

Même avec l'apparition de JUnit 5, cette bibliothèque à toute sa place.

Lien

// entry point for all assertThat methods and utility methods (e.g. entry)
import static org.assertj.core.api.Assertions.*;

// basic assertions
assertThat(frodo.getName()).isEqualTo("Frodo");
assertThat(frodo).isNotEqualTo(sauron);

// chaining string specific assertions
assertThat(frodo.getName()).startsWith("Fro")
                           .endsWith("do")
                           .isEqualToIgnoringCase("frodo");

// collection specific assertions (there are plenty more)
// in the examples below fellowshipOfTheRing is a List<TolkienCharacter>
assertThat(fellowshipOfTheRing).hasSize(9)
                               .contains(frodo, sam)
                               .doesNotContain(sauron);

Hamcrest

Hamcrest est un outil utilisé par Mockito et les assertions JUnit 5 notamment pour écrire des composants qui servent à vérifier qu'une propriété ou un état est vrai, aussi appelé matcher. En effet, très souvent, dans les tests, nous devons vérifier que tel objet est identique à un objet de référence, que telles propriétés ont bien été alimentées etc.

Hamcrest permet ce type de résultat. Et vous pouvez ainsi construires des assertions métiers de vos applications.

import org.junit.jupiter.api.Test;
import static org.hamcrest.MatcherAssert.assertThat; 
import static org.hamcrest.Matchers.*;

public class BiscuitTest {
  @Test 
  public void testEquals() { 
    Biscuit theBiscuit = new Biscuit("Ginger"); 
    Biscuit myBiscuit = new Biscuit("Ginger"); 
    assertThat(theBiscuit, equalTo(myBiscuit)); 
  } 
} 

JMock, JMockit, Powermock

Ces bibliothèques très utiles ne sont plus mises à jour depuis environ 2019. Je ne recommande pas de les utiliser par conséquent, vous risquez d'avoir des soucis de support des nouvelles versions de Java.

HSQLDB, H2

Ces bibliothèques sont très utiles implémenter des tests d'intégration et /ou de mocker la base de données de production.

La limitation gênante de ces bibliothèques c'est que si vous utilisez des idiomes SQL spécifiques à votre base, des procédures stockées, il est fort probable qu'elles ne soit pas supportées. Si c'est un aspect bloquant, pour vous, vous pouvez vous rabattre sur TestContainers.

HSQLDB

H2

DBUnit

DBUnit est un framework permettant d'injecter des données provenant d'un fichier Excel dans votre base de données embarquée (HSQLDB par exemple.

C'est assez pratique quand vous devez initialiser des données pour vos tests et que vous ne souhaitez pas dépendre du langage SQL. Ainsi vos BA et votre client peuvent vous fournir les données directement dans un format qu'ils comprennent. ☺️

DBUnit

TestContainers

Très souvent, les applications Spring viennent avec des tests d'intégration ou systèmes qui nécessitent un environnement de test installé. Toutefois lors de phases de TMA successives, les intervenants changent et ces bases sont perdues.

TestContainers, permet de démarrer / arrêter un container Docker en début de votre test JUnit. Vous pouvez donc utiliser comme dépendance partagée un environnement proche de la production. A vous de créer l'image Docker ( ou d'en réutiliser ) vous permettant d'avoir une base de données correctement initialisée.

Biensûr les principaux inconvénients sont:

• le temps de création du container
• d'avoir Docker installé sur votre poste de développement
• que votre intégration continue supporte le lancement de Docker au sein d'autres containers Docker.

Lien framework

Les frameworks BDD

Il existe plusieurs frameworks pour implémenter des tests BDD avec JUnit.

Voici trois parmi les plus populaires.

Cucumber

Cucumber est la solution la plus complète, la plus connue et multi-language pour implémenter des tests BDD.

Il offre à la fois une syntaxe pour écrire les tests BDD (Gherkins), un IDE, une école, des formations etc.

Lien Cucumber

JGiven

JGiven est un framework pour implémenter des tests d'acceptation avec JUnit en pur Java.

@Test
public void une_crepe_peut_etre_faite_avec_un_oeuf_du_lait_et_la_farine() {
    given().un_oeuf().
        and().du_lait().
        and().un_ingredient( "farine" );

    when().le_cuisinier_melange_tout_dans_un_saladier().
        and().le_cuisiner_cuit_la_pate_dans_la_poele();

    then().le_resultat_est_un_pancake();
}

JBehave

JBehave est un autre framework pour implémenter des tests d'acceptance style BDD.

Given our Payments system supports SWIFT messages
When a FX transaction message arrives
And the "from" currency is USD
And the "to" currency is GBP
And the exchange rate is 0.71002

@Given("a stock of symbol $symbol and a threshold of $threshold")
public void stock(String symbol, double threshold) {
    // ...
}
 
@When("the stock is traded at $price")
@Alias("the stock is exchanged at $price") // single alias    
public void theStockIsTradedAt(double price) {
    // ...
}
 
@Then("the alert status should be $status")
@Aliases(values={"the trader should be alerted of status $status",
                 "the alert status is at $status"}) // multiple aliases    
public void theAlertStatusShouldBe(String status) {
    // ...
}

Les outils

Les IDE Java supportent globalement JUNIT, aussi nulle inquiétude avec Eclipse ou IntelliJ.

Toutefois certains plug-ins apportent des fonctionnalités intéressantes à l'IDE :

Plugins pour IntelliJ

IntelliJ vient avec un support remarquable de JUnit et de nombreux frameworks. Toutefois voici quelques plugins utiles pour améliorer vos développements.

JUnit 5 Mockito code generator

Le pluigin génère tout le code nécessaire afin de pouvoir mocker le SUT. Il permet ainsi d'ajouter les annotations, le Runner etc pour déclarer votre test JUnit.

Lien : Lien plugin

Machinet AI Unit tests

Générer vos tests unitaires via l'intelligence artificielle. Un peu gadget mais parfois fourni des résultats intéressants.

Lien : Lien plugin

Assertions2AssertJ

Plugin très utile pour remplacer les annotations Hamcrest et JUnit par le framework AssertJ.

Lien : Lien plugin

JUnit 4 to 5 Converter

Plugin pour convertir vos tests JUnit 4 en JUnit 5. La configuration Maven reste à votre charge toutefois.

Lien : Lien plugin

Plugins pour Eclipse

Le nombre de plugins intéressants dans le Marketplace est beaucoup plus limité mais voici ma sélection personnelle.

ECLEmma Java Coverage

Cet outil permet de mesurer simplement la couverture de code dans Eclipse via l'exécution de tests unitaires ou de programmes.

Lien : Page plugin

Unecessary Code Detector

Ce petit plugin vous aide à détecter du code potentiellement inutilisé, fonctionnalité fournie dans IntelliJ.

Lien : Page plugin

Quick JUnit

Ce plugin aide le développeur à facilement naviguer entre les classes et les tests. Notamment basculer entre la classe et son test via des raccourcis de clavier.

Lien : Page plugin

JUnitLoop

Ce plugin exécute tous les tests d'un workspace qui potentiellement ont été impactés par les modifications de code qui ont été réalisées. Cela permet d'améliorer le feedback en cours de développement.

Lien : Page plugin

JUnit-Tools

Ce plugin aide le développeur à facilement naviguer entre les classes et les tests. Notamment basculer entre la classe et son test via des raccourcis de clavier.

Lien : Page plugin

Infinitest

Ce plugin exécute tous les tests unitaires en continue, impactés par les modifications de code du développeur. C'est l'équivalent d'un correcteur orthographique où chaque ligne de code est vérifiée par rapport aux tests.

Lien : Page plugin

Mockito Quick Fix Tools

Ce plugin est très utile pour le développeur qui souhaite facilement déclarer des mocks ( en utilisation Mockito) pendant que qu'il développe ses tests unitaires. Ainsi vous pouvez déclarer les dépendances manquants d'une classe sous la forme de Mocks via des quick assists.

Lien : Page plugin

MoreUnit

Ce plugin très utile remplace facilement les plugins Mockito Quick Fix Tools et Quick JUnit en offrant le support de Mockito et JMock ainsi la possibilité de naviguer entre les tests.

Lien : Page plugin