Frage @RunWith (MockitoJUnitRunner.class) vs MockitoAnnotations.initMocks (dies)


Beim Schreiben eines neuen jUnit4-Tests frage ich mich, ob ich ihn verwenden soll @RunWith (MockitoJUnitRunner.class)  oder MockitoAnnotations.initMocks (dies).

Ich habe einen neuen Test erstellt und der Assistent hat automatisch einen Test mit dem Runner erstellt. Javadocs für MockitoJUnitRunner sagen folgendes:

Dieser Runner ist kompatibel mit JUnit 4.4 und höher und fügt folgendes Verhalten hinzu:

Initialisiert mit Mock annotierte Mocks, sodass eine explizite Verwendung von MockitoAnnotations.initMocks (Object) nicht erforderlich ist. Mocks werden vor jeder Testmethode initialisiert.   validiert die Framework-Verwendung nach jeder Testmethode.

Es ist mir nicht klar, ob die Verwendung des Runner einen Vorteil gegenüber der initMocks () Methode, die ich in der Vergangenheit verwendet habe.

Irgendwelche Gedanken oder Verbindungen würden geschätzt werden!


76
2018-05-29 20:34


Ursprung


Antworten:


MockitoJUnitRunner gibt Ihnen eine automatische Validierung der Framework-Nutzung, sowie eine automatische initMocks().

Die automatische Validierung der Framework-Nutzung lohnt sich. Es gibt Ihnen eine bessere Berichterstattung, wenn Sie einen dieser Fehler machen.

  • Du nennst das Statische when Methode, aber nicht das Stubbing mit einem Abgleich abschließen thenReturn, thenThrow oder then. (Fehler 1 im folgenden Code)

  • Du rufst an verify auf einen Schein, aber vergessen, den Methodenaufruf bereitzustellen die du versuchst zu überprüfen. (Fehler 2 im folgenden Code)

  • Du rufst das an when Methode nach doReturn, doThrow oder doAnswer und einen Schein überholen, aber vergessen, die Methode dafür zu liefern du versuchst zu stubsen. (Fehler 3 im folgenden Code)

Wenn Sie die Verwendung des Frameworks noch nicht validiert haben, werden diese Fehler erst im Folgendes Rufen Sie eine Mockito-Methode auf. Das könnte sein

  • in der gleichen Testmethode (wie Fehler 1 unten),
  • in der nächsten Testmethode (wie Fehler 2 unten),
  • in der nächsten Testklasse.

Wenn sie im letzten von Ihnen ausgeführten Test auftreten (wie Fehler 3 unten), werden sie überhaupt nicht gemeldet.

Hier ist, wie jeder dieser Arten von Fehlern aussehen könnte. Angenommen, JUnit führt diese Tests in der Reihenfolge aus, in der sie hier aufgeführt sind.

@Test
public void test1() {

    // ERROR 1
    // This compiles and runs, but it's an invalid use of the framework because 
    // Mockito is still waiting to find out what it should do when myMethod is called.
    // But Mockito can't report it yet, because the call to thenReturn might 
    // be yet to happen.
    when(myMock.method1());

    doSomeTestingStuff();

    // ERROR 1 is reported on the following line, even though it's not the line with
    // the error.
    verify(myMock).method2();

}

@Test
public void test2() {

    doSomeTestingStuff();

    // ERROR 2
    // This compiles and runs, but it's an invalid use of the framework because
    // Mockito doesn't know what method call to verify.  But Mockito can't report 
    // it yet, because the call to the method that's being verified might 
    // be yet to happen.
    verify(myMock);
}

@Test
public void test3() {

    // ERROR 2 is reported on the following line, even though it's not even in 
    // the same test as the error.
    doReturn("Hello").when(myMock).method1();


    // ERROR 3
    // This compiles and runs, but it's an invalid use of the framework because
    // Mockito doesn't know what method call is being stubbed.  But Mockito can't 
    // report it yet, because the call to the method that's being stubbed might 
    // be yet to happen.

    doReturn("World").when(myMock);

    doSomeTestingStuff(); 

    //  ERROR 3 is never reported, because there are no more Mockito calls. 
}

Als ich diese Antwort vor mehr als fünf Jahren schrieb, schrieb ich

Also ich würde die Verwendung der. Empfehlen MockitoJUnitRunner woimmer möglich. Tomasz Nurkiewicz hat jedoch richtig darauf hingewiesen, dass Sie es nicht verwenden können, wenn Sie einen anderen JUnit-Läufer wie den Spring benötigen.

Meine Empfehlung hat sich geändert. Das Mockito-Team hat ein neues Feature hinzugefügt, seit ich diese Antwort geschrieben habe. Es ist eine JUnit-Regel, die genau die gleiche Funktion wie die MockitoJUnitRunner. Aber es ist besser, weil es den Einsatz anderer Läufer nicht ausschließt.

Einschließen

@Rule 
public MockitoRule rule = MockitoJUnit.rule();

in deiner Testklasse. Dies initialisiert die Mocks und automatisiert die Rahmenvalidierung; so wie MockitoJUnitRunner tut. Aber jetzt können Sie verwenden SpringJUnit4ClassRunner oder irgendeinen anderen JUnitRunner. Ab Mockito 2.1.0 gibt es zusätzliche Optionen, die genau steuern, welche Art von Problemen gemeldet werden.


95
2018-05-30 08:36



Mit Runner können Sie ein wenig Code sparen (keine Notwendigkeit für @Before Methode). Andererseits ist die Verwendung eines Läufers manchmal nicht möglich, d. H. Wenn Sie bereits einen verwenden, wie z SpringJUnit4ClassRunner.

Das ist es. Es ist nur eine Frage der Präferenz.


23
2018-05-29 20:40