Tester les rappels avec Mockito

1. Vue d'ensemble

Dans ce court didacticiel, nous allons nous concentrer sur la façon de tester les rappels à l'aide du cadre de test populaire Mockito.

Nous allons explorer deux solutions, en utilisant tout d' abord un ArgumentCaptor et intuitif doAnswer () méthode .

Pour en savoir plus sur les bons tests avec Mockito, consultez notre série Mockito ici.

2. Introduction aux rappels

Un callback est un morceau de code qui est passé en tant qu'argument à une méthode, qui est censé rappeler (exécuter) l'argument à un moment donné .

Cette exécution peut être immédiate comme dans un rappel synchrone, mais plus généralement, elle peut se produire plus tard, comme dans un rappel asynchrone.

Un scénario courant pour l'utilisation des rappels est pendant les interactions de service lorsque nous devons traiter la réponse d'un appel de service .

Dans ce didacticiel, nous utiliserons l' interface de service ci-dessous en tant que collaborateur dans les cas de test:

public interface Service { void doAction(String request, Callback callback); }

Dans l' argument Callback , nous passons une classe qui gérera la réponse en utilisant la méthode reply (T response) :

public interface Callback { void reply(T response); } 

2.1. Un service simple

Nous utiliserons également un exemple de service simple pour montrer comment transmettre et appeler le rappel :

public void doAction() { service.doAction("our-request", new Callback() { @Override public void reply(Response response) { handleResponse(response); } }); } 

La méthode handleResponse vérifie si la réponse est valide avant d'ajouter des données à l' objet Response :

private void handleResponse(Response response) { if (response.isValid()) { response.setData(new Data("Successful data response")); } }

Pour plus de clarté, nous avons choisi de ne pas utiliser d'expression Java Lamda mais l' appel service.doAction pourrait également être écrit de manière plus concise :

service.doAction("our-request", response -> handleResponse(response)); 

Pour en savoir plus sur les expressions Lambda, jetez un œil ici.

3. Utilisation d'un ArgumentCaptor

Voyons maintenant comment nous utilisons Mockito pour récupérer l' objet Callback à l' aide d'un ArgumentCaptor :

@Test public void givenServiceWithValidResponse_whenCallbackReceived_thenProcessed() { ActionHandler handler = new ActionHandler(service); handler.doAction(); verify(service).doAction(anyString(), callbackCaptor.capture()); Callback callback = callbackCaptor.getValue(); Response response = new Response(); callback.reply(response); String expectedMessage = "Successful data response"; Data data = response.getData(); assertEquals( "Should receive a successful message: ", expectedMessage, data.getMessage()); }

Dans cet exemple, nous créons d'abord un ActionHandler avant d'appeler la méthode doAction de ce gestionnaire. Il s'agit simplement d'un wrapper pour notre appel de méthode doAction Simple Service, où nous invoquons notre rappel.

Ensuite, nous vérifions que doAction a été appelé sur notre instance de service fictive en passant anyString () comme premier argument et callbackCaptor.capture () comme second, qui est l'endroit où nous capturons l' objet Callback . La méthode getValue () peut ensuite être utilisée pour renvoyer la valeur capturée de l'argument.

Maintenant que nous avons l' objet Callback , nous créons un objet Response qui est valide par défaut avant d' appeler directement la méthode de réponse et d'affirmer que les données de réponse ont la valeur correcte .

4. Utilisation de la doAnswer () Méthode

Nous allons maintenant examiner une solution courante pour les méthodes de stubbing qui ont des rappels en utilisant l' objet Answer de Mockito et la méthode doAnswer pour stub de la méthode void doAction:

@Test public void givenServiceWithInvalidResponse_whenCallbackReceived_thenNotProcessed() { Response response = new Response(); response.setIsValid(false); doAnswer((Answer) invocation -> { Callback callback = invocation.getArgument(1); callback.reply(response); Data data = response.getData(); assertNull("No data in invalid response: ", data); return null; }).when(service) .doAction(anyString(), any(Callback.class)); ActionHandler handler = new ActionHandler(service); handler.doAction(); } 

Et, dans notre deuxième exemple, nous créons d'abord un objet Response non valide qui sera utilisé plus tard dans le test.

Ensuite, nous configurons la réponse sur notre service fictif de sorte que lorsque doAction est appelé, nous interceptons l'invocation et récupérons les arguments de la méthode en utilisant invocation.getArgument (1) pour obtenir l' argument Callback .

La dernière étape consiste à créer le ActionHandler et à appeler doAction, ce qui provoque l' appel de la réponse .

Pour en savoir plus sur les méthodes de suppression des annulations, jetez un œil ici.

3. Conclusion

Dans ce bref article, nous avons couvert deux manières différentes d'aborder les rappels de test lors des tests avec Mockito.

Comme toujours, les exemples sont disponibles dans ce projet GitHub.