Comment peut-Mockito capture d'arguments passés à l'injection d'une maquette de l'objet de méthodes?

Je suis en train de tester un service de classe, en interne qui rend l'utilisation d'un Ressort AMQP objet de connexion. Cet objet de connexion est injecté par le Printemps. Cependant, je ne veux pas que mon test de l'unité de réellement communiquer avec le courtier AMQP, donc je suis en utilisant Mockito injecter un simulacre de l'objet de connexion.

/** 
 * The real service class being tested.  Has an injected dependency. 
 */ 
public class UserService {

   @Autowired
   private AmqpTemplate amqpTemplate;

   public final String doSomething(final String inputString) {
      final String requestId = UUID.randomUUID().toString();
      final Message message = ...;
      amqpTemplate.send(requestId, message);
      return requestId;
   }
}

/** 
 * Unit test 
 */
public class UserServiceTest {

   /** This is the class whose real code I want to test */
   @InjectMocks
   private UserService userService;

   /** This is a dependency of the real class, that I wish to override with a mock */
   @Mock
   private AmqpTemplate amqpTemplateMock;

   @Before
   public void initMocks() {
      MockitoAnnotations.initMocks(this);
   }

   @Test
   public void testDoSomething() {
      doNothing().when(amqpTemplateMock).send(anyString(), any(Message.class));

      //Call the real service class method, which internally will make 
      //use of the mock (I've verified that this works right).
      userService.doSomething(...);

      //Okay, now I need to verify that UUID string returned by 
      //"userService.doSomething(...) matches the argument that method 
      //internally passed to "amqpTemplateMock.send(...)".  Up here 
      //at the unit test level, how can I capture the arguments passed 
      //to that inject mock for comparison?
      //
      //Since the value being compared is a UUID string created 
      //internally within "userService", I cannot just verify against 
      //a fixed expected value.  The UUID will by definition always be
      //unique.
   }
}

Les commentaires dans cet exemple de code espérons-le, poser la question clairement. Lorsque Mockito injecte un simulacre de dépendance dans une vraie classe, et des tests unitaires sur la véritable cause de la classe pour faire des appels à la maquette, comment pouvez-vous récupérer plus tard exactement les arguments qui ont été transmis à l'injection de fantaisie?

InformationsquelleAutor Steve Perkins | 2015-03-20
  1. 65

    Utiliser un, ou plusieurs, ArgumentCaptors.

    Il est difficile de savoir ce que vos types sont ici, mais de toute façon. Supposons que vous avez une maquette qui a une méthode doSomething() prendre un Foo comme un argument, puis vous faites cela:

    final ArgumentCaptor<Foo> captor = ArgumentCaptor.forClass(Foo.class);

verify(mock).doSomething(captor.capture());

final Foo argument = captor.getValue();

//Test the argument

    Aussi, il ressemble à la méthode void et vous n'avez pas envie de faire quoi que ce soit. Il suffit d'écrire ceci:

    doNothing().when(theMock).doSomething(any());
    • Merci pour l'astuce sur doAnswer() vs doNothing(), j'ai nettoyé le code ci-dessus de l'échantillon en conséquence. Cependant, je ne suis pas sûr si je suis absent quelque chose, ou si votre réponse est encore un niveau retiré de mon problème. Quand je commence à en appelant verify() sur ma maquette de l'objet AVANT que j'ai appelé le réel de la classe qui utilise la maquette à l'interne, puis je reçois le message d'exception, "en Fait, il y avait zéro interactions avec ce simulacre". L'exécution échoue sur le verify() ligne... et n'a même jamais fait pour le code réel que je suis en train de tester.
    • Dans votre exemple, vous essayez de passer un argument à votre maquette de l'objet directement à partir de l'unité de test? Je ne suis pas... je suis en train de capturer un argument qui est passé par une couche intermédiaire entre l'unité de test et la simulation de l'objet. La maquette est d'être injecté dans cet intermédiaire.
    • Ahh! La question qui n'était pas clair à partir de votre extrait de code, c'est que le verify() appel sur la maquette, ainsi que la getValue() appel sur le capteur, les deux viennent APRÈS l'invocation de la méthode sur l'objet réel fait l'objet de test. J'ai été à tort d'appeler verify() préalable à l'objet réel d'invocation de méthode.
    • oups, désolé, je n'y étais pas, mais je vois que vous avez compris 😉
    • Il existe un raccourci pour créer captor dans le niveau de la classe, ainsi: @Captor privé ArgumentCaptor<Foo> fooCaptor;
    InformationsquelleAutor fge
  2. 8

    Vous pouvez brancher doAnswer() à la stub de la send() méthode sur amqpTemplateMock puis capturer l'invocation d'arguments de AmqpTemplate.send().

    La première ligne de votre testDoSomething() être ce

        Mockito.doAnswer(new Answer<Void>() {
          @Override
          public Void answer(final InvocationOnMock invocation) {
            final Object[] args = invocation.getArguments();
            System.out.println("UUID=" + args[0]);  //do your assertions here
            return null;
          }
    }).when(amqpTemplateMock).send(Matchers.anyString(), Matchers.anyObject());

    mettre tous ensemble, le test devient 

    import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

public class UserServiceTest {

  /** This is the class whose real code I want to test */
  @InjectMocks
  private UserService userService;

  /** This is a dependency of the real class, that I wish to override with a mock */
  @Mock
  private AmqpTemplate amqpTemplateMock;

  @Before
  public void initMocks() {
    MockitoAnnotations.initMocks(this);
  }

  @Test
  public void testDoSomething() throws Exception {
    Mockito.doAnswer(new Answer<Void>() {
      @Override
      public Void answer(final InvocationOnMock invocation) {
        final Object[] args = invocation.getArguments();
        System.out.println("UUID=" + args[0]);  //do your assertions here
        return null;
      }
    }).when(amqpTemplateMock).send(Matchers.anyString(), Matchers.anyObject());
    userService.doSomething(Long.toString(System.currentTimeMillis()));
  }
}

    Cela donne de sortie

    UUID=8e276a73-12fa-4a7e-a7cc-488d1ce0291f

    J'ai trouvé ceci par la lecture de ce post,
    Comment faire de la maquette à des méthodes void avec mockito

    InformationsquelleAutor Kirby