Le framework Mockito fournit une variété de méthodes telles que mock(), verify(), when(), etc., utilisées pour tester les applications Java. L’utilisation de ces méthodes prédéfinies rend les tests très simples.
La brève description des méthodes Mockito est donnée ci-dessous :
menu des paramètres Android
Méthode Mockito mock()
Il est utilisé pour créer des objets fictifs d'une classe ou d'une interface donnée. Mockito contient cinq se moquer() méthodes avec des arguments différents. Lorsque nous n'avons rien attribué aux simulations, elles renverront des valeurs par défaut. Les cinq méthodes remplissent la même fonction : se moquer des objets.
Voici les méthodes mock() avec différents paramètres :
Syntaxe: mock (Classe classToMock)
Syntaxe: mock (Class classToMock, Réponse defaultAnswer)
Syntaxe: mock (Classe classToMock, MockSettings mockSettings)
Syntaxe: mock (Classe classToMock, ReturnValues returnValues)
Syntaxe: mock (Classe classToMock, nom de chaîne)
L'extrait de code suivant montre comment utiliser se moquer() méthode:
ToDoService doService = mock(ToDoService.class);
Méthode Mockito quand()
Il active les méthodes de stubbing. Il doit être utilisé lorsque nous voulons nous moquer pour renvoyer des valeurs spécifiques lorsque des méthodes particulières sont appelées. En termes simples, ' Quand la méthode XYZ() est appelée, alors retournez ABC. Il est principalement utilisé lorsqu'il y a une condition à exécuter.
Syntaxe : quand (T méthodeAppel)
L'extrait de code suivant montre comment utiliser la méthode when() :
when(mock.someCode ()).thenReturn(5);
Dans le code ci-dessus, puisRetour() est principalement utilisé avec le quand() méthode.
Méthode Mockito verify()
Le vérifier() La méthode est utilisée pour vérifier si certaines méthodes spécifiées sont appelées ou non. En termes simples, il valide un certain comportement qui s'est produit une fois lors d'un test. Il est utilisé au bas du code de test pour garantir que les méthodes définies sont appelées.
Le framework Mockito garde une trace de tous les appels de méthode avec leurs paramètres pour les objets moqueurs. Après moquerie, nous pouvons vérifier que les conditions définies sont remplies ou non en utilisant la méthode verify(). Ce type de test est parfois appelé tests comportementaux. Il vérifie qu'une méthode est appelée avec les bons paramètres au lieu de vérifier le résultat d'un appel de méthode.
La méthode verify() est également utilisée pour tester le nombre d'invocations. Nous pouvons donc tester le nombre exact d'invocations en utilisant le méthode times, méthode au moins une fois, et au plus méthode pour une méthode moquée.
Il existe deux types de méthodes verify() disponibles dans la classe Mockito, qui sont indiquées ci-dessous :
Syntaxe: vérifier (T mock)
Syntaxe: verify (T mock, mode VerificationMode)
Méthode Mockito espion()
Mockito fournit une méthode pour simuler partiellement un objet, connue sous le nom de espionner méthode. Lorsque vous utilisez la méthode d'espionnage, il existe un objet réel et des espions ou des stubs sont créés à partir de cet objet réel. Si nous ne supprimons pas une méthode à l’aide d’espion, elle appellera le comportement réel de la méthode. La fonction principale de la méthode spy() est qu'elle remplace les méthodes spécifiques de l'objet réel. L'une des fonctions de la méthode spy() est de vérifier l'invocation d'une certaine méthode.
Il existe deux types de méthodes spy() disponibles dans la classe Mockito :
Syntaxe: espion (objet T)
Syntaxe: espion (Classe classToSpy)
L'extrait de code suivant montre comment utiliser la méthode spy() :
List spyArrayList = spy(ArrayList.class);
Méthode Mockito reset()
La méthode Mockito reset() est utilisée pour réinitialiser les mocks. Il est principalement utilisé pour travailler avec les maquettes injectées par conteneur. Habituellement, la méthode reset() aboutit à un code long et à des tests médiocres. Il est préférable de créer de nouveaux mocks plutôt que d'utiliser la méthode reset(). C'est pourquoi la méthode reset() est rarement utilisée dans les tests.
La signature de la méthode reset() est :
instruction if-else java
public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } Méthode Mockito verifyNoMoreInteractions()
Il est utilisé pour vérifier que l'un des simulacres donnés a des interactions non vérifiées. Nous pouvons utiliser cette méthode après avoir vérifié tous les simulacres, pour nous assurer que rien d'autre n'a été invoqué sur les simulacres. Il détecte également les appels non vérifiés qui se produisent avant la méthode de test, par exemple dans setup(), la méthode @Before ou le constructeur. Il s'agit d'une méthode facultative et nous n'avons pas besoin de l'utiliser à chaque test.
La signature de la méthode verifyNoMoreInteractions() est :
public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } Méthode Mockito verifyZeroInteractions()
Il vérifie qu'aucune interaction n'a eu lieu sur les simulations données. Il détecte également les invocations qui ont eu lieu avant la méthode de test, par exemple dans setup(), la méthode @Before ou le constructeur.
La signature de la méthode verifyZeroInteractions() est :
public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } Méthode Mockito doThrow()
Il est utilisé pour stub une méthode void pour lever une exception. Il crée une nouvelle instance d'exception pour chaque appel de méthode. Il existe deux types de méthodes doThrow() disponibles dans la classe Mockito avec différents paramètres, comme indiqué ci-dessous :
La signature de la méthode doThrow() est :
public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } Syntaxe: doThrow(Classe àBeThrown)
La signature de la méthode doThrow() est :
public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } Méthode Mockito doCallRealMethod()
Il est utilisé lorsque l'on veut appeler l'implémentation réelle d'une méthode. En d’autres termes, il est utilisé pour créer des simulations partielles d’un objet. Il est utilisé dans des situations rares, comme pour appeler les méthodes réelles. Elle est similaire à la méthode spy(), et la seule différence est qu’elle aboutit à un code complexe.
La signature de la méthode doCallRealMethod() est :
public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } Méthode Mockito doAnswer()
Il est utilisé lorsque nous voulons remplacer une méthode void avec un type de réponse générique. La signature de la méthode doAnswer() est :
public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } Méthode Mockito doNothing()
Il est utilisé pour définir des méthodes void pour qu'elles ne fassent rien. La méthode doNothing() est utilisée dans de rares situations. Par défaut, les méthodes void sur les instances fictives ne font rien, c'est-à-dire qu'aucune tâche n'est effectuée.
La signature de la méthode doNothing() est :
public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } Méthode Mockito doReturn()
Il est utilisé dans les rares occasions où nous ne pouvons pas utiliser Mockito.when(object). La méthode Mockito.when(object) est toujours suggérée pour le stubbing car elle est sécurisée pour le type d'argument et plus lisible que la méthode doReturn().
tous les 3 mois
La signature de la méthode doReturn() est :
public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } Méthode Mockito inOrder()
Il est utilisé pour créer des objets permettant la vérification des simulations dans un ordre spécifique. La vérification effectuée dans l'ordre est plus flexible car nous n'avons pas besoin de vérifier toutes les interactions. Nous devons vérifier uniquement les interactions qui sont intéressées par les tests (dans l'ordre). Nous pouvons également utiliser la méthode inOrder() pour créer un objet inOrder transmettant des simulations pertinentes pour la vérification dans l'ordre.
La signature de la méthode Mockito.inOrder() est :
public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } Méthode Mockito ignoreStubs()
Il est utilisé pour ignorer les méthodes tronquées des simulations données à des fins de vérification. C'est utile avec les méthodes verifyNoMoreInteractions() ou verify inOrder(). Cela permet également d’éviter la vérification redondante des appels bloqués.
La signature de la méthode ignoreStubs() est :
public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } Méthode Mockito times()
Il est utilisé pour vérifier le nombre exact d’appels de méthode, ce qui signifie qu’il déclare combien de fois une méthode est invoquée. La signature de la méthode times() est :
public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } Méthode Mockito never()
Il est utilisé pour vérifier que l’interaction n’a pas eu lieu. La signature de la méthode never() est :
public static VerificationMode never() { return times(0); } Méthode Mockito atLeastOnce()
Il est utilisé pour vérifier l'invocation au moins une fois, ce qui signifie que la méthode doit être invoquée au moins une fois.
La signature de la méthode atLeastOnce() est :
public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } Méthode Mockito au moins ()
Il est utilisé pour vérifier l'invocation au moins x nombre de fois. Par exemple, étant donné atLeast(3) signifie que la méthode sera invoquée au moins trois fois.
La signature de la méthode atLeast() est :
public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } Méthode Mockito atMost()
Il est utilisé pour vérifier l’invocation au maximum x fois. Par exemple, étant donné atMost(3), cela signifie que la méthode sera invoquée au maximum trois fois.
La signature de la méthode atMost() est :
public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } Méthode Mockito appelle ()
Il permet une vérification non gourmande dans l'ordre. Il ne peut être utilisé qu'avec la méthode de vérification inOrder(). Par exemple, inOrder.verify(mock, lists(3)).xyzMethod('...');
La signature de la méthode call() est :
public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } Méthode Mockito uniquement ()
Il vérifie que la méthode donnée est la seule méthode invoquée. La signature de la méthode only() est :
livecricket.is
public static VerificationMode only() { return VerificationModeFactory.only(); } Méthode Mockito timeout()
Il permet à Mockito d'effectuer une vérification avec un délai d'attente. Il demande à une vérification d'attendre une période de temps spécifique pour une interaction particulière plutôt que d'échouer immédiatement. Cela peut être utile pour tester dans des situations existantes.
La méthode timeout() diffère de la méthode after() car la méthode after() attend toute la période à moins que le résultat final ne soit déclaré alors que la méthode timeout() s'arrêtera dès que la vérification sera réussie. Il est rarement utilisé dans les tests.
La signature de la méthode timeout() est :
public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } Méthode Mockito après()
Il permet à Mockito de vérifier sur une période de temps donnée. Nous avons déjà expliqué que la méthode after() diffère de la méthode timeout().
La signature de la méthode after() est :
public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } Méthode Mockito validateMockitoUsage()
Il est utilisé pour valider explicitement l'état du framework afin de détecter l'utilisation non valide du framework Mockito. Il s'agit d'une fonctionnalité facultative de Mockito car elle valide l'utilisation à tout moment. Le programme d'exécution intégré (MockitoJUnitRunner) et la règle (MockitoRule) appellent la méthode validateMockitoUsage() après chaque méthode de test.
La signature de la méthode validateMockitoUsage() est :
public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } Méthode Mockito withSettings()
Il est utilisé pour créer des simulations avec des paramètres de simulation supplémentaires. Il doit être utilisé occasionnellement lors des tests. Au lieu d'utiliser la méthode withSettings(), créez des tests simples à l'aide de simples simulations. Les principales raisons d'utiliser les MockSettings sont
- En utilisant MockSetting, nous pouvons facilement ajouter d'autres paramètres fictifs en cas de besoin.
- Il combine différents paramètres fictifs sans gâcher le code.
La signature de la méthode withSettings() est :
public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }