Ich habe mich für ** JUnit + Mockito + PowerMock ** in dem Projekt entschieden, an dem ich gerade arbeite. Erstens ist mir alles unbekannt, was JUnit selbst noch nie berührt hat.
Selbst wenn Sie gg mit "** Mockito **" versuchen, gibt es nur wenige Artikel, die erklären, dass Leute ohne Wissen es sofort verwenden können. Oder besser gesagt ** Ich habe nicht viel Japanisch! ** **. Ohne Erklärung auf Japanisch ist es schwer zu verstehen. ..
Also schreibe ich diesen Artikel für mich, der nichts wusste, weil ich kürzlich endlich ein bisschen geschluckt habe.
Diesmal ist ** Mockito ** Edition.
Insbesondere werde ich über den Fall schreiben, in dem Sie eine Methode einer Klasse verspotten möchten, die sich von der zu testenden Klasse unterscheidet.
Erstens gibt es viele Dinge, die Mockito nicht kann. Es ist nicht allzweckmäßig und es gibt nur eine begrenzte Anzahl von Methoden, die verspottet werden können. Ich kann es nicht verspotten
Dies sind die oben genannten vier Typen. (Vielleicht) Ich denke auch, dass abstrakte Klassen nicht verspottet werden konnten. (Vielleicht)
Ansonsten können Sie es grundsätzlich mit mockito (vielleicht) verspotten. Um die obigen vier zu verspotten, müssen Sie "PowerMock" getrennt von Mockito verwenden.
Um eine verspottete Methode aufzurufen, verspotten Sie zunächst die Klasse. Es gibt ** 2 Arten von Verspottungsmethoden **. Nur einer von ihnen ist in Ordnung.
** ① Direkt unter der Klasse @ Mock **
** ② Verwenden Sie die mock () Methode **
Java
public class TestClass {
//① Direkt unter der Klasse@Deklaration der Scheininstanz in Mock
@Mock
private Entity entity; //Dies ist nur eine Deklaration, es wird kein Scheinobjekt erstellt
@Test
public void test001() {
// ② mock()Verwenden Sie die Methode
Entity entity = mock(Entity.class); //Dies allein erzeugt ein Scheinobjekt
}
}
Im Fall von ** ① ** muss diese getrennt von dieser Deklaration initialisiert werden. ** ② ** verspotten Sie die Klasse jedes Mal in der Testklasse. Es muss nicht initialisiert werden.
Im Fall von @ Mock von ** ① ** wurde das Scheinobjekt noch nicht erstellt, daher muss ** initialisiert ** werden.
Java
public class class() {
// @Scheinmuster
@Mock
private ResultEntity entity;
@Before // @Vor Annotation hinzufügen und jede Testmethode vor der Ausführung ausführen.
private void initMocks() {
MockitoAnnotations.initMocks(this); //Initialisierungsmagie
}
}
Ich denke, die ** ① ** Methode ist effektiv, wenn ** es mehrere Testfälle gibt und die Klasse, die Sie verspotten möchten, viele Male erscheint **.
Verwenden Sie die Annotation @ InjectMocks, um einen Mock in die zu testende Klasse direkt unter der Testklasse einzufügen.
public class TestClass {
@Mock
Entity entity; //Verspottete Klasse
@InjectMocks
Human human; //Injizieren Sie Mock in die zu testende Klasse
}
Derzeit ist es möglich, es zu verspotten und dann zu testen. Wenn Sie eine Abdeckung erhalten, ** beträgt diese nicht 100%, es sei denn, die Instanz der zu testenden Klasse heißt **. Wenn Sie also die Abdeckung auf 100% setzen möchten.
@InjectMocks
Human human = new Human();
Es ist okay, so zu schreiben.
Nachdem wir die Klasse verspottet haben, werden wir die Methode für jeden der folgenden Fälle tatsächlich verspotten.
public String etc.
In diesem Fall gibt es ~~ warum ~~ ** 2 Arten **, wie man die Methode verspottet.
Mockito.when(Scheininstanz).Methode(Willkürliches Argument).thenReturn(Beliebiger Rückgabewert);
//Gibt diese Rückgabe zurück, wenn die Methode der verspotteten Klasse aufgerufen wird
Die Methode wird jetzt verspottet, und die Methode wird nicht tatsächlich ausgeführt und ist nur eine Verspottung, die einen beliebigen Rückgabewert zurückgibt.
Übrigens kann der "Mockito" im Kopf mit oder ohne sein.
Da PowerMock auf die gleiche Weise geschrieben ist, ** ist es notwendig, es richtig zu verwenden, wenn es gleichzeitig verwendet wird **, daher denke ich, dass es leichter zu verstehen ist, wenn Sie es in Ihren Kopf stecken.
Mockito.doReturn(Beliebiger Rückgabewert).when(Scheininstanz).Methode(Willkürliches Argument);
//Ich werde diesen Rückgabewert zurückgeben, wenn die Methode der verspotteten Klasse aufgerufen wird
Sowohl ① als auch ② verhalten sich genau gleich. Wie unten erläutert, ist die ** dann-Methode möglicherweise nicht in der Lage, damit umzugehen **. Es scheint also, dass kein Fehler vorliegt, wenn Sie sie mit der do-Methode vereinheitlichen.
public void In diesem Fall kann es nur mit der ** do-Methode ** beschrieben werden.
Mockito.doNothing().when(Scheininstanz).Methode(Willkürliches Argument);
//Es wird nichts zurückgegeben, wenn eine Scheinklassenmethode aufgerufen wird
Es scheint keine Methode namens thenNothing () zu geben.
Da die Methode verspottet wurde, muss sie nicht überprüft werden, aber ich denke, es muss überprüft werden, ob die an die verspottete ** Methode übergebenen Argumente korrekt sind **.
In einem solchen Fall können Sie "ArgumentCaptor" verwenden.
ArgumentCaptor<Schimmel>Variable= ArgumentCaptor.forClass(Schimmel.class);
// forClass()Erstellen Sie einen Container (eine Variable) dieses Typs mit einer Methode
Wenn Sie die obige Variable beim Verspotten einer Methode als Argument übergeben, wird das tatsächlich übergebene Argument erfasst und in der Variablen gespeichert. Fügen Sie zu diesem Zeitpunkt die Methode 'capture ()' hinzu.
Mockito.doReturn("Rückgabewert").when(Klasse).Methode(Variable.capture());
// forClass()Erstellen Sie einen Container (eine Variable) dieses Typs mit einer Methode
Die Variable enthält jetzt die in der tatsächlichen Quelle übergebenen Argumente.
Variable.getValue(); // ①
Variable.getAllValues().get(index); // ②
Mit einer dieser Methoden können Sie den Wert entsprechend dem Typ der Variablen abrufen.
** ① ** Wenn Sie nur ein Argument überprüfen möchten, können Sie die von der Methode getValue () gespeicherten Informationen abrufen.
** ② ** ArgumentCaptor kann viele Male an ** Argumente übergeben werden und so viele Ergebnisse speichern, wie Argumente vorhanden sind **. (Nur für den gleichen Typ.)
In diesem Fall wird es in Form eines Arrays gespeichert. Rufen Sie daher alle Werte mit der Methode getAllValues () ab. Sie können den Wert eines von ihnen mit get (index) abrufen.
Wenn Sie die Variablen wiederverwenden, ist es tatsächlich schwierig zu bestimmen, welche Nummer zu welchem Argument gehört. Deklarieren Sie also im Grunde ** den Inhalt von ArgumentCaptor so viele wie die Anzahl der Argumente ** Ich denke, es ist besser, es zu tun.
ArgumentCaptor<String> str = ArgumentCaptor.forClass(String.class);
Mockito.doReturn("Rückgabewert").when(Class).getStr(str.capture());
assertTaht(str.getValue(), is(Erwarteter Wert des Arguments));
Ich denke, es wird so aussehen.
Wenn Sie eine Methode verspotten, wird sie tatsächlich nicht aufgerufen. Daher müssen Sie möglicherweise ** überprüfen, ob die verspottete Methode ordnungsgemäß aufgerufen wird **.
Zu diesem Zeitpunkt wird die Methode "verify ()" verwendet.
Mockito.verify(Scheininstanz, times(index)).Scheinmethode(Streit);
Sie können überprüfen, wie oft die Methode aufgerufen wurde, indem Sie den erwarteten Wert als Scheininstanz als erstes Argument der Methode "verify ()", die Methode "times ()" als zweites Argument und int als Argument übergeben.
Was meinst du
Das Verspotten einer Methode ohne Rückgabewert erfolgt wie unter [Für eine öffentliche void-Methode ohne Rückgabewert](# Für eine öffentliche void-Methode ohne Rückgabewert) beschrieben.
Wenn Sie die Anzahl der Methodenaufrufe überprüfen möchten, müssen Sie nicht sowohl "doNothing ()" als auch "verify ()" ausführen. Sie können beide gleichzeitig mit nur ** "verify ()" ausführen. ** **.
Anstatt es gleichzeitig zu tun, bedeutet dies, dass es zum Zeitpunkt von ** verify () ** als Methode ohne Rückgabewert verspottet wurde.
Beachten Sie jedoch, dass ** eine Methode mit einem Rückgabewert nicht mit verify () ** verspottet werden kann.
Dies liegt daran, dass verify () ** den Rückgabewert ** nicht verspotten kann.
// doNothing()Auch wenn Sie nicht verspotten, ist dies in Ordnung
Mockito.verify(Scheininstanz, times(index)).Scheinmethode();
Übrigens im obigen Fall +, wenn Sie das Argument überprüfen möchten
// doNothing()Auch wenn Sie nicht verspotten, ist dies in Ordnung
Mockito.verify(Scheininstanz, times(index)).Scheinmethode(Variable.capture());
Auf diese Weise kann das Argument auch zu diesem Zeitpunkt gespeichert werden.
Wenn Sie sich an diese erinnern, werden Sie wahrscheinlich bis zu einem gewissen Grad kämpfen können. Ich habe vor, in Zukunft Verspottungen über andere Methoden derselben Klasse und Verspottungen über neue Methoden zu schreiben.
[Java] Wie man Mockito trinkt (Einführung)
Recommended Posts