Comment tester dans Mockito spécifiques afin d'appels avec les mêmes arguments?

Je veux vérifier l'ordre dans lequel les personnages pour s'assurer qu'ils ne sont pas déformés. J'ai essayé de l'écrire à l'aide de InOrder mais il semble ne pas fonctionner, ou au moins dans Mockito 1.8.5.

@Test
public void inOrderTest() throws IOException{
    final String message = "Hello World!\n";

    for( char c : message.toCharArray() )
        mockWriter.write( c );

    final InOrder inOrder = inOrder( mockWriter );
    for( char c : message.toCharArray() )
        inOrder.verify( mockWriter ).write( c );
    inOrder.verifyNoMoreInteractions();
}

Le test ci-dessus échoue avec le message:

Verification in order failure:
mockWriter.write(108);
Wanted 1 time:
-> at     org.bitbucket.artbugorski.brainfuj.interpreter.InterpreterTest.inOrderTest(InterpreterTest.java:62)
But was 3 times. Undesired invocation:
-> at org.bitbucket.artbugorski.brainfuj.interpreter.InterpreterTest.inOrderTest(InterpreterTest.java:58)

Comment écrit-on un Mockito test pour qui?

EDIT: Déposé en tant que bug http://code.google.com/p/mockito/issues/detail?id=296

InformationsquelleAutor ArtB | 2011-12-04

19

Mes excuses à la précédente, les répondants; mais, à mon avis, à l'aide d'une Réponse vole un peu dans le visage de l'une des idées de base de Mockito, à savoir que stubbing et la vérification sont deux choses complètement distinctes. Mockito a des fonctionnalités pour cogner et de fonctionnalités pour la vérification, et les fabricants de Mockito ont fait un effort pour maintenir les deux. Les réponses sont destinés à cogner; et attendu qu'il y a peu de cas où une Réponse est la meilleure façon de vérifier, je ne pense pas que ce soit l'un d'entre eux.

Je voudrais utiliser un ArgumentCaptor au lieu d'une Réponse. Je voudrais écrire une méthode de ce genre dans la classe de test, puis de l'appeler avec un "Hello world" comme argument. Notez que je n'ai pas testé, donc il peut contenir des fautes de frappe.
```
private void verifyCharactersWritten( String expected ){
    ArgumentCaptor<Character> captor = ArgumentCaptor.forClass( Character.class ); 
    verify( mockWriter, times( expected.length())).write( captor.capture());
    assertEquals( Arrays.asList( expected.toCharArray()), captor.getAllValues());
}
```
Espère que cette aide.
- Slick. Je ne connaissais pas cette fonctionnalité de l'arg captor.
- parfois facilement à vérifier le résultat/de sortie/résultat (si c'est possible), puis lire ce test de code. Je veux dire, si nous savons qu'il doit nous retourner: "certains piquent nous attendions" pour les arguments possibles.
InformationsquelleAutor Dawood ibn Kareem
4

De vérification dans l'ordre est une notion distincte de la façon dont beaucoup de temps que quelque chose est faite, de sorte que lorsque vous arrivez à la " l " et dire Mockito pour vérifier que c'est arrivé, il passe à l'ordre du chèque, mais échoue parce que le 'l' appel a été effectué trois fois, et vous (implicitement) dit-il à attendre d'elle qu'une seule fois. C'est un caprice, j'ai frappé avant d'en Mockito, mais à peu près toutes les fois que cela arrive, je finis par décider que mon test est mal écrit, et quand je le résoudre, le problème disparaît. Dans votre cas, je dirais que c'est façon exagéré pour vérifier chaque personnage écrit à l'Auteur. Si vous voulez vérifier un message lui a été envoyé correctement, vous devriez être en comparant le message d'entrée pour le message de sortie. Dans votre exemple, ce que pourrait impliquer l'utilisation d'un StringWriter au lieu de se moquer de l'écrivain. Puis la fin de votre test, ça ressemble juste à
```
assertThat(stringWriter.toString(), equalTo(message));
```
Si vous avez vraiment à faire ce que vous faites, tout ce que je peux suggérer, c'est de creuser dans le Mockito code pour voir si il y a un moyen pour y arriver et, éventuellement, le dépôt d'un rapport de bug pour voir ce qu'ils en disent.
- Je suis en train d'écrire une machine virtuelle/interprète I/O qui se passe d'un personnage à un moment, il n'y a pas de notion de la totalité d'un message, juste une série de personnages imprimés sur la sortie standard stdout. Je suis en train de veiller à ce qu'au cours de l'impression, je ne suis pas corrompre n'importe quoi (oui, je mets en place ma propre mémoire interne). Le message que je suis en train de le vérifier, c'est "Hello World" donc je ne pense pas que c'est exagéré pour vérifier qu'un message comme ça peut être imprimé correctement, caractère par caractère. 🙂
- Salut, eh bien, si ce test est essentiel, c'est à dire que vous devriez tester ce que vous êtes emtting, je suis d'accord avec @Ryan, vous devriez préférer la comparaison de l'entrée vs la sortie. Lorsque stubbing de votre auteur, l'utilisation d'une réponse personnalisée qui aura pour effet d'ajouter le char dans une habitude StringBuilder, puis de le comparer à notre "Hello World" d'entrée. Sinon, vous pouvez probablement écrire une correspondance personnalisée; quelque chose comme inOrder.verify(mockWriter, times(11)).write(charsThatMatchInOrder("Hello World"));, cependant, ce test peut se casser facilement si les changements de chaînes !
- bien l'extrait de code émulé/interprétation est la partie de l'entrée de test, donc oui, si elle change, il est prévu que le test échoue.
- Je regrette d'avoir écrit ce commentaire, comment ai-je pu ne pas y penser. Vous devriez vraiment favorable à une ArgumentCaptor que David a écrit dans sa réponse.
InformationsquelleAutor Ryan Stewart
2

La raison Mockito fonctionne comme ça, c'est la cohérence entre la vérification dans l'ordre et une vérification régulière. D'autres termes, si nous n'avions pas l'appliquer de cette façon, l'API aurait été surprenant de façon différente 🙂 Vous faites des échanges effectués lors de la tentative de concevoir un décent de l'api.

Donc... la réponse. Tout d'abord, vous devez éviter d'états, tels que les boucles (ou conditionnelles) dans le code de test. La raison en est, vous vous souciez beaucoup pour le code de test de la clarté et de la facilité de maintenance! =)

