C'est un résumé pour moi. Décrit comment créer un test unitaire Java à l'aide de la bibliothèque suivante. --JUnit (cadre de test) --Mockito (cadre de création Mock) --PowerMock (cadre d'extension Mockito)
J'ai utilisé Gradle pour télécharger les fichiers nécessaires (JUnit, Mockito, PowerMock). Le contenu du fichier de paramètres est le suivant.
build.gradle
apply plugin: 'java'
repositories {
jcenter()
}
dependencies {
testCompile 'junit:junit:4.12'
testCompile "org.mockito:mockito-core:2.+"
testCompile 'org.powermock:powermock-module-junit4:2.0.0-RC.4'
testCompile 'org.powermock:powermock-api-mockito2:2.0.0-RC.4'
}
C'est la classe à tester. Envisagez d'utiliser JUnit, Mockito et PowerMock pour cette classe.
Samole.java
public class Sample {
private Sub sub;
public Sample() {}
public Sample(Sub sub) {
this.sub = sub;
}
public String pubGet() {
return "pubGet";
}
public String pubGet(String suffix) {
return pubGet() + suffix;
}
public String pubGetSubValue() {
return sub.getValue();
}
public String pubGetStaticValue() {
return Static.getValue();
}
private String priGet() {
return "priGet";
}
private String priGet(String suffix) {
return priGet() + suffix;
}
public static class Sub {
private String value;
public Sub(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
public static class Static {
public static String getValue() {
return "Static value";
}
}
}
Lorsque vous utilisez uniquement JUnit.
SampleTest.java
import org.junit.Before;
import org.junit.Test;
import java.lang.reflect.Method;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.*;
public class SampleTest {
private Sample instance;
@Before
public void init() {
this.instance = new Sample();
}
@Test
public void pubGet() {
//Test de méthode publique
String actual = instance.pubGet();
assertThat(actual, is("pubGet"));
}
@Test
public void priGet() throws Exception {
//Test de méthode privée (sans arguments)
Method method = Sample.class.getDeclaredMethod("priGet");
method.setAccessible(true);
String actual = (String) method.invoke(instance);
assertThat(actual, is("priGet"));
}
@Test
public void priGet_withArg() throws Exception {
//Test de méthode privée (avec arguments)
Method method = Sample.class.getDeclaredMethod("priGet", String.class);
method.setAccessible(true);
String actual = (String) method.invoke(instance, "Suffix");
assertThat(actual, is("priGetSuffix"));
}
@Test
public void pubGetSubValue() {
Sample instance = new Sample(new Sample.Sub("test"));
String actual = instance.pubGetSubValue();
assertThat(actual, is("test"));
}
}
Lorsque Mockito est ajouté. Vous pouvez réécrire le contenu de la méthode à l'aide d'un simulacre.
SampleForMockitoTest.java
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.*;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class SampleForMockitoTest {
@Mock
private Sample mock;
@Spy
private Sample spy;
@Before
public void init() {
// @Initialiser l'objet fictif de l'annotation fictive
MockitoAnnotations.initMocks(this);
}
@Test
public void pubGetSubValue() {
//Lorsque vous n'utilisez pas de maquette
Sample instance = new Sample(new Sample.Sub("test"));
String actual = instance.pubGetSubValue();
assertThat(actual, is("test"));
}
@Test
public void pubGetSubValue_withMockito() {
//Renvoie la valeur du stub lors de l'utilisation d'un simulacre
Sample.Sub mock = mock(Sample.Sub.class);
when(mock.getValue()).thenReturn("mock value");
Sample instance = new Sample(mock);
String actual = instance.pubGetSubValue();
assertThat(actual, is("mock value"));
}
@Test
public void pubGetSubValue_withMockitoMock() {
// mock()Sera la valeur par défaut (null) si le stub n'est pas implémenté
String actual1 = mock.pubGet();
assertThat(actual1, is(nullValue()));
// mock()Renvoie la valeur du stub lors de l'implémentation du stub
when(mock.pubGet()).thenReturn("mock value");
String actual2 = mock.pubGet();
assertThat(actual2, is("mock value"));
}
@Test
public void pubGetSubValue_withMockitoSpy() {
// spy()Renvoie la valeur réelle sans implémenter le stub
String actual1 = spy.pubGet();
assertThat(actual1, is("pubGet"));
// spy()Renvoie la valeur du stub lors de l'implémentation du stub
when(spy.pubGet()).thenReturn("mock value");
String actual2 = spy.pubGet();
assertThat(actual2, is("mock value"));
}
@Test
public void pubGetSubValue_withMockitoAnswer() {
// mock()Renvoie la valeur du stub lors de l'implémentation du stub
//Answer vous permet d'utiliser des arguments de méthode pour les stubs
when(mock.pubGet(anyString())).thenAnswer(invocation -> {
String arg1 = (String) invocation.getArguments()[0];
return "mock value " + arg1;
});
String actual = mock.pubGet("suffix");
assertThat(actual, is("mock value suffix"));
}
}
Lorsque PowerMock est ajouté.
Vous pouvez réécrire le contenu de la méthode static.
SamleForPowerMockTest.java
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
@RunWith(PowerMockRunner.class)
@PrepareForTest({Sample.Static.class})
public class SamleForPowerMockTest {
private Sample instance;
@Before
public void init() {
instance = new Sample();
}
@Test
public void pubGetWithStatic() {
//Tester la valeur de la méthode statique
String actual = instance.pubGetStaticValue();
assertThat(actual, is("Static value"));
}
@Test
public void pubGetWithStatic_withPowerMock() {
// mockStatic()La méthode statique renvoie la valeur de stub dans
PowerMockito.mockStatic(Sample.Static.class);
//Si vous souhaitez que le comportement d'origine soit différent de la méthode souhaitée, utilisez plutôt PowerMockito.spy()utilisation
// PowerMockito.spy(Sample.Static.class);
PowerMockito.when(Sample.Static.getValue()).thenReturn("PowerMockito value");
String actual = instance.pubGetStaticValue();
assertThat(actual, is("PowerMockito value"));
}
}
PowerMock permet une réécriture puissante. Cependant, si vous comptez trop sur PowerMock, vous perdez de vue son objectif initial (implémentation extensible). J'ai également ressenti le danger d'être un test qui n'a fait que gagner en couverture, il semble donc préférable de réfléchir à où l'utiliser.
J'ai fait référence à Utilisation correcte de Mockito et PowerMock.
Recommended Posts