NoAMockException tout Mockito.vérifier(Objet,VerificationMode.atleast(2))

Je suis à l'aide de mockito pour se moquer de l'unité des cas de test et j'obtiens de l'exception suivante

org.mockito.exceptions.misusing.NotAMockException: 
Argument passed to verify() is of type ConsumerImpl and is not a mock!
Make sure you place the parenthesis correctly!
See the examples of correct verifications:
    verify(mock).someMethod();
    verify(mock, times(10)).someMethod();
    verify(mock, atLeastOnce()).someMetenter code herehod();

et mon code est

 MessageConsumer mConsumer = Mockito.mock(MessageConsumer.class);
            String data = "new Message for Testing";
            Message message = new Message(data.getBytes());
            Mockito.when(mConsumer.next(10, TimeUnit.SECONDS)).thenReturn(message);
            StringParserTest parserTest = new StringParserTest();
            ConsumerImpl<String> consumer = new ConsumerImpl<String>(mConsumer, parserTest);
            String mes=Mockito.verify(consumer,VerificationModeFactory.times(3)).consumeMessage(10,TimeUnit.SECONDS);

S'il vous plaît quelques-on m'aider à résoudre ce problème

Merci d'Avance

SRN

OriginalL'auteur Ramesh | 2013-05-29

4

Bien, c'est exactement ce que mockito dit, vous n'êtes pas en passant d'une maquette pour vérifier !
```
ConsumerImpl<String> consumer = new ConsumerImpl<String>(mConsumer, parserTest);
String mes=Mockito.verify(consumer,VerificationModeFactory.times(3)).consumeMessage(10,TimeUnit.SECONDS);
```
De Plus, si vous avez vérifié une maquette pourquoi voulez-vous stocker le résultat de l'invocation-vous vérifier, ça ne ferait pas de sens, puisque le consommateur est tournée en dérision. Vérifier, c'est de vérifier les appels sur moqué des objets qui sont les collaborateurs de votre unité de l'objet testé. Qui dans ton cas n'est pas vraiment clair.

Également que vous n'utilisez jamais votre maquette mConsumer instance.

Vous devriez certainement séparer votre test en 3 phases, l'une pour l'appareil, l'autre pour l'action, et un pour les vérifications. Utiliser la BDD terminologie pour y parvenir, il augmente la capacité de compréhension et de lisibilité pour le testeur et le futur lecteur de ce code (Et Mockito leur offre dans l'API par le biais d'BDDMockito).

Que je ne comprends pas trop ce que le code est en train de tester, à partir du code que vous avez donné, je vais imaginer des choses. Si par exemple, vous aurez à écrire ce genre de code (à l'aide de import static) :
```
//given a consumer
MessageConsumer message_consumer = mock(MessageConsumer.class);
String the_message_data = "new Message for Testing";
given(message_consumer.next(10, SECONDS)).willReturn(new Message(the_message_data.getBytes()));

//when calling the client of the customer (which is the unit that is tested)
new MessageProcessor(message_consumer).processAll();

//then verify that consumeMessage is called 3 times
verify(message_consumer, times(3)).consumeMessage(10, SECONDS);
```
Rappelez-vous Mockito vous permet de vous concentrer sur les interactions entre les objets — comme c'est le plus important de la notion de programmation orientée objet — et en particulier entre l'testés et ses collaborateurs, qui va certainement se moque de lui.

OriginalL'auteur Brice

Général, nous avons simulé à l'aide de @InjectMock et nous essayons de vérifier une méthode appelée à partir de l'intérieur du cas de test de la méthode.
Voici un scénario qui donnent en général un problème.

public class A{
  @Autowired
  Service s

  public void method1(){
    m2();
  }
  public void method2(){
    s.someMethod();
  }
}

public class ATest{

  @InjectMocks
  A a;

  public void testM1(){
    a.method1();
    Mockito.verify(a, Mockito.times(1)).method2();

  }
}

Ce sera toujours "NoAMockException tout Mockito.vérifier"
au lieu de cela, nous devrions utiliser la suite de la vérification.

public class ATest{
  @InjectMocks
  A a;
  @Mock
  Service s

  public void testM1(){
    a.method1();
    Mockito.verify(s, Mockito.times(1)).someMethod();
  }
}

Ou si nous voulons vérifier() method2()
ensuite, nous avons pour @Maquette de la classe A à la place de @InjectMock

OriginalL'auteur Sumit Sundriyal

Vous devez vous connecter pour publier un commentaire.