Si nous supprimer les boucles de test, nous n'avons plus un cas d'utilisation, mais... Sans les cas d'utilisation, il est difficile de donner une réponse. David ArgumentCaptor peut-être pas une mauvaise idée.

Espère que ça aide!
- Je suis en désaccord. J'ai pu dérouler la boucle et qui auraient le même problème. Je le sais pour un fait que je n'ai que lorsque vous essayez de déboguer ce. Deuxièmement, si c'est de les appeler Aussitôt, mais il ne peut pas vraiment dire dans quel ordre les appels ont été effectués n'est-ce pas une violation flagrante du principe de moindre étonnement?
InformationsquelleAutor Szczepan

Je suis actuellement en train de piratage autour de ce avec une Réponse personnalisée.

final List<Integer> writtenChars = new ArrayList<>();
willAnswer(
        new Answer(){
            @Override
            public Object answer( final InvocationOnMock invocation )throws Throwable {
                final int arg = (int) invocation.getArguments()[0];
                writtenChars.add( arg );
                return null;
            }
        }
    ).given( mockWriter ).write( anyInt() );

Puis, après l'exécution de l'souhaité méthodes de test, je l'encontre de la Chaîne attendue contre la liste.

final Iterator<Integer> writtenCharItr = writtenChars.iterator();
for( int charInt : "Hello World!\n".toCharArray() )
    assertThat(  charInt, is( writtenCharItr.next() )  );
assertThat( "There are no more chars.", writtenCharItr.hasNext(), is(false) );
verify( mockWriter ).flush();

Bien que cela ne fonctionnera pas si vous êtes intéressé par plus d'une fois à l'appel de la méthode, à moins que vous enregistrez dans la liste de la méthode qui m'a appelé, etc.

EDIT: excuses à Brice vous semble indépendamment venir à cette solution, sauf de façon indépendante et de mieux en utilisant un StringBuilder au lieu d'un List, même si, pour un cas général une Liste fonctionne mieux.

A quoi je pensais... Un ArgumentCaptor est bien mieux, il se fait de ce que cette coutume réponse est en train de faire. La réponse de David est beaucoup plus correct dans de nombreuses façons.

InformationsquelleAutor ArtB

C'est un drôle de test, mais encore, il doit être pris en charge par les moqueries de l'API. Je crois qu'il peut être pris en charge par Mockito, puisque d'autres se moquant des Api ne le soutenir.

Avec Unitils Se Moquer De:

Mock<Writer> mockWriter;

@Test
public void inOrderTest() throws Exception {
    Writer writer = mockWriter.getMock();
    final String message = "Hello World!\n";

    for (char c : message.toCharArray())
        writer.write(c);

    for (char c : message.toUpperCase().toCharArray())
        mockWriter.assertInvokedInSequence().write(c);
    MockUnitils.assertNoMoreInvocations();
}

Ou avec JMockit (mon propre outil):

@Test
public void inOrderTest(final Writer mockWriter) throws Exception {
    final String message = "Hello World!\n";

    for (char c : message.toCharArray())
        mockWriter.write(c);

    new FullVerificationsInOrder() {{
        for (char c : message.toCharArray())
            mockWriter.write(c);
    }};
}

InformationsquelleAutor Rogério

Vous devez vous connecter pour publier un commentaire.