Mockito: comment stub vide méthodes d'exécuter du code lorsqu'il est appelé

Je veux stub une classe de dépôt pour tester une autre classe (Titulaire de la classe) qui dispose d'un référentiel. Le référentiel de l'interface prend en charge les opérations CRUD, et a de nombreuses méthodes, mais mon test de l'unité sur le Titulaire de la classe seulement besoin de faire appel à deux d'entre eux. Le référentiel d'interface:

public interface IRepo {
    public void remove(String... sarr);

    public void add(String... sarr);

    //Lots of other methods I don't need now
}

Je veux créer un référentiel de fantaisie qui permet de stocker les cas, définir la logique de add et remove seulement, et fournissent également un moyen de vérifier ce qui est stocké sur elle après l'appel d'ajouter et de supprimer.

Si je fais:

IRepo repoMock = mock(IRepo.class);

Puis j'ai un muet objet qui ne fait rien sur chaque méthode. C'est OK, maintenant j'ai juste besoin de définir le comportement pour ajouter et supprimer.

Je pourrais créer un Set<String> et stub seulement ces deux méthodes pour travailler sur le plateau. Alors je vous instanciez un Titulaire qui a un IRepo, d'injecter de l'partiellement écrasé en moquer, et après l'exercice de la titulaire, vérifiez l'ensemble de vérifier qu'il contient ce qu'il devrait.

J'ai réussi à partiellement stub une méthode void comme remove à l'aide de la méthode dépréciée stubVoid:

Set<String> mySet = new HashSet<>();
stubVoid(repoMock).toAnswer(new Answer<Void>() {

    @Override
    public Void answer(InvocationOnMock invocation) throws Throwable {
        Object[] args = invocation.getArguments();
        String[] stringsToDelete = (String[]) args[0];
        mySet.removeAll(Arrays.asList(stringsToDelete));
        return null;
    }
}).on().remove(Matchers.<String>anyVararg());

Mais est obsolète, et il n'est pas beaucoup mieux que la création d'une mise en œuvre partielle pour IRepo. Est-il un meilleur moyen?

REMARQUE: Java 7 réponses seulement s'il vous plaît, cela devrait fonctionner sous Android.

OriginalL'auteur Mister Smith | 2015-08-21

11

Vous pouvez utiliser
```
  Mockito.doAnswer(new Answer<Void>() {
        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            //DO SOMETHING
            return null;
        }
    }).when(...).remove(Matchers.<String>anyVararg());
```
De la Javadoc:

Utilisation doAnswer() lorsque vous vous voulez talon un vide, une méthode générique de
Réponse.

Cogner les vides nécessite une approche différente de Mockito.quand(Objet)
parce que le compilateur n'aime pas les méthodes void entre les parenthèses...

Exemple:
```
    doAnswer(new Answer() {
    public Object answer(InvocationOnMock invocation) {
        Object[] args = invocation.getArguments();
        Mock mock = invocation.getMock();
        return null;
    }}).when(mock).someMethod();
```
Voir les exemples dans la javadoc de Mockito

Intéressant de voir comment il n'y a pas doSomething acceptant un Exécutable au lieu d'avoir à pirater un annuler la réponse. Est mon cas d'utilisation si farfelu qu'il ne mérite pas d'être dans Mockito de l'API?
Je doute qu'il y est une bibliothèque là pour satisfaire tous les utilisateurs. Mockito est très facile d'étendre (voir ma réponse) pour presque n'importe quel but. Un Exécutable par le moyen ne serait pas de travail dans votre exemple, vous avez besoin de l'invocation d'arguments.
Ma question d'essayer à force de changer certaines données à mi-chemin par le biais d'un test, merci!

OriginalL'auteur Jens

Supposons que vous avez

public class IFace {
    public void yourMethod() {            
    }
}

Puis de s'en moquer vous avez besoin

    IFace mock = Mockito.mock(IFace.class);
    Mockito.doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
            //PUT YOUR CODE HERE
            return null;
        }
    }).when(mock).yourMethod();

OriginalL'auteur talex

Si vous n'aimez vraiment pas à return null de la mise en œuvre de Answer, vous pouvez créer votre propre Réponse mise en œuvre que les délégués à une méthode void:

public abstract class DoesSomethingAnswer implements Answer<Void> {

    @Override
    public Void answer(InvocationOnMock invocation) throws Throwable {
        doSomething(invocation);
        return null;
    }

    protected abstract void doSomething(InvocationOnMock invocation);    
}

Alors votre test a une ligne moins:

    Set<String> mySet = new HashSet<>();
    Mockito.doAnswer(new DoesSomethingAnswer() {
        @Override
        protected void doSomething(InvocationOnMock invocation) {
            Object[] args = invocation.getArguments();
            String[] stringsToDelete = (String[]) args[0];
            mySet.removeAll(Arrays.asList(stringsToDelete));
        }
    }).when(repoMock).remove(Matchers.<String> anyVararg());

Ou, si vous avez juste besoin les arguments de l'invocation:

public abstract class DoesSomethingAnswer implements Answer<Void> {

    @Override
    public Void answer(InvocationOnMock invocation) throws Throwable {
        doSomething(invocation.getArguments());
        return null;
    }

    protected abstract void doSomething(Object[] args);
}

OriginalL'auteur Ruben

Vous devez vous connecter pour publier un commentaire.