Comment se moquer des méthodes void avec Mockito

Comment se moquer des méthodes avec un type de retour vide?

J'ai implémenté un modèle d'observateur mais je ne peux pas me moquer de lui avec Mockito parce que je ne sais pas comment.

Et j'ai essayé de trouver un exemple sur Internet mais je n'ai pas réussi.

Ma classe ressemble à ceci:

public class World {

    List<Listener> listeners;

    void addListener(Listener item) {
        listeners.add(item);
    }

    void doAction(Action goal,Object obj) {
        setState("i received");
        goal.doAction(obj);
        setState("i finished");
    }

    private string state;
    //setter getter state
} 

public class WorldTest implements Listener {

    @Test public void word{
    World  w= mock(World.class);
    w.addListener(this);
    ...
    ...

    }
}

interface Listener {
    void doAction();
}

Le système n'est pas déclenché avec une simulation.

Je veux montrer l'état du système mentionné ci-dessus. Et faites des affirmations selon eux.

Jetez un œil aux documents de l' API Mockito . Comme le document lié mentionne (point n ° 12) , vous pouvez utiliser l' une des doThrow(), doAnswer(), doNothing(), doReturn()famille de méthodes de cadre Mockito pour se moquer des méthodes vides.

Par exemple,

Mockito.doThrow(new Exception()).when(instance).methodName();

ou si vous souhaitez le combiner avec un comportement de suivi,

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

En supposant que vous envisagez de vous moquer du setter setState(String s)dans la classe World ci-dessous, le code utilise la doAnswerméthode pour se moquer de setState.

World  mockWorld = mock(World.class); 
doAnswer(new Answer<Void>() {
    public Void answer(InvocationOnMock invocation) {
      Object[] args = invocation.getArguments();
      System.out.println("called with arguments: " + Arrays.toString(args));
      return null;
    }
}).when(mockWorld).setState(anyString());

Je pense que j'ai trouvé une réponse plus simple à cette question, pour appeler la vraie méthode pour une seule méthode (même si elle a un retour nul), vous pouvez le faire:

Mockito.doCallRealMethod().when(<objectInstance>).<method>();
<objectInstance>.<method>();

Ou, vous pouvez appeler la vraie méthode pour toutes les méthodes de cette classe, en procédant comme suit:

<Object> <objectInstance> = mock(<Object>.class, Mockito.CALLS_REAL_METHODS);

Ajoutant à ce que @sateesh a dit, lorsque vous souhaitez simplement simuler une méthode void afin d'empêcher le test de l'appeler, vous pouvez utiliser Spycette méthode:

World world = new World();
World spy = Mockito.spy(world);
Mockito.doNothing().when(spy).methodToMock();

Lorsque vous souhaitez exécuter votre test, assurez-vous d'appeler la méthode en test sur l' spyobjet et non sur l' worldobjet. Par exemple:

assertEquals(0,spy.methodToTestThatShouldReturnZero());

La solution du soi-disant problème consiste à utiliser un spy Mockito.spy (...) au lieu d'un mock Mockito.mock (..) .

Spy nous permet de nous moquer partiellement. Mockito est bon dans ce domaine. Parce que vous avez une classe qui n'est pas complète, vous vous moquez ainsi de la place requise dans cette classe.

Tout d'abord: vous devez toujours importer mockito static, de cette façon le code sera beaucoup plus lisible (et intuitif):

import static org.mockito.Mockito.*;

Pour des moqueries partielles tout en conservant les fonctionnalités d'origine sur le reste, mockito propose "Spy".

Vous pouvez l'utiliser comme suit:

private World world = spy(World.class);

Pour éliminer l'exécution d'une méthode, vous pouvez utiliser quelque chose comme ceci:

doNothing().when(someObject).someMethod(anyObject());

pour donner un comportement personnalisé à une méthode, utilisez "when" avec un "thenReturn":

doReturn("something").when(this.world).someMethod(anyObject());

Pour plus d'exemples, veuillez trouver les excellents échantillons de mockito dans la doc.

