Verwenden von Mockito zum Nachahmen von Klassen mit generischen Parametern

Gibt es eine saubere Methode, eine Klasse mit generischen Parametern zu verspotten? Angenommen, ich muss eine Klasse verspotten Foo<T> die ich in eine Methode übergeben muss, die a erwartet Foo<Bar>. Folgendes kann ich problemlos tun:

Foo mockFoo = mock(Foo.class);
when(mockFoo.getValue).thenReturn(new Bar());

Vorausgesetzt getValue() gibt den generischen Typ zurück T. Aber das wird Kätzchen haben, wenn ich es später in eine Methode erwarte Foo<Bar>. Ist Casting die einzige Möglichkeit, dies zu tun?

Ich denke, Sie müssen es werfen, aber es sollte nicht so schlimm sein:

Foo<Bar> mockFoo = (Foo<Bar>) mock(Foo.class);
when(mockFoo.getValue()).thenReturn(new Bar());

Eine andere Möglichkeit, dies zu umgehen, ist die Verwendung @Mock Anmerkung statt. Funktioniert nicht in allen Fällen, sieht aber viel sexier aus 🙂

Hier ist ein Beispiel:

@RunWith(MockitoJUnitRunner.class)
public class FooTests {

    @Mock
    public Foo<Bar> fooMock;
    
    @Test
    public void testFoo() {
        when(fooMock.getValue()).thenReturn(new Bar());
    }
}

Das MockitoJUnitRunner initialisiert die mit annotierten Felder @Mock.

Sie könnten immer eine Zwischenklasse/Schnittstelle erstellen, die den generischen Typ erfüllt, den Sie angeben möchten. Wenn beispielsweise Foo eine Schnittstelle wäre, könnten Sie die folgende Schnittstelle in Ihrer Testklasse erstellen.

private interface FooBar extends Foo<Bar>
{
}

In Situationen, in denen Foo a nicht endgültig Klasse, Sie könnten die Klasse einfach mit dem folgenden Code erweitern und dasselbe tun:

public class FooBar extends Foo<Bar>
{
}

Dann könnten Sie eines der obigen Beispiele mit dem folgenden Code verwenden:

Foo<Bar> mockFoo = mock(FooBar.class);
when(mockFoo.getValue()).thenReturn(new Bar());

Ein … kreieren Test-Utility-Methode. Besonders nützlich, wenn Sie es mehr als einmal benötigen.

@Test
public void testMyTest() {
    // ...
    Foo<Bar> mockFooBar = mockFoo();
    when(mockFooBar.getValue).thenReturn(new Bar());

    Foo<Baz> mockFooBaz = mockFoo();
    when(mockFooBaz.getValue).thenReturn(new Baz());

    Foo<Qux> mockFooQux = mockFoo();
    when(mockFooQux.getValue).thenReturn(new Qux());
    // ...
}

@SuppressWarnings("unchecked") // still needed :( but just once :)
private <T> Foo<T> mockFoo() {
    return mock(Foo.class);
}

Ich stimme zu, dass man Warnungen in Klassen oder Methoden nicht unterdrücken sollte, da man andere, versehentlich unterdrückte Warnungen übersehen könnte. Aber IMHO ist es absolut sinnvoll, eine Warnung zu unterdrücken, die nur eine einzige Codezeile betrifft.

@SuppressWarnings("unchecked")
Foo<Bar> mockFoo = mock(Foo.class);

Wie in den anderen Antworten erwähnt, gibt es keine gute Möglichkeit, die zu verwenden mock() & spy() Methoden direkt ohne unsicheren Generika-Zugriff und/oder Unterdrückung von Generika-Warnungen.

Es gibt derzeit ein offenes Problem im Mockito-Projekt (#1531), um Unterstützung für die Verwendung von hinzuzufügen mock() & spy() Methoden ohne Generika-Warnungen. Das Problem wurde im November 2018 eröffnet, aber es gibt keine Hinweise darauf, dass es priorisiert wird. Laut einem der Kommentare des Mockito-Mitarbeiters zu diesem Problem:

Angesichts dessen .class nicht gut mit Generika spielt, glaube ich nicht, dass wir in Mockito eine Lösung finden können. Kannst du schon @Mock (Die JUnit5-Erweiterung erlaubt auch Methodenparameter @Mocks) und das sollte eine geeignete Alternative sein. Daher können wir dieses Problem offen halten, aber angesichts dessen ist es unwahrscheinlich, dass es jemals behoben wird @Mock ist eine bessere API.

Mit JUnit5 denke ich, dass der beste Weg ist, @ExtendWith(MockitoExtension.class) mit @Mock im Methodenparameter oder im Feld zu verwenden.

Das folgende Beispiel zeigt dies mit Hamcrest-Matchern.

package com.vogella.junit5;                                                                    
                                                                                               
import static org.hamcrest.MatcherAssert.assertThat;                                           
import static org.hamcrest.Matchers.hasItem;                                                   
import static org.mockito.Mockito.verify;                                                      
                                                                                               
import java.util.Arrays;                                                                       
import java.util.List;                                                                         
                                                                                               
import org.junit.jupiter.api.Test;                                                             
import org.junit.jupiter.api.extension.ExtendWith;                                             
import org.mockito.ArgumentCaptor;                                                             
import org.mockito.Captor;                                                                     
import org.mockito.Mock;                                                                       
import org.mockito.junit.jupiter.MockitoExtension;                                             
                                                                                               
@ExtendWith(MockitoExtension.class)                                                            
public class MockitoArgumentCaptureTest {                                                      
                                                                                               
                                                                                               
    @Captor                                                                                    
    private ArgumentCaptor<List<String>> captor;                                               
                                                                                               
    @Test                                                                                      
    public final void shouldContainCertainListItem(@Mock List<String> mockedList) {            
        var asList = Arrays.asList("someElement_test", "someElement");                         
        mockedList.addAll(asList);                                                             
                                                                                               
        verify(mockedList).addAll(captor.capture());                                           
        List<String> capturedArgument = captor.getValue();                                     
        assertThat(capturedArgument, hasItem("someElement"));                                  
    }                                                                                          
}                                                                                              
                                                                                              

Sehen https://www.vogella.com/tutorials/Mockito/article.html für die erforderlichen Maven/Gradle-Abhängigkeiten.