[JAVA] Exemple de code pour la simulation de base et les tests avec Mockito 3 + JUnit 5

Aperçu

Exemple de code

Liste des codes sources

├── build.gradle
└── src
    ├── main
    │   └── java
    │       ├── Client.java
    │       └── Worker.java
    └── test
        └── java
            └── ClientTest.java

build.gradle

Fichier de configuration Gradle pour l'exécution du test de construction.

plugins {
  id 'java'
}

repositories {
  jcenter()
}

dependencies {
  //Présentation de Junit 5
  // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter
  testImplementation 'org.junit.jupiter:junit-jupiter:5.6.2'

  //Présentation de Mockito 3
  // https://mvnrepository.com/artifact/org.mockito/mockito-core
  testImplementation 'org.mockito:mockito-core:3.4.6'

  //Présentation de la bibliothèque d'extension JUnit 5 par Mockito
  // https://mvnrepository.com/artifact/org.mockito/mockito-junit-jupiter
  testImplementation 'org.mockito:mockito-junit-jupiter:3.4.6'
}

test {
  //Paramètres pour utiliser la plateforme JUnit
  useJUnitPlatform()

  //Paramètres de sortie pendant le test
  testLogging {
    //Afficher la sortie standard et la sortie d'erreur standard pendant le test
    showStandardStreams true
    //Événement de sortie(TestLogEvent)
    events 'started', 'skipped', 'passed', 'failed'
    //Paramètres de sortie lorsqu'une exception se produit(TestExceptionFormat)
    exceptionFormat 'full'
  }
}

src/main/java/Worker.java

La classe à se moquer.

public class Worker {

  //Méthode avec argument / valeur de retour
  public int ariari(int x) {
    throw new IllegalStateException("Exceptions qui semblent se produire en fonction de l'environnement");
  }

  //Méthode sans argument / sans valeur de retour
  public void nasinasi() {
    throw new IllegalStateException("Exceptions qui semblent se produire en fonction de l'environnement");
  }
}

src/main/java/Client.java

La classe à tester.

public class Client {

  private Worker worker;

  //Appeler une méthode avec des arguments et des valeurs de retour
  public int callAriari(int x) {
    return worker.ariari(x * 2); //Valeur doublée pour le travailleur#Passer à Ariari
  }

  //Appeler une méthode sans arguments et sans valeur de retour
  public int callNasinasi(int x) {
    worker.nasinasi(); // Worker#Appeler nasinasi
    return x * 2; //Renvoie une valeur doublée
  }
}

src/test/java/ClientTest.java

Classe de test. Simulez la classe Worker avec Mockito 3 et testez la classe Client avec JUnit 5.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;

@ExtendWith(MockitoExtension.class) //Extension JUnit 5 par Mockito
public class ClientTest {

  //Objet à injecter simulé
  @InjectMocks
  private Client client = new Client();

  //Objet à se moquer
  @Mock
  private Worker mockedWorker;

  @Test
vide public avec argument_Il y a une valeur de retour() {
    //Comportement simulé: Worker#Renvoie 6 lorsque 2 est passé à ariari
    doReturn(6).when(mockedWorker).ariari(2);
    //tester: Client#Passer 1 à callAriari est un faux travailleur#Passez 2 à Ariari et 6 est retourné
    assertEquals(6, client.callAriari(1));
  }

  @Test
public void aucun argument_Aucune valeur de retour() {
    //Comportement simulé: Worker#Ne rien faire en appelant nasinasi
    doNothing().when(mockedWorker).nasinasi();
    //tester: Client#Passer 1 à appelerNasinasi est un faux travailleur#Exécutez nasinasi et récupérez-en 2
    assertEquals(2, client.callNasinasi(1));
  }

  @Test
public void Une exception s'est produite() {
    //Comportement simulé: Worker#Lance une exception lorsque 4 est passé à ariari
    doThrow(new IllegalArgumentException("Exception simulée")).when(mockedWorker).ariari(4);
    //tester: Client#Passer 2 pour appeler Ariari est un faux travailleur#Passer 4 à Ariari lève une exception
    IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> client.callAriari(2));
    //tester:L'exception contient le message attendu
    assertEquals("Exception simulée", e.getMessage());
  }

  @Test
appel séquentiel public void() {
    //Comportement simulé: Worker#Lève une exception deux fois lorsque 6 est passé à ariari, puis renvoie 18.
    doThrow(new IllegalArgumentException("1ère exception simulée"))
      .doThrow(new IllegalArgumentException("Deuxième exception fictive"))
      .doReturn(18)
      .when(mockedWorker).ariari(6);
    //tester: Client#Passer 3 pour appeler Ariari est un faux travailleur#Passez 6 à Ariari et lancez une exception
    IllegalArgumentException e1 = assertThrows(IllegalArgumentException.class, () -> client.callAriari(3));
    assertEquals("1ère exception simulée", e1.getMessage());
    //tester: Client#Passer 3 pour appeler Ariari est un faux travailleur#Passez 6 à Ariari et lancez une exception
    IllegalArgumentException e2 = assertThrows(IllegalArgumentException.class, () -> client.callAriari(3));
    assertEquals("Deuxième exception fictive", e2.getMessage());
    //tester: Client#Passer 3 pour appeler Ariari est un faux travailleur#Passez 6 à Ariari et 18 est retourné
    assertEquals(18, client.callAriari(3));
  }
}

Essai

Un exemple d'exécution de la tâche de test dans Gradle.

$ gradle test

> Task :test

ClientTest >Aucun argument_Aucune valeur de retour() STARTED

ClientTest >Aucun argument_Aucune valeur de retour() PASSED

ClientTest >Avec argument_Il y a une valeur de retour() STARTED

ClientTest >Avec argument_Il y a une valeur de retour() PASSED

ClientTest >Il y a une exception() STARTED

ClientTest >Il y a une exception() PASSED

ClientTest >Appel séquentiel() STARTED

ClientTest >Appel séquentiel() PASSED

BUILD SUCCESSFUL in 2s
3 actionable tasks: 3 executed

Matériel de référence

Recommended Posts

Exemple de code pour la simulation de base et les tests avec Mockito 3 + JUnit 5
Démarrez les tests d'interface utilisateur avec Dagger2 et Mockito
Réécrivez le code de java.io.File avec java.nio.Path et java.nio.Files
Test de la logique d'envoi et de réception de demande avec MockWebServer dans JUnit
Exemple de code pour analyser la date et l'heure avec SimpleDateFormat de Java
Création d'image Docker de l'extension Keycloak et test de performances par Gatling
Nouvelles fonctionnalités de Java 9 et exemple de code
Avec ruby ● × Game et Othello (examen de base)
Lier le code Java et C ++ avec SWIG