Comment se moquer des méthodes void avec mockito - il y a deux options:

1. doAnswer - Si nous voulons que notre méthode void moquée fasse quelque chose (moquer le comportement malgré le fait d'être nul).
2. doThrow- Ensuite, il y a Mockito.doThrow()si vous voulez lever une exception de la méthode void moquée.

Voici un exemple de la façon de l'utiliser (pas un cas d'utilisation idéal, mais je voulais juste illustrer l'utilisation de base).

@Test
public void testUpdate() {

    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            Object[] arguments = invocation.getArguments();
            if (arguments != null && arguments.length > 1 && arguments[0] != null && arguments[1] != null) {

                Customer customer = (Customer) arguments[0];
                String email = (String) arguments[1];
                customer.setEmail(email);

            }
            return null;
        }
    }).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("[email protected]", "[email protected]");

    //some asserts
    assertThat(customer, is(notNullValue()));
    assertThat(customer.getEmail(), is(equalTo("[email protected]")));

}

@Test(expected = RuntimeException.class)
public void testUpdate_throwsException() {

    doThrow(RuntimeException.class).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("[email protected]", "[email protected]");

}
}

Vous pouvez trouver plus de détails sur la façon de se moquer et de tester les méthodes de vide avec Mockito dans mon article Comment se moquer avec Mockito (Un guide complet avec des exemples)

Ajout d'une autre réponse au groupe (sans jeu de mots) ...

Vous devez appeler la méthode doAnswer si vous ne pouvez pas \ ne voulez pas utiliser espion. Cependant, vous n'avez pas nécessairement besoin de lancer votre propre réponse . Il existe plusieurs implémentations par défaut. Notamment, CallsRealMethods .

En pratique, cela ressemble à ceci:

doAnswer(new CallsRealMethods()).when(mock)
        .voidMethod(any(SomeParamClass.class));

Ou:

doAnswer(Answers.CALLS_REAL_METHODS.get()).when(mock)
        .voidMethod(any(SomeParamClass.class));

Dans Java 8, cela peut être rendu un peu plus propre, en supposant que vous ayez une importation statique pour org.mockito.Mockito.doAnswer:

doAnswer(i -> {
  // Do stuff with i.getArguments() here
  return null;
}).when(*mock*).*method*(*methodArguments*);

Le return null;est important et sans lui, la compilation échouera avec des erreurs assez obscures car elle ne pourra pas trouver un remplacement approprié doAnswer.

Par exemple, un ExecutorServicequi exécute immédiatement tout Runnablepassé execute()peut être implémenté en utilisant:

doAnswer(i -> {
  ((Runnable) i.getArguments()[0]).run();
  return null;
}).when(executor).execute(any());

Je pense que vos problèmes sont dus à votre structure de test. J'ai trouvé difficile de mélanger la simulation avec la méthode traditionnelle d'implémentation des interfaces dans la classe de test (comme vous l'avez fait ici).

Si vous implémentez l'écouteur en tant que maquette, vous pouvez alors vérifier l'interaction.

Listener listener = mock(Listener.class);
w.addListener(listener);
world.doAction(..);
verify(listener).doAction();

Cela devrait vous convaincre que le «monde» fait la bonne chose.

Utiliser Mockito.doThrow comme dans:

Mockito.doThrow(new Exception()).when(instance).methodName();

vous pouvez essayer ce bel exemple:

public void testCloseStreamOnException() throws Exception {
    OutputStream outputStream = Mockito.mock(OutputStream.class);
    IFileOutputStream ifos = new IFileOutputStream(outputStream);
    Mockito.doThrow(new IOException("Dummy Exception")).when(outputStream).flush();
    try {
      ifos.close();
      fail("IOException is not thrown");
    } catch (IOException ioe) {
      assertEquals("Dummy Exception", ioe.getMessage());
    }
    Mockito.verify(outputStream).close();
  }

Source: http://apisonar.com/java-examples/org.mockito.Mockito.doThrow.html#Example-19