Verwenden von Mockito zum Verspotten 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 an eine Methode übergeben muss, die a erwartet Foo<Bar>. Ich kann Folgendes leicht genug tun:

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

Angenommen, es wird getValue()der generische Typ zurückgegeben T. Aber das wird Kätzchen haben, wenn ich es später in eine erwartete Methode übergebe Foo<Bar>. Ist Casting das einzige Mittel, um dies zu tun?

Ich denke, Sie müssen es besetzen, 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 @Mockumgehen, besteht darin, stattdessen Anmerkungen zu verwenden. Funktioniert nicht in allen Fällen, sieht aber viel sexy 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 MockitoJUnitRunnerinitialisiert die mit Anmerkungen versehenen Felder @Mock.

Sie können jederzeit eine Zwischenklasse / Schnittstelle erstellen, die dem generischen Typ entspricht, den Sie angeben möchten. Wenn Foo beispielsweise 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 eine nicht endgültige Klasse ist, können Sie 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());

Erstellen Sie eine Testdienstprogrammmethode . Besonders nützlich, wenn Sie es mehrmals 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 bin damit einverstanden, dass man Warnungen in Klassen oder Methoden nicht unterdrücken sollte, da man andere, versehentlich unterdrückte Warnungen übersehen könnte. Aber meiner Meinung nach ist es absolut vernünftig, eine Warnung zu unterdrücken, die nur eine einzige Codezeile betrifft.

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

Hier ist ein interessanter Fall: Die Methode empfängt eine generische Sammlung und gibt eine generische Sammlung desselben Basistyps zurück. Beispielsweise:

Collection<? extends Assertion> map(Collection<? extends Assertion> assertions);

Diese Methode kann mit einer Kombination aus Mockito anyCollectionOf Matcher und der Antwort verspottet werden.

when(mockedObject.map(anyCollectionOf(Assertion.class))).thenAnswer(
     new Answer<Collection<Assertion>>() {
         @Override
         public Collection<Assertion> answer(InvocationOnMock invocation) throws Throwable {
             return new ArrayList<Assertion>();
         }
     });