Utilisation de Mockito pour simuler des classes avec des paramètres génériques

Existe-t-il une méthode propre de se moquer d'une classe avec des paramètres génériques? Disons que je dois me moquer d'une classe Foo<T>que je dois passer dans une méthode qui attend a Foo<Bar>. Je peux faire ce qui suit assez facilement:

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

En supposant que getValue()renvoie le type générique T. Mais ça va avoir des chatons quand je le passerai plus tard dans une méthode attendante Foo<Bar>. Le casting est-il le seul moyen d'y parvenir?

Je pense que vous devez le lancer, mais ça ne devrait pas être trop mal:

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

Une autre solution consiste à utiliser à la @Mockplace des annotations. Ne fonctionne pas dans tous les cas, mais semble beaucoup plus sexy :)

Voici un exemple:

@RunWith(MockitoJUnitRunner.class)
public class FooTests {

    @Mock
    public Foo<Bar> fooMock;

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

Le MockitoJUnitRunnerinitialise les champs annotés avec @Mock.

Vous pouvez toujours créer une classe / interface intermédiaire qui satisferait le type générique que vous souhaitez spécifier. Par exemple, si Foo était une interface, vous pouvez créer l'interface suivante dans votre classe de test.

private interface FooBar extends Foo<Bar>
{
}

Dans les situations où Foo est une classe non finale , vous pouvez simplement étendre la classe avec le code suivant et faire la même chose:

public class FooBar extends Foo<Bar>
{
}

Ensuite, vous pouvez utiliser l'un des exemples ci-dessus avec le code suivant:

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

Créez une méthode utilitaire de test . Particulièrement utile si vous en avez besoin plusieurs fois.

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

Je suis d'accord qu'il ne faut pas supprimer les avertissements dans les classes ou les méthodes car on pourrait ignorer d'autres avertissements supprimés accidentellement. Mais à mon humble avis, il est absolument raisonnable de supprimer un avertissement qui affecte uniquement une seule ligne de code.

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

Voici un cas intéressant: la méthode reçoit une collection générique et retourne une collection générique du même type de base. Par exemple:

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

Cette méthode peut être simulée avec la combinaison de Mockito anyCollectionOf matcher et de 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>();
         }
     });