Es ist eine Zusammenfassung für mich. Beschreibt das Erstellen eines Java-Komponententests mithilfe der folgenden Bibliothek. --JUnit (Testing Framework) --Mockito (Mock Creation Framework) --PowerMock (Mockito-Erweiterungsframework)
Ich habe Gradle verwendet, um die erforderlichen Dateien (JUnit, Mockito, PowerMock) herunterzuladen. Der Inhalt der Einstellungsdatei ist wie folgt.
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'
}
Dies ist die zu testende Klasse. Erwägen Sie die Verwendung von JUnit, Mockito und PowerMock für diese Klasse.
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";
}
}
}
Wenn Sie nur JUnit verwenden.
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() {
//Öffentlicher Methodentest
String actual = instance.pubGet();
assertThat(actual, is("pubGet"));
}
@Test
public void priGet() throws Exception {
//Privater Methodentest (keine Argumente)
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 {
//Privater Methodentest (mit Argumenten)
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"));
}
}
Wenn Mockito hinzugefügt wird. Sie können den Inhalt der Methode mit einem Mock umschreiben.
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() {
// @Initialisieren Sie das Scheinobjekt der Scheinanmerkung
MockitoAnnotations.initMocks(this);
}
@Test
public void pubGetSubValue() {
//Wenn Sie kein Modell verwenden
Sample instance = new Sample(new Sample.Sub("test"));
String actual = instance.pubGetSubValue();
assertThat(actual, is("test"));
}
@Test
public void pubGetSubValue_withMockito() {
//Gibt den Wert des Stubs zurück, wenn ein Mock verwendet wird
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()Wird der Standardwert (null) sein, wenn stub nicht implementiert ist
String actual1 = mock.pubGet();
assertThat(actual1, is(nullValue()));
// mock()Gibt den Wert des Stubs zurück, wenn der Stub implementiert wird
when(mock.pubGet()).thenReturn("mock value");
String actual2 = mock.pubGet();
assertThat(actual2, is("mock value"));
}
@Test
public void pubGetSubValue_withMockitoSpy() {
// spy()Gibt den tatsächlichen Wert zurück, ohne den Stub zu implementieren
String actual1 = spy.pubGet();
assertThat(actual1, is("pubGet"));
// spy()Gibt den Wert des Stubs zurück, wenn der Stub implementiert wird
when(spy.pubGet()).thenReturn("mock value");
String actual2 = spy.pubGet();
assertThat(actual2, is("mock value"));
}
@Test
public void pubGetSubValue_withMockitoAnswer() {
// mock()Gibt den Wert des Stubs zurück, wenn der Stub implementiert wird
//Mit Antwort können Sie Methodenargumente für Stubs verwenden
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"));
}
}
Wenn PowerMock hinzugefügt wird. Sie können den Inhalt der statischen Methode neu schreiben.
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() {
//Testen Sie den Wert der statischen Methode
String actual = instance.pubGetStaticValue();
assertThat(actual, is("Static value"));
}
@Test
public void pubGetWithStatic_withPowerMock() {
// mockStatic()Die statische Methode gibt den Stub-Wert in zurück
PowerMockito.mockStatic(Sample.Static.class);
//Wenn Sie das ursprüngliche Verhalten anders als die gewünschte Methode wünschen, verwenden Sie stattdessen PowerMockito.spy()verwenden
// PowerMockito.spy(Sample.Static.class);
PowerMockito.when(Sample.Static.getValue()).thenReturn("PowerMockito value");
String actual = instance.pubGetStaticValue();
assertThat(actual, is("PowerMockito value"));
}
}
PowerMock ermöglicht ein leistungsstarkes Umschreiben. Wenn Sie sich jedoch zu sehr auf PowerMock verlassen, verlieren Sie den ursprünglichen Zweck aus den Augen (erweiterbare Implementierung). Ich hatte auch das Risiko, ein Test zu sein, der nur in den Vordergrund gerückt ist. Daher scheint es besser, darüber nachzudenken, wo ich ihn verwenden soll.
Ich habe auf [Verwendung von Mockito und PowerMock ordnungsgemäß] verwiesen (https://qiita.com/euledge/items/a224777c15ae7145114a).
Recommended Posts