Méthodes simulées de Mockito

1. Vue d'ensemble

Ce didacticiel illustre diverses utilisations des méthodes de simulation statiques standard de l' API Mockito .

Comme pour d'autres articles axés sur le framework Mockito (comme Mockito Verify ou Mockito When / Then), la classe MyList ci-dessous sera utilisée comme collaborateur à simuler dans les cas de test:

public class MyList extends AbstractList { @Override public String get(int index) { return null; } @Override public int size() { return 1; } }

2. Simulation simple

La variante surchargée la plus simple de la méthode fictive est celle avec un seul paramètre pour la classe à simuler:

public static  T mock(Class classToMock)

Nous utiliserons cette méthode pour simuler une classe et définir une attente:

MyList listMock = mock(MyList.class); when(listMock.add(anyString())).thenReturn(false);

Ensuite, exécutez une méthode sur la maquette:

boolean added = listMock.add(randomAlphabetic(6));

Le code suivant confirme que la méthode add a été appelée sur la maquette et que l'appel renvoie une valeur qui correspond à l'attente que nous avons définie auparavant:

verify(listMock).add(anyString()); assertThat(added, is(false));

3. Se moquer du nom de simulacre

Dans cette section, nous allons couvrir une autre variante de la méthode mock qui est fournie avec un argument spécifiant le nom du mock:

public static  T mock(Class classToMock, String name)

D'une manière générale, le nom d'une maquette n'a rien à voir avec le code de travail, mais peut être utile en matière de débogage, où le nom de la maquette est utilisé pour détecter les erreurs de vérification.

Pour nous assurer que le nom fourni d'un simulacre est inclus dans le message d'une exception levée suite à une vérification infructueuse, nous nous baserons sur une implémentation JUnit de l' interface TestRul e, appelée ExpectedException , et l'inclurons dans une classe de test:

@Rule public ExpectedException thrown = ExpectedException.none();

Cette règle sera utilisée pour gérer les exceptions levées par les méthodes de test.

Dans le code suivant, nous créons une maquette pour la classe MyList et la nommons myMock :

MyList listMock = mock(MyList.class, "myMock");

Ensuite, définissez une attente sur une méthode du simulacre et exécutez-la:

when(listMock.add(anyString())).thenReturn(false); listMock.add(randomAlphabetic(6));

Nous allons créer une vérification ayant échoué intentionnellement qui devrait lever une exception avec le message contenant des informations sur le simulacre. Pour ce faire, les attentes sur l'exception doivent d'abord être définies:

thrown.expect(TooLittleActualInvocations.class); thrown.expectMessage(containsString("myMock.add"));

La vérification suivante doit échouer et lancer une exception correspondant à ce qui était attendu:

verify(listMock, times(2)).add(anyString());

Voici le message de l'exception levée:

org.mockito.exceptions.verification.TooLittleActualInvocations: myMock.add(); Wanted 2 times: at com.baeldung.mockito.MockitoMockTest .whenUsingMockWithName_thenCorrect(MockitoMockTest.java:...) but was 1 time: at com.baeldung.mockito.MockitoMockTest .whenUsingMockWithName_thenCorrect(MockitoMockTest.java:...)

Comme nous pouvons le voir, le nom du simulacre a été inclus dans le message d'exception, ce qui sera utile pour trouver le point d'échec en cas d'échec de la vérification.

4. Se moquer avec réponse

Ici, nous allons démontrer l'utilisation d'une variante fictive dans laquelle la stratégie pour les réponses fictives à l'interaction est configurée au moment de la création. Cette maquette de la signature de la méthode dans l'apparence de documentation Mockito comme suit:

public static  T mock(Class classToMock, Answer defaultAnswer)

Commençons par la définition d'une implémentation de l' interface Answer :

class CustomAnswer implements Answer { @Override public Boolean answer(InvocationOnMock invocation) throws Throwable { return false; } }

La classe CustomAnswer ci-dessus est utilisée pour la génération d'une maquette:

MyList listMock = mock(MyList.class, new CustomAnswer());

Si nous ne définissons pas une attente sur une méthode, la réponse par défaut, qui a été configurée par le type CustomAnswer , entrera en jeu. Afin de le prouver, nous allons sauter l'étape de définition des attentes et passer à l'exécution de la méthode:

boolean added = listMock.add(randomAlphabetic(6));

La vérification et l'assertion suivantes confirment que la méthode fictive avec un argument Answer a fonctionné comme prévu:

verify(listMock).add(anyString()); assertThat(added, is(false));

5. Mocking avec MockSettings

La dernière maquette procédé qui est couvert dans cet article est la variante avec un paramètre du MockSettings de type. Cette méthode surchargée est utilisée pour fournir une maquette non standard.

Il existe plusieurs paramètres personnalisés pris en charge par les méthodes de l' interface MockSettings , tels que l'enregistrement d'un écouteur pour les appels de méthode sur la maquette actuelle avec invocationListeners , la configuration de la sérialisation avec serializable , la spécification de l'instance à espionner avec spiedInstance , la configuration de Mockito pour tenter d'utiliser un constructeur lors de l'instanciation d'une maquette avec useConstructor et quelques autres.

Pour plus de commodité, nous réutiliserons la classe CustomAnswer introduite dans la section précédente pour créer une implémentation MockSettings qui définit une réponse par défaut.

Un objet MockSettings est instancié par une méthode de fabrique comme suit:

MockSettings customSettings = withSettings().defaultAnswer(new CustomAnswer());

Cet objet de réglage sera utilisé dans la création d'une nouvelle maquette:

MyList listMock = mock(MyList.class, customSettings);

Semblable à la section précédente, nous invoquerons l' ajouter méthode d'une MyList instance et vérifier qu'une fausse méthode avec un MockSettings l' argument fonctionne comme il est censé en utilisant le code suivant:

boolean added = listMock.add(randomAlphabetic(6)); verify(listMock).add(anyString()); assertThat(added, is(false));

6. Conclusion

Ce tutoriel a couvert la méthode simulée de Mockito en détail. L'implémentation de ces exemples et extraits de code se trouve dans un projet GitHub.