├── 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));
}
}
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
Recommended Posts