Używanie Mockito do kpienia z klas za pomocą ogólnych parametrów

Czy istnieje czysta metoda wyśmiewania klasy za pomocą ogólnych parametrów? Powiedz, że muszę wyśmiewać klasę, Foo<T>którą muszę przekazać do metody, która oczekuje Foo<Bar>. Z łatwością mogę wykonać następujące czynności:

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

Zakładając, getValue()zwraca typ ogólny T. Ale to będzie miało kocięta, kiedy później przekażę to do metody, która się spodziewa Foo<Bar>. Czy casting jest jedynym sposobem na zrobienie tego?

Myślę, że musisz go rzucić, ale nie powinno być tak źle:

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

Innym sposobem jest użycie @Mockadnotacji. Nie działa we wszystkich przypadkach, ale wygląda o wiele bardziej seksownie :)

Oto przykład:

@RunWith(MockitoJUnitRunner.class)
public class FooTests {

    @Mock
    public Foo<Bar> fooMock;

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

MockitoJUnitRunnerInicjuje pola z adnotacjami @Mock.

Zawsze możesz utworzyć klasę pośrednią / interfejs, który spełnia typ ogólny, który chcesz określić. Na przykład, jeśli Foo był interfejsem, możesz utworzyć następujący interfejs w swojej klasie testowej.

private interface FooBar extends Foo<Bar>
{
}

W sytuacjach, gdzie Foo jest non-final class, można po prostu rozszerzyć klasę z następującego kodu i zrobić to samo:

public class FooBar extends Foo<Bar>
{
}

Następnie możesz wykorzystać jeden z powyższych przykładów z następującym kodem:

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

Utwórz testową metodę narzędzia . Szczególnie przydatne, jeśli potrzebujesz go więcej niż raz.

@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);
}

Zgadzam się, że nie należy tłumić ostrzeżeń w klasach lub metodach, ponieważ można przeoczyć inne, przypadkowo tłumione ostrzeżenia. Ale IMHO jest absolutnie uzasadnione, aby ukryć ostrzeżenie, które dotyczy tylko jednego wiersza kodu.

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

Oto ciekawy przypadek: metoda odbiera ogólną kolekcję i zwraca ogólną kolekcję tego samego typu podstawowego. Na przykład:

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

Metodę tę można wyśmiewać za pomocą kombinacji Mockito anyCollectionOf matcher i Answer.

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