Quelle est la différence entre Mockito.mock (SomeClass) et l’annotation @Mock?

Quelle est la différence entre la Mockito.mock(Class classToMock) et l’annotation @Mock ? Sont-ils les mêmes?

Par exemple, est-ce que:

 private TestClass test = Mockito.mock(TestClass.class); 

le même que:

 @Mock private TestClass test; 

Ils obtiennent tous deux le même résultat. L’utilisation d’une annotation ( @Mock ) est généralement considérée comme “plus propre”, car vous ne remplissez pas votre code avec des affectations standard qui se ressemblent toutes.

Notez que pour utiliser l’annotation @Mock , votre classe de test doit être annotée avec @RunWith(MockitoJUnitRunner.class) ou contenir un appel à MockitoAnnotations.initMocks(this) dans sa méthode @Before .

La différence réside dans les lignes de code que vous devez écrire 🙂 🙂 🙂

Sérieusement, l’utilisation des annotations a exactement le même effet que l’utilisation du Mockito.mock.

Pour citer la documentation de MockitoAnnotations l’utilisation des annotations présente les avantages suivants:

  • Permet la création abrégée d’objects requirejs pour les tests.

  • Réduit le code de création répétitif.

  • Rend la classe de test plus lisible.

  • L’erreur de vérification est plus facile à lire car le nom du champ est
    utilisé pour identifier le simulacre.

Le javadoc pour MockitoAnnotations est ici

Ils sont tous deux considérés comme identiques et réalisent la même chose, mais je préférerais le second:

@Mock est une annotation qui:

  • Réduit le code de création répétitif.
  • Rend la classe de test plus lisible.
  • Permet la création abrégée d’objects requirejs pour le test.

L’utilisation de l’annotation présente deux avantages importants.

  • Une maquette créée avec @Mock peut être injectée dans la classe que vous testez, à l’aide de l’annotation @InjectMocks . C’est une technique puissante qui peut faciliter considérablement les tests. Cela ne fonctionnera tout simplement pas avec les mock créés par la méthode mock .
  • Si vous avez des erreurs impliquant votre maquette, le nom du simulacre apparaîtra dans le message. Si vous avez utilisé @Mock , alors ce nom sera simplement le nom du champ. Cela rend très facile la recherche du problème.

Bien sûr, en plus de ces deux avantages importants, la plupart des gens trouvent la notation @Mock beaucoup plus lisible et réduisent la quantité de code. Je ne vois aucune raison de ne pas l’utiliser.

La réponse à la question est une grosse erreur. Nous venons de résoudre certains problèmes causés par Mockito.mock (Your.class) en tant que champ. Nous avons eu peu de méthodes @Test. La 4ème méthode lançait une exception avec ‘thenThrow (ex)’. Toutes les méthodes @Test après l’échec et la raison était l’exception levée. Ils partageaient l’instance simulée et la condition «quand». Après nous avons changé de

 TestClass testInstance = Mockito.mock(TestClass.class); 

à

 @Mock TestClass testInstance; 

tout a commencé à fonctionner comme prévu. Mockito.mock crée donc un simulacre de partage entre les méthodes de test, contrairement à @Mock.